void
ags_lv2_option_manager_finalize(GObject *gobject)
{
  AgsLv2OptionManager *lv2_option_manager;

  lv2_option_manager = AGS_LV2_OPTION_MANAGER(gobject);
  
  g_hash_table_destroy(lv2_option_manager->ressource);

  if(lv2_option_manager == ags_lv2_option_manager){
    ags_lv2_option_manager = NULL;
  }

  pthread_mutex_destroy(lv2_option_manager->obj_mutex);
  free(lv2_option_manager->obj_mutex);

  pthread_mutexattr_destroy(lv2_option_manager->obj_mutexattr);
  free(lv2_option_manager->obj_mutexattr);

  /* call parent */
  G_OBJECT_CLASS(ags_lv2_option_manager_parent_class)->finalize(gobject);  
}
Esempio n. 2
0
/*
 * Initialize slog library. Function parses config file and reads log 
 * level and save to file flag from config. First argument is file name 
 * where log will be saved and second argument conf is config file path 
 * to be parsedand third argument lvl is log level for this message.
 */
void slog_init(const char* fname, const char* conf, int lvl, int flvl, int t_safe)
{
    int status = 0;

    /* Set up default values */
    slg.level = lvl;
    slg.file_level = flvl;
    slg.to_file = 0;
    slg.pretty = 0;
    slg.filestamp = 1;
    slg.td_safe = t_safe;

    /* Init mutex sync */
    if (t_safe)
    {
        /* Init mutex attribute */
        pthread_mutexattr_t m_attr;
        if (pthread_mutexattr_init(&m_attr) ||
            pthread_mutexattr_settype(&m_attr, PTHREAD_MUTEX_RECURSIVE) ||
            pthread_mutex_init(&slog_mutex, &m_attr) ||
            pthread_mutexattr_destroy(&m_attr))
        {
            printf("<%s:%d> %s: [ERROR] Can not initialize mutex: %d\n", 
                __FILE__, __LINE__, __FUNCTION__, errno);
            slg.td_safe = 0;
        }
    }

    /* Parse config file */
    if (conf != NULL) 
    {
        slg.fname = fname;
        status = parse_config(conf);
    }

    /* Handle config parser status */
    if (!status) slog(0, SLOG_INFO, "Initializing logger values without config");
    else slog(0, SLOG_INFO, "Loading logger config from: %s", conf);
}
Esempio n. 3
0
//critical_section_t
critical_section_t::critical_section_t(bool recursive_flag) throw()
{
#ifdef LINUX

        pthread_mutexattr_t mtx_attr;
        pthread_mutexattr_init(&mtx_attr);
        if(recursive_flag) pthread_mutexattr_settype(&mtx_attr, PTHREAD_MUTEX_RECURSIVE);
        pthread_mutex_init(&_mtx, &mtx_attr);
        pthread_mutexattr_destroy(&mtx_attr);
#elif defined(WIN32)

	if(recursive_flag)
	{
		InitializeCriticalSection(&_cs);
		_sem = NULL;
	}
	else //non-recursive
	{
		_sem = ::CreateSemaphore(NULL,1,1,NULL);
	}
#endif //LINUX
}
Esempio n. 4
0
/*! \brief Create and initialize a critical section
 *
 * UNIX/Linux
 *
 * \return Pointer to critical section created and initialized (casted to \c void *).
*/
void * PMS_CreateCriticalSection(void)
{
  pthread_mutex_t * ptCS;          /* Mutex for critical section */
  pthread_mutexattr_t mutexattr;   /* Mutex attribute variable */

  ptCS = (pthread_mutex_t *)malloc(sizeof(pthread_mutex_t));
  if(!ptCS) {
    PMS_SHOW_ERROR("Failed to allocation critical section structure\n");
    return NULL;
  }
#ifndef PMS_OIL_MERGE_DISABLE_MEM
  memVal+=sizeof(pthread_mutex_t);
#endif

  /* Initialize the attributes set */
  pthread_mutexattr_init(&mutexattr);

#ifdef MACOSX
  /* Set the mutex as a normal mutex */
  pthread_mutexattr_settype(&mutexattr, PTHREAD_MUTEX_NORMAL);
#else
#ifdef __NetBSD__
  /* Set the mutex as a normal mutex */
  pthread_mutexattr_settype(&mutexattr, PTHREAD_MUTEX_NORMAL);
#else
  /* Set the mutex as a fast mutex */
  pthread_mutexattr_settype(&mutexattr, PTHREAD_MUTEX_ADAPTIVE_NP);
#endif
#endif

  /* create the mutex with the attributes set */
  pthread_mutex_init(ptCS, &mutexattr);

  /* After initializing the mutex, the attribute can be destroyed */
  pthread_mutexattr_destroy(&mutexattr);

  return (void*)ptCS;
}
Esempio n. 5
0
int main(void)
{
	int ret;
	pthread_t tid[2];
	pthread_attr_t attr;
	pthread_mutexattr_t mutexattr;

	pthread_attr_init(&attr);
	pthread_mutexattr_init(&mutexattr);

	pthread_attr_setdetachstate(&attr, 
		PTHREAD_CREATE_DETACHED);
	pthread_mutexattr_settype(&mutexattr,
		PTHREAD_MUTEX_RECURSIVE_NP);
	
	pthread_mutex_init(&lock, &mutexattr);
	pthread_mutexattr_destroy(&mutexattr);



	ret = pthread_create(&tid[0], &attr, 
		test0, NULL);
	if (ret) {
		fprintf(stderr, "create:%s\n", strerror(ret));
		exit(1);
	}

	ret = pthread_create(&tid[0], &attr, 
		test1, NULL);
	if (ret) {
		fprintf(stderr, "create:%s\n", strerror(ret));
		exit(1);
	}	

	pthread_attr_destroy(&attr);

	pthread_exit(NULL);
}
int initCrashSimulationThread(rtSimulationThread_t *p_thread, inputThread_t *p_inputThread)
{
	int ret;
	pthread_mutexattr_t attr;
	
	ret = initRTMutexAttr(&attr);
	if(ret != 0) {
		PRINT_ERR("Failed to init rt mutex attributes (%d).\n", ret);
		return ret;
	}
	
	ret = pthread_mutex_init(&p_thread->simulationMutex, &attr);
	if(ret != 0) {
		PRINT_ERR("Failed to init mutex (%d).\n", ret);
		return ret;
	}
	
	ret = pthread_barrier_init(&p_thread->startBarrier, NULL, 2);
	if(ret != 0) {
		PRINT_ERR("Failed to init barrier (%d).\n", ret);
		return ret;
	}
	
	ret = initSimulation(&p_thread->simulation, DEF_DISTANCE);
	if(ret != 0) {
		PRINT_ERR("Failed to init simulation (%d).\n", ret);
		return ret;
	}
	p_thread->simulate = 0;
	p_thread->keepRunning = 0;
	p_thread->running = 0;
	p_thread->exitCode = 0;
	p_thread->inputThread = p_inputThread;
	
	pthread_mutexattr_destroy(&attr);
	
	return 0;
}
Esempio n. 7
0
static int
do_test (void)
{
  pthread_mutex_t m;

  int e = pthread_mutex_init (&m, ATTR);
  if (ATTR != NULL && e == ENOTSUP)
    {
      puts ("cannot support selected type of mutexes");
      e = pthread_mutex_init (&m, NULL);
    }
  if (e != 0)
    {
      puts ("mutex_init failed");
      return 1;
    }

  if (ATTR != NULL && pthread_mutexattr_destroy (ATTR) != 0)
    {
      puts ("mutexattr_destroy failed");
      return 1;
    }

  if (pthread_mutex_lock (&m) != 0)
    {
      puts ("1st mutex_lock failed");
      return 1;
    }

  /* Set an alarm for 1 second.  The wrapper will expect this.  */
  alarm (1);

  /* This call should never return.  */
  pthread_mutex_lock (&m);

  puts ("2nd mutex_lock returned");
  return 1;
}
Esempio n. 8
0
int main()
{
	pthread_mutexattr_t mta;
	int rc;

	/* Initialize a mutex attributes object */
	if ((rc=pthread_mutexattr_init(&mta)) != 0)
	{
		fprintf(stderr,"Cannot initialize mutex attributes object\n");
		return PTS_UNRESOLVED;
	}

	/* Destroy the mutex attributes object */
	if (pthread_mutexattr_destroy(&mta) != 0)
	{
		fprintf(stderr,"Error at pthread_mutexattr_destroy(), rc=%d\n", rc);
		printf("Test FAILED\n");
		return PTS_FAIL;
	}

	printf("Test PASSED\n");
	return PTS_PASS;
}
int usbi_mutex_init_recursive(pthread_mutex_t *mutex, pthread_mutexattr_t *attr)
{
	int err;
	pthread_mutexattr_t stack_attr;
	if (!attr) {
		attr = &stack_attr;
		err = pthread_mutexattr_init(&stack_attr);
		if (err != 0)
			return err;
	}

	err = pthread_mutexattr_settype(attr, PTHREAD_MUTEX_RECURSIVE);
	if (err != 0)
		goto finish;

	err = pthread_mutex_init(mutex, attr);

finish:
	if (attr == &stack_attr)
		pthread_mutexattr_destroy(&stack_attr);

	return err;
}
Esempio n. 10
0
IMutexLock::IMutexLock()
{
#ifdef  WIN32
  if (InitializeCriticalSectionAndSpinCount(&_M_mutex, 2000) != TRUE) {
    DeleteCriticalSection(&_M_mutex);
    std::cerr << "init critical section failed !" << std::endl;
  }
#elif defined(HAVE_PTHREAD)
  int       _ret_code = 0;
  if ((_ret_code = pthread_mutexattr_init(&_M_mutexattr)) != 0)
    std::cerr << "mutex attribute init failed !" << std::endl;
  if (_ret_code == 0)
    _ret_code = pthread_mutexattr_settype(&_M_mutexattr, PTHREAD_MUTEX_ERRORCHECK);
  if (_ret_code == 0)
    if ((_ret_code = pthread_mutex_init(&_M_mutex, &_M_mutexattr)) != 0)
      err_msg("pthread_mutex_init failed");

  if (_ret_code != 0) {
    (void)pthread_mutex_destroy(&_M_mutex);
    (void)pthread_mutexattr_destroy(&_M_mutexattr);
  }
#endif  // end of WIN32
}
Esempio n. 11
0
zMutex::zMutex(void) {
  _lockedCount = 0;
  _isDestroying = false;

#if defined(_WIN32)
  _cs = new CRITICAL_SECTION;
  InitializeMutexAndSpinCount((LPCRITICAL_SECTION)_cs, 500);
#else
  pthread_mutexattr_t mutexAttr;

  int res = pthread_mutexattr_init(&mutexAttr);
  CHECK_FATAL(res, "pthread_mutexattr_init");

  res = pthread_mutexattr_settype(&mutexAttr, PTHREAD_MUTEX_RECURSIVE);
  CHECK_FATAL(res, "pthread_mutexattr_settype PTHREAD_MUTEX_RECURSIVE");

  res = pthread_mutex_init(&_mutex, &mutexAttr);
  CHECK_FATAL(res, "pthread_mutex_init");

  res = pthread_mutexattr_destroy(&mutexAttr);
  CHECK_FATAL(res, "pthread_mutexattr_destroy");
#endif
}
Esempio n. 12
0
/**
 * Contruct our Mutex
 */
