Esempio n. 1
0
    void run() {
/**
 * note: this test will deadlock if the code breaks
 */

#if defined(__linux__) || defined(__APPLE__)

        // create
        pthread_rwlock_t lk;
        verify(pthread_rwlock_init(&lk, 0) == 0);

        // read lock
        verify(pthread_rwlock_rdlock(&lk) == 0);

        AtomicUInt32 x1(0);
        stdx::thread t1(stdx::bind(worker1, &lk, &x1));
        while (!x1.load())
            ;
        verify(x1.load() == 1);
        sleepmillis(500);
        verify(x1.load() == 1);

        AtomicUInt32 x2(0);

        stdx::thread t2(stdx::bind(worker2, &lk, &x2));
        t2.join();
        verify(x2.load() == 1);

        pthread_rwlock_unlock(&lk);

        for (int i = 0; i < 2000; i++) {
            if (x1.load() == 2)
                break;
            sleepmillis(1);
        }

        verify(x1.load() == 2);
        t1.join();
#endif
    }
Esempio n. 2
0
Region::Region(Palette* p, int i) {

	spritelist = new SpriteList();

	id = i;
	name = "";
	SetTypeAndSid(UNKNOWN, 0, 0);

	_loop = NULL;
	_disableNotes = false;

	palette = p;
	_lastScheduled = -1;
	_chording = false;
	_looping = DEFAULT_LOOPING;

	NosuchLockInit(&_region_mutex,"region");
	// spritelist_rwlock = PTHREAD_RWLOCK_INITIALIZER;
	cursorlist_rwlock = PTHREAD_RWLOCK_INITIALIZER;
	// int rc1 = pthread_rwlock_init(&spritelist_rwlock, NULL);
	int rc = pthread_rwlock_init(&cursorlist_rwlock, NULL);
	if ( rc ) {
		NosuchDebug("Failure on pthread_rwlock_init!? rc=%d",rc);
	}

	_latestNoteTime = 0;
	x_min = 0.00f;
	y_min = 0.00f;
	x_max = 1.0f;
	y_max = 1.0f;
	_channel = -1;

	PaletteHost* ph = p->paletteHost();
	_graphicBehaviour = ph->makeGraphicBehaviour(this);
	_musicBehaviour = ph->makeMusicBehaviour(this);

	_noteBehaviour = new NoteBehaviourDefault(this);

	initParams();
}
Esempio n. 3
0
TEST(sfrlock, uncontended_write_cost) {
  double t;
  double r;
  pthread_mutex_t mutex;
  pthread_rwlock_t rwlock;
  sfrlock_t sfrlock;

  sfrlock_init(&sfrlock);
  pthread_rwlock_init(&rwlock, nullptr);
  pthread_mutex_init(&mutex, nullptr);

  r = measure_time([&] () {
        for (unsigned cnt = repeat; cnt; cnt--) {
          sfrlock_wrlock(&sfrlock);
          sfrlock_wrunlock(&sfrlock);
        }
      });
  printf("sfrlock_t time: %lf ms\n", r / 1e6);

  t = measure_time([&] () {
        for (unsigned cnt = repeat; cnt; cnt--) {
          pthread_rwlock_wrlock(&rwlock);
          pthread_rwlock_unlock(&rwlock);
        }
      });
  printf("pthread_rwlock_t time: %lf ms (%+.2lf%%)\n", t / 1e6,
         -(1 - (t / r)) * 100);

  t = measure_time([&] () {
        for (unsigned cnt = repeat; cnt; cnt--) {
          pthread_mutex_lock(&mutex);
          pthread_mutex_unlock(&mutex);
        }
      });
  printf("pthread_mutex_t time: %lf ms (%+.2lf%%)\n", t / 1e6,
         -(1 - (t / r)) * 100);

  pthread_rwlock_destroy(&rwlock);
  pthread_mutex_destroy(&mutex);
}
Esempio n. 4
0
ESFReadWriteLock::ESFReadWriteLock() :
    _magic(0) {
#ifdef HAVE_PTHREAD_RWLOCK_INIT

    if (0 == pthread_rwlock_init(&_lock, 0)) {
        _magic = ESF_MAGIC;
    }

#elif defined HAVE_PTHREAD_MUTEX_INIT && defined HAVE_PTHREAD_COND_INIT && \
      defined HAVE_PTHREAD_MUTEX_DESTROY && defined HAVE_PTHREAD_COND_DESTROY

    if ( 0 != pthread_mutex_init( &_lock._mutex, 0 ) )
    {
        return;
    }

    if ( 0 != pthread_cond_init( &_lock._readSignal, 0 ) )
    {
        pthread_mutex_destroy( &_lock._mutex );
        return;
    }

    if ( 0 != pthread_cond_init( &_lock._writeSignal, 0 ) )
    {
        pthread_mutex_destroy( &_lock._mutex );
        pthread_cond_destroy( &_lock._readSignal );
        return;
    }

    _lock._readersActive = 0;
    _lock._readersWaiting = 0;
    _lock._writersActive = 0;
    _lock._writersWaiting = 0;

    _magic = ESF_MAGIC;

#else
#error "Platform has no rw lock initializer"
#endif
}
Esempio n. 5
0
void dt_control_init(dt_control_t *s)
{
  memset(s->vimkey, 0, sizeof(s->vimkey));
  s->vimkey_cnt = 0;

  // same thread as init
  s->gui_thread = pthread_self();

  // initialize static mutex
  dt_pthread_mutex_init(&_control_gdk_lock_threads_mutex, NULL);

  // s->last_expose_time = dt_get_wtime();
  s->key_accelerators_on = 1;
  s->log_pos = s->log_ack = 0;
  s->log_busy = 0;
  s->log_message_timeout_id = 0;
  dt_pthread_mutex_init(&(s->log_mutex), NULL);
  s->progress = 200.0f;

  dt_conf_set_int("ui_last/view", DT_MODE_NONE);

  pthread_cond_init(&s->cond, NULL);
  dt_pthread_mutex_init(&s->cond_mutex, NULL);
  dt_pthread_mutex_init(&s->queue_mutex, NULL);
  dt_pthread_mutex_init(&s->run_mutex, NULL);
  pthread_rwlock_init(&s->xprofile_lock, NULL);
  dt_pthread_mutex_init(&(s->global_mutex), NULL);
  dt_pthread_mutex_init(&(s->progress_system.mutex), NULL);

  // start threads
  dt_control_jobs_init(s);

  s->button_down = 0;
  s->button_down_which = 0;
  s->mouse_over_id = -1;
  s->dev_closeup = 0;
  s->dev_zoom_x = 0;
  s->dev_zoom_y = 0;
  s->dev_zoom = DT_ZOOM_FIT;
}
Esempio n. 6
0
/* init function (must be called once) */
rsRetVal
dnscacheInit(void)
{
    DEFiRet;
    if((dnsCache.ht = create_hashtable(100, hash_from_key_fn, key_equals_fn,
                                       (void(*)(void*))entryDestruct)) == NULL) {
        DBGPRINTF("dnscache: error creating hash table!\n");
        ABORT_FINALIZE(RS_RET_ERR); // TODO: make this degrade, but run!
    }
    dnsCache.nEntries = 0;
    pthread_rwlock_init(&dnsCache.rwlock, NULL);
    CHKiRet(objGetObjInterface(&obj)); /* this provides the root pointer for all other queries */
    CHKiRet(objUse(glbl, CORE_COMPONENT));
    CHKiRet(objUse(errmsg, CORE_COMPONENT));
    CHKiRet(objUse(prop, CORE_COMPONENT));

    prop.Construct(&staticErrValue);
    prop.SetString(staticErrValue, (uchar*)"???", 3);
    prop.ConstructFinalize(staticErrValue);
finalize_it:
    RETiRet;
}
Esempio n. 7
0
DICTIONARY *dictionary_create(uint32_t flags) {
	debug(D_DICTIONARY, "Creating dictionary.");

	DICTIONARY *dict = calloc(1, sizeof(DICTIONARY));
	if(unlikely(!dict)) fatal("Cannot allocate DICTIONARY");

	if(flags & DICTIONARY_FLAG_WITH_STATISTICS) {
		dict->stats = calloc(1, sizeof(struct dictionary_stats));
		if(!dict->stats) fatal("Cannot allocate statistics for DICTIONARY");
	}

	if(!(flags & DICTIONARY_FLAG_SINGLE_THREADED)) {
		dict->rwlock = calloc(1, sizeof(pthread_rwlock_t));
		if(!dict->rwlock) fatal("Cannot allocate pthread_rwlock_t for DICTIONARY");
		pthread_rwlock_init(dict->rwlock, NULL);
	}

	avl_init(&dict->values_index, name_value_compare);
	dict->flags = flags;

	return dict;
}
Esempio n. 8
0
File: serwer.c Progetto: Solmis/SO
int main(int argc, char *argv[])
{
    L = atol(argv[1]);
    K = atol(argv[2]);
    M = atol(argv[3]);

    if (signal(SIGINT, exit_server) == SIG_ERR)
        syserr("Error in signal (SIGINT)");

    init_queues();

    int thr_err;
    pthread_t thread_id;
    make_attr_detached();
    if (thr_err = pthread_rwlock_init(&rwlock, NULL))
        syserr_ext(thr_err, "Error in function pthread_rwlock_init");

    Mesg mesg;
    int bytes_rcvd;
    while (1)
    {
        if ((bytes_rcvd = msgrcv(msg_rcv_id, &mesg, MAX_BUFF, 0, 0)) <= 0)
            syserr("Error in msgrcv (receiving type(pid))");
        mesg.mesg_data[bytes_rcvd] = '\0';

        if (mesg.mesg_type == READ_TYPE_KOM)
        {
            if ((thr_err = pthread_create(&thread_id, &attr, serve_committee, &mesg.mesg_data)) != 0)
                syserr_ext(thr_err, "Error in pthread_create (for serve_committee)");
        }
        else
        {
            if ((thr_err = pthread_create(&thread_id, &attr, serve_report, &mesg.mesg_data)) != 0)
                syserr_ext(thr_err, "Error in pthread_create (for serve_report)");
        }
    }

    exit_server(0);
}
Esempio n. 9
0
static void
init_read_write_lock(pthread_rwlock_t* lock)
{
    pthread_rwlockattr_t* pattr;
#if defined(YOG_HAVE_PTHREAD_RWLOCKATTR_INIT)
    pthread_rwlockattr_t attr;
    pthread_rwlockattr_init(&attr);
#   if defined(YOG_HAVE_PTHREAD_RWLOCKATTR_SETKIND_NP)
    pthread_rwlockattr_setkind_np(&attr, PTHREAD_RWLOCK_PREFER_WRITER_NP);
#   endif
    pattr = &attr;
#else
    pattr = NULL;
#endif
    int err;
    if ((err = pthread_rwlock_init(lock, pattr)) != 0) {
        YOG_BUG(NULL, "pthread_rwlock_init failed: %s", strerror(err));
    }
#if defined(YOG_HAVE_PTHREAD_RWLOCKATTR_INIT) && defined(YOG_HAVE_PTHREAD_RWLOCKATTR_DESTROY)
    pthread_rwlockattr_destroy(&attr);
#endif
}
Esempio n. 10
0
/* The user must define this function if she wants to use the node
   cache.  Create and initialize a node.  */
