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 }
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(); }
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); }
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 }
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; }
/* 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; }
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; }
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); }
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 }
/* 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; }
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; }
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); }
// 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; }
/* 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; }
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; }
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; }
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; }
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); }
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; }
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)); }
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; }
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; }
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); }
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); } }
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; }
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; }
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; }
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; }
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; }