Example #1
0
static void init_serial_port(char *devname, int iobase, int irq, struct unit *unit) {
  struct serial_port *sp;
  dev_t devno;

  sp = (struct serial_port *) kmalloc(sizeof(struct serial_port));
  memset(sp, 0, sizeof(struct serial_port));

  sp->iobase = iobase;
  sp->irq = irq;

  sp->cfg.speed = 115200;
  sp->cfg.databits = 8;
  sp->cfg.parity = PARITY_NONE;
  sp->cfg.stopbits = 1;
  sp->cfg.rx_timeout = INFINITE;
  sp->cfg.tx_timeout = INFINITE;

  init_dpc(&sp->dpc);
  sp->dpc.flags |= DPC_NORAND;

  init_event(&sp->event, 0, 0);

  init_sem(&sp->tx_sem, QUEUE_SIZE);
  init_mutex(&sp->tx_lock, 0);

  init_sem(&sp->rx_sem, 0);
  init_mutex(&sp->rx_lock, 0);

  // Disable interrupts
  outp(sp->iobase + UART_IER, 0);

  // Determine UART type
  check_uart_type(sp);

  // Set baudrate, parity, databits and stopbits
  serial_config(sp);

  // Enable FIFO
  if (sp->type == UART_16550A) {
    outp(sp->iobase + UART_FCR, FCR_ENABLE | FCR_RCV_RST | FCR_XMT_RST | FCR_TRIGGER_14);
  }

  // Turn on DTR, RTS and OUT2
  sp->mcr = MCR_DTR | MCR_RTS | MCR_IENABLE;  
  outp(sp->iobase + UART_MCR, sp->mcr);

  // Create device
  devno = dev_make(devname, &serial_driver, unit, sp);

  // Enable interrupts
  register_interrupt(&sp->intr, IRQ2INTR(sp->irq), serial_handler, sp);
  enable_irq(sp->irq);
  outp((unsigned short) (sp->iobase + UART_IER), IER_ERXRDY | IER_ETXRDY | IER_ERLS | IER_EMSC);

  kprintf(KERN_INFO "%s: %s iobase 0x%x irq %d\n", device(devno)->name, uart_name[sp->type], sp->iobase, sp->irq);
}
Example #2
0
void
osi_PostPopulateVCache(struct vcache *avc) {
    memset(&(avc->vc_bhv_desc), 0, sizeof(avc->vc_bhv_desc));
    bhv_desc_init(&(avc->vc_bhv_desc), avc, avc, &Afs_vnodeops);

#if defined(AFS_SGI65_ENV)
    vn_bhv_head_init(&(avc->v.v_bh), "afsvp");
    vn_bhv_insert_initial(&(avc->v.v_bh), &(avc->vc_bhv_desc));
    avc->v.v_mreg = avc->v.v_mregb = (struct pregion *)avc;
# if defined(VNODE_TRACING)
    avc->v.v_trace = ktrace_alloc(VNODE_TRACE_SIZE, 0);
# endif
    init_bitlock(&avc->v.v_pcacheflag, VNODE_PCACHE_LOCKBIT, "afs_pcache",
		 avc->v.v_number);
    init_mutex(&avc->v.v_filocksem, MUTEX_DEFAULT, "afsvfl", (long)avc);
    init_mutex(&avc->v.v_buf_lock, MUTEX_DEFAULT, "afsvnbuf", (long)avc);
#else
    bhv_head_init(&(avc->v.v_bh));
    bhv_insert_initial(&(avc->v.v_bh), &(avc->vc_bhv_desc));
#endif

    vnode_pcache_init(&avc->v);

#if defined(DEBUG) && defined(VNODE_INIT_BITLOCK)
    /* Above define is never true execpt in SGI test kernels. */
    init_bitlock(&avc->v.v_flag, VLOCK, "vnode", avc->v.v_number);
#endif

#ifdef INTR_KTHREADS
    AFS_VN_INIT_BUF_LOCK(&(avc->v));
#endif

    vSetVfsp(avc, afs_globalVFS);
    vSetType(avc, VREG);

    VN_SET_DPAGES(&(avc->v), NULL);
    osi_Assert((avc->v.v_flag & VINACT) == 0);
    avc->v.v_flag = 0;
    osi_Assert(VN_GET_PGCNT(&(avc->v)) == 0);
    osi_Assert(avc->mapcnt == 0 && avc->vc_locktrips == 0);
    osi_Assert(avc->vc_rwlockid == OSI_NO_LOCKID);
    osi_Assert(avc->v.v_filocks == NULL);
# if !defined(AFS_SGI65_ENV)
    osi_Assert(avc->v.v_filocksem == NULL);
# endif
    osi_Assert(avc->cred == NULL);
# if defined(AFS_SGI64_ENV)
    vnode_pcache_reinit(&avc->v);
    avc->v.v_rdev = NODEV;
# endif
    vn_initlist((struct vnlist *)&avc->v);
    avc->lastr = 0;
}
Example #3
0
PJ_DEF(pj_status_t) pj_init(void)
{
    char dummy_guid[PJ_GUID_LENGTH];
    pj_str_t guid;

    PJ_LOG(5, ("pj_init", "Initializing PJ Library.."));

    /* Init this thread's TLS. */
#if PJ_HAS_THREADS
    if (pj_thread_init() != 0) {
	PJ_LOG(1, ("pj_init", "Thread initialization has returned an error"));
	return -1;
    }

    /* Critical section. */
    if (init_mutex(&critical_section, "critsec", PJ_MUTEX_SIMPLE) != 0)
	return -1;

#endif
    
    /* Init random seed. */
    srand( clock() );

    /* Startup GUID. */
    guid.ptr = dummy_guid;
    pj_generate_unique_string( &guid );


    return PJ_OK;
}
Example #4
0
DynamicPlane::DynamicPlane() : gstDynamic()
#endif
{
	// initialize transform to identity
	fixedPlane = new TexturePlane(0.0, 1.0, 0.0, 0.0);
#ifdef	VRPN_USE_HDAPI
	//XXX Probably going to need some linking code in here somewhere to keep track of objects
#else
	xform.identity();
	fixedPlane->setParent(this);
#endif
	buzzForce = new BuzzForceField();
	buzzForce->setPlane(vrpn_HapticPlane(0.0, 1.0, 0.0, 0.0));
	buzzForce->setSpring(fixedPlane->getSurfaceKspring());
	buzzForce->restrictToSurface(TRUE);
	buzzForce->adjustToTexturePlane(fixedPlane);

	plane = vrpn_HapticPlane(0.0, 1.0, 0.0, 0.0);
	lastPlane = vrpn_HapticPlane(plane);
#ifdef	VRPN_USE_HDAPI
	//XXX Probably going to need some linking code in here somewhere to keep track of objects
#else
	addChild(fixedPlane);
	addChild(buzzForce);
#endif
        _using_buzz = FALSE;
	_active = FALSE;
	_is_new_plane = FALSE;
	buzzForce->deactivate();
	fixedPlane->enableTexture();
	fixedPlane->setTextureSize(10.0);
	fixedPlane->setTextureAspectRatio(0.0);
	fixedPlane->setInEffect(FALSE);
	init_mutex(&xform_mutex);
}
Example #5
0
void TexturePlane::init() {
	isNewPlane = FALSE;
	inEffect= FALSE;
	isInRecovery = FALSE;
	recoveryPlaneCount = 0;
	originalPlane = plane;
	lastDepth = 0;
	dIncrement = 0;
	numRecoveryCycles = 1;
	//  boundingRadius = 1000.0;
#ifndef	VRPN_USE_HDAPI
	invalidateCumTransf();
	dynamicParent = NULL;
#endif
	textureOrigin = vrpn_HapticPosition(0,0,0);

	usingTexture = 0;
	texWL = 10.0;
	texWN = 1/texWL;
	texAmp = 0;
	textureAspect = texAmp*2.0/texWL;

	fadeActive = FALSE;
	fadeOldKspring = 0;
	dSpring_dt = 0;
	dataCB = NULL;
	userdata = NULL;
	data_time = 0;
	safety_ineffect = TRUE;
	newCoordinates = FALSE;
	inContact = FALSE;
	init_mutex(&tex_param_mutex);
}
Example #6
0
File: main.c Project: pivie/voting
int main(int argc, char **argv)
{
    int i, dup_vote;
    int cores, block_size;
    cores = 16;
    block_size = 1024*1024;
    int *thread;
    file_struct *fs;
    threadpool_t *pool;

    thread = malloc(sizeof(int));

    if(argc<2)
    {
        printf("[usage] vote_counter [-dupvote] [-cores C] [-blocksize B] [filename1] ... [filenameN]\n");
        exit(-1);
    }

    char **file_list = malloc(sizeof(char *) * MAX_FILE_NUM);
    memset(file_list, 0, (sizeof(char*))*MAX_FILE_NUM);

    //analyze input arguments
    if(!(dup_vote = opts(argc, argv, file_list, &cores, &block_size, &thread)))
    {
        exit(-1);
    }
    
    printf("thread number %d\n", *thread);
    //printf("cores %d; block_size %d\n", cores, block_size);
    
    //create pool according to total file size & number
    if((pool = threadpool_create(*thread, cores, 0)) == NULL)
    {
        printf("[error] can not initalize thread\n");
        exit(-1);
    }

    init_mutex();

    dup_vote = dup_vote == 2 ? TRUE : FALSE;

    for (i=0; file_list[i]!=NULL; i++)
    {
        fs = malloc(sizeof(file_struct));
        fs->filename = file_list[i];
        fs->dup_vote = dup_vote;
        fs->block_size = block_size;

        //send read task to thread pool
        threadpool_add(pool, &readfile, fs, 0);

    }

    //wait until all thread finish their job
    threadpool_destroy(pool, 1);

    get_vote_result(3);

    return 0;
}
Example #7
0
static int init_task_struct(struct task_struct *task, u32 flag)
{
	struct task_struct *parent;
	unsigned long flags;

	/* if thread is a kernel thread, his parent is idle */
	if (flag & PROCESS_TYPE_KERNEL)
		parent = idle;
	else
		parent = current;

	/* get a new pid */
	task->pid = get_new_pid(task);
	if ((task->pid) < 0)
		return -EINVAL;

	task->uid = parent->uid;
	task->stack_base = NULL;
	task->stack_base = NULL;
	strncpy(task->name, parent->name, PROCESS_NAME_SIZE);
	task->flag = flag;
	task->state = 0;

	/* add task to the child list of his parent. */
	task->parent = parent;
	init_list(&task->p);
	init_list(&task->child);
	init_mutex(&task->mutex);

	enter_critical(&flags);
	list_add(&parent->child, &task->p);
	exit_critical(&flags);
	
	return 0;
}
Example #8
0
int x11c_initialise(X11Common* x11Common, int reviewDuration, OnScreenDisplay* osd, X11WindowInfo* windowInfo)
{
    memset(x11Common, 0, sizeof(x11Common));

    x11Common->reviewDuration = reviewDuration;
    x11Common->osd = osd;

    x11Common->progressBarInput.data = x11Common;
    x11Common->progressBarInput.set_listener = x11c_set_pbar_listener;
    x11Common->progressBarInput.unset_listener = x11c_unset_pbar_listener;
    x11Common->progressBarInput.close = x11c_close_pbar;

    x11Common->keyboardInput.data = x11Common;
    x11Common->keyboardInput.set_listener = x11c_set_keyboard_listener;
    x11Common->keyboardInput.unset_listener = x11c_unset_keyboard_listener;
    x11Common->keyboardInput.close = x11c_close_keyboard;

    x11Common->mouseInput.data = x11Common;
    x11Common->mouseInput.set_listener = x11c_set_mouse_listener;
    x11Common->mouseInput.unset_listener = x11c_unset_mouse_listener;
    x11Common->mouseInput.close = x11c_close_mouse;

    if (windowInfo)
    {
        x11Common->windowInfo = *windowInfo;
    }

    CHK_ORET(XInitThreads() != 0);
    
    CHK_ORET(init_mutex(&x11Common->eventMutex));

    CHK_ORET(create_joinable_thread(&x11Common->processEventThreadId, process_event_thread, x11Common));

    return 1;
}
Example #9
0
static inline bool init_mutexes(void)
{
	DWORD pid = GetCurrentProcessId();

	tex_mutexes[0] = init_mutex(MUTEX_TEXTURE1, pid);
	if (!tex_mutexes[0]) {
		return false;
	}

	tex_mutexes[1] = init_mutex(MUTEX_TEXTURE2, pid);
	if (!tex_mutexes[1]) {
		return false;
	}

	return true;
}
Example #10
0
PJ_DEF(pj_status_t) pj_init(void)
{
    WSADATA wsa;
    char dummy_guid[32]; /* use maximum GUID length */
    pj_str_t guid;

    PJ_LOG(5, ("pj_init", "Initializing PJ Library.."));

    /* Init Winsock.. */
    if (WSAStartup(MAKEWORD(2,0), &wsa) != 0) {
	PJ_LOG(1, ("pj_init", "Winsock initialization has returned an error"));
	return -1;
    }

    /* Init this thread's TLS. */
    if (pj_thread_init() != 0) {
	PJ_LOG(1, ("pj_init", "Thread initialization has returned an error"));
	return -1;
    }
    
    /* Init random seed. */
    srand( GetCurrentProcessId() );

    /* Startup GUID. */
    guid.ptr = dummy_guid;
    pj_generate_unique_string( &guid );

    /* Initialize critical section. */
    if (init_mutex(&critical_section_mutex, "pj%p") != 0)
	return -1;

    return PJ_OK;
}
Example #11
0
OFDPE
init_port_manager( const size_t max_send_queue_length, const size_t max_recv_queue_length ) {
  if ( max_send_queue_length == 0 || max_recv_queue_length == 0 ) {
    error( "Failed to initialize port manager. Maximum queue length must be greater than zero "
           "( max_send_queue = %u, max_recv_queue = %u ).", max_send_queue_length, max_recv_queue_length );
    return ERROR_INVALID_PARAMETER;
  }

  bool ret = init_mutex( &mutex );
  if ( !ret ) {
    return ERROR_INIT_MUTEX;
  }

  ret = lock_mutex( &mutex );
  if ( !ret ) {
    return ERROR_LOCK;
  }

  config.max_send_queue_length = max_send_queue_length;
  config.max_recv_queue_length = max_recv_queue_length;

  init_switch_port();

  add_periodic_event_callback_safe( PORT_STATUS_UPDATE_INTERVAL, update_switch_port_status_and_stats, NULL );

  ret = unlock_mutex( &mutex );
  if ( !ret ) {
    return ERROR_UNLOCK;
  }

  return OFDPE_SUCCESS;
}
Example #12
0
File: dir.c Project: dayne/zunkfs
static struct dentry *new_dentry(struct dentry *parent,
		struct disk_dentry *ddent, struct chunk_node *ddent_cnode,
		struct mutex *ddent_mutex)
{
	struct dentry *dentry;