dashee::Threads::LockMutex::LockMutex()
{
    this->mutex = new pthread_mutex_t();
    this->attr = new pthread_mutexattr_t();
    
    if (pthread_mutexattr_init(this->attr) != 0)
	throw ExceptionLock("Thread attribute init failed");

    if (pthread_mutexattr_settype(this->attr, PTHREAD_MUTEX_ERRORCHECK) != 0)
	throw ExceptionLock("Thread attribute set failed");
    
    // Make sure that initilization comes out as good, otherwise we should
    // absolutly die die die
    int ec = pthread_mutex_init(this->mutex, this->attr);
    if (ec != 0)
	throw ExceptionLock(
		"Error Initilizing LockMutex, ec='" + 
		dashee::itostr(ec) + "'. This should not happen!"
	    );

    pthread_mutexattr_destroy(this->attr);
    this->attr = NULL;
}
Esempio n. 13
0
static void *scene_create(obs_data_t settings, struct obs_source *source)
{
	pthread_mutexattr_t attr;
	struct obs_scene *scene = bmalloc(sizeof(struct obs_scene));
	scene->source     = source;
	scene->first_item = NULL;

	if (pthread_mutexattr_init(&attr) != 0)
		goto fail;
	if (pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE) != 0)
		goto fail;
	if (pthread_mutex_init(&scene->mutex, &attr) != 0) {
		blog(LOG_ERROR, "scene_create: Couldn't initialize mutex");
		goto fail;
	}

	return scene;