error_t
diskfs_user_make_node (struct node **npp, struct lookup_context *ctx)
{
  struct node *np;
  struct disknode *dn;

  /* Create the new node.  */
  np = diskfs_make_node_alloc (sizeof *dn);
  if (np == NULL)
    return ENOMEM;

  /* Format specific data for the new node.  */
  dn = diskfs_node_disknode (np);
  dn->dirents = 0;
  dn->dir_idx = 0;
  dn->pager = 0;
  pthread_rwlock_init (&dn->alloc_lock, NULL);
  pokel_init (&dn->indir_pokel, diskfs_disk_pager, disk_cache);

  *npp = np;
  return 0;
}
Esempio n. 11
0
int main(int argc, char** argv)
{
  pthread_t thread1;
  pthread_t thread2;

#if 0

  VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DRD_TRACE_ADDR,
                                  &s_racy, 0, 0, 0, 0, 0);
#endif

  pthread_rwlock_init(&s_rwlock, 0);
  pthread_create(&thread1, 0, thread_func, 0);
  pthread_create(&thread2, 0, thread_func, 0);
  pthread_join(thread1, 0);
  pthread_join(thread2, 0);
  pthread_rwlock_destroy(&s_rwlock);

  fprintf(stderr, "Result: %d\n", s_racy);

  return 0;
}
int main(int argc, char **argv)
{
	int retval, i;

	pthread_t writer_id, reader_id;
	pthread_attr_t attr;
	int nreadercount = 1, nwritercount = 1;

	if (argc != 2) {
		fprintf(stderr, "usage, <%s threadcount>", argv[0]);
		return -1;
	}
	retval = pthread_rwlock_init(&rwlock, NULL);
	if (retval) {
		fprintf(stderr, "init lock failed\n");
		return retval;
	}
	pthread_attr_init(&attr);
	//pthread_attr_setdetachstate用来设置线程的分离状态
	//也就是说一个线程怎么样终止自己,状态设置为PTHREAD_CREATE_DETACHED
	//表示以分离状态启动线程
	pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
	
	//分别在main函数中对读出者和写入者加锁,得到的处理结果是不一样的
	pthread_rwlock_wrlock(&rwlock);
//	pthread_rwlock_rdlock(&rwlock);
	for (i = 0; i < atoi(argv[1]); i++) {
		if (random() % 2) {
			pthread_create(&reader_id, &attr, readers, (void *)nreadercount);
			printf("create reader %d\n", nreadercount++);
		} else {
			pthread_create(&writer_id, &attr, writers, (void *)nwritercount);
			printf("create writer %d\n", nwritercount++);
		}
	}
	pthread_rwlock_unlock(&rwlock);
	sleep(20);//sleep是为了等待另外的线程的执行
	return 0;	
}
Esempio n. 13
0
int init_mapping()
{
	int i;
	for (i = 0; i < MAP_TABLE_SIZE; i++) {
		memset(&(ip_map_table[i]), 0, sizeof(struct ip_map_table_node));
		if (pthread_rwlock_init(&(ip_map_table[i].rwlock), NULL) != 0) {
			fprintf(stderr, "Error initialize mutex for map-table\n");
			return(1);
		}
	}
	for (i = 0; i < HASH_TABLE_SIZE; i++) {
		memset(&(hash_table[i]), 0, sizeof(struct hash_table_array_node));
		if (pthread_mutex_init(&(hash_table[i].mutex), NULL) != 0) {
			fprintf(stderr, "Error initialize mutex for hash-table\n");
			return(1);
		}
	}
	for (i = 0; i < VSERVER_MAXSIZE; i++) {
		memset(&(vserver_list[i]), 0, sizeof(struct vserver_list_node));
	}
	return(0);
}
Esempio n. 14
0
// create a file handle from an fs_entry
struct fs_file_handle* fs_file_handle_create( struct fs_core* core, struct fs_entry* ent, char const* opened_path, uint64_t parent_id, char const* parent_name ) {
    struct fs_file_handle* fh = SG_CALLOC( struct fs_file_handle, 1 );
    fh->flags = 0;
    fh->open_count = 0;
    fh->fent = ent;
    fh->volume = ent->volume;
    fh->file_id = ent->file_id;
    fh->path = strdup( opened_path );
    fh->parent_name = strdup( parent_name );
    fh->parent_id = parent_id;
    fh->transfer_timeout_ms = (core->conf->transfer_timeout) * 1000L;
    fh->dirty = false;