	assert(have_mutex(ddent_mutex));
	
	dentry = malloc(sizeof(struct dentry));
	if (!dentry)
		return ERR_PTR(ENOMEM);

	dentry->ddent = ddent;
	dentry->ddent_cnode = ddent_cnode;
	dentry->ddent_mutex = ddent_mutex;
	dentry->parent = parent;
	dentry->size = le64toh(ddent->size);
	dentry->mode = le16toh(ddent->mode);
	dentry->mtime.tv_sec = le32toh(ddent->mtime);
	dentry->mtime.tv_usec = ddent->mtime_csec * 10000;

	init_mutex(&dentry->mutex);
	dentry->ref_count = 0;
	memset(&dentry->chunk_tree, 0, sizeof(struct chunk_tree));
	dentry->secret_chunk = NULL;

	if (parent) {
		locked_inc(&parent->ref_count, parent->ddent_mutex);
		assert(ddent_cnode != NULL);
		assert(!IS_ERR(ddent_cnode));
		dentry_ptr(dentry) = dentry;
	}

	return dentry;
}
Example #13
0
void Init_rbcoremidi()
{
    init_mutex();
    
    init_midi_data();
    
    install_at_exit_handler();
    
    mCoreMIDI = rb_define_module("CoreMIDI");
    mCoreMIDIAPI = rb_define_module_under(mCoreMIDI, "API");
    
    rb_define_singleton_method(mCoreMIDIAPI, "create_input_port", t_create_input_port, 2);
    rb_define_singleton_method(mCoreMIDIAPI, "create_client", t_create_client, 1);
    rb_define_singleton_method(mCoreMIDIAPI, "get_sources", t_get_sources, 0);
    rb_define_singleton_method(mCoreMIDIAPI, "get_num_sources", t_get_num_sources, 0);
    rb_define_singleton_method(mCoreMIDIAPI, "connect_source_to_port", t_connect_source_to_port, 2);
    rb_define_singleton_method(mCoreMIDIAPI, "disconnect_source_from_port", t_disconnect_source_from_port, 2);
    rb_define_singleton_method(mCoreMIDIAPI, "check_for_new_data", t_check_for_new_data, 0);

    // Define CoreMIDI::API::InputPort class
    cInputPort = rb_define_class_under(mCoreMIDIAPI, "InputPort", rb_cObject);
    rb_define_alloc_func(cInputPort, inputport_alloc);
    rb_define_method(cInputPort, "initialize", inputport_initialize, 0);
    
    // Define CoreMIDI::API::MIDIClient class
    cMIDIClient = rb_define_class_under(mCoreMIDIAPI, "MIDIClient", rb_cObject);
    rb_define_alloc_func(cMIDIClient, midiclient_alloc);
    rb_define_method(cMIDIClient, "initialize", midiclient_initialize, 0);
}
Example #14
0
/**
 * Re-allocate memory
 *
 * @param mem   pointer to previously talloc'ed memory
 * @param size  amount of memory requested
 *
 * @return a pointer to the allocated memory if successful, NULL otherwise
 */
