/*
* __wt_txn_global_init --
* Initialize the global transaction state.
*/
int
__wt_txn_global_init(WT_SESSION_IMPL *session, const char *cfg[])
{
WT_CONNECTION_IMPL *conn;
WT_TXN_GLOBAL *txn_global;
WT_TXN_STATE *s;
u_int i;
WT_UNUSED(cfg);
conn = S2C(session);
txn_global = &conn->txn_global;
txn_global->current = txn_global->last_running =
txn_global->oldest_id = WT_TXN_FIRST;
WT_RET(__wt_spin_init(session,
&txn_global->id_lock, "transaction id lock"));
WT_RET(__wt_rwlock_alloc(session,
&txn_global->scan_rwlock, "transaction scan lock"));
WT_RET(__wt_rwlock_alloc(session,
&txn_global->nsnap_rwlock, "named snapshot lock"));
txn_global->nsnap_oldest_id = WT_TXN_NONE;
TAILQ_INIT(&txn_global->nsnaph);
WT_RET(__wt_calloc_def(
session, conn->session_size, &txn_global->states));
WT_CACHE_LINE_ALIGNMENT_VERIFY(session, txn_global->states);
for (i = 0, s = txn_global->states; i < conn->session_size; i++, s++)
s->id = s->snap_min = WT_TXN_NONE;
return (0);
}
/*
* __wt_logmgr_create --
* Initialize the log subsystem (before running recovery).
*/
int
__wt_logmgr_create(WT_SESSION_IMPL *session, const char *cfg[])
{
WT_CONNECTION_IMPL *conn;
WT_LOG *log;
bool run;
conn = S2C(session);
/* Handle configuration. */
WT_RET(__logmgr_config(session, cfg, &run, false));
/* If logging is not configured, we're done. */
if (!run)
return (0);
FLD_SET(conn->log_flags, WT_CONN_LOG_ENABLED);
/*
* Logging is on, allocate the WT_LOG structure and open the log file.
*/
WT_RET(__wt_calloc_one(session, &conn->log));
log = conn->log;
WT_RET(__wt_spin_init(session, &log->log_lock, "log"));
WT_RET(__wt_spin_init(session, &log->log_slot_lock, "log slot"));
WT_RET(__wt_spin_init(session, &log->log_sync_lock, "log sync"));
WT_RET(__wt_spin_init(session, &log->log_writelsn_lock,
"log write LSN"));
WT_RET(__wt_rwlock_alloc(session,
&log->log_archive_lock, "log archive lock"));
if (FLD_ISSET(conn->direct_io, WT_FILE_TYPE_LOG))
log->allocsize =
WT_MAX((uint32_t)conn->buffer_alignment, WT_LOG_ALIGN);
else
log->allocsize = WT_LOG_ALIGN;
WT_INIT_LSN(&log->alloc_lsn);
WT_INIT_LSN(&log->ckpt_lsn);
WT_INIT_LSN(&log->first_lsn);
WT_INIT_LSN(&log->sync_lsn);
/*
* We only use file numbers for directory sync, so this needs to
* initialized to zero.
*/
WT_ZERO_LSN(&log->sync_dir_lsn);
WT_INIT_LSN(&log->trunc_lsn);
WT_INIT_LSN(&log->write_lsn);
WT_INIT_LSN(&log->write_start_lsn);
log->fileid = 0;
WT_RET(__wt_cond_alloc(
session, "log sync", false, &log->log_sync_cond));
WT_RET(__wt_cond_alloc(
session, "log write", false, &log->log_write_cond));
WT_RET(__wt_log_open(session));
WT_RET(__wt_log_slot_init(session));
return (0);
}
/*
* __lsm_tree_open --
* Open an LSM tree structure.
*/
static int
__lsm_tree_open(
WT_SESSION_IMPL *session, const char *uri, WT_LSM_TREE **treep)
{
WT_DECL_RET;
WT_LSM_TREE *lsm_tree;
WT_ASSERT(session, F_ISSET(session, WT_SESSION_SCHEMA_LOCKED));
/* Make sure no one beat us to it. */
TAILQ_FOREACH(lsm_tree, &S2C(session)->lsmqh, q)
if (strcmp(uri, lsm_tree->name) == 0) {
*treep = lsm_tree;
return (0);
}
/* Try to open the tree. */
WT_RET(__wt_calloc_def(session, 1, &lsm_tree));
WT_ERR(__wt_rwlock_alloc(session, "lsm tree", &lsm_tree->rwlock));
WT_ERR(__wt_cond_alloc(session, "lsm ckpt", 0, &lsm_tree->work_cond));
WT_ERR(__lsm_tree_set_name(session, lsm_tree, uri));
WT_ERR(__wt_lsm_meta_read(session, lsm_tree));
/*
* Sanity check the configuration. Do it now since this is the first
* time we have the LSM tree configuration.
*/
WT_ERR(__lsm_tree_open_check(session, lsm_tree));
if (lsm_tree->nchunks == 0) {
F_SET(lsm_tree, WT_LSM_TREE_NEED_SWITCH);
WT_ERR(__wt_lsm_tree_switch(session, lsm_tree));
}
/* Set the generation number so cursors are opened on first usage. */
lsm_tree->dsk_gen = 1;
/* Now the tree is setup, make it visible to others. */
lsm_tree->refcnt = 1;
TAILQ_INSERT_HEAD(&S2C(session)->lsmqh, lsm_tree, q);
F_SET(lsm_tree, WT_LSM_TREE_OPEN);
WT_ERR(__lsm_tree_start_worker(session, lsm_tree));
*treep = lsm_tree;
if (0) {
err: WT_TRET(__lsm_tree_discard(session, lsm_tree));
}
return (ret);
}
/*
* __wt_thread_group_create --
* Create a new thread group, assumes incoming group structure is
* zero initialized.
*/
int
__wt_thread_group_create(
WT_SESSION_IMPL *session, WT_THREAD_GROUP *group, const char *name,
uint32_t min, uint32_t max, uint32_t flags,
int (*run_func)(WT_SESSION_IMPL *session, WT_THREAD *context))
{
WT_DECL_RET;
bool cond_alloced;
/* Check that the structure is initialized as expected */
WT_ASSERT(session, group->alloc == 0);
cond_alloced = false;
__wt_verbose(session, WT_VERB_THREAD_GROUP,
"Creating thread group: %p", (void *)group);
WT_RET(__wt_rwlock_alloc(session, &group->lock, "Thread group"));
WT_ERR(__wt_cond_alloc(
session, "Thread group cond", false, &group->wait_cond));
cond_alloced = true;
__wt_writelock(session, group->lock);
group->run_func = run_func;
group->name = name;
WT_TRET(__thread_group_resize(session, group, min, max, flags));
__wt_writeunlock(session, group->lock);
/* Cleanup on error to avoid leaking resources */
err: if (ret != 0) {
if (cond_alloced)
WT_TRET(__wt_cond_destroy(session, &group->wait_cond));
__wt_rwlock_destroy(session, &group->lock);
}
return (ret);
}
/*
* __wt_connection_init --
* Structure initialization for a just-created WT_CONNECTION_IMPL handle.
*/
int
__wt_connection_init(WT_CONNECTION_IMPL *conn)
{
WT_SESSION_IMPL *session;
u_int i;
session = conn->default_session;
for (i = 0; i < WT_HASH_ARRAY_SIZE; i++) {
TAILQ_INIT(&conn->dhhash[i]); /* Data handle hash lists */
TAILQ_INIT(&conn->fhhash[i]); /* File handle hash lists */
}
TAILQ_INIT(&conn->dhqh); /* Data handle list */
TAILQ_INIT(&conn->dlhqh); /* Library list */
TAILQ_INIT(&conn->dsrcqh); /* Data source list */
TAILQ_INIT(&conn->fhqh); /* File list */
TAILQ_INIT(&conn->collqh); /* Collator list */
TAILQ_INIT(&conn->compqh); /* Compressor list */
TAILQ_INIT(&conn->encryptqh); /* Encryptor list */
TAILQ_INIT(&conn->extractorqh); /* Extractor list */
TAILQ_INIT(&conn->lsmqh); /* WT_LSM_TREE list */
/* Setup the LSM work queues. */
TAILQ_INIT(&conn->lsm_manager.switchqh);
TAILQ_INIT(&conn->lsm_manager.appqh);
TAILQ_INIT(&conn->lsm_manager.managerqh);
/* Random numbers. */
__wt_random_init(&session->rnd);
/* Configuration. */
WT_RET(__wt_conn_config_init(session));
/* Statistics. */
WT_RET(__wt_stat_connection_init(session, conn));
/* Spinlocks. */
WT_RET(__wt_spin_init(session, &conn->api_lock, "api"));
WT_SPIN_INIT_TRACKED(session, &conn->checkpoint_lock, checkpoint);
WT_SPIN_INIT_TRACKED(session, &conn->dhandle_lock, handle_list);
WT_RET(__wt_spin_init(session, &conn->encryptor_lock, "encryptor"));
WT_RET(__wt_spin_init(session, &conn->fh_lock, "file list"));
WT_RET(__wt_spin_init(session, &conn->las_lock, "lookaside table"));
WT_SPIN_INIT_TRACKED(session, &conn->metadata_lock, metadata);
WT_RET(__wt_spin_init(session, &conn->reconfig_lock, "reconfigure"));
WT_SPIN_INIT_TRACKED(session, &conn->schema_lock, schema);
WT_SPIN_INIT_TRACKED(session, &conn->table_lock, table);
WT_RET(__wt_spin_init(session, &conn->turtle_lock, "turtle file"));
/* Read-write locks */
WT_RET(__wt_rwlock_alloc(
session, &conn->hot_backup_lock, "hot backup"));
WT_RET(__wt_calloc_def(session, WT_PAGE_LOCKS, &conn->page_lock));
WT_CACHE_LINE_ALIGNMENT_VERIFY(session, conn->page_lock);
for (i = 0; i < WT_PAGE_LOCKS; ++i)
WT_RET(
__wt_spin_init(session, &conn->page_lock[i], "btree page"));
/* Setup the spin locks for the LSM manager queues. */
WT_RET(__wt_spin_init(session,
&conn->lsm_manager.app_lock, "LSM application queue lock"));
WT_RET(__wt_spin_init(session,
&conn->lsm_manager.manager_lock, "LSM manager queue lock"));
WT_RET(__wt_spin_init(
session, &conn->lsm_manager.switch_lock, "LSM switch queue lock"));
WT_RET(__wt_cond_alloc(
session, "LSM worker cond", false, &conn->lsm_manager.work_cond));
/*
* Generation numbers.
*
* Start split generations at one. Threads publish this generation
* number before examining tree structures, and zero when they leave.
* We need to distinguish between threads that are in a tree before the
* first split has happened, and threads that are not in a tree.
*/
conn->split_gen = 1;
/*
* Block manager.
* XXX
* If there's ever a second block manager, we'll want to make this
* more opaque, but for now this is simpler.
*/
WT_RET(__wt_spin_init(session, &conn->block_lock, "block manager"));
for (i = 0; i < WT_HASH_ARRAY_SIZE; i++)
TAILQ_INIT(&conn->blockhash[i]);/* Block handle hash lists */
TAILQ_INIT(&conn->blockqh); /* Block manager list */
return (0);
}
/*
* __lsm_tree_open --
* Open an LSM tree structure.
*/
static int
__lsm_tree_open(
WT_SESSION_IMPL *session, const char *uri, WT_LSM_TREE **treep)
{
WT_CONNECTION_IMPL *conn;
WT_DECL_RET;
WT_LSM_TREE *lsm_tree;
conn = S2C(session);
lsm_tree = NULL;
WT_ASSERT(session, F_ISSET(session, WT_SESSION_SCHEMA_LOCKED));
/* Start the LSM manager thread if it isn't running. */
if (WT_ATOMIC_CAS4(conn->lsm_manager.lsm_workers, 0, 1))
WT_RET(__wt_lsm_manager_start(session));
/* Make sure no one beat us to it. */
TAILQ_FOREACH(lsm_tree, &S2C(session)->lsmqh, q)
if (strcmp(uri, lsm_tree->name) == 0) {
*treep = lsm_tree;
return (0);
}
/* Try to open the tree. */
WT_RET(__wt_calloc_def(session, 1, &lsm_tree));
WT_ERR(__wt_rwlock_alloc(session, &lsm_tree->rwlock, "lsm tree"));
WT_ERR(__lsm_tree_set_name(session, lsm_tree, uri));
WT_ERR(__wt_lsm_meta_read(session, lsm_tree));
/*
* Sanity check the configuration. Do it now since this is the first
* time we have the LSM tree configuration.
*/
WT_ERR(__lsm_tree_open_check(session, lsm_tree));
if (lsm_tree->nchunks == 0) {
F_SET(lsm_tree, WT_LSM_TREE_NEED_SWITCH);
WT_ERR(__wt_lsm_tree_switch(session, lsm_tree));
}
/* Set the generation number so cursors are opened on first usage. */
lsm_tree->dsk_gen = 1;
/*
* Setup reference counting. Use separate reference counts for tree
* handles and queue entries, so that queue entries don't interfere
* with getting handles exclusive.
*/
lsm_tree->refcnt = 1;
lsm_tree->queue_ref = 0;
/* Set a flush timestamp as a baseline. */
WT_ERR(__wt_epoch(session, &lsm_tree->last_flush_ts));
/* Now the tree is setup, make it visible to others. */
TAILQ_INSERT_HEAD(&S2C(session)->lsmqh, lsm_tree, q);
F_SET(lsm_tree, WT_LSM_TREE_ACTIVE | WT_LSM_TREE_OPEN);
*treep = lsm_tree;
if (0) {
err: WT_TRET(__lsm_tree_discard(session, lsm_tree));
}
return (ret);
}
/*
* __conn_dhandle_get --
* Allocate a new data handle, lock it exclusively, and return it linked
* into the connection's list.
*/
static int
__conn_dhandle_get(WT_SESSION_IMPL *session,
const char *name, const char *ckpt, uint32_t flags)
{
WT_BTREE *btree;
WT_CONNECTION_IMPL *conn;
WT_DATA_HANDLE *dhandle;
WT_DECL_RET;
uint32_t bucket;
conn = S2C(session);
/*
* We have the handle lock, check whether we can find the handle we
* are looking for. If we do, and we can lock it in the state we
* want, this session will take ownership and we are done.
*/
ret = __wt_conn_dhandle_find(session, name, ckpt, flags);
if (ret == 0) {
dhandle = session->dhandle;
WT_RET(__conn_dhandle_open_lock(session, dhandle, flags));
return (0);
}
WT_RET_NOTFOUND_OK(ret);
/*
* If no handle was found, allocate the data handle and a btree handle,
* then initialize the data handle. Exclusively lock the data handle
* before inserting it in the list.
*/
WT_RET(__wt_calloc_one(session, &dhandle));
WT_ERR(__wt_rwlock_alloc(session, &dhandle->rwlock, "data handle"));
dhandle->name_hash = __wt_hash_city64(name, strlen(name));
WT_ERR(__wt_strdup(session, name, &dhandle->name));
if (ckpt != NULL)
WT_ERR(__wt_strdup(session, ckpt, &dhandle->checkpoint));
WT_ERR(__wt_calloc_one(session, &btree));
dhandle->handle = btree;
btree->dhandle = dhandle;
WT_ERR(__wt_spin_init(
session, &dhandle->close_lock, "data handle close"));
F_SET(dhandle, WT_DHANDLE_EXCLUSIVE);
WT_ERR(__wt_writelock(session, dhandle->rwlock));
/*
* Prepend the handle to the connection list, assuming we're likely to
* need new files again soon, until they are cached by all sessions.
* Find the right hash bucket to insert into as well.
*/
WT_ASSERT(session, F_ISSET(session, WT_SESSION_HANDLE_LIST_LOCKED));
bucket = dhandle->name_hash % WT_HASH_ARRAY_SIZE;
WT_CONN_DHANDLE_INSERT(conn, dhandle, bucket);
session->dhandle = dhandle;
return (0);
err: WT_TRET(__wt_rwlock_destroy(session, &dhandle->rwlock));
__wt_free(session, dhandle->name);
__wt_free(session, dhandle->checkpoint);
__wt_free(session, dhandle->handle); /* btree free */
__wt_spin_destroy(session, &dhandle->close_lock);
__wt_overwrite_and_free(session, dhandle);
return (ret);
}
