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);
}