fail:
	pthread_mutexattr_destroy(&attr);
	bfree(scene);
	return NULL;
}
Esempio n. 14
0
    poster(Blink * _blink, bool & ok)
      : state(WAIT), blink(_blink)
    {
      pthread_mutexattr_t attr;
      pthread_mutexattr_init(&attr);
      pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK);
      pthread_mutex_init(&mutex, &attr);
      pthread_mutexattr_destroy(&attr);
      switch(pthread_create(&thread_id, 0, run, this)){
      case EAGAIN:
	if(0 != blink->m_os)
	  (*blink->m_os) << "insufficient resources for thread.\n";
	ok = false;
	break;
      case EINVAL:
	if(0 != blink->m_os)
	  (*blink->m_os) << "BUG [invalid attr for pthread_create()]\n";
	ok = false;
	break;
      default:
	ok = true;
      }
    }
Esempio n. 15
0
/*---------------------------------------------------------------------------------*/
void engine::finalize(){
  if ( runMultiThread ) {
    pthread_mutex_destroy(&thread_lock);
    pthread_mutexattr_destroy(&mutex_attr);
    task_submission_finished=true;
    LOG_INFO(LOG_MULTI_THREAD,"before join\n");
    if ( thread_model  >=1){
      pthread_join(mbsend_tid,NULL);
      LOG_INFO(LOG_MULTI_THREAD," MBSend thread joined\n");
    }
    if ( thread_model  >=2){
      pthread_join(mbrecv_tid,NULL);
      LOG_INFO(LOG_MULTI_THREAD,"MBRecv thread joined\n");
    }
    pthread_join(thread_id,NULL);
    LOG_INFO(LOG_MULTI_THREAD,"Admin thread joined\n");
  }
  else
    doProcessLoop((void *)this);
  globalSync();
  if(cfg->getDLB())
    dlb.dumpDLB();
}
Esempio n. 16
0
	DeckLinkConsumer()
	{
		pthread_mutexattr_t mta;

		m_displayMode = NULL;
		m_deckLinkKeyer = NULL;
		m_deckLinkOutput = NULL;
		m_deckLink = NULL;

		m_aqueue = mlt_deque_init();
		m_frames = mlt_deque_init();

		// operation locks
		m_op_id = OP_NONE;
		m_op_arg = 0;
		pthread_mutexattr_init( &mta );
		pthread_mutexattr_settype( &mta, PTHREAD_MUTEX_RECURSIVE );
		pthread_mutex_init( &m_op_lock, &mta );
		pthread_mutex_init( &m_op_arg_mutex, &mta );
		pthread_mutexattr_destroy( &mta );
		pthread_cond_init( &m_op_arg_cond, NULL );
		pthread_create( &m_op_thread, NULL, op_main, this );
	}
