/*
* __wt_connection_destroy --
* Destroy the connection's underlying WT_CONNECTION_IMPL structure.
*/
int
__wt_connection_destroy(WT_CONNECTION_IMPL *conn)
{
WT_DECL_RET;
WT_SESSION_IMPL *session;
u_int i;
/* Check there's something to destroy. */
if (conn == NULL)
return (0);
session = conn->default_session;
/*
* Close remaining open files (before discarding the mutex, the
* underlying file-close code uses the mutex to guard lists of
* open files.
*/
WT_TRET(__wt_close(session, &conn->lock_fh));
/* Remove from the list of connections. */
__wt_spin_lock(session, &__wt_process.spinlock);
TAILQ_REMOVE(&__wt_process.connqh, conn, q);
__wt_spin_unlock(session, &__wt_process.spinlock);
/* Configuration */
__wt_conn_config_discard(session); /* configuration */
__wt_conn_foc_discard(session); /* free-on-close */
__wt_spin_destroy(session, &conn->api_lock);
__wt_spin_destroy(session, &conn->block_lock);
__wt_spin_destroy(session, &conn->checkpoint_lock);
__wt_spin_destroy(session, &conn->dhandle_lock);
__wt_spin_destroy(session, &conn->encryptor_lock);
__wt_spin_destroy(session, &conn->fh_lock);
WT_TRET(__wt_rwlock_destroy(session, &conn->hot_backup_lock));
__wt_spin_destroy(session, &conn->reconfig_lock);
__wt_spin_destroy(session, &conn->schema_lock);
__wt_spin_destroy(session, &conn->table_lock);
for (i = 0; i < WT_PAGE_LOCKS(conn); ++i)
__wt_spin_destroy(session, &conn->page_lock[i]);
__wt_free(session, conn->page_lock);
/* Free allocated memory. */
__wt_free(session, conn->cfg);
__wt_free(session, conn->home);
__wt_free(session, conn->error_prefix);
__wt_free(session, conn->sessions);
__wt_free(NULL, conn);
return (ret);
}
/*
* __wt_cache_destroy --
* Discard the underlying cache.
*/
int
__wt_cache_destroy(WT_SESSION_IMPL *session)
{
WT_CACHE *cache;
WT_CONNECTION_IMPL *conn;
WT_DECL_RET;
WT_SESSION *wt_session;
int i;
conn = S2C(session);
cache = conn->cache;
if (cache == NULL)
return (0);
/* The cache should be empty at this point. Complain if not. */
if (cache->pages_inmem != cache->pages_evict)
__wt_errx(session,
"cache server: exiting with %" PRIu64 " pages in "
"memory and %" PRIu64 " pages evicted",
cache->pages_inmem, cache->pages_evict);
if (cache->bytes_inmem != 0)
__wt_errx(session,
"cache server: exiting with %" PRIu64 " bytes in memory",
cache->bytes_inmem);
if (cache->bytes_dirty_intl + cache->bytes_dirty_leaf != 0 ||
cache->pages_dirty_intl + cache->pages_dirty_leaf != 0)
__wt_errx(session,
"cache server: exiting with %" PRIu64
" bytes dirty and %" PRIu64 " pages dirty",
cache->bytes_dirty_intl + cache->bytes_dirty_leaf,
cache->pages_dirty_intl + cache->pages_dirty_leaf);
WT_TRET(__wt_cond_auto_destroy(session, &cache->evict_cond));
__wt_spin_destroy(session, &cache->evict_pass_lock);
__wt_spin_destroy(session, &cache->evict_queue_lock);
__wt_spin_destroy(session, &cache->evict_walk_lock);
wt_session = &cache->walk_session->iface;
if (wt_session != NULL)
WT_TRET(wt_session->close(wt_session, NULL));
for (i = 0; i < WT_EVICT_QUEUE_MAX; ++i) {
__wt_spin_destroy(session, &cache->evict_queues[i].evict_lock);
__wt_free(session, cache->evict_queues[i].evict_queue);
}
__wt_free(session, conn->cache);
return (ret);
}
/*销毁一个connection evict cache对象*/
int __wt_cache_destroy(WT_SESSION_IMPL *session)
{
WT_CACHE *cache;
WT_CONNECTION_IMPL *conn;
WT_DECL_RET;
conn = S2C(session);
cache = conn->cache;
if (cache == NULL)
return 0;
WT_TRET(__wt_cond_destroy(session, &cache->evict_cond));
WT_TRET(__wt_cond_destroy(session, &cache->evict_waiter_cond));
__wt_spin_destroy(session, &cache->evict_lock);
__wt_spin_destroy(session, &cache->evict_walk_lock);
__wt_free(session, cache->evict);
__wt_free(session, conn->cache);
return ret;
}
/*
* __wt_cache_destroy --
* Discard the underlying cache.
*/
int
__wt_cache_destroy(WT_SESSION_IMPL *session)
{
WT_CACHE *cache;
WT_CONNECTION_IMPL *conn;
WT_DECL_RET;
conn = S2C(session);
cache = conn->cache;
if (cache == NULL)
return (0);
/* The cache should be empty at this point. Complain if not. */
if (cache->pages_inmem != cache->pages_evict)
__wt_errx(session,
"cache server: exiting with %" PRIu64 " pages in "
"memory and %" PRIu64 " pages evicted",
cache->pages_inmem, cache->pages_evict);
if (cache->bytes_inmem != 0)
__wt_errx(session,
"cache server: exiting with %" PRIu64 " bytes in memory",
cache->bytes_inmem);
if (cache->bytes_dirty != 0 || cache->pages_dirty != 0)
__wt_errx(session,
"cache server: exiting with %" PRIu64
" bytes dirty and %" PRIu64 " pages dirty",
cache->bytes_dirty, cache->pages_dirty);
WT_TRET(__wt_cond_auto_destroy(session, &cache->evict_cond));
WT_TRET(__wt_cond_destroy(session, &cache->evict_waiter_cond));
__wt_spin_destroy(session, &cache->evict_lock);
__wt_spin_destroy(session, &cache->evict_walk_lock);
__wt_free(session, cache->evict_queue);
__wt_free(session, conn->cache);
return (ret);
}
/*
* __wt_connection_destroy --
* Destroy the connection's underlying WT_CONNECTION_IMPL structure.
*/
void
__wt_connection_destroy(WT_CONNECTION_IMPL *conn)
{
WT_SESSION_IMPL *session;
/* Check there's something to destroy. */
if (conn == NULL)
return;
session = conn->default_session;
/* Remove from the list of connections. */
__wt_spin_lock(session, &__wt_process.spinlock);
TAILQ_REMOVE(&__wt_process.connqh, conn, q);
__wt_spin_unlock(session, &__wt_process.spinlock);
/* Configuration */
__wt_conn_config_discard(session); /* configuration */
__wt_conn_foc_discard(session); /* free-on-close */
__wt_spin_destroy(session, &conn->api_lock);
__wt_spin_destroy(session, &conn->block_lock);
__wt_spin_destroy(session, &conn->checkpoint_lock);
__wt_rwlock_destroy(session, &conn->dhandle_lock);
__wt_spin_destroy(session, &conn->encryptor_lock);
__wt_spin_destroy(session, &conn->fh_lock);
__wt_rwlock_destroy(session, &conn->hot_backup_lock);
__wt_spin_destroy(session, &conn->metadata_lock);
__wt_spin_destroy(session, &conn->reconfig_lock);
__wt_spin_destroy(session, &conn->schema_lock);
__wt_rwlock_destroy(session, &conn->table_lock);
__wt_spin_destroy(session, &conn->turtle_lock);
/* Free allocated memory. */
__wt_free(session, conn->cfg);
__wt_free(session, conn->home);
__wt_free(session, conn->error_prefix);
__wt_free(session, conn->sessions);
__wt_stat_connection_discard(session, conn);
__wt_free(NULL, conn);
}
/*
* __wt_txn_global_destroy --
* Destroy the global transaction state.
*/
void
__wt_txn_global_destroy(WT_SESSION_IMPL *session)
{
WT_CONNECTION_IMPL *conn;
WT_TXN_GLOBAL *txn_global;
conn = S2C(session);
txn_global = &conn->txn_global;
if (txn_global == NULL)
return;
__wt_spin_destroy(session, &txn_global->id_lock);
__wt_rwlock_destroy(session, &txn_global->scan_rwlock);
__wt_rwlock_destroy(session, &txn_global->nsnap_rwlock);
__wt_free(session, txn_global->states);
}
/*
* __block_destroy --
* Destroy a block handle.
*/
static int
__block_destroy(WT_SESSION_IMPL *session, WT_BLOCK *block)
{
WT_CONNECTION_IMPL *conn;
WT_DECL_RET;
conn = S2C(session);
TAILQ_REMOVE(&conn->blockqh, block, q);
if (block->name != NULL)
__wt_free(session, block->name);
if (block->fh != NULL)
WT_TRET(__wt_close(session, block->fh));
__wt_spin_destroy(session, &block->live_lock);
__wt_overwrite_and_free(session, block);
return (ret);
}
/*
* __wt_conn_optrack_teardown --
* Clean up connection-wide resources used for operation logging.
*/
int
__wt_conn_optrack_teardown(WT_SESSION_IMPL *session, bool reconfig)
{
WT_CONNECTION_IMPL *conn;
WT_DECL_RET;
conn = S2C(session);
if (!reconfig)
/* Looks like we are shutting down */
__wt_free(session, conn->optrack_path);
if (!F_ISSET(conn, WT_CONN_OPTRACK))
return (0);
__wt_spin_destroy(session, &conn->optrack_map_spinlock);
WT_TRET(__wt_close(session, &conn->optrack_map_fh));
__wt_free(session, conn->dummy_session.optrack_buf);
return (ret);
}
/*
* __wt_connection_destroy --
* Destroy the connection's underlying WT_CONNECTION_IMPL structure.
*/
int
__wt_connection_destroy(WT_CONNECTION_IMPL *conn)
{
WT_DECL_RET;
WT_SESSION_IMPL *session;
/* Check there's something to destroy. */
if (conn == NULL)
return (0);
session = conn->default_session;
/*
* Close remaining open files (before discarding the mutex, the
* underlying file-close code uses the mutex to guard lists of
* open files.
*/
if (conn->lock_fh != NULL)
WT_TRET(__wt_close(session, conn->lock_fh));
if (conn->log_fh != NULL)
WT_TRET(__wt_close(session, conn->log_fh));
/* Remove from the list of connections. */
__wt_spin_lock(session, &__wt_process.spinlock);
TAILQ_REMOVE(&__wt_process.connqh, conn, q);
__wt_spin_unlock(session, &__wt_process.spinlock);
__wt_spin_destroy(session, &conn->api_lock);
__wt_spin_destroy(session, &conn->fh_lock);
__wt_spin_destroy(session, &conn->metadata_lock);
__wt_spin_destroy(session, &conn->schema_lock);
__wt_spin_destroy(session, &conn->serial_lock);
__wt_spin_destroy(session, &conn->block_lock);
/* Free allocated memory. */
__wt_free(session, conn->home);
__wt_free(session, conn->sessions);
__wt_free(NULL, conn);
return (ret);
}
/*
* __wt_logmgr_destroy --
* Destroy the log archiving server thread and logging subsystem.
*/
int
__wt_logmgr_destroy(WT_SESSION_IMPL *session)
{
WT_CONNECTION_IMPL *conn;
WT_DECL_RET;
WT_SESSION *wt_session;
conn = S2C(session);
if (!FLD_ISSET(conn->log_flags, WT_CONN_LOG_ENABLED)) {
/*
* We always set up the log_path so printlog can work without
* recovery. Therefore, always free it, even if logging isn't
* on.
*/
__wt_free(session, conn->log_path);
return (0);
}
if (conn->log_tid_set) {
WT_TRET(__wt_cond_signal(session, conn->log_cond));
WT_TRET(__wt_thread_join(session, conn->log_tid));
conn->log_tid_set = 0;
}
if (conn->log_file_tid_set) {
WT_TRET(__wt_cond_signal(session, conn->log_file_cond));
WT_TRET(__wt_thread_join(session, conn->log_file_tid));
conn->log_file_tid_set = 0;
}
if (conn->log_file_session != NULL) {
wt_session = &conn->log_file_session->iface;
WT_TRET(wt_session->close(wt_session, NULL));
conn->log_file_session = NULL;
}
if (conn->log_wrlsn_tid_set) {
WT_TRET(__wt_cond_signal(session, conn->log_wrlsn_cond));
WT_TRET(__wt_thread_join(session, conn->log_wrlsn_tid));
conn->log_wrlsn_tid_set = 0;
}
if (conn->log_wrlsn_session != NULL) {
wt_session = &conn->log_wrlsn_session->iface;
WT_TRET(wt_session->close(wt_session, NULL));
conn->log_wrlsn_session = NULL;
}
WT_TRET(__wt_log_slot_destroy(session));
WT_TRET(__wt_log_close(session));
/* Close the server thread's session. */
if (conn->log_session != NULL) {
wt_session = &conn->log_session->iface;
WT_TRET(wt_session->close(wt_session, NULL));
conn->log_session = NULL;
}
/* Destroy the condition variables now that all threads are stopped */
WT_TRET(__wt_cond_destroy(session, &conn->log_cond));
WT_TRET(__wt_cond_destroy(session, &conn->log_file_cond));
WT_TRET(__wt_cond_destroy(session, &conn->log_wrlsn_cond));
WT_TRET(__wt_cond_destroy(session, &conn->log->log_sync_cond));
WT_TRET(__wt_cond_destroy(session, &conn->log->log_write_cond));
WT_TRET(__wt_rwlock_destroy(session, &conn->log->log_archive_lock));
__wt_spin_destroy(session, &conn->log->log_lock);
__wt_spin_destroy(session, &conn->log->log_slot_lock);
__wt_spin_destroy(session, &conn->log->log_sync_lock);
__wt_spin_destroy(session, &conn->log->log_writelsn_lock);
__wt_free(session, conn->log_path);
__wt_free(session, conn->log);
return (ret);
}
/*
* __wt_connection_destroy --
* Destroy the connection's underlying WT_CONNECTION_IMPL structure.
*/
int
__wt_connection_destroy(WT_CONNECTION_IMPL *conn)
{
WT_DECL_RET;
WT_SESSION_IMPL *session;
u_int i;
/* Check there's something to destroy. */
if (conn == NULL)
return (0);
session = conn->default_session;
/* Remove from the list of connections. */
__wt_spin_lock(session, &__wt_process.spinlock);
TAILQ_REMOVE(&__wt_process.connqh, conn, q);
__wt_spin_unlock(session, &__wt_process.spinlock);
/* Configuration */
__wt_conn_config_discard(session); /* configuration */
__wt_conn_foc_discard(session); /* free-on-close */
__wt_spin_destroy(session, &conn->api_lock);
__wt_spin_destroy(session, &conn->block_lock);
__wt_spin_destroy(session, &conn->checkpoint_lock);
__wt_spin_destroy(session, &conn->dhandle_lock);
__wt_spin_destroy(session, &conn->encryptor_lock);
__wt_spin_destroy(session, &conn->fh_lock);
__wt_rwlock_destroy(session, &conn->hot_backup_lock);
__wt_spin_destroy(session, &conn->las_lock);
__wt_spin_destroy(session, &conn->metadata_lock);
__wt_spin_destroy(session, &conn->reconfig_lock);
__wt_spin_destroy(session, &conn->schema_lock);
__wt_spin_destroy(session, &conn->table_lock);
__wt_spin_destroy(session, &conn->turtle_lock);
for (i = 0; i < WT_PAGE_LOCKS; ++i)
__wt_spin_destroy(session, &conn->page_lock[i]);
__wt_free(session, conn->page_lock);
/* Destroy the file-system configuration. */
if (conn->file_system != NULL && conn->file_system->terminate != NULL)
WT_TRET(conn->file_system->terminate(
conn->file_system, (WT_SESSION *)session));
/* Free allocated memory. */
__wt_free(session, conn->cfg);
__wt_free(session, conn->home);
__wt_free(session, conn->error_prefix);
__wt_free(session, conn->sessions);
__wt_stat_connection_discard(session, conn);
__wt_free(NULL, conn);
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);
}