    uint64_t gateway_type = ms_client_get_gateway_type( core->ms, ent->coordinator );
    if( gateway_type == SYNDICATE_AG ) {
        fh->is_AG = true;
    }

    pthread_rwlock_init( &fh->lock, NULL );

    return fh;
}
Esempio n. 15
0
/* Initialize TPCLog LOG to use the provided DIRNAME to store its associated
 * entries. Sets LOG's NEXTID field based on the entries that currently exist
 * in DIRNAME. */
int tpclog_init(tpclog_t *log, char *dirname) {
  struct stat st;
  unsigned long nextid = 0;
  char filename[MAX_FILENAME];
  if (stat(dirname, &st) == -1) {
    if (mkdir(dirname, 0700) == -1)
      return errno;
  }
  log->dirname = malloc(strlen(dirname) + 1);
  if (!log->dirname)
    fatal_malloc();
  strcpy(log->dirname, dirname);
  pthread_rwlock_init(&log->lock, NULL);

  /* Iterate through entries to determine next available ID, since this log may
   * be recovering from a crash. */
  sprintf(filename, "%s/%lu%s", log->dirname, nextid++, TPCLOG_FILETYPE);
  while (stat(filename, &st) != -1)
    sprintf(filename, "%s/%lu%s", log->dirname, nextid++, TPCLOG_FILETYPE);
  log->nextid = nextid - 1;
  return 0;
}
Esempio n. 16
0
int main(void)
{
	int i;

	thread = (void *)malloc(NTASKS*sizeof(pthread_t));
	task = (void *)malloc(NTASKS*sizeof(RT_TASK *));
	pthread_setschedparam_np(2*NTASKS, SCHED_FIFO, 0, 0x1, PTHREAD_HARD_REAL_TIME_NP);
	pthread_rwlock_init(rwl = &rwls, 0);
	pthread_barrier_init(&barrier, NULL, NTASKS + 1);
	rt_set_oneshot_mode();
	start_rt_timer(0);
	for (i = 0; i < NTASKS; i++) {
		pthread_create(&thread[i], NULL, (void *)thread_fun, (void *)(i + 1));
	}
	pthread_barrier_wait(&barrier);
	pthread_rwlock_destroy(rwl);
	pthread_barrier_destroy(&barrier);
	stop_rt_timer();
	free(thread);
	free(task);
	return 0;
}
Esempio n. 17
0
lagopus_result_t
lagopus_rwlock_reinitialize(lagopus_rwlock_t *rwlptr) {
  lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;

  if (rwlptr != NULL &&
      *rwlptr != NULL) {
    int st;

    errno = 0;
    if ((st = pthread_rwlock_init(&((*rwlptr)->m_rwl), NULL)) == 0) {
      (*rwlptr)->m_prev_cancel_state = -INT_MAX;
      ret = LAGOPUS_RESULT_OK;
    } else {
      errno = st;
      ret = LAGOPUS_RESULT_POSIX_API_ERROR;
    }
  } else {
    ret = LAGOPUS_RESULT_INVALID_ARGS;
  }

  return ret;
}
Esempio n. 18
0
int main(int argc, char *argv[])
{
	/* rwlock init */
	pthread_rwlock_init(&sync.rwlock, NULL);
	/* data init */
	sync.data = 0;
	/* create thread 10 */
	int i;
	pthread_t ptrdid;
	for (i = 0; 10 > i; i++) {
		if (0 == i)
			pthread_create(&ptrdid, NULL, pthread_wr, NULL);
		else
			pthread_create(&ptrdid, NULL, pthread_rd, NULL);
		usleep(1000 * 100);
	}
	for ( ; ; )
		pause();
	/* rwlock destroy */
	pthread_rwlock_destroy(&sync.rwlock);
	return 0;
}
Esempio n. 19
0
static struct tc_device *tc_device_create(char *id)
{
	struct tc_device *d = tc_device_index_find(id, 0);