Esempio n. 17
0
int myfunc() {
	int ret = 0;
	int type = 0;
	pthread_mutexattr_t attr;
	if ((ret = pthread_mutexattr_init(&attr)) != 0)
	{
		printf("pthread_mutexattr_init error: %s\n", strerror(ret));       
		return ret; 
	}
	if ((ret = pthread_mutexattr_gettype(&attr, &type)) != 0)
	{
		printf("gettype error\n");
		return ret;
	}
	whichtype(type);

	if ((ret = pthread_mutexattr_destroy(&attr)) != 0)
	{
		printf("destroy error\n");
		return ret;
	}
    return 0;
}
Esempio n. 18
0
//建立临界区
void MThreadBase::rv_CreateSection()
{
	if(s_blSectionFlag)
		return;
	#ifndef LINUXCODE
		::InitializeCriticalSection(&s_stSection);
	#else	
		/*
		 *	GUOGUO 2009-08-11 设置临界区锁的属性为可递归锁,支持同一线程连续调用lock
		 */
		//	ADD
		pthread_mutexattr_t attr;
		pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE_NP);
		//	ADD END

		pthread_mutex_init(&s_stSection,&attr);

		//	ADD
		pthread_mutexattr_destroy(&attr);
		//	ADD END
	#endif
	s_blSectionFlag = true;
}
Esempio n. 19
0
/**
 * Close metadata file of a fake device.
 */