void* trealloc ( void* mem, size_t size ) {

	if (mutex == NULL) {
		init_mutex();
	}
	pthread_mutex_lock(mutex);
	void **header[3], **aux;

	if ( !mem ) { 
		pthread_mutex_unlock(mutex);
		return talloc( size, NULL );
	}

	header[0] = ((void**)mem)[-3];
	header[1] = ((void**)mem)[-2];
	header[2] = ((void**)mem)[-1];

	aux = realloc( (void**)mem - 3, size + sizeof( void* ) * 3 );
	if ( !aux ) { 
		pthread_mutex_unlock(mutex);
		return NULL;
	}

	if ( (void**)mem - 3 != aux ) {

		aux[0] = header[0];
		aux[1] = header[1];
		aux[2] = header[2];
		if ( aux[0] ) header[0][2] = aux;
		if ( aux[1] ) header[1][2] = aux;
		if ( aux[2] ) header[2][ header[2][1] == (void**)mem - 3 ] = aux;
	}
	pthread_mutex_unlock(mutex);
	return aux + 3;
}
Example #15
0
/* support for malloc.h */
void init_mem(void *buffer, unsigned int size)
{
#	ifdef SAFE
	init_mutex(&malloc_mutex);
#	endif
	_mem_init((unsigned int)buffer, (unsigned int)buffer + size);
}
Example #16
0
static VALUE 
rb_mutex_alloc(VALUE klass)
{
    Mutex *mutex;
    mutex = ALLOC(Mutex);
    init_mutex(mutex);
    return Data_Wrap_Struct(klass, mark_mutex, free_mutex, mutex);
}
Example #17
0
static void
init_queue(Queue *queue)
{
    init_mutex(&queue->mutex);
    init_condvar(&queue->value_available);
    init_condvar(&queue->space_available);
    init_list(&queue->values);
    queue->capacity = 0;
}
Example #18
0
mutex_t *thread_create_mutex(const char *name)
{
    mutex_t *tmp = init_mutex(name);

    if (!tmp) {
        kernel_panic("cannot create a mutex.\n");
    }

    return (tmp);
}
Example #19
0
void init_scheduler()
{
	if(num_Thread==0)
	{
		th_t *mainThread, *scheduleThread;
		
		if((mainThread = thread_alloc()) == NULL)
			abort();
			
		if((scheduleThread = thread_alloc()) == NULL)
			abort();
		init_sigaction();	
		
		if((ready_queueHead = queueHead_alloc()) == NULL)
			abort();
			
		if((sched_queueHead = queueHead_alloc()) == NULL)
			abort();
			
		th_queue_init(ready_queueHead);
		th_queue_init(sched_queueHead);
		
		//th_queue_init(&kernel_queue);
		mainThread->mctx.status = TH_WAITING;
		mainThread->mctx.stackAddr = NULL;
		mainThread->tid = num_Thread++;
		scheduleThread->mctx.status = TH_SCHED;
		//scheduleThread->tid = num_kernel_thread++;
		main_kernel_id = scheduleThread->tid = getpid();
		num_kernel_thread++;
		

		if((scheduleThread->mctx.stackAddr = stack_alloc()) == NULL)
			abort();
			
		if((mainThread->mctx.stackAddr = stack_alloc()) == NULL)
			abort();
			
		//create machine context
		void (*fnptr)(void*) = (void(*)(void*))scheduler;
		mctx_create(&(scheduleThread->mctx), fnptr, NULL, scheduleThread->mctx.stackAddr, STACK_SIZE);

	//		mctx_create(&mctx_list[0],fnptr,NULL,mctx_list[0].stackAddr,STACK_SIZE);

		th_queue_insert(sched_queueHead, PRIORITY_SCHEDULER, scheduleThread);
		
		th_queue_insert(ready_queueHead, PRIORITY_NORMAL, mainThread);		
		
		init_sigaction();
		init_mutex();
		//th_queue_insert(&kernel_queue, PRIORITY_SCHEDULER, scheduleThread);
		switch_to_scheduler();	//jump to scheduler
	}
}
Example #20
0
int hac_create_http_access(MediaPlayer* player, int port, HTTPAccess** access)
{
    HTTPAccess* newAccess;

    CALLOC_ORET(newAccess, HTTPAccess, 1);

    CHK_OFAIL(har_create_resources(&newAccess->resources));

    newAccess->control = ply_get_media_control(player);
    if (newAccess->control == NULL)
    {
        fprintf(stderr, "Media player has no control\n");
        goto fail;
    }

    newAccess->playerListener.data = newAccess;
    newAccess->playerListener.frame_displayed_event = hac_frame_displayed_event;
    newAccess->playerListener.frame_dropped_event = hac_frame_dropped_event;
    newAccess->playerListener.state_change_event = hac_state_change_event;
    newAccess->playerListener.end_of_source_event = hac_end_of_source_event;
    newAccess->playerListener.start_of_source_event = hac_start_of_source_event;
    newAccess->playerListener.player_closed = hac_player_closed;

    if (!ply_register_player_listener(player, &newAccess->playerListener))
    {
        fprintf(stderr, "Failed to register http access as player listener\n");
        goto fail;
    }

    CHK_OFAIL((newAccess->ctx = shttpd_init(NULL, "document_root", "/dev/null", NULL)) != NULL);
    shttpd_register_uri(newAccess->ctx, "/", &http_player_page, newAccess);
    shttpd_register_uri(newAccess->ctx, "/player.html", &http_player_page, newAccess);
    shttpd_register_uri(newAccess->ctx, "/index.html", &http_player_page, newAccess);
    shttpd_register_uri(newAccess->ctx, "/resources/*", &http_static_content, newAccess);
    shttpd_register_uri(newAccess->ctx, "/player/state.xml", &http_player_state_xml, newAccess);
    shttpd_register_uri(newAccess->ctx, "/player/state.txt", &http_player_state_txt, newAccess);
    shttpd_register_uri(newAccess->ctx, "/player/control/*", &http_player_control, newAccess);
    CHK_OFAIL(shttpd_listen(newAccess->ctx, port, 0));


    CHK_OFAIL(init_mutex(&newAccess->playerStateMutex));
    CHK_OFAIL(create_joinable_thread(&newAccess->httpThreadId, http_thread, newAccess));


    *access = newAccess;
    return 1;

fail:
    hac_free_http_access(&newAccess);
    return 0;
}
Example #21
0
/*
 * pj_init(void).
 * Init PJLIB!
 */