	if(!d) {
		debug(D_TC_LOOP, "TC: Creating device '%s'", id);

		d = calloc(1, sizeof(struct tc_device));
		if(!d) {
			fatal("Cannot allocate memory for tc_device %s", id);
			return NULL;
		}

		d->id = strdup(id);
		d->hash = simple_hash(d->id);

		d->classes_index.root = NULL;
		d->classes_index.compar = tc_class_compare;
#ifdef AVL_LOCK_WITH_MUTEX
		pthread_mutex_init(&d->classes_index.mutex, NULL);
#else
		pthread_rwlock_init(&d->classes_index.rwlock, NULL);
#endif

		tc_device_index_add(d);

		if(!tc_device_root) {
			tc_device_root = d;
		}
		else {
			d->next = tc_device_root;
			tc_device_root->prev = d;
			tc_device_root = d;
		}
	}

	return(d);
}
Esempio n. 20
0
int
ptw32_rwlock_check_need_init (pthread_rwlock_t * rwlock)
{
    int result = 0;
    ptw32_mcs_local_node_t node;

    /*
     * The following guarded test is specifically for statically
     * initialised rwlocks (via PTHREAD_RWLOCK_INITIALIZER).
     */
    ptw32_mcs_lock_acquire(&ptw32_rwlock_test_init_lock, &node);

    /*
     * We got here possibly under race
     * conditions. Check again inside the critical section
     * and only initialise if the rwlock is valid (not been destroyed).
     * If a static rwlock has been destroyed, the application can
     * re-initialise it only by calling pthread_rwlock_init()
     * explicitly.
     */
    if (*rwlock == PTHREAD_RWLOCK_INITIALIZER)
    {
        result = pthread_rwlock_init (rwlock, NULL);
    }
    else if (*rwlock == NULL)
    {
        /*
         * The rwlock has been destroyed while we were waiting to
         * initialise it, so the operation that caused the
         * auto-initialisation should fail.
         */
        result = EINVAL;
    }

    ptw32_mcs_lock_release(&node);

    return result;
}
Esempio n. 21
0
int main(int argc, char** argv) {
	signal(SIGINT, stopHandler); /* catches ctrl-c */
#ifdef UA_MULTITHREADING
	pthread_rwlock_init(&writeLock, 0);
#endif

	UA_Server *server = UA_Server_new(UA_ServerConfig_standard);
	logger = Logger_Stdout_new();
	UA_Server_setLogger(server, logger);
    UA_ByteString certificate = loadCertificate();
    UA_Server_setServerCertificate(server, certificate);
    UA_ByteString_deleteMembers(&certificate);
	UA_Server_addNetworkLayer(server, ServerNetworkLayerTCP_new(UA_ConnectionConfig_standard, 16664));

	// add node with the datetime data source
	UA_DataSource dateDataSource = (UA_DataSource)
        {.handle = NULL,
		.read = readTimeData,
		.release = releaseTimeData,
		.write = NULL};
	const UA_QualifiedName dateName = UA_QUALIFIEDNAME(1, "current time");
	UA_Server_addDataSourceVariableNode(server, dateDataSource, dateName, UA_NODEID_NULL,
                                        UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER),
                                        UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES));

	//cpu temperature monitoring for linux machines
	if((temperatureFile = fopen("/sys/class/thermal/thermal_zone0/temp", "r"))){
		// add node with the data source
		UA_DataSource temperatureDataSource = (UA_DataSource)
    	    {.handle = NULL,
			.read = readTemperature,
			.release = releaseTemperature,
			.write = NULL};
		const UA_QualifiedName tempName = UA_QUALIFIEDNAME(1, "cpu temperature");
		UA_Server_addDataSourceVariableNode(server, temperatureDataSource, tempName, UA_NODEID_NULL,
                                            UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER),
                                            UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES));
	}