static void
zbc_fake_close_metadata(zbc_fake_device_t *fdev)
{

    if ( fdev->zbd_meta_fd > 0 ) {

        if ( fdev->zbd_meta ) {
            msync(fdev->zbd_meta, fdev->zbd_meta_size, MS_SYNC);
            munmap(fdev->zbd_meta, fdev->zbd_meta_size);
            fdev->zbd_meta = NULL;
            fdev->zbd_meta_size = 0;
        }

        close(fdev->zbd_meta_fd);
        fdev->zbd_meta_fd = -1;

        pthread_mutexattr_destroy(&fdev->zbd_mutex_attr);

    }

    return;

}
Esempio n. 20
0
MessageQueue::MessageQueue( int maxMessages_ ) :
	shutdown( false ),
	maxMessages( maxMessages_ ),
	messages( new message_t[ maxMessages_ ] ),
	head( 0 ),
	tail( 0 )
{
	assert( maxMessages > 0 );

	for ( int i = 0; i < maxMessages; i++ )
	{
		messages[i].string = NULL;
		messages[i].synced = false;
	}

	pthread_mutexattr_t	attr;
	pthread_mutexattr_init( &attr );
	pthread_mutexattr_settype( &attr, PTHREAD_MUTEX_ERRORCHECK );
	pthread_mutex_init( &mutex, &attr );
	pthread_mutexattr_destroy( &attr );
	pthread_cond_init( &posted, NULL );
	pthread_cond_init( &received, NULL );
}
Esempio n. 21
0
/*****************************************************************************
 * vlc_mutex_init: initialize a recursive mutex (Do not use)
 *****************************************************************************/
int vlc_mutex_init_recursive( vlc_mutex_t *p_mutex )
{
#if defined( LIBVLC_USE_PTHREAD )
    pthread_mutexattr_t attr;
    int                 i_result;

    pthread_mutexattr_init( &attr );
#  if defined (__GLIBC__) && (__GLIBC_MINOR__ < 6)
    pthread_mutexattr_setkind_np( &attr, PTHREAD_MUTEX_RECURSIVE_NP );
#  else
    pthread_mutexattr_settype( &attr, PTHREAD_MUTEX_RECURSIVE );
#  endif
    i_result = pthread_mutex_init( p_mutex, &attr );
    pthread_mutexattr_destroy( &attr );
    return( i_result );
#elif defined( WIN32 )
    /* Create mutex returns a recursive mutex */
    *p_mutex = CreateMutex( 0, FALSE, 0 );
    return (*p_mutex != NULL) ? 0 : ENOMEM;
#else
# error Unimplemented!
#endif
}
Esempio n. 22
0
void print_pthread_info()
{
#if defined(HAVE_LIBPTHREAD)
  pthread_attr_t attr;
  pthread_mutexattr_t m_attr;
  pthread_condattr_t c_attr;

#if defined(PTHREAD_KEYS_MAX)
  fprintf(stderr, "PTHREAD_KEYS_MAX    = %d\n", PTHREAD_KEYS_MAX);
#endif
#if defined(PTHREAD_DESTRUCTOR_ITERATIONS)
  fprintf(stderr, "PTHREAD_DESTRUCTOR_ITERATIONS = %d\n", PTHREAD_DESTRUCTOR_ITERATIONS);
#endif
#if defined(PTHREAD_THREADS_MAX)
  fprintf(stderr, "PTHREAD_THREADS_MAX = %d\n", PTHREAD_THREADS_MAX);
#endif
#if defined(PTHREAD_STACK_MIN)
  fprintf(stderr, "PTHREAD_STACK_MIN   = %d\n", PTHREAD_STACK_MIN);
#endif

  fprintf(stderr, "\n");

  pthread_attr_init(&attr);
  print_pthread_attr("Default pthread attr", &attr);
  pthread_attr_destroy(&attr);

  pthread_mutexattr_init(&m_attr);
  print_pthread_mutexattr("Default pthread mutexattr", &m_attr);
  pthread_mutexattr_destroy(&m_attr);

  pthread_condattr_init(&c_attr);
  print_pthread_condattr("Default pthread condattr ", &c_attr);
  pthread_condattr_destroy(&c_attr);

  fprintf(stderr, "\n");
#endif
}
ESL_DECLARE(esl_status_t) esl_mutex_create(esl_mutex_t **mutex)
{
	esl_status_t status = ESL_FAIL;
#ifndef WIN32
	pthread_mutexattr_t attr;
#endif
	esl_mutex_t *check = NULL;

	check = (esl_mutex_t *)malloc(sizeof(**mutex));
	if (!check)
		goto done;
#ifdef WIN32
	InitializeCriticalSection(&check->mutex);
#else
	if (pthread_mutexattr_init(&attr))
		goto done;

	if (pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE))
		goto fail;

	if (pthread_mutex_init(&check->mutex, &attr))
		goto fail;

	goto success;

 fail:
	pthread_mutexattr_destroy(&attr);
	goto done;

 success:
