/** command "show logging" */ int _dessert_cli_cmd_logging(struct cli_def* cli, char* command, char* argv[], int argc) { pthread_rwlock_rdlock(&_dessert_logrbuf_len_lock); int i = 0; int max = _dessert_logrbuf_len - 1; char* line; if(_dessert_logrbuf_len < 1) { cli_print( cli, "logging to ringbuffer is disabled - use \"logging ringbuffer [int]\" in config-mode first"); pthread_rwlock_unlock(&_dessert_logrbuf_len_lock); return CLI_ERROR; } if(argc == 1) { int max2 = (int) strtol(argv[0], NULL, 10); if(max2 > 0) { max = max2; } } /* where to start and print? */ if(max > _dessert_logrbuf_used) { max = _dessert_logrbuf_used; } i = _dessert_logrbuf_cur - max - 1; if(i < 0) { i += _dessert_logrbuf_len; } while(max > 0) { i++; max--; if(i == _dessert_logrbuf_len) { i = 0; } line = _dessert_logrbuf + (DESSERT_LOGLINE_MAX * i); cli_print(cli, "%s", line); } pthread_rwlock_unlock(&_dessert_logrbuf_len_lock); return CLI_OK; }
void rw_lock_read_lock(rw_lock_t* lock) { #ifdef __MINGW32__ EnterCriticalSection(&lock->readlock); EnterCriticalSection(&lock->lock); lock->readers++; ResetEvent(lock->writelock); LeaveCriticalSection(&lock->lock); LeaveCriticalSection(&lock->readlock); #else pthread_rwlock_rdlock(lock); #endif }
void * writer() { for (int i = 0; i < 5; i++) { pthread_rwlock_rdlock(&rwlock); pthread_rwlock_trywrlock(&rwlock); value += 1; pthread_rwlock_unlock(&rwlock); sleep(i); } pthread_exit(NULL); }
struct list * list_lookup(int lookup_id) { struct list *curr; int rv; rv=pthread_rwlock_rdlock(&rw); // 只讀表,因此以讀模式申請讀寫鎖 check_error(rv, "lookup: read lock"); for (curr=list_head; curr !=NULL; curr=curr->next) // 查詢記錄位置 if (curr->id >= lookup_id) break; if (curr != NULL && curr->id != lookup_id) curr = (struct list *)NULL; // 沒有找到 rv = pthread_rwlock_unlock(&rw); // 釋放讀寫鎖 check_error(rv, "add: write unlock"); return (curr); }
static int cache_get(lua_State * L) { size_t len1,len2; const char * key_l=lua_tolstring(L,1,&len1); char * val=NULL; pthread_rwlock_rdlock(&rwlock); val=hashtable_get(ht,key_l,&len2); //printf("%p %s %u\n",val,val,len2); if(val==NULL) { pthread_rwlock_unlock(&rwlock); return 0; } lua_pushlstring(L,val,len2); pthread_rwlock_unlock(&rwlock); return 1; }
struct gate_info *gate_info_manager_t::get_best_gate_incref(uint64_t uid) { struct gate_info *info = NULL; pthread_rwlock_rdlock(&rwlock); size_t sz = gate_infos.size(); if (sz > 0) { int idx = (int)(uid % (uint64_t)sz); info = gate_infos[idx]; gate_info_incref(info); } pthread_rwlock_unlock(&rwlock); return info; }
void runpath_list_fprintf(runpath_list_type * list ) { pthread_rwlock_rdlock( &list->lock ); { FILE * stream = util_mkdir_fopen( list->export_file , "w"); const char * line_fmt = runpath_list_get_line_fmt( list ); int index; vector_sort( list->list , runpath_node_cmp ); for (index =0; index < vector_get_size( list->list ); index++) { const runpath_node_type * node = runpath_list_iget_node__( list , index ); runpath_node_fprintf( node , line_fmt , stream ); } fclose( stream ); } pthread_rwlock_unlock( &list->lock ); }
/* * Find a job for the given thread ID. */ struct job * job_find(struct queue *qp, pthread_t id) { struct job *jp; if (pthread_rwlock_rdlock(&qp->q_lock) != 0) return NULL; for (jp = qp->q_head; jp != NULL; jp = jp->j_next) if (pthread_equal(jp->j_id, id)) break; pthread_rwlock_unlock(&qp->q_lock); return jp; }
//--------------------------------------------------------------------------------------------------------------------- int pmip_cache_iterate(int (*func) (void *, void *), void *arg) { int err; int mutex_return_code; mutex_return_code = pthread_rwlock_rdlock(&pmip_lock); if (mutex_return_code != 0) { dbg("pthread_rwlock_rdlock(&pmip_lock) %s\n", strerror(mutex_return_code)); } err = pmip_hash_iterate(&g_pmip_hash, func, arg); mutex_return_code = pthread_rwlock_unlock(&pmip_lock); if (mutex_return_code != 0) { dbg("pthread_rwlock_unlock(&pmip_lock) %s\n", strerror(mutex_return_code)); } return err; }
void RateLimiter::Release(int counter_index, const char * key, uint64_t amount) { TSReleaseAssert(!pthread_rwlock_rdlock(&rwlock_keymap_)); std::map<const char *,LimiterState *>::iterator it = keymap_.find(key); TSReleaseAssert(!pthread_rwlock_unlock(&rwlock_keymap_)); TSReleaseAssert( it != keymap_.end() ); LimiterState * state = it->second; TSMutexLock(update_mutex_); state->set_taken(counter_index, state->taken(counter_index) - amount); dbg("released amount, currently taken %f", state->taken(counter_index)); TSMutexUnlock(update_mutex_); }
//--------------------------------------------------------------------------------------------------------------------- pmip_entry_t *pmip_cache_get(const struct in6_addr * our_addr, const struct in6_addr * peer_addr) { pmip_entry_t *bce; assert(peer_addr && our_addr); pthread_rwlock_rdlock(&pmip_lock); bce = hash_get(&g_pmip_hash, our_addr, peer_addr); if (bce) { pthread_rwlock_wrlock(&bce->lock); //dbg("PMIP cache entry is found for: %x:%x:%x:%x:%x:%x:%x:%x with type %d\n", NIP6ADDR(&bce->mn_hw_address), (bce->type)); } else { pthread_rwlock_unlock(&pmip_lock); //dbg("PMIP cache entry is NOT found for %x:%x:%x:%x:%x:%x:%x:%x <-> %x:%x:%x:%x:%x:%x:%x:%x\n", NIP6ADDR(our_addr), NIP6ADDR(peer_addr)); } return bce; }
/* Looks for the photoset specified in the argument. * Returns pointer to the stored cached_information * or 0 if not found. */ cached_information *photoset_lookup(const char *photoset) { cached_photoset *cps; cached_information *ci_copy = NULL; pthread_rwlock_rdlock(&cache_lock); if(check_cache()) goto fail; cps = g_hash_table_lookup(photoset_ht, photoset); if(cps) ci_copy = copy_cached_info(&(cps->ci)); fail: pthread_rwlock_unlock(&cache_lock); return ci_copy; }
/** * \brief Bind to a variable * * Subscribe to the give variable and automatically populate its value in the float whose reference is passed * * \param name Name of the variable to subscribe to * \param store_to Pointer to a float to store the value of the variable when it is updated * \return 0 on success */ int Var_bind(char* name, float* store_to) { Subscription* s; Var_subscribe(name); pthread_rwlock_rdlock(&subscriptions_lock); { s = Dictionary_get(subscriptions, name); s->writeback = store_to; } pthread_rwlock_unlock(&subscriptions_lock); (*s->writeback) = s->current; return 0; }
static void __dcethread_child_fork(void) { unsigned int i; pthread_rwlock_rdlock(&atfork_lock); for (i = 0; i < atfork_handlers_len; i++) { if (atfork_handlers[i].child_fork) atfork_handlers[i].child_fork(atfork_handlers[i].user_state); } pthread_rwlock_unlock(&atfork_lock); }
/* Force log context acquisition through a function */ static rpmlogCtx rpmlogCtxAcquire(int write) { static struct rpmlogCtx_s _globalCtx = { PTHREAD_RWLOCK_INITIALIZER, RPMLOG_UPTO(RPMLOG_NOTICE), 0, NULL, NULL, NULL, NULL }; rpmlogCtx ctx = &_globalCtx; /* XXX: errors should be handled */ if (write) pthread_rwlock_wrlock(&ctx->lock); else pthread_rwlock_rdlock(&ctx->lock); return ctx; }
/** * TryReadLock * * This will attempt to aquire the read lock. If it is not able to do so false will be returned. * If the lock is aquired true will be returned. * * If the lock is not aquired you should not make a call to Unlock as the lock is not owned. **/ bool RWLock::TryReadLock() { int ret = pthread_rwlock_rdlock(&m_lock); if (ret == 0) return true; switch(ret) { case EBUSY: return false; default: abort(); } return false; }
void glthread_rwlock_rdlock (gl_rwlock_t *lock) { if (!lock->initialized) { if (pthread_mutex_lock (&lock->guard) != 0) abort (); if (!lock->initialized) glthread_rwlock_init (lock); if (pthread_mutex_unlock (&lock->guard) != 0) abort (); } if (pthread_rwlock_rdlock (&lock->rwlock) != 0) abort (); }
NOEXPORT void dyn_lock_function(int mode, struct CRYPTO_dynlock_value *value, const char *file, int line) { (void)file; /* squash the unused parameter warning */ (void)line; /* squash the unused parameter warning */ if(mode&CRYPTO_LOCK) { /* either CRYPTO_READ or CRYPTO_WRITE (but not both) are needed */ if(!(mode&CRYPTO_READ)==!(mode&CRYPTO_WRITE)) fatal("Invalid locking mode"); if(mode&CRYPTO_WRITE) pthread_rwlock_wrlock(&value->rwlock); else pthread_rwlock_rdlock(&value->rwlock); } else pthread_rwlock_unlock(&value->rwlock); }
static ucs_async_mode_t ucs_async_handler_mode(int id) { ucs_async_mode_t mode; khiter_t hash_it; pthread_rwlock_rdlock(&ucs_async_global_context.handlers_lock); hash_it = ucs_async_handler_kh_get(id); if (ucs_async_handler_kh_is_end(hash_it)) { mode = UCS_ASYNC_MODE_POLL; } else { mode = kh_value(&ucs_async_global_context.handlers, hash_it)->mode; } pthread_rwlock_unlock(&ucs_async_global_context.handlers_lock); return mode; }
void CPacBioUtility::AcquireLock(bool bExclusive) { #ifdef _WIN32 if(bExclusive) AcquireSRWLockExclusive(&m_hRwLock); else AcquireSRWLockShared(&m_hRwLock); #else if(bExclusive) pthread_rwlock_wrlock(&m_hRwLock); else pthread_rwlock_rdlock(&m_hRwLock); #endif }
/*********************** * Read-Write Lock ***********************/ BOOL _RWLockLockR(pthread_rwlock_t *lock, DWORD timeout) { if(timeout == INFINITE) return pthread_rwlock_rdlock(lock) == 0; else { while(!pthread_rwlock_tryrdlock(lock) && timeout > 0) { usleep(10000); if(timeout > 10) timeout -= 10; else return FALSE; } return TRUE; } }
// 3. PUT_FILE_CLEANUP static void proc_cmd_put_file_cleanup(struct mg_connection* conn, const struct mg_request_info* request_info) { char str_command[100]; logger_remotem("PUT_FILE with CLEANUP: delete all files in %s", UPLOAD_DIRECTORY); // Clean up upload directory sprintf(str_command, "exec rm -rf %s/*", ODI_UPLOAD); pthread_rwlock_rdlock(&rwlock); system(str_command); pthread_rwlock_unlock(&rwlock); // Process upload file proc_cmd_put_file(conn, request_info); logger_remotem("PUT_FILE with CLEANUP: SUCCESS"); }
void* run1(void* arglist) { pthread_t id = pthread_self(); printf("[run1] TID=%d\n", (int)id); printf("[run1] started\n"); pthread_rwlock_rdlock(&lock); printf("[run1] a read lock is obtained\n"); pthread_rwlock_unlock(&lock); printf("[run1] a read lock is released\n"); return NULL; }
struct job* job_find(struct queue *qb,pthread_t id) { struct job *jb; if(pthread_rwlock_rdlock(&qb->q_lock) != 0) return NULL; for(jb=qb->q_head;jb != NULL;jp = jb->j_next) if(pthread_equal(jb->j_id,id)) break; pthread_rwlock_unlock(&qb->q_lock); return jb; }
/* Returns a copy of the port's statistics description. */ struct ofl_port_stats * MALLOC_ATTR pcap_drv_get_port_stats(struct pcap_drv *drv, size_t drv_port_no) { pthread_rwlock_rdlock(drv->ports_rwlock); struct pcap_port *port = drv->ports[drv_port_no]; pthread_rwlock_unlock(drv->ports_rwlock); if (port != NULL) { pthread_mutex_lock(port->stats_mutex); struct ofl_port_stats *ret = memcpy(malloc(sizeof(struct ofl_port_stats)), port->of_stats, sizeof(struct ofl_port_stats)); pthread_mutex_unlock(port->stats_mutex); return ret; } else { return NULL; } }
void summary_key_set_fwrite(summary_key_set_type * set, const char * filename) { pthread_rwlock_rdlock( &set->rw_lock ); { FILE * stream = util_mkdir_fopen(filename , "w"); if (stream) { stringlist_type * keys = hash_alloc_stringlist(set->key_set); stringlist_fwrite(keys, stream); stringlist_free(keys); fclose( stream ); } else { util_abort("%s: failed to open: %s for writing \n", __func__, filename); } } pthread_rwlock_unlock( &set->rw_lock ); }
/* Extrae_OMPT_tf_task_id_set_running Annotates whether a ompt task is running or not. */ void Extrae_OMPT_tf_task_id_set_running (ompt_task_id_t ompt_tid, int b) { unsigned u; pthread_rwlock_rdlock (&mutex_tid_tf); for (u = 0; u < n_allocated_ompt_tids_tf; u++) if (ompt_tids_tf[u].tid == ompt_tid) { ompt_tids_tf[u].is_running = b; break; } pthread_rwlock_unlock (&mutex_tid_tf); }
static void state_map_select_matching__( state_map_type * map , bool_vector_type * select_target , int select_mask , bool select) { pthread_rwlock_rdlock( &map->rw_lock ); { { const int * map_ptr = int_vector_get_ptr( map->state ); for (int i=0; i < int_vector_size( map->state ); i++) { int state_value = map_ptr[i]; if (state_value & select_mask) bool_vector_iset( select_target , i , select); } } pthread_rwlock_unlock( &map->rw_lock ); } }
static void *reader(void *arg) { (void) arg; /* PRINTF("%s", "start"); */ for (int i = 0; i < NUM_ITERATIONS; ++i) { pthread_rwlock_rdlock(&rwlock); unsigned cur = counter; do_sleep(1); /* simulate time that it takes to read the value */ PRINTF("%i: read <- %2u (correct = %u)", i, cur, cur == counter); pthread_rwlock_unlock(&rwlock); do_sleep(1); } /* PRINTF("%s", "done"); */ return NULL; }
void* AdConHash::LookUp(char * pKey) { struct node_s* pNode; if (m_pHandle == NULL) { return NULL; } pthread_rwlock_rdlock(&m_pLock); pNode = const_cast<struct node_s *>(conhash_lookup(m_pHandle, pKey)); pthread_rwlock_unlock(&m_pLock); if(pNode == NULL) return NULL; return pNode->value; }