PJ_DEF(pj_status_t) pj_init(void)
{
    char dummy_guid[PJ_GUID_MAX_LENGTH];
    pj_str_t guid;
    pj_status_t rc;

#if PJ_HAS_THREADS
    /* Init this thread's TLS. */
    if ((rc=pj_thread_init()) != 0) {
	return rc;
    }

    /* Critical section. */
    if ((rc=init_mutex(&critical_section, "critsec", PJ_MUTEX_RECURSE)) != 0)
	return rc;

#endif

    /* Init logging */
    pj_log_init();

    /* Initialize exception ID for the pool. 
     * Must do so after critical section is configured.
     */
    rc = pj_exception_id_alloc("PJLIB/No memory", &PJ_NO_MEMORY_EXCEPTION);
    if (rc != PJ_SUCCESS)
        return rc;
    
    /* Init random seed. */
    /* Or probably not. Let application in charge of this */
    /* pj_srand( clock() ); */

    /* Startup GUID. */
    guid.ptr = dummy_guid;
    pj_generate_unique_string( &guid );

    /* Startup timestamp */
#if defined(PJ_HAS_HIGH_RES_TIMER) && PJ_HAS_HIGH_RES_TIMER != 0
    {
	pj_timestamp dummy_ts;
	if ((rc=pj_get_timestamp(&dummy_ts)) != 0) {
	    return rc;
	}
    }
#endif   

    PJ_LOG(4,(THIS_FILE, "pjlib %s for POSIX initialized",
	      PJ_VERSION));

    return PJ_SUCCESS;
}
Example #22
0
locker::locker(bool use_mutex /* = true */, bool use_spinlock /* = false */)
: pFile_(NULL)
, myFHandle_(false)
{
	fHandle_ = ACL_FILE_INVALID;
	if (use_mutex)
		init_mutex(use_spinlock);
	else
	{
		mutex_ = NULL;
#ifdef	ACL_HAS_SPINLOCK
		spinlock_ = NULL;
#endif
	}
}
Example #23
0
/**
 * Allocate zeroed memory
 *
 * @param size    amount of memory requested
 * @param parent  pointer to previously talloc'ed memory from wich this chunk
 *                depends or NULL
 *
 * @return a pointer to the allocated memory
 */