#endif
	*mutex = check;
	status = ESL_SUCCESS;

 done:
	return status;
}
Esempio n. 24
0
Sender::Sender(OlySocket* socket) {
	mDataFile = NULL;
	mDataSocket = NULL;

	// Set up the socket connection
	if (socket) {
		char streamline[64] = {0};
		mDataSocket = socket;

		// Receive magic sequence - can wait forever
		// Streamline will send data prior to the magic sequence for legacy support, which should be ignored for v4+
		while (strcmp("STREAMLINE", streamline) != 0) {
			if (mDataSocket->receiveString(streamline, sizeof(streamline)) == -1) {
				logg->logError("Socket disconnected");
				handleException();
			}
		}

		// Send magic sequence - must be done first, after which error messages can be sent
		char magic[32];
		snprintf(magic, 32, "GATOR %i\n", PROTOCOL_VERSION);
		mDataSocket->send(magic, strlen(magic));

		gSessionData->mWaitingOnCommand = true;
		logg->logMessage("Completed magic sequence");
	}

	pthread_mutexattr_t attr;
	if (pthread_mutexattr_init(&attr) != 0 ||
			pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK) != 0 ||
			pthread_mutex_init(&mSendMutex, &attr) != 0 ||
			pthread_mutexattr_destroy(&attr) != 0 ||
			false) {
		logg->logError("Unable to setup mutex");
		handleException();
	}
}
Esempio n. 25
0
static void opal_mutex_construct(opal_mutex_t *m)
{
#if OPAL_HAVE_POSIX_THREADS

#if OPAL_ENABLE_DEBUG
    pthread_mutexattr_t attr;
    pthread_mutexattr_init(&attr);

    /* set type to ERRORCHECK so that we catch recursive locks */
#if OMPI_HAVE_PTHREAD_MUTEX_ERRORCHECK_NP
    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK_NP);
#elif OMPI_HAVE_PTHREAD_MUTEX_ERRORCHECK
    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK);
#endif /* OMPI_HAVE_PTHREAD_MUTEX_ERRORCHECK_NP */

    pthread_mutex_init(&m->m_lock_pthread, &attr);
    pthread_mutexattr_destroy(&attr);

#else

    /* Without debugging, choose the fastest available mutexes */
    pthread_mutex_init(&m->m_lock_pthread, NULL);

#endif /* OPAL_ENABLE_DEBUG */

#endif

#if OPAL_ENABLE_DEBUG && !OPAL_ENABLE_MULTI_THREADS
    m->m_lock_debug = 0;
    m->m_lock_file = NULL;
    m->m_lock_line = 0;
#endif

#if OPAL_HAVE_ATOMIC_SPINLOCKS
    opal_atomic_init( &m->m_lock_atomic, OPAL_ATOMIC_UNLOCKED );
