nscd_rc_t _nscd_init_all_getent_ctx_base() { int i; nscd_rc_t rc; char *me = "_nscd_init_all_getent_ctx_base"; (void) rw_wrlock(&nscd_getent_ctx_base_lock); for (i = 0; i < NSCD_NUM_DB; i++) { rc = _nscd_init_getent_ctx_base(i, 0); if (rc != NSCD_SUCCESS) { (void) rw_unlock(&nscd_getent_ctx_base_lock); return (rc); } } _NSCD_LOG(NSCD_LOG_GETENT_CTX | NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_DEBUG) (me, "all getent context base initialized\n"); (void) rw_unlock(&nscd_getent_ctx_base_lock); return (NSCD_SUCCESS); }
void resolve_symbols() { void *foo; global_cond_flag = TRUE; #ifdef SOLARIS mutex_lock(&queue_lock); mutex_trylock(&queue_lock); mutex_unlock(&queue_lock); foo = (void *)&cond_signal; foo = (void *)&cond_wait; foo = (void *)&cond_timedwait; sema_post(&global_sema_lock); sema_wait(&global_sema_lock); rw_rdlock(&global_rw_lock); rw_unlock(&global_rw_lock); rw_wrlock(&global_rw_lock); rw_unlock(&global_rw_lock); #endif #ifdef POSIX pthread_mutex_lock(&queue_lock); pthread_mutex_trylock(&queue_lock); pthread_mutex_unlock(&queue_lock); foo = (void *)&pthread_cond_signal; foo = (void *)&pthread_cond_wait; foo = (void *)&pthread_cond_timedwait; sem_post(&global_sema_lock); sem_wait(&global_sema_lock); #endif }
/* * Deletes the specified root information */ static uint32_t dfs_root_remove(const char *rootdir) { int attrdirfd; int err = 0; (void) rw_wrlock(&dfs_root_rwl); if ((attrdirfd = attropen(rootdir, ".", O_RDONLY)) > 0) { if (unlinkat(attrdirfd, DFS_ROOT_XATTR, 0) == -1) { if (errno != ENOENT) err = errno; } (void) close(attrdirfd); } else { err = errno; } (void) rw_unlock(&dfs_root_rwl); if (err != 0) { syslog(LOG_DEBUG, "dfs: failed to remove root info %s (%d)", rootdir, err); return (ERROR_INTERNAL_ERROR); } return (ERROR_SUCCESS); }
/* * smb_nic_fini * * Destroys the interface list. */ void smb_nic_fini(void) { (void) rw_wrlock(&smb_niclist.nl_rwl); smb_nic_list_destroy(); (void) rw_unlock(&smb_niclist.nl_rwl); }
void solaris_locking_callback(int mode, int type, char *file, int line) { # if 0 fprintf(stderr, "thread=%4d mode=%s lock=%s %s:%d\n", CRYPTO_thread_id(), (mode & CRYPTO_LOCK) ? "l" : "u", (type & CRYPTO_READ) ? "r" : "w", file, line); # endif # if 0 if (CRYPTO_LOCK_SSL_CERT == type) fprintf(stderr, "(t,m,f,l) %ld %d %s %d\n", CRYPTO_thread_id(), mode, file, line); # endif if (mode & CRYPTO_LOCK) { # ifdef USE_MUTEX mutex_lock(&(lock_cs[type])); # else if (mode & CRYPTO_READ) rw_rdlock(&(lock_cs[type])); else rw_wrlock(&(lock_cs[type])); # endif lock_count[type]++; } else { # ifdef USE_MUTEX mutex_unlock(&(lock_cs[type])); # else rw_unlock(&(lock_cs[type])); # endif } }
/* * Sets the provided information for the specified root or root target. * Root is specified by 'rootdir' and the target is specified by * (t_server, t_share) pair. Only information items needed for given * information level (infolvl) is valid in the passed DFS info structure * 'info'. */ uint32_t dfs_root_setinfo(const char *rootdir, dfs_info_t *info, uint32_t infolvl) { dfs_info_t curinfo; uint32_t status = ERROR_SUCCESS; int xfd; (void) rw_wrlock(&dfs_root_rwl); if ((xfd = dfs_root_xopen(rootdir, O_RDWR)) < 0) { (void) rw_unlock(&dfs_root_rwl); return (ERROR_INTERNAL_ERROR); } status = dfs_root_xread(xfd, &curinfo, DFS_INFO_ALL); if (status != ERROR_SUCCESS) { dfs_root_xclose(xfd); (void) rw_unlock(&dfs_root_rwl); return (status); } status = dfs_modinfo(DFS_OBJECT_ROOT, &curinfo, info, infolvl); if (status == ERROR_SUCCESS) status = dfs_root_xwrite(xfd, &curinfo); dfs_root_xclose(xfd); (void) rw_unlock(&dfs_root_rwl); dfs_info_free(&curinfo); return (status); }
static g_cache_ptr get_g_cache(void) { g_cache_ptr gc; /* always enter with a READ LOCK and exit with one too */ ASSERT(RW_READ_HELD(&g_cache_lock)); if ((gc = groups_cache) != 0) { return (gc); } (void) rw_unlock(&g_cache_lock); /* write lock the cache and try again */ (void) rw_wrlock(&g_cache_lock); if ((gc = groups_cache) != 0) { (void) rw_unlock(&g_cache_lock); (void) rw_rdlock(&g_cache_lock); return (gc); } gc = groups_cache = calloc(1, sizeof (*groups_cache)); if (groups_cache == 0) { (void) rw_unlock(&g_cache_lock); (void) rw_rdlock(&g_cache_lock); return (0); } (void) rw_unlock(&g_cache_lock); (void) rw_rdlock(&g_cache_lock); return (gc); }
int create_server(THD *thd, LEX_SERVER_OPTIONS *server_options) { int error= ER_FOREIGN_SERVER_EXISTS; FOREIGN_SERVER *server; DBUG_ENTER("create_server"); DBUG_PRINT("info", ("server_options->server_name %s", server_options->server_name)); rw_wrlock(&THR_LOCK_servers); /* hit the memory first */ if (hash_search(&servers_cache, (uchar*) server_options->server_name, server_options->server_name_length)) goto end; if (!(server= prepare_server_struct_for_insert(server_options))) { /* purecov: begin inspected */ error= ER_OUT_OF_RESOURCES; goto end; /* purecov: end */ } error= insert_server(thd, server); DBUG_PRINT("info", ("error returned %d", error)); end: rw_unlock(&THR_LOCK_servers); DBUG_RETURN(error); }
void mntlist_new(char *host, char *path) { (void) rw_wrlock(&rmtab_lock); mntlist_insert(host, path); (void) rw_unlock(&rmtab_lock); }
/* * FUNCTION: _nscd_add_getent_ctx * * Add a getent context to the internal context database. */ static nscd_rc_t _nscd_add_getent_ctx( nscd_getent_context_t *ptr, nscd_cookie_num_t cookie_num) { int size; char buf[32]; nscd_db_entry_t *db_entry; nscd_getent_ctx_t *gnctx; if (ptr == NULL) return (NSCD_INVALID_ARGUMENT); (void) snprintf(buf, sizeof (buf), "%lld", cookie_num); size = sizeof (*gnctx); db_entry = _nscd_alloc_db_entry(NSCD_DATA_CTX_ADDR, (const char *)buf, size, 1, 1); if (db_entry == NULL) return (NSCD_NO_MEMORY); gnctx = (nscd_getent_ctx_t *)*(db_entry->data_array); gnctx->ptr = ptr; gnctx->cookie_num = cookie_num; (void) rw_wrlock(&getent_ctxDB_rwlock); (void) _nscd_add_db_entry(getent_ctxDB, buf, db_entry, NSCD_ADD_DB_ENTRY_FIRST); (void) rw_unlock(&getent_ctxDB_rwlock); return (NSCD_SUCCESS); }
void mntlist_delete_all(char *host) { HASHSET_ITERATOR iterator; struct mntentry *m; (void) rw_wrlock(&rmtab_lock); iterator = h_iterator(mntlist); while (m = (struct mntentry *)h_next(iterator)) { if (strcasecmp(m->m_host, host)) continue; rmtab_delete(m->m_pos); (void) h_delete(mntlist, m); free(m->m_path); free(m->m_host); free(m); } if (RMTAB_TOOMANY_DELETED()) rmtab_rewrite(); (void) rw_unlock(&rmtab_lock); if (iterator != NULL) free(iterator); }
/* * Set the IPC username and password hash in memory. If the domain * join succeeds, the credentials will be committed for use with * authenticated IPC. Otherwise, they should be rolled back. */ void smb_ipc_set(char *plain_user, uint8_t *passwd_hash) { (void) rw_wrlock(&smb_ipc_lock); (void) strlcpy(ipc_info.user, plain_user, sizeof (ipc_info.user)); (void) memcpy(ipc_info.passwd, passwd_hash, SMBAUTH_HASH_SZ); (void) rw_unlock(&smb_ipc_lock); }
/* * Save the host credentials to be used for authenticated IPC. * The credentials are also saved to the original IPC info as * rollback data in case the join domain process fails later. */ void smb_ipc_commit(void) { (void) rw_wrlock(&smb_ipc_lock); (void) smb_getsamaccount(ipc_info.user, SMB_USERNAME_MAXLEN); (void) smb_get_machine_passwd(ipc_info.passwd, SMBAUTH_HASH_SZ); (void) memcpy(&ipc_orig_info, &ipc_info, sizeof (smb_ipc_t)); (void) rw_unlock(&smb_ipc_lock); }
/* * Restore the original credentials */ void smb_ipc_rollback(void) { (void) rw_wrlock(&smb_ipc_lock); (void) strlcpy(ipc_info.user, ipc_orig_info.user, sizeof (ipc_info.user)); (void) memcpy(ipc_info.passwd, ipc_orig_info.passwd, sizeof (ipc_info.passwd)); (void) rw_unlock(&smb_ipc_lock); }
void Rw_wrlock(rwlock_t *rwptr) { int n; if ( (n = rw_wrlock(rwptr)) == 0) return; errno = n; err_sys("rw_wrlock error"); }
static void event_handler() { (void) rw_wrlock(&svm_lock); free_svm(svm_listp); svm_listp = NULL; (mdl_metaflushnames)(0); (void) load_svm(); (void) rw_unlock(&svm_lock); }
/* * smb_nic_init * * Initializes the interface list. */ int smb_nic_init(void) { int rc; (void) rw_wrlock(&smb_niclist.nl_rwl); smb_nic_list_destroy(); rc = smb_nic_list_create(); (void) rw_unlock(&smb_niclist.nl_rwl); return (rc); }
void rw_enter(krwlock_t *rwlp, krw_t rw) { int rc; if (rw == RW_READER) { rc = rw_rdlock(&rwlp->rw_lock); } else { rc = rw_wrlock(&rwlp->rw_lock); rwlp->rw_owner = _curthread(); } VERIFY(rc == 0); }
P_LIB_API pboolean p_rwlock_writer_lock (PRWLock *lock) { if (P_UNLIKELY (lock == NULL)) return FALSE; if (P_UNLIKELY (rw_wrlock (&lock->hdl) == 0)) return TRUE; else { P_ERROR ("PRWLock::p_rwlock_writer_lock: rw_wrlock() failed"); return FALSE; } }
/* ARGSUSED */ void sm_simu_crash_svc(void *myidp) { int i; struct mon_entry *monitor_q; int found = 0; /* Only one crash should be running at a time. */ mutex_lock(&crash_lock); if (debug) (void) printf("proc sm_simu_crash\n"); if (in_crash) { cond_wait(&crash_finish, &crash_lock); mutex_unlock(&crash_lock); return; } else { in_crash = 1; } mutex_unlock(&crash_lock); for (i = 0; i < MAX_HASHSIZE; i++) { mutex_lock(&mon_table[i].lock); monitor_q = mon_table[i].sm_monhdp; if (monitor_q != (struct mon_entry *)NULL) { mutex_unlock(&mon_table[i].lock); found = 1; break; } mutex_unlock(&mon_table[i].lock); } /* * If there are entries found in the monitor table, * initiate a crash, else zero out the in_crash variable. */ if (found) { mutex_lock(&crash_lock); die = 1; /* Signal sm_retry() thread if sleeping. */ cond_signal(&retrywait); mutex_unlock(&crash_lock); rw_wrlock(&thr_rwlock); sm_crash(); rw_unlock(&thr_rwlock); } else { mutex_lock(&crash_lock); in_crash = 0; mutex_unlock(&crash_lock); } }
static int dfs_root_add(const char *rootdir, dfs_info_t *info) { uint32_t status = ERROR_INTERNAL_ERROR; int xfd; (void) rw_wrlock(&dfs_root_rwl); if ((xfd = dfs_root_xopen(rootdir, O_CREAT | O_TRUNC | O_RDWR)) > 0) { status = dfs_root_xwrite(xfd, info); dfs_root_xclose(xfd); } (void) rw_unlock(&dfs_root_rwl); return (status); }
bool servers_reload(THD *thd) { TABLE_LIST tables[1]; bool return_val= TRUE; DBUG_ENTER("servers_reload"); if (thd->locked_tables) { // Can't have locked tables here thd->lock=thd->locked_tables; thd->locked_tables=0; close_thread_tables(thd); } DBUG_PRINT("info", ("locking servers_cache")); rw_wrlock(&THR_LOCK_servers); bzero((char*) tables, sizeof(tables)); tables[0].alias= tables[0].table_name= (char*) "servers"; tables[0].db= (char*) "mysql"; tables[0].lock_type= TL_READ; if (simple_open_n_lock_tables(thd, tables)) { /* Execution might have been interrupted; only print the error message if an error condition has been raised. */ if (thd->main_da.is_error()) sql_print_error("Can't open and lock privilege tables: %s", thd->main_da.message()); return_val= FALSE; goto end; } if ((return_val= servers_load(thd, tables))) { // Error. Revert to old list /* blast, for now, we have no servers, discuss later way to preserve */ DBUG_PRINT("error",("Reverting to old privileges")); servers_free(); } end: close_thread_tables(thd); DBUG_PRINT("info", ("unlocking servers_cache")); rw_unlock(&THR_LOCK_servers); DBUG_RETURN(return_val); }
/* * smb_lucache_flush * * Removes and frees all the cache entries */ static void smb_lucache_flush(void) { void *cookie = NULL; smb_ucnode_t *ucnode; (void) rw_wrlock(&smb_uch.uc_cache_lck); while ((ucnode = avl_destroy_nodes(&smb_uch.uc_cache, &cookie)) != NULL) { free(ucnode->cn_user.su_name); free(ucnode->cn_user.su_fullname); free(ucnode->cn_user.su_desc); free(ucnode); } (void) rw_unlock(&smb_uch.uc_cache_lck); }
/* * Set up IPC connection credentials. */ void smb_ipc_init(void) { int rc; (void) rw_wrlock(&smb_ipc_lock); bzero(&ipc_info, sizeof (smb_ipc_t)); bzero(&ipc_orig_info, sizeof (smb_ipc_t)); (void) smb_getsamaccount(ipc_info.user, SMB_USERNAME_MAXLEN); rc = smb_get_machine_passwd(ipc_info.passwd, SMBAUTH_HASH_SZ); if (rc != 0) *ipc_info.passwd = 0; (void) rw_unlock(&smb_ipc_lock); }
nscd_rc_t _nscd_alloc_getent_ctx_base() { (void) rw_wrlock(&nscd_getent_ctx_base_lock); nscd_getent_ctx_base = calloc(NSCD_NUM_DB, sizeof (nscd_getent_ctx_base_t *)); if (nscd_getent_ctx_base == NULL) { (void) rw_unlock(&nscd_getent_ctx_base_lock); return (NSCD_NO_MEMORY); } (void) rw_unlock(&nscd_getent_ctx_base_lock); return (NSCD_SUCCESS); }
/* read_write: use a global Reader/Writer lock to process array's data */ void read_write(Workblk *array, struct scripttab *k) { #ifdef SOLARIS switch (array->tid % NUM_OF_THREADS) { case 0: case 1: default: rw_rdlock(&global_rw_lock); array->ready = gethrtime(); array->vready = gethrvtime(); array->compute_ready = array->ready; array->compute_vready = array->vready; (k->called_func)(&array->list[0]); array->compute_done = gethrtime(); array->compute_vdone = gethrvtime(); rw_unlock(&global_rw_lock); break; case 2: rw_wrlock(&global_rw_lock); array->ready = gethrtime(); array->vready = gethrvtime(); array->compute_ready = array->ready; array->compute_vready = array->vready; (k->called_func)(&array->list[0]); array->compute_done = gethrtime(); array->compute_vdone = gethrvtime(); rw_unlock(&global_rw_lock); break; } #endif /* make another call to preclude tail-call optimization on the unlock */ (void) gethrtime(); }
int drop_server(THD *thd, LEX_SERVER_OPTIONS *server_options) { int error; TABLE_LIST tables; TABLE *table; LEX_STRING name= { server_options->server_name, server_options->server_name_length }; DBUG_ENTER("drop_server"); DBUG_PRINT("info", ("server name server->server_name %s", server_options->server_name)); bzero((char*) &tables, sizeof(tables)); tables.db= (char*) "mysql"; tables.alias= tables.table_name= (char*) "servers"; rw_wrlock(&THR_LOCK_servers); /* hit the memory hit first */ if ((error= delete_server_record_in_cache(server_options))) goto end; if (! (table= open_ltable(thd, &tables, TL_WRITE, 0))) { error= my_errno; goto end; } error= delete_server_record(table, name.str, name.length); /* close the servers table before we call closed_cached_connection_tables */ close_thread_tables(thd); if (close_cached_connection_tables(thd, TRUE, &name)) { push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN, ER_UNKNOWN_ERROR, "Server connection in use"); } end: rw_unlock(&THR_LOCK_servers); DBUG_RETURN(error); }
/* * Lock the cache with the specified mode. * If the cache is in updating state and a read lock is * requested, the lock won't be granted until either the * update is finished or SMB_CACHE_UPDATE_WAIT has passed. * * Whenever a lock is granted, the number of inflight cache * operations is incremented. */ static int smb_cache_lock(smb_cache_t *chandle, int mode) { (void) mutex_lock(&chandle->ch_mtx); switch (chandle->ch_state) { case SMB_CACHE_STATE_NOCACHE: case SMB_CACHE_STATE_DESTROYING: (void) mutex_unlock(&chandle->ch_mtx); return (ENODATA); case SMB_CACHE_STATE_REFRESHING: /* * Read operations should wait until the update * is completed. */ if (mode == SMB_CACHE_RDLOCK) { if (!smb_cache_wait(chandle)) { (void) mutex_unlock(&chandle->ch_mtx); return (ETIME); } } /* FALLTHROUGH */ case SMB_CACHE_STATE_READY: chandle->ch_nops++; break; default: assert(0); } (void) mutex_unlock(&chandle->ch_mtx); /* * Lock has to be taken outside the mutex otherwise * there could be a deadlock */ if (mode == SMB_CACHE_RDLOCK) (void) rw_rdlock(&chandle->ch_cache_lck); else (void) rw_wrlock(&chandle->ch_cache_lck); return (0); }
int dhcp_modify_dd_entry(dsvc_handle_t hand, const void *origp, void *newp) { #ifndef DEBUG return (modify_dd_entry(hand, origp, newp)); #else /* DEBUG */ int ret; int hind = (int)hand; int ind; dn_rec_t *dnp; dbg_t *dbp; dbg_t *dbg_db; if (dbg_net && hind >= 0 && hind < DBG_MAXTABLE) { dbg_db = (dbg_t *)dbg_handle[hind]; dnp = (dn_rec_t *)newp; ind = dnp->dn_cip.s_addr & dbg_mask; dbp = &dbg_db[ind]; (void) rw_wrlock(&dbg_lock[hind]); dbp->dn_lease = dnp->dn_lease; dbp->dn_cid_len = dnp->dn_cid_len; dbp->dn_flags = dnp->dn_flags; /* * Performance: avoid routine call when NULL string * is being copied. */ if ((dbp->dn_cid[0] = dnp->dn_cid[0]) != '\0') (void) memcpy(dbp->dn_cid, dnp->dn_cid, dnp->dn_cid_len); (void) rw_unlock(&dbg_lock[hind]); ret = DSVC_SUCCESS; } else ret = modify_dd_entry(hand, origp, newp); return (ret); #endif /* DEBUG */ }
/* * FUNCTION: _nscd_create_getent_ctxDB * * Create the internal getent context database to keep track of the * getent contexts currently being used. */ nscd_db_t * _nscd_create_getent_ctxDB() { nscd_db_t *ret; (void) rw_wrlock(&getent_ctxDB_rwlock); if (getent_ctxDB != NULL) { (void) rw_unlock(&getent_ctxDB_rwlock); return (getent_ctxDB); } ret = _nscd_alloc_db(NSCD_DB_SIZE_LARGE); if (ret != NULL) getent_ctxDB = ret; (void) rw_unlock(&getent_ctxDB_rwlock); return (ret); }