void* tcalloc ( size_t size, void* parent ) {

	if (mutex == NULL) {
		init_mutex();
	}
	pthread_mutex_lock(mutex);
	void **mem = calloc( 1, size + sizeof( void* ) * 3 );
	if ( !mem ) { 
		pthread_mutex_unlock(mutex);
		return NULL;
	}

	talloc_set_parent( mem + 3, parent );
	pthread_mutex_unlock(mutex);
	return mem + 3;
}
Example #24
0
/*
 * allocate a queue 
 * our event is auto-reset and initially reset
 */
TASKQ *task_allocq (int numthreads, int timeout)
{
  TASKQ *q;

  q = (TASKQ *) malloc (sizeof (TASKQ));
  init_mutex (q);
  init_ready (q, FALSE);
  q->timeout = timeout;
  q->queue = NULL;
  q->pool = NULL;
  q->maxthreads = numthreads;
  q->running = 0;
  q->waiting = 0;
  q->stop = 0;
  return (q);
}
Example #25
0
/**
 * Free memory
 *
 * @param mem  pointer to previously talloc'ed memory
 */
void tfree ( void* mem ) {
	if ( !mem ) return;

	if (mutex == NULL) {
		init_mutex();
	}
	pthread_mutex_lock(mutex);

	talloc_set_parent( mem, NULL );

	__tfree( ((void**)mem)[-3] );

	free( (void**)mem - 3 );
	
	pthread_mutex_unlock(mutex);
	
}
Example #26
0
int init_dv_decoder_resources()
{
    if (g_decoderResourceRefCount == 0)
    {
        av_register_all();

        memset(&g_decoderResource, 0, sizeof(DVDecoderResource));
        CHK_ORET(init_mutex(&g_decoderResource.resourceMutex));
        g_decoderResourceRefCount = 1;
    }
    else
    {
        g_decoderResourceRefCount++;
    }

    return 1;
}
Example #27
0
static char *sqlite_chunkdb_ctor(const char *spec, struct chunk_db *chunk_db)
{
	struct db_info *db_info = chunk_db->db_info;
	int error;

	init_mutex(&db_info->mutex);

	error = sqlite3_open(spec, &db_info->db);
	if (error != SQLITE_OK) {
		char *errstr = sprintf_new(
				"Can't open SQLite database '%s': %s.",
				spec, sqlite3_errmsg(db_info->db));
		sqlite3_close(db_info->db);
		return errstr;
	}

	return 0;
}
Example #28
0
	//init.