#endif
}
Esempio n. 26
0
static ph_dns_channel_t *create_chan(void)
{
  ph_dns_channel_t *chan;
  struct ares_options opts;
  int res;
  pthread_mutexattr_t attr;

  chan = ph_mem_alloc(mt.chan);
  if (!chan) {
    return NULL;
  }

  pthread_mutexattr_init(&attr);
  pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
  pthread_mutex_init(&chan->chanlock, &attr);
  pthread_mutexattr_destroy(&attr);

  if (ph_ht_init(&chan->sock_map, 4, &sock_key, &ph_ht_ptr_val_def) != PH_OK) {
    ph_panic("failed to init sock map");
  }

  memset(&opts, 0, sizeof(opts));
  opts.sock_state_cb_data = chan;
  opts.sock_state_cb = sock_state_cb;
  opts.flags = ARES_FLAG_STAYOPEN;

  res = ares_init_options(&chan->chan, &opts,
      ARES_OPT_SOCK_STATE_CB|ARES_OPT_FLAGS);

  if (res != ARES_SUCCESS) {
    ph_panic("failed to ares_init_options: %s", ares_strerror(res));
  }

  ares_set_socket_callback(chan->chan, sock_create_cb, chan);

  return chan;
}
Esempio n. 27
0
int 
main(void)
{
    int             err;
    int             condition;
    int             arg;
    struct timespec when;

    if ((err = pthread_mutexattr_init(&attr)) != 0) {
        printf("pthread_mutexattr_init failed\n");
        return(1);
    }
    err = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
    if (err != 0) {
        printf("pthread_mutexattr_settype failed\n");
    }
    else if ((err = pthread_mutex_init(&mutex, &attr)) != 0) {
        printf("pthread_mutex_init failed\n");
    }
    pthread_mutexattr_destroy(&attr);
    if (err != 0) {
        return(1);
    }
    /* ... */
    pthread_mutex_lock(&mutex);
    condition = 1;
    if (condition) {
        /* calculate target time "when" */
        maketimespec(&when, 5);
        timeout(&when, retry, (void *)arg);
    }
    /* ... */
    pthread_mutex_unlock(&mutex);
    /* ... */
    sleep(10); /* wait */
    exit(0); /* fflush */
}
Esempio n. 28
0
int usbi_mutex_init_recursive(pthread_mutex_t *mutex, pthread_mutexattr_t *attr)
{
	int err;
	pthread_mutexattr_t stack_attr;
	if (!attr) {
		attr = &stack_attr;
		err = pthread_mutexattr_init(&stack_attr);
		if (err != 0)
			return err;
	}

	/* mutexattr_settype requires _GNU_SOURCE or _XOPEN_SOURCE >= 500 on Linux */
	err = pthread_mutexattr_settype(attr, PTHREAD_MUTEX_RECURSIVE);
	if (err != 0)
		goto finish;

	err = pthread_mutex_init(mutex, attr);

finish:
	if (attr == &stack_attr)
		pthread_mutexattr_destroy(&stack_attr);

	return err;
}
Esempio n. 29
0
void OSAcquireMutex(void)
{
	if(!mutexInitialized)
    {
        int ret;
        pthread_mutexattr_t attr;
        ret = pthread_mutexattr_init(&attr);	//initially not locked
        RI_ASSERT(!ret);	//check that there aren't any errors
        ret = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);	//count the number of recursive locks
        RI_ASSERT(!ret);	//check that there aren't any errors
        ret = pthread_mutex_init(&mutex, &attr);
        pthread_mutexattr_destroy(&attr);
        RI_ASSERT(!ret);	//check that there aren't more errors
        RI_UNREF(ret);
        mutexInitialized = true;
    }
	int ret = pthread_mutex_lock(&mutex);
	RI_ASSERT(ret != EINVAL);	//assert that the mutex has been initialized
	RI_ASSERT(ret != EAGAIN);	//assert that the maximum number of recursive locks hasn't been exceeded
	RI_ASSERT(ret != EDEADLK);	//recursive mutexes shouldn't return this
	RI_ASSERT(!ret);	//check that there aren't other errors
	RI_UNREF(ret);
	mutexRefCount++;
}
/* Fonction appelée au lancement du programme
 */
void initialisationProgramme() {
    // Implémenter ici l'initialisation de vos variables, la création
    // de vos objets système, etc.

    /* initialisation du scheduler en mode FIFO et a la priorité max*/ 
    int priority = 0;
    int pid = getpid();
    priority = sched_get_priority_max(SCHED_FIFO);
    struct sched_param param;
    param.sched_priority = priority;
    if (sched_setscheduler(pid, SCHED_FIFO, & param) != 0) {
        perror("sched_setscheduler");
    exit(EXIT_FAILURE);  
    }

    /* creation et initialisation des mutex pour la console et la ressource*/
    pthread_mutexattr_t attributsMutex;
    pthread_mutexattr_init(&attributsMutex);
    pthread_mutexattr_settype(&attributsMutex, PTHREAD_MUTEX_DEFAULT);
    pthread_mutex_init(&mutConsole, &attributsMutex);
    pthread_mutex_init(&mutRessourceGlobale, &attributsMutex);
    pthread_mutexattr_destroy(&attributsMutex); 

}