Esempio n. 22
0
krad_transmitter_t *krad_transmitter_create () {

	int t;
	krad_transmitter_t *krad_transmitter;

	t = 0;
	krad_transmitter = NULL;
	
	krad_transmitter = calloc (1, sizeof(krad_transmitter_t));

	if (krad_transmitter == NULL) {
		printke ("Krad Transmitter: Out of memory!");
		return NULL;		
	}
	
	krad_transmitter->krad_transmissions = calloc (DEFAULT_MAX_TRANSMISSIONS, sizeof(krad_transmission_t));

	if (krad_transmitter->krad_transmissions == NULL) {
		free (krad_transmitter);
		printke ("Krad Transmitter: Out of memory!");
		return NULL;
	}
	
	for (t = 0; t < DEFAULT_MAX_TRANSMISSIONS; t++) {
		krad_transmitter->krad_transmissions[t].krad_transmitter = krad_transmitter;
	}
	
	pthread_rwlock_init (&krad_transmitter->krad_transmissions_rwlock, NULL);

	krad_transmitter->not_found_len += sprintf (krad_transmitter->not_found + krad_transmitter->not_found_len, "HTTP/1.1 404 Not Found\r\n");
	krad_transmitter->not_found_len += sprintf (krad_transmitter->not_found + krad_transmitter->not_found_len, "Status: 404 Not Found\r\n");
	krad_transmitter->not_found_len += sprintf (krad_transmitter->not_found + krad_transmitter->not_found_len, "Connection: close\r\n");
	krad_transmitter->not_found_len += sprintf (krad_transmitter->not_found + krad_transmitter->not_found_len, "Content-Type: text/html; charset=utf-8\r\n");
	krad_transmitter->not_found_len += sprintf (krad_transmitter->not_found + krad_transmitter->not_found_len, "\r\n404 Not Found");

	return krad_transmitter;

}
Esempio n. 23
0
container_t *container_creator(uint32_t container_type,allocator_t *allocator)
{
	container_t *p;

	p = (container_t *)allocator_mem_alloc(allocator,sizeof(container_t));
	if(p == NULL){
		goto err;
	}

	dbg_str(DBG_CONTAINER_DETAIL,"container_t addr:%p,sizeof_container_struct:%d",p,sizeof(container_t));
	p->container_type = container_type;
	p->allocator = allocator;
	p->c_ops_p = &container_modules[container_type].c_ops;
	p->it_ops_p = &container_modules[container_type].it_ops;
	pthread_rwlock_init(&p->head_lock,NULL);   

	if(p->c_ops_p == NULL || p->it_ops_p == NULL){
		allocator_mem_free(p->allocator,p);
		p = NULL;
	}
err:
	return p;
}
Esempio n. 24
0
C_Para::C_Para()
{
	m_nStartSMSType = 1;
	m_nTimeOutWaitOtherIMonitor = 300;
	m_nDiskCheckDelay = 300;
	m_nEthCheckDelay = 10;
	m_nHallListCheckDelay = 5;
	m_nTMSCheckDelay = 5;
	m_nOtherMonitorCheckDelay = 10;
	m_nOtherTMSCheckDelay = 10;
	m_nOtherSMSCheckDelay = 5;
	m_nOtherRAIDCheckDelay = 5;
	m_nOtherEthCheckDelay = 5;
	m_nOtherSwitchCheckDelay = 5;
	m_nOtherSpeedLmtCheckDelay = 5;
	m_nOtherEWCheckDelay = 5;
	m_nSSD_Raid_Num = 0;
	m_nSATA_Raid_Num = 0;
	m_nDBSynchCheckDelay = 0;

	pthread_rwlock_init(&m_rwlk_main,NULL);

}
Esempio n. 25
0
int main(int argc, char **argv) 
{
    int listenfd, port, clientlen;
    struct sockaddr_in clientaddr;

    /* Check command line args */
    if (argc != 2) {
		fprintf(stderr, "usage: %s <port>\n", argv[0]);
		exit(1);
    }
    Signal(SIGPIPE, SIG_IGN);
    pthread_rwlock_init(&lock, 0);
    port = atoi(argv[1]);
    pthread_t tid;
    proxy_cache = initialize_cache();
    listenfd = Open_listenfd(port);
    while (1) {
		clientlen = sizeof(clientaddr);
		int *connfdp = Malloc(sizeof(int));
		*connfdp = Accept(listenfd, (SA *)&clientaddr, (socklen_t *)&clientlen);
		Pthread_create(&tid, NULL, doit_thread, connfdp);
    }
}
Esempio n. 26
0
DWORD
VmDirInitializeRWLockContent(
    PVMDIR_RWLOCK   pLock
    )
{
    DWORD dwError = 0;

    if (!pLock || pLock->bInitialized)
    {
        dwError = VMDIR_ERROR_INVALID_PARAMETER;
        BAIL_ON_VMDIR_ERROR(dwError);
    }

    memset(&pLock->lock, 0, sizeof(pthread_mutex_t));

    dwError = pthread_rwlock_init(&pLock->lock, NULL);
    BAIL_ON_VMDIR_ERROR(dwError);

    pLock->bInitialized = TRUE;

error:
    return dwError;
}
Esempio n. 27
0
static TACommandVerdict pthread_rwlock_init_cmd(TAThread thread, TAInputStream stream)
{
    pthread_rwlock_t* rwlock;
    pthread_rwlockattr_t* attr;
    int res;

    // Prepare
    rwlock = readPointer(&stream);
    attr = readPointer(&stream);

    START_TARGET_OPERATION(thread);

    // Execute
    res = pthread_rwlock_init(rwlock, attr);

    END_TARGET_OPERATION(thread);

    // Response
    writeInt(thread, res);
    sendResponse(thread);

    return taDefaultVerdict;
}
Esempio n. 28
0
APR_DECLARE(apr_status_t) apr_thread_rwlock_create(apr_thread_rwlock_t **rwlock,
                                                   apr_pool_t *pool)
{
    apr_thread_rwlock_t *new_rwlock;
    apr_status_t stat;

    new_rwlock = apr_palloc(pool, sizeof(apr_thread_rwlock_t));
    new_rwlock->pool = pool;

    if ((stat = pthread_rwlock_init(&new_rwlock->rwlock, NULL))) {
#ifdef PTHREAD_SETS_ERRNO
        stat = errno;
#endif
        return stat;
    }

    apr_pool_cleanup_register(new_rwlock->pool,
                              (void *)new_rwlock, thread_rwlock_cleanup,
                              apr_pool_cleanup_null);

    *rwlock = new_rwlock;
    return APR_SUCCESS;
}
Esempio n. 29
0
NTSTATUS
SrvElementsConfigSetupInitial(
    VOID
    )
{
    NTSTATUS ntStatus = STATUS_SUCCESS;

    pthread_rwlock_init(&gSrvElements.configLock, NULL);
    gSrvElements.pConfigLock = &gSrvElements.configLock;

    ntStatus = SrvElementsConfigRefresh();
    BAIL_ON_NT_STATUS(ntStatus);

cleanup:

    return ntStatus;

error:

    SrvElementsConfigFree(&gSrvElements.config);

    goto cleanup;
}
Esempio n. 30
0
task task_new(void)
{
    task p;
    int err;

    if ((p = calloc(1, sizeof *p)) == NULL)
        return NULL;

    if ((err = pthread_rwlock_init(&p->sublock, NULL)) != 0) {
        free(p);
        return NULL;
    }

    if ((p->q = fifo_new(METAL_TASK_QUEUE_SIZE)) == NULL) {
        free(p);
        return NULL;
    }

    p->name[0] = '\0';
    p->tid = 0; // system tid. Hmm... -1 is not allowed.

    return p;
}