static int32_t init( struct CSession_t *pThis, const CSessionParam *pSessionParam )
{
	int32_t iRetCode = -1;
	
	if ( !pThis || !pSessionParam )
		return iRetCode;
	
	if ( init_mutex( &( pThis->Locker ) ) < 0 )
		return iRetCode;	
	
	lock( &( pThis->Locker ) );	
	
	iRetCode = init_http_socket( pThis, pSessionParam );
	
	unlock( &( pThis->Locker ) );
	
	return iRetCode;
}
Example #29
0
static void init(void)
{
    int i;
    char *s;
    char *error;
    struct rlimit rlim;

    getrlimit(RLIMIT_NOFILE, &rlim);
    max_fds=(int) rlim.rlim_max;

    fds=(struct fadv_info *) malloc(max_fds * sizeof(struct fadv_info));

    assert(fds != NULL);

    _original_open = (int (*)(const char *, int, mode_t)) dlsym(RTLD_NEXT, "open");
    _original_open64 = (int (*)(const char *, int, mode_t)) dlsym(RTLD_NEXT, "open64");
    _original_creat = (int (*)(const char *, int, mode_t)) dlsym(RTLD_NEXT, "creat");
    _original_creat64 = (int (*)(const char *, int, mode_t)) dlsym(RTLD_NEXT, "creat64");
    _original_openat = (int (*)(int, const char *, int, mode_t)) dlsym(RTLD_NEXT, "openat");
    _original_openat64 = (int (*)(int, const char *, int, mode_t)) dlsym(RTLD_NEXT, "openat64");
    _original_dup = (int (*)(int)) dlsym(RTLD_NEXT, "dup");
    _original_dup2 = (int (*)(int, int)) dlsym(RTLD_NEXT, "dup2");
    _original_close = (int (*)(int)) dlsym(RTLD_NEXT, "close");
    _original_fopen = (FILE *(*)(const char *, const char *)) dlsym(RTLD_NEXT, "fopen");
    _original_fopen64 = (FILE *(*)(const char *, const char *)) dlsym(RTLD_NEXT, "fopen64");
    _original_fclose = (int (*)(FILE *)) dlsym(RTLD_NEXT, "fclose");

    if ((error = dlerror()) != NULL)  {
        fprintf(stderr, "%s\n", error);
        exit(EXIT_FAILURE);
    }

    if((s = getenv(env_nr_fadvise)) != NULL)
        nr_fadvise = atoi(s);
    if(nr_fadvise <= 0)
        nr_fadvise = 1;

    PAGESIZE = getpagesize();
    for(i = 0; i < max_fds; i++)
        fds[i].fd = -1;
    init_mutex();
    init_debugging();
    handle_stdout();
}
Example #30
0
void sync_threads() {

    //init the mutex variables
    init_mutex();

    //create thread ids
    pthread_t tid[THREADS];

    pthread_create(&tid[0], NULL, thread0, NULL);
    pthread_create(&tid[1], NULL, thread1, NULL);
    pthread_create(&tid[2], NULL, thread2, NULL);

    pthread_join(tid[0], NULL);
    pthread_join(tid[1], NULL);
    pthread_join(tid[2], NULL);

    sem_destroy(&mutex[0]);
    sem_destroy(&mutex[1]);
    sem_destroy(&mutex[2]);
}