/*
* __wt_open --
* Open a file handle.
*/
int
__wt_open(WT_SESSION_IMPL *session,
const char *name, uint32_t file_type, uint32_t flags, WT_FH **fhp)
{
WT_CONNECTION_IMPL *conn;
WT_DECL_RET;
WT_FH *fh;
bool lock_file, open_called;
char *path;
WT_ASSERT(session, file_type != 0); /* A file type is required. */
conn = S2C(session);
fh = NULL;
open_called = false;
path = NULL;
WT_RET(__open_verbose(session, name, file_type, flags));
/* Check if the handle is already open. */
if (__wt_handle_search(session, name, true, NULL, &fh)) {
/*
* XXX
* The in-memory implementation has to reset the file offset
* when a file is re-opened (which obviously also depends on
* in-memory configurations never opening a file in more than
* one thread at a time). This needs to be fixed.
*/
if (F_ISSET(fh, WT_FH_IN_MEMORY) && fh->ref == 1)
fh->off = 0;
*fhp = fh;
return (0);
}
/* Allocate a structure and set the name. */
WT_ERR(__wt_calloc_one(session, &fh));
WT_ERR(__wt_strdup(session, name, &fh->name));
/*
* If this is a read-only connection, open all files read-only except
* the lock file.
*
* The only file created in read-only mode is the lock file.
*/
if (F_ISSET(conn, WT_CONN_READONLY)) {
lock_file = strcmp(name, WT_SINGLETHREAD) == 0;
if (!lock_file)
LF_SET(WT_OPEN_READONLY);
WT_ASSERT(session, lock_file || !LF_ISSET(WT_OPEN_CREATE));
}
/* Create the path to the file. */
if (!LF_ISSET(WT_OPEN_FIXED))
WT_ERR(__wt_filename(session, name, &path));
/* Call the underlying open function. */
WT_ERR(conn->handle_open(
session, fh, path == NULL ? name : path, file_type, flags));
open_called = true;
/*
* Repeat the check for a match: if there's no match, link our newly
* created handle onto the database's list of files.
*/
if (__wt_handle_search(session, name, true, fh, fhp)) {
err:
if (open_called)
WT_TRET(fh->fh_close(session, fh));
if (fh != NULL) {
__wt_free(session, fh->name);
__wt_free(session, fh);
}
}
__wt_free(session, path);
return (ret);
}
/*
* __txn_op_apply --
* Apply a transactional operation during recovery.
*/
static int
__txn_op_apply(
WT_RECOVERY *r, WT_LSN *lsnp, const uint8_t **pp, const uint8_t *end)
{
WT_CURSOR *cursor, *start, *stop;
WT_DECL_RET;
WT_ITEM key, start_key, stop_key, value;
WT_SESSION_IMPL *session;
uint64_t recno, start_recno, stop_recno;
uint32_t fileid, mode, optype, opsize;
session = r->session;
cursor = NULL;
/* Peek at the size and the type. */
WT_ERR(__wt_logop_read(session, pp, end, &optype, &opsize));
end = *pp + opsize;
switch (optype) {
case WT_LOGOP_COL_PUT:
WT_ERR(__wt_logop_col_put_unpack(session, pp, end,
&fileid, &recno, &value));
GET_RECOVERY_CURSOR(session, r, lsnp, fileid, &cursor);
cursor->set_key(cursor, recno);
__wt_cursor_set_raw_value(cursor, &value);
WT_ERR(cursor->insert(cursor));
break;
case WT_LOGOP_COL_REMOVE:
WT_ERR(__wt_logop_col_remove_unpack(session, pp, end,
&fileid, &recno));
GET_RECOVERY_CURSOR(session, r, lsnp, fileid, &cursor);
cursor->set_key(cursor, recno);
WT_ERR(cursor->remove(cursor));
break;
case WT_LOGOP_COL_TRUNCATE:
WT_ERR(__wt_logop_col_truncate_unpack(session, pp, end,
&fileid, &start_recno, &stop_recno));
GET_RECOVERY_CURSOR(session, r, lsnp, fileid, &cursor);
/* Set up the cursors. */
if (start_recno == WT_RECNO_OOB) {
start = NULL;
stop = cursor;
} else if (stop_recno == WT_RECNO_OOB) {
start = cursor;
stop = NULL;
} else {
start = cursor;
WT_ERR(__recovery_cursor(
session, r, lsnp, fileid, true, &stop));
}
/* Set the keys. */
if (start != NULL)
start->set_key(start, start_recno);
if (stop != NULL)
stop->set_key(stop, stop_recno);
WT_TRET(session->iface.truncate(&session->iface, NULL,
start, stop, NULL));
/* If we opened a duplicate cursor, close it now. */
if (stop != NULL && stop != cursor)
WT_TRET(stop->close(stop));
WT_ERR(ret);
break;
case WT_LOGOP_ROW_PUT:
WT_ERR(__wt_logop_row_put_unpack(session, pp, end,
&fileid, &key, &value));
GET_RECOVERY_CURSOR(session, r, lsnp, fileid, &cursor);
__wt_cursor_set_raw_key(cursor, &key);
__wt_cursor_set_raw_value(cursor, &value);
WT_ERR(cursor->insert(cursor));
break;
case WT_LOGOP_ROW_REMOVE:
WT_ERR(__wt_logop_row_remove_unpack(session, pp, end,
&fileid, &key));
GET_RECOVERY_CURSOR(session, r, lsnp, fileid, &cursor);
__wt_cursor_set_raw_key(cursor, &key);
WT_ERR(cursor->remove(cursor));
break;
case WT_LOGOP_ROW_TRUNCATE:
WT_ERR(__wt_logop_row_truncate_unpack(session, pp, end,
&fileid, &start_key, &stop_key, &mode));
GET_RECOVERY_CURSOR(session, r, lsnp, fileid, &cursor);
/* Set up the cursors. */
start = stop = NULL;
switch (mode) {
case WT_TXN_TRUNC_ALL:
/* Both cursors stay NULL. */
break;
case WT_TXN_TRUNC_BOTH:
start = cursor;
WT_ERR(__recovery_cursor(
session, r, lsnp, fileid, true, &stop));
break;
case WT_TXN_TRUNC_START:
start = cursor;
break;
case WT_TXN_TRUNC_STOP:
stop = cursor;
break;
WT_ILLEGAL_VALUE_ERR(session);
}
/* Set the keys. */
if (start != NULL)
__wt_cursor_set_raw_key(start, &start_key);
if (stop != NULL)
__wt_cursor_set_raw_key(stop, &stop_key);
WT_TRET(session->iface.truncate(&session->iface, NULL,
start, stop, NULL));
/* If we opened a duplicate cursor, close it now. */
if (stop != NULL && stop != cursor)
WT_TRET(stop->close(stop));
WT_ERR(ret);
break;
WT_ILLEGAL_VALUE_ERR(session);
}
/* Reset the cursor so it doesn't block eviction. */
if (cursor != NULL)
WT_ERR(cursor->reset(cursor));
err: if (ret != 0)
__wt_err(session, ret, "Operation failed during recovery");
return (ret);
}
/*
* __wt_page_in_func --
* Acquire a hazard pointer to a page; if the page is not in-memory,
* read it from the disk and build an in-memory version.
*/
int
__wt_page_in_func(WT_SESSION_IMPL *session, WT_REF *ref, uint32_t flags
#ifdef HAVE_DIAGNOSTIC
, const char *file, int line
#endif
)
{
WT_DECL_RET;
WT_PAGE *page;
u_int sleep_cnt, wait_cnt;
int busy, force_attempts, oldgen;
for (force_attempts = oldgen = 0, wait_cnt = 0;;) {
switch (ref->state) {
case WT_REF_DISK:
case WT_REF_DELETED:
if (LF_ISSET(WT_READ_CACHE))
return (WT_NOTFOUND);
/*
* The page isn't in memory, attempt to read it.
* Make sure there is space in the cache.
*/
WT_RET(__wt_cache_full_check(session));
WT_RET(__wt_cache_read(session, ref));
oldgen = LF_ISSET(WT_READ_WONT_NEED) ||
F_ISSET(session, WT_SESSION_NO_CACHE);
continue;
case WT_REF_READING:
if (LF_ISSET(WT_READ_CACHE))
return (WT_NOTFOUND);
if (LF_ISSET(WT_READ_NO_WAIT))
return (WT_NOTFOUND);
WT_STAT_FAST_CONN_INCR(session, page_read_blocked);
break;
case WT_REF_LOCKED:
if (LF_ISSET(WT_READ_NO_WAIT))
return (WT_NOTFOUND);
WT_STAT_FAST_CONN_INCR(session, page_locked_blocked);
break;
case WT_REF_SPLIT:
return (WT_RESTART);
case WT_REF_MEM:
/*
* The page is in memory: get a hazard pointer, update
* the page's LRU and return. The expected reason we
* can't get a hazard pointer is because the page is
* being evicted; yield and try again.
*/
#ifdef HAVE_DIAGNOSTIC
WT_RET(
__wt_hazard_set(session, ref, &busy, file, line));
#else
WT_RET(__wt_hazard_set(session, ref, &busy));
#endif
if (busy) {
WT_STAT_FAST_CONN_INCR(
session, page_busy_blocked);
break;
}
page = ref->page;
WT_ASSERT(session, page != NULL);
/* Forcibly evict pages that are too big. */
if (!LF_ISSET(WT_READ_NO_EVICT) &&
force_attempts < 10 &&
__evict_force_check(session, page)) {
++force_attempts;
if ((ret = __wt_page_release_busy(
session, ref, flags)) == EBUSY) {
/* If forced eviction fails, stall. */
ret = 0;
wait_cnt += 1000;
} else
WT_RET(ret);
WT_STAT_FAST_CONN_INCR(
session, page_forcible_evict_blocked);
break;
}
/* Check if we need an autocommit transaction. */
if ((ret = __wt_txn_autocommit_check(session)) != 0) {
WT_TRET(__wt_hazard_clear(session, page));
return (ret);
}
/*
* If we read the page and we are configured to not
* trash the cache, set the oldest read generation so
* the page is forcibly evicted as soon as possible.
*
* Otherwise, update the page's read generation.
*/
if (oldgen && page->read_gen == WT_READGEN_NOTSET)
__wt_page_evict_soon(page);
else if (!LF_ISSET(WT_READ_NO_GEN) &&
page->read_gen < __wt_cache_read_gen(session))
page->read_gen =
__wt_cache_read_gen_set(session);
return (0);
WT_ILLEGAL_VALUE(session);
}
/*
* We failed to get the page -- yield before retrying, and if
* we've yielded enough times, start sleeping so we don't burn
* CPU to no purpose.
*/
if (++wait_cnt < 1000)
__wt_yield();
else {
sleep_cnt = WT_MIN(wait_cnt, 10000);
wait_cnt *= 2;
WT_STAT_FAST_CONN_INCRV(session, page_sleep, sleep_cnt);
__wt_sleep(0, sleep_cnt);
}
}
}
/*
* __wt_btcur_update --
* Update a record in the tree.
*/
int
__wt_btcur_update(WT_CURSOR_BTREE *cbt)
{
WT_BTREE *btree;
WT_CURSOR *cursor;
WT_DECL_RET;
WT_SESSION_IMPL *session;
btree = cbt->btree;
cursor = &cbt->iface;
session = (WT_SESSION_IMPL *)cursor->session;
WT_STAT_FAST_CONN_INCR(session, cursor_update);
WT_STAT_FAST_DATA_INCR(session, cursor_update);
WT_STAT_FAST_DATA_INCRV(
session, cursor_update_bytes, cursor->value.size);
if (btree->type == BTREE_ROW)
WT_RET(__cursor_size_chk(session, &cursor->key));
WT_RET(__cursor_size_chk(session, &cursor->value));
/*
* The tree is no longer empty: eviction should pay attention to it,
* and it's no longer possible to bulk-load into it.
*/
if (btree->bulk_load_ok) {
btree->bulk_load_ok = 0;
__wt_btree_evictable(session, 1);
}
retry: WT_RET(__cursor_func_init(cbt, 1));
switch (btree->type) {
case BTREE_COL_FIX:
case BTREE_COL_VAR:
WT_ERR(__cursor_col_search(session, cbt, NULL));
/*
* If not overwriting, fail if the key doesn't exist. If we
* find an update for the key, check for conflicts. Update the
* record if it exists. Creating a record past the end of the
* tree in a fixed-length column-store implicitly fills the gap
* with empty records. Update the record in that case, the
* record exists.
*/
if (!F_ISSET(cursor, WT_CURSTD_OVERWRITE)) {
WT_ERR(__curfile_update_check(cbt));
if ((cbt->compare != 0 || !__cursor_valid(cbt, NULL)) &&
!__cursor_fix_implicit(btree, cbt))
WT_ERR(WT_NOTFOUND);
}
ret = __cursor_col_modify(session, cbt, 0);
break;
case BTREE_ROW:
WT_ERR(__cursor_row_search(session, cbt, NULL, 1));
/*
* If not overwriting, check for conflicts and fail if the key
* does not exist.
*/
if (!F_ISSET(cursor, WT_CURSTD_OVERWRITE)) {
WT_ERR(__curfile_update_check(cbt));
if (cbt->compare != 0 || !__cursor_valid(cbt, NULL))
WT_ERR(WT_NOTFOUND);
}
ret = __cursor_row_modify(session, cbt, 0);
break;
WT_ILLEGAL_VALUE_ERR(session);
}
err: if (ret == WT_RESTART)
goto retry;
/*
* If successful, point the cursor at internal copies of the data. We
* could shuffle memory in the cursor so the key/value pair are in local
* buffer memory, but that's a data copy. We don't want to do another
* search (and we might get a different update structure if we race).
* To make this work, we add a field to the btree cursor to pass back a
* pointer to the modify function's allocated update structure.
*/
if (ret == 0)
WT_TRET(__wt_kv_return(session, cbt, cbt->modify_update));
if (ret != 0)
WT_TRET(__cursor_reset(cbt));
return (ret);
}
/*
* __log_archive_once --
* Perform one iteration of log archiving. Must be called with the
* log archive lock held.
*/
static int
__log_archive_once(WT_SESSION_IMPL *session, uint32_t backup_file)
{
WT_CONNECTION_IMPL *conn;
WT_DECL_RET;
WT_LOG *log;
uint32_t lognum, min_lognum;
u_int i, logcount;
bool locked;
char **logfiles;
conn = S2C(session);
log = conn->log;
logcount = 0;
locked = false;
logfiles = NULL;
/*
* If we're coming from a backup cursor we want the smaller of
* the last full log file copied in backup or the checkpoint LSN.
* Otherwise we want the minimum of the last log file written to
* disk and the checkpoint LSN.
*/
if (backup_file != 0)
min_lognum = WT_MIN(log->ckpt_lsn.l.file, backup_file);
else
min_lognum = WT_MIN(
log->ckpt_lsn.l.file, log->sync_lsn.l.file);
__wt_verbose(session, WT_VERB_LOG,
"log_archive: archive to log number %" PRIu32, min_lognum);
/*
* Main archive code. Get the list of all log files and
* remove any earlier than the minimum log number.
*/
WT_ERR(__wt_fs_directory_list(
session, conn->log_path, WT_LOG_FILENAME, &logfiles, &logcount));
/*
* We can only archive files if a hot backup is not in progress or
* if we are the backup.
*/
__wt_readlock(session, &conn->hot_backup_lock);
locked = true;
if (!conn->hot_backup || backup_file != 0) {
for (i = 0; i < logcount; i++) {
WT_ERR(__wt_log_extract_lognum(
session, logfiles[i], &lognum));
if (lognum < min_lognum)
WT_ERR(__wt_log_remove(
session, WT_LOG_FILENAME, lognum));
}
}
__wt_readunlock(session, &conn->hot_backup_lock);
locked = false;
/*
* Indicate what is our new earliest LSN. It is the start
* of the log file containing the last checkpoint.
*/
WT_SET_LSN(&log->first_lsn, min_lognum, 0);
if (0)
err: __wt_err(session, ret, "log archive server error");
if (locked)
__wt_readunlock(session, &conn->hot_backup_lock);
WT_TRET(__wt_fs_directory_list_free(session, &logfiles, logcount));
return (ret);
}
/*
* __wt_btcur_search --
* Search for a matching record in the tree.
*/
int
__wt_btcur_search(WT_CURSOR_BTREE *cbt)
{
WT_BTREE *btree;
WT_CURSOR *cursor;
WT_DECL_RET;
WT_SESSION_IMPL *session;
WT_UPDATE *upd;
int valid;
btree = cbt->btree;
cursor = &cbt->iface;
session = (WT_SESSION_IMPL *)cursor->session;
upd = NULL; /* -Wuninitialized */
WT_STAT_FAST_CONN_INCR(session, cursor_search);
WT_STAT_FAST_DATA_INCR(session, cursor_search);
if (btree->type == BTREE_ROW)
WT_RET(__cursor_size_chk(session, &cursor->key));
/*
* If we have a page pinned, search it; if we don't have a page pinned,
* or the search of the pinned page doesn't find an exact match, search
* from the root.
*/
valid = 0;
if (F_ISSET(cbt, WT_CBT_ACTIVE) &&
cbt->ref->page->read_gen != WT_READGEN_OLDEST) {
__wt_txn_cursor_op(session);
WT_ERR(btree->type == BTREE_ROW ?
__cursor_row_search(session, cbt, cbt->ref, 0) :
__cursor_col_search(session, cbt, cbt->ref));
valid = cbt->compare == 0 && __cursor_valid(cbt, &upd);
}
if (!valid) {
WT_ERR(__cursor_func_init(cbt, 1));
WT_ERR(btree->type == BTREE_ROW ?
__cursor_row_search(session, cbt, NULL, 0) :
__cursor_col_search(session, cbt, NULL));
valid = cbt->compare == 0 && __cursor_valid(cbt, &upd);
}
if (valid)
ret = __wt_kv_return(session, cbt, upd);
else if (__cursor_fix_implicit(btree, cbt)) {
/*
* Creating a record past the end of the tree in a fixed-length
* column-store implicitly fills the gap with empty records.
*/
cbt->recno = cursor->recno;
cbt->v = 0;
cursor->value.data = &cbt->v;
cursor->value.size = 1;
} else
ret = WT_NOTFOUND;
err: if (ret != 0)
WT_TRET(__cursor_reset(cbt));
return (ret);
}
/*
* __wt_btcur_insert --
* Insert a record into the tree.
*/
int
__wt_btcur_insert(WT_CURSOR_BTREE *cbt)
{
WT_BTREE *btree;
WT_CURSOR *cursor;
WT_DECL_RET;
WT_SESSION_IMPL *session;
btree = cbt->btree;
cursor = &cbt->iface;
session = (WT_SESSION_IMPL *)cursor->session;
WT_STAT_FAST_CONN_INCR(session, cursor_insert);
WT_STAT_FAST_DATA_INCR(session, cursor_insert);
WT_STAT_FAST_DATA_INCRV(session,
cursor_insert_bytes, cursor->key.size + cursor->value.size);
if (btree->type == BTREE_ROW)
WT_RET(__cursor_size_chk(session, &cursor->key));
WT_RET(__cursor_size_chk(session, &cursor->value));
/*
* The tree is no longer empty: eviction should pay attention to it,
* and it's no longer possible to bulk-load into it.
*/
if (btree->bulk_load_ok) {
btree->bulk_load_ok = 0;
__wt_btree_evictable(session, 1);
}
retry: WT_RET(__cursor_func_init(cbt, 1));
switch (btree->type) {
case BTREE_COL_FIX:
case BTREE_COL_VAR:
/*
* If WT_CURSTD_APPEND is set, insert a new record (ignoring
* the application's record number). First we search for the
* maximum possible record number so the search ends on the
* last page. The real record number is assigned by the
* serialized append operation.
*/
if (F_ISSET(cursor, WT_CURSTD_APPEND))
cbt->iface.recno = UINT64_MAX;
WT_ERR(__cursor_col_search(session, cbt, NULL));
if (F_ISSET(cursor, WT_CURSTD_APPEND))
cbt->iface.recno = 0;
/*
* If not overwriting, fail if the key exists. Creating a
* record past the end of the tree in a fixed-length
* column-store implicitly fills the gap with empty records.
* Fail in that case, the record exists.
*/
if (!F_ISSET(cursor, WT_CURSTD_OVERWRITE) &&
((cbt->compare == 0 && __cursor_valid(cbt, NULL)) ||
(cbt->compare != 0 && __cursor_fix_implicit(btree, cbt))))
WT_ERR(WT_DUPLICATE_KEY);
WT_ERR(__cursor_col_modify(session, cbt, 0));
if (F_ISSET(cursor, WT_CURSTD_APPEND))
cbt->iface.recno = cbt->recno;
break;
case BTREE_ROW:
WT_ERR(__cursor_row_search(session, cbt, NULL, 1));
/*
* If not overwriting, fail if the key exists, else insert the
* key/value pair.
*/
if (!F_ISSET(cursor, WT_CURSTD_OVERWRITE) &&
cbt->compare == 0 && __cursor_valid(cbt, NULL))
WT_ERR(WT_DUPLICATE_KEY);
ret = __cursor_row_modify(session, cbt, 0);
break;
WT_ILLEGAL_VALUE_ERR(session);
}
err: if (ret == WT_RESTART)
goto retry;
/* Insert doesn't maintain a position across calls, clear resources. */
if (ret == 0)
WT_TRET(__curfile_leave(cbt));
if (ret != 0)
WT_TRET(__cursor_reset(cbt));
return (ret);
}
/*
* __lsm_bloom_create --
* Create a bloom filter for a chunk of the LSM tree that has been
* checkpointed but not yet been merged.
*/
static int
__lsm_bloom_create(WT_SESSION_IMPL *session,
WT_LSM_TREE *lsm_tree, WT_LSM_CHUNK *chunk, u_int chunk_off)
{
WT_BLOOM *bloom;
WT_CURSOR *src;
WT_DECL_RET;
WT_ITEM key;
uint64_t insert_count;
WT_RET(__wt_lsm_tree_setup_bloom(session, lsm_tree, chunk));
bloom = NULL;
/*
* This is merge-like activity, and we don't want compacts to give up
* because we are creating a bunch of bloom filters before merging.
*/
++lsm_tree->merge_progressing;
WT_RET(__wt_bloom_create(session, chunk->bloom_uri,
lsm_tree->bloom_config, chunk->count,
lsm_tree->bloom_bit_count, lsm_tree->bloom_hash_count, &bloom));
/* Open a special merge cursor just on this chunk. */
WT_ERR(__wt_open_cursor(session, lsm_tree->name, NULL, NULL, &src));
F_SET(src, WT_CURSTD_RAW);
WT_ERR(__wt_clsm_init_merge(src, chunk_off, chunk->id, 1));
/*
* Setup so that we don't hold pages we read into cache, and so
* that we don't get stuck if the cache is full. If we allow
* ourselves to get stuck creating bloom filters, the entire tree
* can stall since there may be no worker threads available to flush.
*/
F_SET(session, WT_SESSION_NO_CACHE | WT_SESSION_NO_EVICTION);
for (insert_count = 0; (ret = src->next(src)) == 0; insert_count++) {
WT_ERR(src->get_key(src, &key));
__wt_bloom_insert(bloom, &key);
}
WT_ERR_NOTFOUND_OK(ret);
WT_TRET(src->close(src));
WT_TRET(__wt_bloom_finalize(bloom));
WT_ERR(ret);
F_CLR(session, WT_SESSION_NO_CACHE);
/* Load the new Bloom filter into cache. */
WT_CLEAR(key);
WT_ERR_NOTFOUND_OK(__wt_bloom_get(bloom, &key));
__wt_verbose(session, WT_VERB_LSM,
"LSM worker created bloom filter %s. "
"Expected %" PRIu64 " items, got %" PRIu64,
chunk->bloom_uri, chunk->count, insert_count);
/* Ensure the bloom filter is in the metadata. */
__wt_lsm_tree_writelock(session, lsm_tree);
F_SET(chunk, WT_LSM_CHUNK_BLOOM);
ret = __wt_lsm_meta_write(session, lsm_tree);
++lsm_tree->dsk_gen;
__wt_lsm_tree_writeunlock(session, lsm_tree);
if (ret != 0)
WT_ERR_MSG(session, ret, "LSM bloom worker metadata write");
err: if (bloom != NULL)
WT_TRET(__wt_bloom_close(bloom));
F_CLR(session, WT_SESSION_NO_CACHE | WT_SESSION_NO_EVICTION);
return (ret);
}
/*
* __wt_lsm_free_chunks --
* Try to drop chunks from the tree that are no longer required.
*/
int
__wt_lsm_free_chunks(WT_SESSION_IMPL *session, WT_LSM_TREE *lsm_tree)
{
WT_DECL_RET;
WT_LSM_CHUNK *chunk;
WT_LSM_WORKER_COOKIE cookie;
u_int i, skipped;
int drop_ret;
bool flush_metadata;
flush_metadata = false;
if (lsm_tree->nold_chunks == 0)
return (0);
/*
* Make sure only a single thread is freeing the old chunk array
* at any time.
*/
if (!__wt_atomic_cas32(&lsm_tree->freeing_old_chunks, 0, 1))
return (0);
/*
* Take a copy of the current state of the LSM tree and look for chunks
* to drop. We do it this way to avoid holding the LSM tree lock while
* doing I/O or waiting on the schema lock.
*
* This is safe because only one thread will be in this function at a
* time. Merges may complete concurrently, and the old_chunks array
* may be extended, but we shuffle down the pointers each time we free
* one to keep the non-NULL slots at the beginning of the array.
*/
WT_CLEAR(cookie);
WT_RET(__lsm_copy_chunks(session, lsm_tree, &cookie, true));
for (i = skipped = 0; i < cookie.nchunks; i++) {
chunk = cookie.chunk_array[i];
WT_ASSERT(session, chunk != NULL);
/* Skip the chunk if another worker is using it. */
if (chunk->refcnt > 1) {
++skipped;
continue;
}
/*
* Don't remove files if a hot backup is in progress.
*
* The schema lock protects the set of live files, this check
* prevents us from removing a file that hot backup already
* knows about.
*/
if (S2C(session)->hot_backup)
break;
/*
* Drop any bloom filters and chunks we can. Don't try to drop
* a chunk if the bloom filter drop fails.
* An EBUSY return indicates that a cursor is still open in
* the tree - move to the next chunk in that case.
* An ENOENT return indicates that the LSM tree metadata was
* out of sync with the on disk state. Update the
* metadata to match in that case.
*/
if (F_ISSET(chunk, WT_LSM_CHUNK_BLOOM)) {
drop_ret = __lsm_drop_file(session, chunk->bloom_uri);
if (drop_ret == EBUSY) {
++skipped;
continue;
} else if (drop_ret != ENOENT)
WT_ERR(drop_ret);
flush_metadata = true;
F_CLR(chunk, WT_LSM_CHUNK_BLOOM);
}
if (chunk->uri != NULL) {
drop_ret = __lsm_drop_file(session, chunk->uri);
if (drop_ret == EBUSY) {
++skipped;
continue;
} else if (drop_ret != ENOENT)
WT_ERR(drop_ret);
flush_metadata = true;
}
/* Lock the tree to clear out the old chunk information. */
__wt_lsm_tree_writelock(session, lsm_tree);
/*
* The chunk we are looking at should be the first one in the
* tree that we haven't already skipped over.
*/
WT_ASSERT(session, lsm_tree->old_chunks[skipped] == chunk);
__wt_free(session, chunk->bloom_uri);
__wt_free(session, chunk->uri);
__wt_free(session, lsm_tree->old_chunks[skipped]);
/* Shuffle down to keep all occupied slots at the beginning. */
if (--lsm_tree->nold_chunks > skipped) {
memmove(lsm_tree->old_chunks + skipped,
lsm_tree->old_chunks + skipped + 1,
(lsm_tree->nold_chunks - skipped) *
sizeof(WT_LSM_CHUNK *));
lsm_tree->old_chunks[lsm_tree->nold_chunks] = NULL;
}
__wt_lsm_tree_writeunlock(session, lsm_tree);
/*
* Clear the chunk in the cookie so we don't attempt to
* decrement the reference count.
*/
cookie.chunk_array[i] = NULL;
}
err: /* Flush the metadata unless the system is in panic */
if (flush_metadata && ret != WT_PANIC) {
__wt_lsm_tree_writelock(session, lsm_tree);
WT_TRET(__wt_lsm_meta_write(session, lsm_tree));
__wt_lsm_tree_writeunlock(session, lsm_tree);
}
__lsm_unpin_chunks(session, &cookie);
__wt_free(session, cookie.chunk_array);
lsm_tree->freeing_old_chunks = 0;
/* Returning non-zero means there is no work to do. */
if (!flush_metadata)
WT_TRET(WT_NOTFOUND);
return (ret);
}
/*
* __wt_tree_walk --
* Move to the next/previous page in the tree.
*/
int
__wt_tree_walk(WT_SESSION_IMPL *session,
WT_REF **refp, uint64_t *walkcntp, uint32_t flags)
{
WT_BTREE *btree;
WT_DECL_RET;
WT_PAGE *page;
WT_PAGE_INDEX *pindex;
WT_REF *couple, *couple_orig, *ref;
bool empty_internal, prev, skip;
uint32_t slot;
btree = S2BT(session);
empty_internal = false;
/*
* Tree walks are special: they look inside page structures that splits
* may want to free. Publish that the tree is active during this
* window.
*/
WT_ENTER_PAGE_INDEX(session);
/* Walk should never instantiate deleted pages. */
LF_SET(WT_READ_NO_EMPTY);
/*
* !!!
* Fast-truncate currently only works on row-store trees.
*/
if (btree->type != BTREE_ROW)
LF_CLR(WT_READ_TRUNCATE);
prev = LF_ISSET(WT_READ_PREV) ? 1 : 0;
/*
* There are multiple reasons and approaches to walking the in-memory
* tree:
*
* (1) finding pages to evict (the eviction server);
* (2) writing just dirty leaves or internal nodes (checkpoint);
* (3) discarding pages (close);
* (4) truncating pages in a range (fast truncate);
* (5) skipping pages based on outside information (compaction);
* (6) cursor scans (applications).
*
* Except for cursor scans and compaction, the walk is limited to the
* cache, no pages are read. In all cases, hazard pointers protect the
* walked pages from eviction.
*
* Walks use hazard-pointer coupling through the tree and that's OK
* (hazard pointers can't deadlock, so there's none of the usual
* problems found when logically locking up a btree). If the eviction
* thread tries to evict the active page, it fails because of our
* hazard pointer. If eviction tries to evict our parent, that fails
* because the parent has a child page that can't be discarded. We do
* play one game: don't couple up to our parent and then back down to a
* new leaf, couple to the next page to which we're descending, it
* saves a hazard-pointer swap for each cursor page movement.
*
* !!!
* NOTE: we depend on the fact it's OK to release a page we don't hold,
* that is, it's OK to release couple when couple is set to NULL.
*
* Take a copy of any held page and clear the return value. Remember
* the hazard pointer we're currently holding.
*
* We may be passed a pointer to btree->evict_page that we are clearing
* here. We check when discarding pages that we're not discarding that
* page, so this clear must be done before the page is released.
*/
couple = couple_orig = ref = *refp;
*refp = NULL;
/* If no page is active, begin a walk from the start of the tree. */
if (ref == NULL) {
ref = &btree->root;
if (ref->page == NULL)
goto done;
goto descend;
}
ascend: /*
* If the active page was the root, we've reached the walk's end.
* Release any hazard-pointer we're holding.
*/
if (__wt_ref_is_root(ref)) {
WT_ERR(__wt_page_release(session, couple, flags));
goto done;
}
/* Figure out the current slot in the WT_REF array. */
__page_refp(session, ref, &pindex, &slot);
for (;;) {
/*
* If we're at the last/first slot on the page, return this page
* in post-order traversal. Otherwise we move to the next/prev
* slot and left/right-most element in its subtree.
*/
if ((prev && slot == 0) ||
(!prev && slot == pindex->entries - 1)) {
ref = ref->home->pg_intl_parent_ref;
/*
* If we got all the way through an internal page and
* all of the child pages were deleted, mark it for
* eviction.
*/
if (empty_internal && pindex->entries > 1) {
__wt_page_evict_soon(ref->page);
empty_internal = false;
}
/* Optionally skip internal pages. */
if (LF_ISSET(WT_READ_SKIP_INTL))
goto ascend;
/*
* We've ascended the tree and are returning an internal
* page. If it's the root, discard our hazard pointer,
* otherwise, swap our hazard pointer for the page we'll
* return.
*/
if (__wt_ref_is_root(ref))
WT_ERR(__wt_page_release(
session, couple, flags));
else {
/*
* Locate the reference to our parent page then
* swap our child hazard pointer for the parent.
* We don't handle restart or not-found returns.
* It would require additional complexity and is
* not a possible return: we're moving to the
* parent of the current child page, our parent
* reference can't have split or been evicted.
*/
__page_refp(session, ref, &pindex, &slot);
if ((ret = __wt_page_swap(
session, couple, ref, flags)) != 0) {
WT_TRET(__wt_page_release(
session, couple, flags));
WT_ERR(ret);
}
}
*refp = ref;
goto done;
}
if (prev)
--slot;
else
++slot;
if (walkcntp != NULL)
++*walkcntp;
for (;;) {
/*
* Move to the next slot, and set the reference hint if
* it's wrong (used when we continue the walk). We don't
* update those hints when splitting, so it's common for
* them to be incorrect in some workloads.
*/
ref = pindex->index[slot];
if (ref->pindex_hint != slot)
ref->pindex_hint = slot;
/*
* If we see any child states other than deleted, the
* page isn't empty.
*/
if (ref->state != WT_REF_DELETED &&
!LF_ISSET(WT_READ_TRUNCATE))
empty_internal = false;
if (LF_ISSET(WT_READ_CACHE)) {
/*
* Only look at unlocked pages in memory:
* fast-path some common cases.
*/
if (LF_ISSET(WT_READ_NO_WAIT) &&
ref->state != WT_REF_MEM)
break;
} else if (LF_ISSET(WT_READ_TRUNCATE)) {
/*
* Avoid pulling a deleted page back in to try
* to delete it again.
*/
if (ref->state == WT_REF_DELETED &&
__wt_delete_page_skip(session, ref, false))
break;
/*
* If deleting a range, try to delete the page
* without instantiating it.
*/
WT_ERR(__wt_delete_page(session, ref, &skip));
if (skip)
break;
empty_internal = false;
} else if (LF_ISSET(WT_READ_COMPACT)) {
/*
* Skip deleted pages, rewriting them doesn't
* seem useful.
*/
if (ref->state == WT_REF_DELETED)
break;
/*
* If the page is in-memory, we want to look at
* it (it may have been modified and written,
* and the current location is the interesting
* one in terms of compaction, not the original
* location). If the page isn't in-memory, test
* if the page will help with compaction, don't
* read it if we don't have to.
*/
if (ref->state == WT_REF_DISK) {
WT_ERR(__wt_compact_page_skip(
session, ref, &skip));
if (skip)
break;
}
} else {
/*
* Try to skip deleted pages visible to us.
*/
if (ref->state == WT_REF_DELETED &&
__wt_delete_page_skip(session, ref, false))
break;
}
ret = __wt_page_swap(session, couple, ref, flags);
/*
* Not-found is an expected return when only walking
* in-cache pages, or if we see a deleted page.
*/
if (ret == WT_NOTFOUND) {
ret = 0;
break;
}
/*
* The page we're moving to might have split, in which
* case move to the last position we held.
*/
if (ret == WT_RESTART) {
ret = 0;
/*
* If a new walk that never coupled from the
* root to a new saved position in the tree,
* restart the walk.
*/
if (couple == &btree->root) {
ref = &btree->root;
if (ref->page == NULL)
goto done;
goto descend;
}
/*
* If restarting from some original position,
* repeat the increment or decrement we made at
* that time. Otherwise, couple is an internal
* page we've acquired after moving from that
* starting position and we can treat it as a
* new page. This works because we never acquire
* a hazard pointer on a leaf page we're not
* going to return to our caller, this will quit
* working if that ever changes.
*/
WT_ASSERT(session,
couple == couple_orig ||
WT_PAGE_IS_INTERNAL(couple->page));
ref = couple;
__page_refp(session, ref, &pindex, &slot);
if (couple == couple_orig)
break;
}
WT_ERR(ret);
/*
* A new page: configure for traversal of any internal
* page's children, else return the leaf page.
*/
descend: couple = ref;
page = ref->page;
if (WT_PAGE_IS_INTERNAL(page)) {
WT_INTL_INDEX_GET(session, page, pindex);
slot = prev ? pindex->entries - 1 : 0;
empty_internal = true;
} else {
*refp = ref;
goto done;
}
}
}
done:
err: WT_LEAVE_PAGE_INDEX(session);
return (ret);
}
/*
* __wt_lsm_checkpoint_chunk --
* Flush a single LSM chunk to disk.
*/
int
__wt_lsm_checkpoint_chunk(WT_SESSION_IMPL *session,
WT_LSM_TREE *lsm_tree, WT_LSM_CHUNK *chunk)
{
WT_DECL_RET;
WT_TXN_ISOLATION saved_isolation;
bool flush_set;
flush_set = false;
/*
* If the chunk is already checkpointed, make sure it is also evicted.
* Either way, there is no point trying to checkpoint it again.
*/
if (F_ISSET(chunk, WT_LSM_CHUNK_ONDISK) &&
!F_ISSET(chunk, WT_LSM_CHUNK_STABLE) &&
!chunk->evicted) {
WT_WITH_HANDLE_LIST_LOCK(session,
ret = __lsm_discard_handle(session, chunk->uri, NULL));
if (ret == 0)
chunk->evicted = 1;
else if (ret == EBUSY)
ret = 0;
else
WT_RET_MSG(session, ret, "discard handle");
}
if (F_ISSET(chunk, WT_LSM_CHUNK_ONDISK)) {
__wt_verbose(session, WT_VERB_LSM,
"LSM worker %s already on disk",
chunk->uri);
return (0);
}
/* Stop if a running transaction needs the chunk. */
WT_RET(__wt_txn_update_oldest(
session, WT_TXN_OLDEST_STRICT | WT_TXN_OLDEST_WAIT));
if (chunk->switch_txn == WT_TXN_NONE ||
!__wt_txn_visible_all(session, chunk->switch_txn)) {
__wt_verbose(session, WT_VERB_LSM,
"LSM worker %s: running transaction, return",
chunk->uri);
return (0);
}
if (!__wt_atomic_cas8(&chunk->flushing, 0, 1))
return (0);
flush_set = true;
__wt_verbose(session, WT_VERB_LSM, "LSM worker flushing %s",
chunk->uri);
/*
* Flush the file before checkpointing: this is the expensive part in
* terms of I/O.
*
* !!!
* We can wait here for checkpoints and fsyncs to complete, which can
* take a long time.
*/
if ((ret = __wt_session_get_btree(
session, chunk->uri, NULL, NULL, 0)) == 0) {
/*
* Set read-uncommitted: we have already checked that all of the
* updates in this chunk are globally visible, use the cheapest
* possible check in reconciliation.
*/
saved_isolation = session->txn.isolation;
session->txn.isolation = WT_ISO_READ_UNCOMMITTED;
ret = __wt_cache_op(session, WT_SYNC_WRITE_LEAVES);
session->txn.isolation = saved_isolation;
WT_TRET(__wt_session_release_btree(session));
}
WT_ERR(ret);
__wt_verbose(session, WT_VERB_LSM, "LSM worker checkpointing %s",
chunk->uri);
/*
* Turn on metadata tracking to ensure the checkpoint gets the
* necessary handle locks.
*
* Ensure that we don't race with a running checkpoint: the checkpoint
* lock protects against us racing with an application checkpoint in
* this chunk. Don't wait for it, though: checkpoints can take a long
* time, and our checkpoint operation should be very quick.
*/
WT_ERR(__wt_meta_track_on(session));
WT_WITH_CHECKPOINT_LOCK(session, ret,
WT_WITH_SCHEMA_LOCK(session, ret,
ret = __wt_schema_worker(
session, chunk->uri, __wt_checkpoint, NULL, NULL, 0)));
WT_TRET(__wt_meta_track_off(session, false, ret != 0));
if (ret != 0)
WT_ERR_MSG(session, ret, "LSM checkpoint");
/* Now the file is written, get the chunk size. */
WT_ERR(__wt_lsm_tree_set_chunk_size(session, chunk));
/* Update the flush timestamp to help track ongoing progress. */
__wt_epoch(session, &lsm_tree->last_flush_ts);
++lsm_tree->chunks_flushed;
/* Lock the tree, mark the chunk as on disk and update the metadata. */
__wt_lsm_tree_writelock(session, lsm_tree);
F_SET(chunk, WT_LSM_CHUNK_ONDISK);
ret = __wt_lsm_meta_write(session, lsm_tree);
++lsm_tree->dsk_gen;
/* Update the throttle time. */
__wt_lsm_tree_throttle(session, lsm_tree, true);
__wt_lsm_tree_writeunlock(session, lsm_tree);
if (ret != 0)
WT_ERR_MSG(session, ret, "LSM metadata write");
WT_PUBLISH(chunk->flushing, 0);
flush_set = false;
/*
* Clear the no-eviction flag so the primary can be evicted and
* eventually closed. Only do this once the checkpoint has succeeded:
* otherwise, accessing the leaf page during the checkpoint can trigger
* forced eviction.
*/
WT_ERR(__wt_session_get_btree(session, chunk->uri, NULL, NULL, 0));
__wt_btree_evictable(session, true);
WT_ERR(__wt_session_release_btree(session));
/* Make sure we aren't pinning a transaction ID. */
__wt_txn_release_snapshot(session);
__wt_verbose(session, WT_VERB_LSM, "LSM worker checkpointed %s",
chunk->uri);
/* Schedule a bloom filter create for our newly flushed chunk. */
if (!FLD_ISSET(lsm_tree->bloom, WT_LSM_BLOOM_OFF))
WT_ERR(__wt_lsm_manager_push_entry(
session, WT_LSM_WORK_BLOOM, 0, lsm_tree));
else
WT_ERR(__wt_lsm_manager_push_entry(
session, WT_LSM_WORK_MERGE, 0, lsm_tree));
err: if (flush_set)
WT_PUBLISH(chunk->flushing, 0);
return (ret);
}
/*
* __wt_connection_close --
* Close a connection handle.
*/
int
__wt_connection_close(WT_CONNECTION_IMPL *conn)
{
WT_CONNECTION *wt_conn;
WT_DECL_RET;
WT_DLH *dlh;
WT_SESSION_IMPL *s, *session;
u_int i;
wt_conn = &conn->iface;
session = conn->default_session;
/* Shut down the subsystems, ensuring workers see the state change. */
F_SET(conn, WT_CONN_CLOSING);
WT_FULL_BARRIER();
/*
* Clear any pending async operations and shut down the async worker
* threads and system before closing LSM.
*/
WT_TRET(__wt_async_flush(session));
WT_TRET(__wt_async_destroy(session));
/*
* Shut down server threads other than the eviction server, which is
* needed later to close btree handles. Some of these threads access
* btree handles, so take care in ordering shutdown to make sure they
* exit before files are closed.
*/
WT_TRET(__wt_lsm_manager_destroy(session));
/*
* Once the async and LSM threads exit, we shouldn't be opening any
* more files.
*/
F_SET(conn, WT_CONN_CLOSING_NO_MORE_OPENS);
WT_FULL_BARRIER();
WT_TRET(__wt_checkpoint_server_destroy(session));
WT_TRET(__wt_statlog_destroy(session, true));
WT_TRET(__wt_sweep_destroy(session));
/* The eviction server is shut down last. */
WT_TRET(__wt_evict_destroy(session));
/* Close open data handles. */
WT_TRET(__wt_conn_dhandle_discard(session));
/* Shut down metadata tracking. */
WT_TRET(__wt_meta_track_destroy(session));
/*
* Now that all data handles are closed, tell logging that a checkpoint
* has completed then shut down the log manager (only after closing
* data handles). The call to destroy the log manager is outside the
* conditional because we allocate the log path so that printlog can
* run without running logging or recovery.
*/
if (ret == 0 && FLD_ISSET(conn->log_flags, WT_CONN_LOG_ENABLED) &&
FLD_ISSET(conn->log_flags, WT_CONN_LOG_RECOVER_DONE))
WT_TRET(__wt_txn_checkpoint_log(
session, true, WT_TXN_LOG_CKPT_STOP, NULL));
WT_TRET(__wt_logmgr_destroy(session));
/* Free memory for collators, compressors, data sources. */
WT_TRET(__wt_conn_remove_collator(session));
WT_TRET(__wt_conn_remove_compressor(session));
WT_TRET(__wt_conn_remove_data_source(session));
WT_TRET(__wt_conn_remove_encryptor(session));
WT_TRET(__wt_conn_remove_extractor(session));
/* Disconnect from shared cache - must be before cache destroy. */
WT_TRET(__wt_conn_cache_pool_destroy(session));
/* Discard the cache. */
WT_TRET(__wt_cache_destroy(session));
/* Discard transaction state. */
__wt_txn_global_destroy(session);
/* Close the lock file, opening up the database to other connections. */
if (conn->lock_fh != NULL)
WT_TRET(__wt_close(session, &conn->lock_fh));
/* Close any optrack files */
if (session->optrack_fh != NULL)
WT_TRET(__wt_close(session, &session->optrack_fh));
/* Close operation tracking */
WT_TRET(__wt_conn_optrack_teardown(session, false));
/* Close any file handles left open. */
WT_TRET(__wt_close_connection_close(session));
/*
* Close the internal (default) session, and switch back to the dummy
* session in case of any error messages from the remaining operations
* while destroying the connection handle.
*/
if (session != &conn->dummy_session) {
WT_TRET(session->iface.close(&session->iface, NULL));
session = conn->default_session = &conn->dummy_session;
}
/*
* The session split stash, hazard information and handle arrays aren't
* discarded during normal session close, they persist past the life of
* the session. Discard them now.
*/
if (!F_ISSET(conn, WT_CONN_LEAK_MEMORY))
if ((s = conn->sessions) != NULL)
for (i = 0; i < conn->session_size; ++s, ++i) {
__wt_free(session, s->cursor_cache);
__wt_free(session, s->dhhash);
__wt_stash_discard_all(session, s);
__wt_free(session, s->hazard);
}
/* 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));
/* Close extensions, first calling any unload entry point. */
while ((dlh = TAILQ_FIRST(&conn->dlhqh)) != NULL) {
TAILQ_REMOVE(&conn->dlhqh, dlh, q);
if (dlh->terminate != NULL)
WT_TRET(dlh->terminate(wt_conn));
WT_TRET(__wt_dlclose(session, dlh));
}
/* Destroy the handle. */
__wt_connection_destroy(conn);
return (ret);
}
/*
* __create_file --
* Create a new 'file:' object.
*/
static int
__create_file(WT_SESSION_IMPL *session,
const char *uri, int exclusive, const char *config)
{
WT_DECL_ITEM(val);
WT_DECL_RET;
uint32_t allocsize;
int is_metadata;
const char *filename, **p, *filecfg[] =
{ WT_CONFIG_BASE(session, file_meta), config, NULL, NULL };
char *fileconf;
fileconf = NULL;
is_metadata = strcmp(uri, WT_METAFILE_URI) == 0;
filename = uri;
if (!WT_PREFIX_SKIP(filename, "file:"))
WT_RET_MSG(session, EINVAL, "Expected a 'file:' URI: %s", uri);
/* Check if the file already exists. */
if (!is_metadata && (ret =
__wt_metadata_search(session, uri, &fileconf)) != WT_NOTFOUND) {
if (exclusive)
WT_TRET(EEXIST);
goto err;
}
/* Sanity check the allocation size. */
WT_RET(__wt_direct_io_size_check(
session, filecfg, "allocation_size", &allocsize));
/* Create the file. */
WT_ERR(__wt_block_manager_create(session, filename, allocsize));
if (WT_META_TRACKING(session))
WT_ERR(__wt_meta_track_fileop(session, NULL, uri));
/*
* If creating an ordinary file, append the file ID and current version
* numbers to the passed-in configuration and insert the resulting
* configuration into the metadata.
*/
if (!is_metadata) {
WT_ERR(__wt_scr_alloc(session, 0, &val));
WT_ERR(__wt_buf_fmt(session, val,
"id=%" PRIu32 ",version=(major=%d,minor=%d)",
++S2C(session)->next_file_id,
WT_BTREE_MAJOR_VERSION_MAX, WT_BTREE_MINOR_VERSION_MAX));
for (p = filecfg; *p != NULL; ++p)
;
*p = val->data;
WT_ERR(__wt_config_collapse(session, filecfg, &fileconf));
WT_ERR(__wt_metadata_insert(session, uri, fileconf));
}
/*
* Open the file to check that it was setup correctly. We don't need to
* pass the configuration, we just wrote the collapsed configuration
* into the metadata file, and it's going to be read/used by underlying
* functions.
*
* Keep the handle exclusive until it is released at the end of the
* call, otherwise we could race with a drop.
*/
WT_ERR(__wt_session_get_btree(
session, uri, NULL, NULL, WT_DHANDLE_EXCLUSIVE));
if (WT_META_TRACKING(session))
WT_ERR(__wt_meta_track_handle_lock(session, 1));
else
WT_ERR(__wt_session_release_btree(session));
err: __wt_scr_free(session, &val);
__wt_free(session, fileconf);
return (ret);
}
/*
* __create_table --
* Create a table.
*/
static int
__create_table(WT_SESSION_IMPL *session,
const char *name, int exclusive, const char *config)
{
WT_CONFIG conf;
WT_CONFIG_ITEM cgkey, cgval, cval;
WT_DECL_RET;
WT_TABLE *table;
const char *cfg[4] =
{ WT_CONFIG_BASE(session, table_meta), config, NULL, NULL };
const char *tablename;
char *tableconf, *cgname;
size_t cgsize;
int ncolgroups;
cgname = NULL;
table = NULL;
tableconf = NULL;
tablename = name;
if (!WT_PREFIX_SKIP(tablename, "table:"))
return (EINVAL);
if ((ret = __wt_schema_get_table(session,
tablename, strlen(tablename), 0, &table)) == 0) {
__wt_schema_release_table(session, table);
return (exclusive ? EEXIST : 0);
}
WT_RET_NOTFOUND_OK(ret);
WT_ERR(__wt_config_gets(session, cfg, "colgroups", &cval));
WT_ERR(__wt_config_subinit(session, &conf, &cval));
for (ncolgroups = 0;
(ret = __wt_config_next(&conf, &cgkey, &cgval)) == 0;
ncolgroups++)
;
WT_ERR_NOTFOUND_OK(ret);
WT_ERR(__wt_config_collapse(session, cfg, &tableconf));
if ((ret = __wt_metadata_insert(session, name, tableconf)) != 0) {
/*
* If the entry already exists in the metadata, we're done.
* This is an error for exclusive creates but okay otherwise.
*/
if (ret == WT_DUPLICATE_KEY)
ret = exclusive ? EEXIST : 0;
goto err;
}
/* Attempt to open the table now to catch any errors. */
WT_ERR(__wt_schema_get_table(
session, tablename, strlen(tablename), 1, &table));
if (ncolgroups == 0) {
cgsize = strlen("colgroup:") + strlen(tablename) + 1;
WT_ERR(__wt_calloc_def(session, cgsize, &cgname));
snprintf(cgname, cgsize, "colgroup:%s", tablename);
WT_ERR(__create_colgroup(session, cgname, exclusive, config));
}
if (0) {
err: if (table != NULL) {
WT_TRET(__wt_schema_remove_table(session, table));
table = NULL;
}
}
if (table != NULL)
__wt_schema_release_table(session, table);
__wt_free(session, cgname);
__wt_free(session, tableconf);
return (ret);
}
/*
* __sync_file --
* Flush pages for a specific file.
*/
static int
__sync_file(WT_SESSION_IMPL *session, WT_CACHE_OP syncop)
{
struct timespec end, start;
WT_BTREE *btree;
WT_DECL_RET;
WT_PAGE *page;
WT_PAGE_MODIFY *mod;
WT_REF *walk;
WT_TXN *txn;
uint64_t internal_bytes, internal_pages, leaf_bytes, leaf_pages;
uint64_t saved_snap_min;
uint32_t flags;
bool evict_reset;
btree = S2BT(session);
walk = NULL;
txn = &session->txn;
saved_snap_min = WT_SESSION_TXN_STATE(session)->snap_min;
flags = WT_READ_CACHE | WT_READ_NO_GEN;
internal_bytes = leaf_bytes = 0;
internal_pages = leaf_pages = 0;
if (WT_VERBOSE_ISSET(session, WT_VERB_CHECKPOINT))
WT_RET(__wt_epoch(session, &start));
switch (syncop) {
case WT_SYNC_WRITE_LEAVES:
/*
* Write all immediately available, dirty in-cache leaf pages.
*
* Writing the leaf pages is done without acquiring a high-level
* lock, serialize so multiple threads don't walk the tree at
* the same time.
*/
if (!btree->modified)
return (0);
__wt_spin_lock(session, &btree->flush_lock);
if (!btree->modified) {
__wt_spin_unlock(session, &btree->flush_lock);
return (0);
}
flags |= WT_READ_NO_WAIT | WT_READ_SKIP_INTL;
for (walk = NULL;;) {
WT_ERR(__wt_tree_walk(session, &walk, flags));
if (walk == NULL)
break;
/*
* Write dirty pages if nobody beat us to it. Don't
* try to write the hottest pages: checkpoint will have
* to visit them anyway.
*/
page = walk->page;
if (__wt_page_is_modified(page) &&
__wt_txn_visible_all(
session, page->modify->update_txn)) {
if (txn->isolation == WT_ISO_READ_COMMITTED)
__wt_txn_get_snapshot(session);
leaf_bytes += page->memory_footprint;
++leaf_pages;
WT_ERR(__wt_reconcile(session, walk, NULL, 0));
}
}
break;
case WT_SYNC_CHECKPOINT:
/*
* If we are flushing a file at read-committed isolation, which
* is of particular interest for flushing the metadata to make
* schema-changing operation durable, get a transactional
* snapshot now.
*
* All changes committed up to this point should be included.
* We don't update the snapshot in between pages because (a)
* the metadata shouldn't be that big, and (b) if we do ever
*/
if (txn->isolation == WT_ISO_READ_COMMITTED)
__wt_txn_get_snapshot(session);
/*
* We cannot check the tree modified flag in the case of a
* checkpoint, the checkpoint code has already cleared it.
*
* Writing the leaf pages is done without acquiring a high-level
* lock, serialize so multiple threads don't walk the tree at
* the same time. We're holding the schema lock, but need the
* lower-level lock as well.
*/
__wt_spin_lock(session, &btree->flush_lock);
/*
* When internal pages are being reconciled by checkpoint their
* child pages cannot disappear from underneath them or be split
* into them, nor can underlying blocks be freed until the block
* lists for the checkpoint are stable. Set the checkpointing
* flag to block eviction of dirty pages until the checkpoint's
* internal page pass is complete, then wait for any existing
* eviction to complete.
*/
WT_PUBLISH(btree->checkpointing, WT_CKPT_PREPARE);
WT_ERR(__wt_evict_file_exclusive_on(session, &evict_reset));
if (evict_reset)
__wt_evict_file_exclusive_off(session);
WT_PUBLISH(btree->checkpointing, WT_CKPT_RUNNING);
/* Write all dirty in-cache pages. */
flags |= WT_READ_NO_EVICT;
for (walk = NULL;;) {
WT_ERR(__wt_tree_walk(session, &walk, flags));
if (walk == NULL)
break;
/* Skip clean pages. */
if (!__wt_page_is_modified(walk->page))
continue;
/*
* Take a local reference to the page modify structure
* now that we know the page is dirty. It needs to be
* done in this order otherwise the page modify
* structure could have been created between taking the
* reference and checking modified.
*/
page = walk->page;
mod = page->modify;
/*
* Write dirty pages, unless we can be sure they only
* became dirty after the checkpoint started.
*
* We can skip dirty pages if:
* (1) they are leaf pages;
* (2) there is a snapshot transaction active (which
* is the case in ordinary application checkpoints
* but not all internal cases); and
* (3) the first dirty update on the page is
* sufficiently recent that the checkpoint
* transaction would skip them.
*
* Mark the tree dirty: the checkpoint marked it clean
* and we can't skip future checkpoints until this page
* is written.
*/
if (!WT_PAGE_IS_INTERNAL(page) &&
F_ISSET(txn, WT_TXN_HAS_SNAPSHOT) &&
WT_TXNID_LT(txn->snap_max, mod->first_dirty_txn)) {
__wt_page_modify_set(session, page);
continue;
}
if (WT_PAGE_IS_INTERNAL(page)) {
internal_bytes += page->memory_footprint;
++internal_pages;
} else {
leaf_bytes += page->memory_footprint;
++leaf_pages;
}
WT_ERR(__wt_reconcile(session, walk, NULL, 0));
}
break;
case WT_SYNC_CLOSE:
case WT_SYNC_DISCARD:
WT_ILLEGAL_VALUE_ERR(session);
}
if (WT_VERBOSE_ISSET(session, WT_VERB_CHECKPOINT)) {
WT_ERR(__wt_epoch(session, &end));
WT_ERR(__wt_verbose(session, WT_VERB_CHECKPOINT,
"__sync_file WT_SYNC_%s wrote:\n\t %" PRIu64
" bytes, %" PRIu64 " pages of leaves\n\t %" PRIu64
" bytes, %" PRIu64 " pages of internal\n\t"
"Took: %" PRIu64 "ms",
syncop == WT_SYNC_WRITE_LEAVES ?
"WRITE_LEAVES" : "CHECKPOINT",
leaf_bytes, leaf_pages, internal_bytes, internal_pages,
WT_TIMEDIFF_MS(end, start)));
}
err: /* On error, clear any left-over tree walk. */
if (walk != NULL)
WT_TRET(__wt_page_release(session, walk, flags));
/*
* If we got a snapshot in order to write pages, and there was no
* snapshot active when we started, release it.
*/
if (txn->isolation == WT_ISO_READ_COMMITTED &&
saved_snap_min == WT_TXN_NONE)
__wt_txn_release_snapshot(session);
if (btree->checkpointing != WT_CKPT_OFF) {
/*
* Update the checkpoint generation for this handle so visible
* updates newer than the checkpoint can be evicted.
*
* This has to be published before eviction is enabled again,
* so that eviction knows that the checkpoint has completed.
*/
WT_PUBLISH(btree->checkpoint_gen,
S2C(session)->txn_global.checkpoint_gen);
WT_STAT_FAST_DATA_SET(session,
btree_checkpoint_generation, btree->checkpoint_gen);
/*
* Clear the checkpoint flag and push the change; not required,
* but publishing the change means stalled eviction gets moving
* as soon as possible.
*/
btree->checkpointing = WT_CKPT_OFF;
WT_FULL_BARRIER();
/*
* If this tree was being skipped by the eviction server during
* the checkpoint, clear the wait.
*/
btree->evict_walk_period = 0;
/*
* Wake the eviction server, in case application threads have
* stalled while the eviction server decided it couldn't make
* progress. Without this, application threads will be stalled
* until the eviction server next wakes.
*/
WT_TRET(__wt_evict_server_wake(session));
}
__wt_spin_unlock(session, &btree->flush_lock);
/*
* Leaves are written before a checkpoint (or as part of a file close,
* before checkpointing the file). Start a flush to stable storage,
* but don't wait for it.
*/
if (ret == 0 && syncop == WT_SYNC_WRITE_LEAVES)
WT_RET(btree->bm->sync(btree->bm, session, true));
return (ret);
}
/*
* __wt_lsm_tree_create --
* Create an LSM tree structure for the given name.
*/
int
__wt_lsm_tree_create(WT_SESSION_IMPL *session,
const char *uri, int exclusive, const char *config)
{
WT_CONFIG_ITEM cval;
WT_DECL_ITEM(buf);
WT_DECL_RET;
WT_LSM_TREE *lsm_tree;
const char *cfg[] =
{ WT_CONFIG_BASE(session, session_create), config, NULL };
const char *tmpconfig;
/* If the tree is open, it already exists. */
if ((ret = __wt_lsm_tree_get(session, uri, 0, &lsm_tree)) == 0) {
__wt_lsm_tree_release(session, lsm_tree);
return (exclusive ? EEXIST : 0);
}
WT_RET_NOTFOUND_OK(ret);
/*
* If the tree has metadata, it already exists.
*
* !!!
* Use a local variable: we don't care what the existing configuration
* is, but we don't want to overwrite the real config.
*/
if (__wt_metadata_search(session, uri, &tmpconfig) == 0) {
__wt_free(session, tmpconfig);
return (exclusive ? EEXIST : 0);
}
WT_RET_NOTFOUND_OK(ret);
WT_RET(__wt_config_gets(session, cfg, "key_format", &cval));
if (WT_STRING_MATCH("r", cval.str, cval.len))
WT_RET_MSG(session, EINVAL,
"LSM trees cannot be configured as column stores");
WT_RET(__wt_calloc_def(session, 1, &lsm_tree));
WT_ERR(__lsm_tree_set_name(session, lsm_tree, uri));
WT_ERR(__wt_config_gets(session, cfg, "key_format", &cval));
WT_ERR(__wt_strndup(session, cval.str, cval.len,
&lsm_tree->key_format));
WT_ERR(__wt_config_gets(session, cfg, "value_format", &cval));
WT_ERR(__wt_strndup(session, cval.str, cval.len,
&lsm_tree->value_format));
WT_ERR(__wt_config_gets(session, cfg, "collator", &cval));
WT_ERR(__wt_strndup(session, cval.str, cval.len,
&lsm_tree->collator_name));
WT_ERR(__wt_config_gets(session, cfg, "lsm.auto_throttle", &cval));
if (cval.val)
F_SET(lsm_tree, WT_LSM_TREE_THROTTLE);
else
F_CLR(lsm_tree, WT_LSM_TREE_THROTTLE);
WT_ERR(__wt_config_gets(session, cfg, "lsm.bloom", &cval));
FLD_SET(lsm_tree->bloom,
(cval.val == 0 ? WT_LSM_BLOOM_OFF : WT_LSM_BLOOM_MERGED));
WT_ERR(__wt_config_gets(session, cfg, "lsm.bloom_oldest", &cval));
if (cval.val != 0)
FLD_SET(lsm_tree->bloom, WT_LSM_BLOOM_OLDEST);
if (FLD_ISSET(lsm_tree->bloom, WT_LSM_BLOOM_OFF) &&
FLD_ISSET(lsm_tree->bloom, WT_LSM_BLOOM_OLDEST))
WT_ERR_MSG(session, EINVAL,
"Bloom filters can only be created on newest and oldest "
"chunks if bloom filters are enabled");
WT_ERR(__wt_config_gets(session, cfg, "lsm.bloom_config", &cval));
if (cval.type == WT_CONFIG_ITEM_STRUCT) {
cval.str++;
cval.len -= 2;
}
WT_ERR(__wt_strndup(session, cval.str, cval.len,
&lsm_tree->bloom_config));
WT_ERR(__wt_config_gets(session, cfg, "lsm.bloom_bit_count", &cval));
lsm_tree->bloom_bit_count = (uint32_t)cval.val;
WT_ERR(__wt_config_gets(session, cfg, "lsm.bloom_hash_count", &cval));
lsm_tree->bloom_hash_count = (uint32_t)cval.val;
WT_ERR(__wt_config_gets(session, cfg, "lsm.chunk_max", &cval));
lsm_tree->chunk_max = (uint64_t)cval.val;
WT_ERR(__wt_config_gets(session, cfg, "lsm.chunk_size", &cval));
lsm_tree->chunk_size = (uint64_t)cval.val;
if (lsm_tree->chunk_size > lsm_tree->chunk_max)
WT_ERR_MSG(session, EINVAL,
"Chunk size (chunk_size) must be smaller than or equal to "
"the maximum chunk size (chunk_max)");
WT_ERR(__wt_config_gets(session, cfg, "lsm.merge_max", &cval));
lsm_tree->merge_max = (uint32_t)cval.val;
lsm_tree->merge_min = lsm_tree->merge_max / 2;
WT_ERR(__wt_config_gets(session, cfg, "lsm.merge_threads", &cval));
lsm_tree->merge_threads = (uint32_t)cval.val;
/* Sanity check that api_data.py is in sync with lsm.h */
WT_ASSERT(session, lsm_tree->merge_threads <= WT_LSM_MAX_WORKERS);
/*
* Set up the config for each chunk. If possible, avoid high latencies
* from fsync by flushing the cache every 8MB (will be overridden by
* any application setting).
*/
tmpconfig = "";
#ifdef HAVE_SYNC_FILE_RANGE
if (!S2C(session)->direct_io)
tmpconfig = "os_cache_dirty_max=8MB,";
#endif
WT_ERR(__wt_scr_alloc(session, 0, &buf));
WT_ERR(__wt_buf_fmt(session, buf,
"%s%s,key_format=u,value_format=u", tmpconfig, config));
lsm_tree->file_config = __wt_buf_steal(session, buf, NULL);
/* Create the first chunk and flush the metadata. */
WT_ERR(__wt_lsm_meta_write(session, lsm_tree));
/* Discard our partially populated handle. */
ret = __lsm_tree_discard(session, lsm_tree);
lsm_tree = NULL;
/*
* Open our new tree and add it to the handle cache. Don't discard on
* error: the returned handle is NULL on error, and the metadata
* tracking macros handle cleaning up on failure.
*/
if (ret == 0)
ret = __lsm_tree_open(session, uri, &lsm_tree);
if (ret == 0)
__wt_lsm_tree_release(session, lsm_tree);
if (0) {
err: WT_TRET(__lsm_tree_discard(session, lsm_tree));
}
__wt_scr_free(&buf);
return (ret);
}
/*
* __wt_btcur_range_truncate --
* Discard a cursor range from the tree.
*/
int
__wt_btcur_range_truncate(WT_CURSOR_BTREE *start, WT_CURSOR_BTREE *stop)
{
WT_BTREE *btree;
WT_CURSOR_BTREE *cbt;
WT_DECL_RET;
WT_SESSION_IMPL *session;
cbt = (start != NULL) ? start : stop;
session = (WT_SESSION_IMPL *)cbt->iface.session;
btree = cbt->btree;
/*
* We always delete in a forward direction because it's faster, assert
* our caller provided us with a start cursor.
*/
WT_ASSERT(session, start != NULL);
/*
* For recovery, log the start and stop keys for a truncate operation,
* not the individual records removed. On the other hand, for rollback
* we need to keep track of all the in-memory operations.
*
* We deal with this here by logging the truncate range first, then (in
* the logging code) disabling writing of the in-memory remove records
* to disk.
*/
if (FLD_ISSET(S2C(session)->log_flags, WT_CONN_LOG_ENABLED))
WT_RET(__wt_txn_truncate_log(session, start, stop));
switch (btree->type) {
case BTREE_COL_FIX:
WT_ERR(__cursor_truncate_fix(
session, start, stop, __cursor_col_modify));
break;
case BTREE_COL_VAR:
WT_ERR(__cursor_truncate(
session, start, stop, __cursor_col_modify));
break;
case BTREE_ROW:
/*
* The underlying cursor comparison routine requires cursors be
* fully instantiated when truncating row-store objects because
* it's comparing page and/or skiplist positions, not keys. (Key
* comparison would work, it's only that a key comparison would
* be relatively expensive, especially with custom collators.
* Column-store objects have record number keys, so the key
* comparison is cheap.) The session truncate code did cursor
* searches when setting up the truncate so we're good to go: if
* that ever changes, we'd need to do something here to ensure a
* fully instantiated cursor.
*/
WT_ERR(__cursor_truncate(
session, start, stop, __cursor_row_modify));
break;
}
err: if (FLD_ISSET(S2C(session)->log_flags, WT_CONN_LOG_ENABLED))
WT_TRET(__wt_txn_truncate_end(session));
return (ret);
}
/*
* __lsm_tree_close --
* Close an LSM tree structure.
*/
static int
__lsm_tree_close(WT_SESSION_IMPL *session, WT_LSM_TREE *lsm_tree)
{
WT_DECL_RET;
WT_SESSION *wt_session;
WT_SESSION_IMPL *s;
uint32_t i;
if (F_ISSET(lsm_tree, WT_LSM_TREE_WORKING)) {
F_CLR(lsm_tree, WT_LSM_TREE_WORKING);
/*
* Signal all threads to wake them up, then wait for them to
* exit.
*
* !!!
* If we have the schema lock, have the LSM worker sessions
* inherit the flag before we do anything. The thread may
* already be waiting for the schema lock, but the loop in the
* WT_WITH_SCHEMA_LOCK macro takes care of that.
*/
if (F_ISSET(S2C(session), WT_CONN_LSM_MERGE))
for (i = 0; i < lsm_tree->merge_threads; i++) {
if ((s = lsm_tree->worker_sessions[i]) == NULL)
continue;
if (F_ISSET(session, WT_SESSION_SCHEMA_LOCKED))
s->skip_schema_lock = 1;
WT_TRET(__wt_cond_signal(
session, lsm_tree->work_cond));
WT_TRET(__wt_thread_join(
session, lsm_tree->worker_tids[i]));
}
if (F_ISSET(session, WT_SESSION_SCHEMA_LOCKED))
lsm_tree->ckpt_session->skip_schema_lock = 1;
WT_TRET(__wt_cond_signal(session, lsm_tree->work_cond));
WT_TRET(__wt_thread_join(session, lsm_tree->ckpt_tid));
}
/*
* Close the worker thread sessions. Do this in the main thread to
* avoid deadlocks.
*/
for (i = 0; i < lsm_tree->merge_threads; i++) {
if ((s = lsm_tree->worker_sessions[i]) == NULL)
continue;
lsm_tree->worker_sessions[i] = NULL;
wt_session = &s->iface;
WT_TRET(wt_session->close(wt_session, NULL));
}
if (lsm_tree->ckpt_session != NULL) {
wt_session = &lsm_tree->ckpt_session->iface;
WT_TRET(wt_session->close(wt_session, NULL));
}
if (ret != 0) {
__wt_err(session, ret, "shutdown error while cleaning up LSM");
(void)__wt_panic(session);
}
return (ret);
}
/*
* __wt_btcur_search_near --
* Search for a record in the tree.
*/
int
__wt_btcur_search_near(WT_CURSOR_BTREE *cbt, int *exactp)
{
WT_BTREE *btree;
WT_CURSOR *cursor;
WT_DECL_RET;
WT_SESSION_IMPL *session;
WT_UPDATE *upd;
int exact, valid;
btree = cbt->btree;
cursor = &cbt->iface;
session = (WT_SESSION_IMPL *)cursor->session;
upd = NULL; /* -Wuninitialized */
exact = 0;
WT_STAT_FAST_CONN_INCR(session, cursor_search_near);
WT_STAT_FAST_DATA_INCR(session, cursor_search_near);
if (btree->type == BTREE_ROW)
WT_RET(__cursor_size_chk(session, &cursor->key));
/*
* If we have a row-store page pinned, search it; if we don't have a
* page pinned, or the search of the pinned page doesn't find an exact
* match, search from the root. Unlike WT_CURSOR.search, ignore pinned
* pages in the case of column-store, search-near isn't an interesting
* enough case for column-store to add the complexity needed to avoid
* the tree search.
*
* Set the "insert" flag for the btree row-store search; we may intend
* to position the cursor at the end of the tree, rather than match an
* existing record.
*/
valid = 0;
if (btree->type == BTREE_ROW &&
F_ISSET(cbt, WT_CBT_ACTIVE) &&
cbt->ref->page->read_gen != WT_READGEN_OLDEST) {
__wt_txn_cursor_op(session);
WT_ERR(__cursor_row_search(session, cbt, cbt->ref, 1));
/*
* Search-near is trickier than search when searching an already
* pinned page. If search returns the first or last page slots,
* discard the results and search the full tree as the neighbor
* pages might offer better matches. This test is simplistic as
* we're ignoring append lists (there may be no page slots or we
* might be legitimately positioned after the last page slot).
* Ignore those cases, it makes things too complicated.
*/
if (cbt->slot != 0 &&
cbt->slot != cbt->ref->page->pg_row_entries - 1)
valid = __cursor_valid(cbt, &upd);
}
if (!valid) {
WT_ERR(__cursor_func_init(cbt, 1));
WT_ERR(btree->type == BTREE_ROW ?
__cursor_row_search(session, cbt, NULL, 1) :
__cursor_col_search(session, cbt, NULL));
valid = __cursor_valid(cbt, &upd);
}
/*
* If we find a valid key, return it.
*
* Else, creating a record past the end of the tree in a fixed-length
* column-store implicitly fills the gap with empty records. In this
* case, we instantiate the empty record, it's an exact match.
*
* Else, move to the next key in the tree (bias for prefix searches).
* Cursor next skips invalid rows, so we don't have to test for them
* again.
*
* Else, redo the search and move to the previous key in the tree.
* Cursor previous skips invalid rows, so we don't have to test for
* them again.
*
* If that fails, quit, there's no record to return.
*/
if (valid) {
exact = cbt->compare;
ret = __wt_kv_return(session, cbt, upd);
} else if (__cursor_fix_implicit(btree, cbt)) {
cbt->recno = cursor->recno;
cbt->v = 0;
cursor->value.data = &cbt->v;
cursor->value.size = 1;
exact = 0;
} else if ((ret = __wt_btcur_next(cbt, 0)) != WT_NOTFOUND)
exact = 1;
else {
WT_ERR(btree->type == BTREE_ROW ?
__cursor_row_search(session, cbt, NULL, 1) :
__cursor_col_search(session, cbt, NULL));
if (__cursor_valid(cbt, &upd)) {
exact = cbt->compare;
ret = __wt_kv_return(session, cbt, upd);
} else if ((ret = __wt_btcur_prev(cbt, 0)) != WT_NOTFOUND)
exact = -1;
}
err: if (ret != 0)
WT_TRET(__cursor_reset(cbt));
if (exactp != NULL && (ret == 0 || ret == WT_NOTFOUND))
*exactp = exact;
return (ret);
}
/*
* __wt_lsm_tree_rename --
* Rename an LSM tree.
*/
int
__wt_lsm_tree_rename(WT_SESSION_IMPL *session,
const char *olduri, const char *newuri, const char *cfg[])
{
WT_DECL_RET;
WT_ITEM buf;
WT_LSM_CHUNK *chunk;
WT_LSM_TREE *lsm_tree;
const char *old;
u_int i;
int locked;
old = NULL;
WT_CLEAR(buf);
locked = 0;
/* Get the LSM tree. */
WT_RET(__wt_lsm_tree_get(session, olduri, 1, &lsm_tree));
/* Shut down the LSM worker. */
WT_ERR(__lsm_tree_close(session, lsm_tree));
/* Prevent any new opens. */
WT_ERR(__wt_lsm_tree_lock(session, lsm_tree, 1));
locked = 1;
/* Set the new name. */
WT_ERR(__lsm_tree_set_name(session, lsm_tree, newuri));
/* Rename the chunks. */
for (i = 0; i < lsm_tree->nchunks; i++) {
chunk = lsm_tree->chunk[i];
old = chunk->uri;
chunk->uri = NULL;
WT_ERR(__wt_lsm_tree_chunk_name(
session, lsm_tree, chunk->id, &buf));
chunk->uri = __wt_buf_steal(session, &buf, NULL);
WT_ERR(__wt_schema_rename(session, old, chunk->uri, cfg));
__wt_free(session, old);
if (F_ISSET_ATOMIC(chunk, WT_LSM_CHUNK_BLOOM)) {
old = chunk->bloom_uri;
chunk->bloom_uri = NULL;
WT_ERR(__wt_lsm_tree_bloom_name(
session, lsm_tree, chunk->id, &buf));
chunk->bloom_uri = __wt_buf_steal(session, &buf, NULL);
F_SET_ATOMIC(chunk, WT_LSM_CHUNK_BLOOM);
WT_ERR(__wt_schema_rename(
session, old, chunk->uri, cfg));
__wt_free(session, old);
}
}
WT_ERR(__wt_lsm_meta_write(session, lsm_tree));
locked = 0;
WT_ERR(__wt_lsm_tree_unlock(session, lsm_tree));
WT_ERR(__wt_metadata_remove(session, olduri));
err: if (locked)
WT_TRET(__wt_lsm_tree_unlock(session, lsm_tree));
if (old != NULL)
__wt_free(session, old);
/*
* Discard this LSM tree structure. The first operation on the renamed
* tree will create a new one.
*/
WT_TRET(__lsm_tree_discard(session, lsm_tree));
return (ret);
}
/*
* __wt_btcur_remove --
* Remove a record from the tree.
*/
int
__wt_btcur_remove(WT_CURSOR_BTREE *cbt)
{
WT_BTREE *btree;
WT_CURSOR *cursor;
WT_DECL_RET;
WT_SESSION_IMPL *session;
btree = cbt->btree;
cursor = &cbt->iface;
session = (WT_SESSION_IMPL *)cursor->session;
WT_STAT_FAST_CONN_INCR(session, cursor_remove);
WT_STAT_FAST_DATA_INCR(session, cursor_remove);
WT_STAT_FAST_DATA_INCRV(session, cursor_remove_bytes, cursor->key.size);
if (btree->type == BTREE_ROW)
WT_RET(__cursor_size_chk(session, &cursor->key));
retry: WT_RET(__cursor_func_init(cbt, 1));
switch (btree->type) {
case BTREE_COL_FIX:
case BTREE_COL_VAR:
WT_ERR(__cursor_col_search(session, cbt, NULL));
/*
* If we find a matching record, check whether an update would
* conflict. Do this before checking if the update is visible
* in __cursor_valid, or we can miss conflict.
*/
WT_ERR(__curfile_update_check(cbt));
/* Remove the record if it exists. */
if (cbt->compare != 0 || !__cursor_valid(cbt, NULL)) {
if (!__cursor_fix_implicit(btree, cbt))
WT_ERR(WT_NOTFOUND);
/*
* Creating a record past the end of the tree in a
* fixed-length column-store implicitly fills the
* gap with empty records. Return success in that
* case, the record was deleted successfully.
*
* Correct the btree cursor's location: the search
* will have pointed us at the previous/next item,
* and that's not correct.
*/
cbt->recno = cursor->recno;
} else
ret = __cursor_col_modify(session, cbt, 1);
break;
case BTREE_ROW:
/* Remove the record if it exists. */
WT_ERR(__cursor_row_search(session, cbt, NULL, 0));
/* Check whether an update would conflict. */
WT_ERR(__curfile_update_check(cbt));
if (cbt->compare != 0 || !__cursor_valid(cbt, NULL))
WT_ERR(WT_NOTFOUND);
ret = __cursor_row_modify(session, cbt, 1);
break;
WT_ILLEGAL_VALUE_ERR(session);
}
err: if (ret == WT_RESTART)
goto retry;
/*
* If the cursor is configured to overwrite and the record is not
* found, that is exactly what we want.
*/
if (F_ISSET(cursor, WT_CURSTD_OVERWRITE) && ret == WT_NOTFOUND)
ret = 0;
if (ret != 0)
WT_TRET(__cursor_reset(cbt));
return (ret);
}
/*
* __wt_schema_open_index --
* Open one or more indices for a table.
*/
int
__wt_schema_open_index(WT_SESSION_IMPL *session,
WT_TABLE *table, const char *idxname, size_t len, WT_INDEX **indexp)
{
WT_CURSOR *cursor;
WT_DECL_ITEM(tmp);
WT_DECL_RET;
WT_INDEX *idx;
u_int i;
int cmp, match;
const char *idxconf, *name, *tablename, *uri;
/* Check if we've already done the work. */
if (idxname == NULL && table->idx_complete)
return (0);
cursor = NULL;
idx = NULL;
match = 0;
/* Build a search key. */
tablename = table->name;
(void)WT_PREFIX_SKIP(tablename, "table:");
WT_ERR(__wt_scr_alloc(session, 512, &tmp));
WT_ERR(__wt_buf_fmt(session, tmp, "index:%s:", tablename));
/* Find matching indices. */
WT_ERR(__wt_metadata_cursor(session, NULL, &cursor));
cursor->set_key(cursor, tmp->data);
if ((ret = cursor->search_near(cursor, &cmp)) == 0 && cmp < 0)
ret = cursor->next(cursor);
for (i = 0; ret == 0; i++, ret = cursor->next(cursor)) {
WT_ERR(cursor->get_key(cursor, &uri));
name = uri;
if (!WT_PREFIX_SKIP(name, tmp->data))
break;
/* Is this the index we are looking for? */
match = idxname == NULL || WT_STRING_MATCH(name, idxname, len);
/*
* Ensure there is space, including if we have to make room for
* a new entry in the middle of the list.
*/
WT_ERR(__wt_realloc_def(session, &table->idx_alloc,
WT_MAX(i, table->nindices) + 1, &table->indices));
/* Keep the in-memory list in sync with the metadata. */
cmp = 0;
while (table->indices[i] != NULL &&
(cmp = strcmp(uri, table->indices[i]->name)) > 0) {
/* Index no longer exists, remove it. */
__wt_free(session, table->indices[i]);
memmove(&table->indices[i], &table->indices[i + 1],
(table->nindices - i) * sizeof(WT_INDEX *));
table->indices[--table->nindices] = NULL;
}
if (cmp < 0) {
/* Make room for a new index. */
memmove(&table->indices[i + 1], &table->indices[i],
(table->nindices - i) * sizeof(WT_INDEX *));
table->indices[i] = NULL;
++table->nindices;
}
if (!match)
continue;
if (table->indices[i] == NULL) {
WT_ERR(cursor->get_value(cursor, &idxconf));
WT_ERR(__wt_calloc_one(session, &idx));
WT_ERR(__wt_strdup(session, uri, &idx->name));
WT_ERR(__wt_strdup(session, idxconf, &idx->config));
WT_ERR(__open_index(session, table, idx));
table->indices[i] = idx;
idx = NULL;
/*
* If the slot is bigger than anything else we've seen,
* bump the number of indices.
*/
if (i >= table->nindices)
table->nindices = i + 1;
}
/* If we were looking for a single index, we're done. */
if (indexp != NULL)
*indexp = table->indices[i];
if (idxname != NULL)
break;
}
WT_ERR_NOTFOUND_OK(ret);
if (idxname != NULL && !match)
ret = WT_NOTFOUND;
/* If we did a full pass, we won't need to do it again. */
if (idxname == NULL) {
table->nindices = i;
table->idx_complete = 1;
}
err: __wt_scr_free(session, &tmp);
if (idx != NULL)
WT_TRET(__wt_schema_destroy_index(session, idx));
if (cursor != NULL)
WT_TRET(cursor->close(cursor));
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);
F_CLR(conn, WT_CONN_SERVER_LOG);
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_cond_signal(session, conn->log_cond);
WT_TRET(__wt_thread_join(session, conn->log_tid));
conn->log_tid_set = false;
}
if (conn->log_file_tid_set) {
__wt_cond_signal(session, conn->log_file_cond);
WT_TRET(__wt_thread_join(session, conn->log_file_tid));
conn->log_file_tid_set = false;
}
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_cond_signal(session, conn->log_wrlsn_cond);
WT_TRET(__wt_thread_join(session, conn->log_wrlsn_tid));
conn->log_wrlsn_tid_set = false;
}
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_cond_destroy(session, &conn->log_cond);
__wt_cond_destroy(session, &conn->log_file_cond);
__wt_cond_destroy(session, &conn->log_wrlsn_cond);
__wt_cond_destroy(session, &conn->log->log_sync_cond);
__wt_cond_destroy(session, &conn->log->log_write_cond);
__wt_rwlock_destroy(session, &conn->log->log_archive_lock);
__wt_spin_destroy(session, &conn->log->log_lock);
__wt_spin_destroy(session, &conn->log->log_fs_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_schema_open_table --
* Open a named table.
*/
int
__wt_schema_open_table(WT_SESSION_IMPL *session,
const char *name, size_t namelen, int ok_incomplete, WT_TABLE **tablep)
{
WT_CONFIG cparser;
WT_CONFIG_ITEM ckey, cval;
WT_CURSOR *cursor;
WT_DECL_ITEM(buf);
WT_DECL_RET;
WT_TABLE *table;
const char *tconfig;
char *tablename;
cursor = NULL;
table = NULL;
tablename = NULL;
WT_ASSERT(session, F_ISSET(session, WT_SESSION_TABLE_LOCKED));
WT_ERR(__wt_scr_alloc(session, 0, &buf));
WT_ERR(__wt_buf_fmt(session, buf, "table:%.*s", (int)namelen, name));
WT_ERR(__wt_strndup(session, buf->data, buf->size, &tablename));
WT_ERR(__wt_metadata_cursor(session, NULL, &cursor));
cursor->set_key(cursor, tablename);
WT_ERR(cursor->search(cursor));
WT_ERR(cursor->get_value(cursor, &tconfig));
WT_ERR(__wt_calloc_one(session, &table));
table->name = tablename;
tablename = NULL;
table->name_hash = __wt_hash_city64(name, namelen);
WT_ERR(__wt_config_getones(session, tconfig, "columns", &cval));
WT_ERR(__wt_config_getones(session, tconfig, "key_format", &cval));
WT_ERR(__wt_strndup(session, cval.str, cval.len, &table->key_format));
WT_ERR(__wt_config_getones(session, tconfig, "value_format", &cval));
WT_ERR(__wt_strndup(session, cval.str, cval.len, &table->value_format));
WT_ERR(__wt_strdup(session, tconfig, &table->config));
/* Point to some items in the copy to save re-parsing. */
WT_ERR(__wt_config_getones(session, table->config,
"columns", &table->colconf));
/*
* Count the number of columns: tables are "simple" if the columns
* are not named.
*/
WT_ERR(__wt_config_subinit(session, &cparser, &table->colconf));
table->is_simple = 1;
while ((ret = __wt_config_next(&cparser, &ckey, &cval)) == 0)
table->is_simple = 0;
if (ret != WT_NOTFOUND)
goto err;
/* Check that the columns match the key and value formats. */
if (!table->is_simple)
WT_ERR(__wt_schema_colcheck(session,
table->key_format, table->value_format, &table->colconf,
&table->nkey_columns, NULL));
WT_ERR(__wt_config_getones(session, table->config,
"colgroups", &table->cgconf));
/* Count the number of column groups. */
WT_ERR(__wt_config_subinit(session, &cparser, &table->cgconf));
table->ncolgroups = 0;
while ((ret = __wt_config_next(&cparser, &ckey, &cval)) == 0)
++table->ncolgroups;
if (ret != WT_NOTFOUND)
goto err;
if (table->ncolgroups > 0 && table->is_simple)
WT_ERR_MSG(session, EINVAL,
"%s requires a table with named columns", tablename);
WT_ERR(__wt_calloc_def(session, WT_COLGROUPS(table), &table->cgroups));
WT_ERR(__wt_schema_open_colgroups(session, table));
if (!ok_incomplete && !table->cg_complete)
WT_ERR_MSG(session, EINVAL, "'%s' cannot be used "
"until all column groups are created",
table->name);
/* Copy the schema generation into the new table. */
table->schema_gen = S2C(session)->schema_gen;
*tablep = table;
if (0) {
err: if (table != NULL)
WT_TRET(__wt_schema_destroy_table(session, table));
}
if (cursor != NULL)
WT_TRET(cursor->close(cursor));
__wt_free(session, tablename);
__wt_scr_free(session, &buf);
return (ret);
}
/*
* __backup_start --
* Start a backup.
*/
static int
__backup_start(
WT_SESSION_IMPL *session, WT_CURSOR_BACKUP *cb, const char *cfg[])
{
WT_CONNECTION_IMPL *conn;
WT_DECL_RET;
int exist, log_only, target_list;
conn = S2C(session);
cb->next = 0;
cb->list = NULL;
/*
* Single thread hot backups: we're holding the schema lock, so we
* know we'll serialize with other attempts to start a hot backup.
*/
if (conn->hot_backup)
WT_RET_MSG(
session, EINVAL, "there is already a backup cursor open");
/*
* The hot backup copy is done outside of WiredTiger, which means file
* blocks can't be freed and re-allocated until the backup completes.
* The checkpoint code checks the backup flag, and if a backup cursor
* is open checkpoints aren't discarded. We release the lock as soon
* as we've set the flag, we don't want to block checkpoints, we just
* want to make sure no checkpoints are deleted. The checkpoint code
* holds the lock until it's finished the checkpoint, otherwise we
* could start a hot backup that would race with an already-started
* checkpoint.
*/
__wt_spin_lock(session, &conn->hot_backup_lock);
conn->hot_backup = 1;
__wt_spin_unlock(session, &conn->hot_backup_lock);
/* Create the hot backup file. */
WT_ERR(__backup_file_create(session, cb, 0));
/* Add log files if logging is enabled. */
/*
* If a list of targets was specified, work our way through them.
* Else, generate a list of all database objects.
*
* Include log files if doing a full backup, and copy them before
* copying data files to avoid rolling the metadata forward across
* a checkpoint that completes during the backup.
*/
target_list = 0;
WT_ERR(__backup_uri(session, cb, cfg, &target_list, &log_only));
if (!target_list) {
WT_ERR(__backup_log_append(session, cb, 1));
WT_ERR(__backup_all(session, cb));
}
/* Add the hot backup and standard WiredTiger files to the list. */
if (log_only) {
/*
* Close any hot backup file.
* We're about to open the incremental backup file.
*/
WT_TRET(__wt_fclose(session, &cb->bfp, WT_FHANDLE_WRITE));
WT_ERR(__backup_file_create(session, cb, log_only));
WT_ERR(__backup_list_append(
session, cb, WT_INCREMENTAL_BACKUP));
} else {
WT_ERR(__backup_list_append(session, cb, WT_METADATA_BACKUP));
WT_ERR(__wt_exist(session, WT_BASECONFIG, &exist));
if (exist)
WT_ERR(__backup_list_append(
session, cb, WT_BASECONFIG));
WT_ERR(__wt_exist(session, WT_USERCONFIG, &exist));
if (exist)
WT_ERR(__backup_list_append(
session, cb, WT_USERCONFIG));
WT_ERR(__backup_list_append(session, cb, WT_WIREDTIGER));
}
err: /* Close the hot backup file. */
WT_TRET(__wt_fclose(session, &cb->bfp, WT_FHANDLE_WRITE));
if (ret != 0) {
WT_TRET(__backup_cleanup_handles(session, cb));
WT_TRET(__backup_stop(session));
}
return (ret);
}
/*
* __wt_page_in --
* Acquire a hazard pointer to a page; if the page is not in-memory,
* read it from the disk and build an in-memory version.
*/
int
__wt_page_in_func(
WT_SESSION_IMPL *session, WT_PAGE *parent, WT_REF *ref
#ifdef HAVE_DIAGNOSTIC
, const char *file, int line
#endif
)
{
WT_DECL_RET;
WT_PAGE *page;
int busy, oldgen;
for (oldgen = 0;;) {
switch (ref->state) {
case WT_REF_DISK:
case WT_REF_DELETED:
/*
* The page isn't in memory, attempt to read it.
*
* First make sure there is space in the cache.
*/
WT_RET(__wt_cache_full_check(session, 0));
WT_RET(__wt_cache_read(session, parent, ref));
oldgen = F_ISSET(session, WT_SESSION_NO_CACHE) ? 1 : 0;
continue;
case WT_REF_EVICT_FORCE:
case WT_REF_LOCKED:
case WT_REF_READING:
/*
* The page is being read or considered for eviction --
* wait for that to be resolved.
*/
break;
case WT_REF_EVICT_WALK:
case WT_REF_MEM:
/*
* The page is in memory: get a hazard pointer, update
* the page's LRU and return. The expected reason we
* can't get a hazard pointer is because the page is
* being evicted; yield and try again.
*/
#ifdef HAVE_DIAGNOSTIC
WT_RET(
__wt_hazard_set(session, ref, &busy, file, line));
#else
WT_RET(__wt_hazard_set(session, ref, &busy));
#endif
if (busy)
break;
page = ref->page;
WT_ASSERT(session,
page != NULL && !WT_PAGE_IS_ROOT(page));
/*
* Ensure the page doesn't have ancient updates on it.
* If it did, reading the page could ignore committed
* updates. This should be extremely unlikely in real
* applications, wait for eviction of the page to avoid
* the issue.
*/
if (page->modify != NULL &&
__wt_txn_ancient(session, page->modify->first_id)) {
page->read_gen = WT_READ_GEN_OLDEST;
WT_RET(__wt_page_release(session, page));
break;
}
/* Check if we need an autocommit transaction. */
if ((ret = __wt_txn_autocommit_check(session)) != 0) {
WT_TRET(__wt_hazard_clear(session, page));
return (ret);
}
/*
* If this page has ever been considered for eviction,
* and its generation is aging, update it.
*/
if (page->read_gen != WT_READ_GEN_NOTSET &&
page->read_gen < __wt_cache_read_gen(session))
page->read_gen =
__wt_cache_read_gen_set(session);
/*
* If we read the page and we are configured to not
* trash the cache, set the oldest read generation so
* the page is forcibly evicted as soon as possible.
*/
if (oldgen && page->read_gen == WT_READ_GEN_NOTSET)
page->read_gen = WT_READ_GEN_OLDEST;
return (0);
WT_ILLEGAL_VALUE(session);
}
/* We failed to get the page -- yield before retrying. */
__wt_yield();
}
}
/*
* __wt_txn_recover --
* Run recovery.
*/
int
__wt_txn_recover(WT_SESSION_IMPL *session)
{
WT_CONNECTION_IMPL *conn;
WT_CURSOR *metac;
WT_DECL_RET;
WT_RECOVERY r;
struct WT_RECOVERY_FILE *metafile;
char *config;
bool eviction_started, needs_rec, was_backup;
conn = S2C(session);
WT_CLEAR(r);
WT_INIT_LSN(&r.ckpt_lsn);
eviction_started = false;
was_backup = F_ISSET(conn, WT_CONN_WAS_BACKUP);
/* We need a real session for recovery. */
WT_RET(__wt_open_internal_session(conn, "txn-recover",
false, WT_SESSION_NO_LOGGING, &session));
r.session = session;
WT_ERR(__wt_metadata_search(session, WT_METAFILE_URI, &config));
WT_ERR(__recovery_setup_file(&r, WT_METAFILE_URI, config));
WT_ERR(__wt_metadata_cursor_open(session, NULL, &metac));
metafile = &r.files[WT_METAFILE_ID];
metafile->c = metac;
/*
* If no log was found (including if logging is disabled), or if the
* last checkpoint was done with logging disabled, recovery should not
* run. Scan the metadata to figure out the largest file ID.
*/
if (!FLD_ISSET(S2C(session)->log_flags, WT_CONN_LOG_EXISTED) ||
WT_IS_MAX_LSN(&metafile->ckpt_lsn)) {
WT_ERR(__recovery_file_scan(&r));
conn->next_file_id = r.max_fileid;
goto done;
}
/*
* First, do a pass through the log to recover the metadata, and
* establish the last checkpoint LSN. Skip this when opening a hot
* backup: we already have the correct metadata in that case.
*/
if (!was_backup) {
r.metadata_only = true;
/*
* If this is a read-only connection, check if the checkpoint
* LSN in the metadata file is up to date, indicating a clean
* shutdown.
*/
if (F_ISSET(conn, WT_CONN_READONLY)) {
WT_ERR(__wt_log_needs_recovery(
session, &metafile->ckpt_lsn, &needs_rec));
if (needs_rec)
WT_ERR_MSG(session, WT_RUN_RECOVERY,
"Read-only database needs recovery");
}
if (WT_IS_INIT_LSN(&metafile->ckpt_lsn))
WT_ERR(__wt_log_scan(session,
NULL, WT_LOGSCAN_FIRST, __txn_log_recover, &r));
else {
/*
* Start at the last checkpoint LSN referenced in the
* metadata. If we see the end of a checkpoint while
* scanning, we will change the full scan to start from
* there.
*/
r.ckpt_lsn = metafile->ckpt_lsn;
ret = __wt_log_scan(session,
&metafile->ckpt_lsn, 0, __txn_log_recover, &r);
if (ret == ENOENT)
ret = 0;
WT_ERR(ret);
}
}
/* Scan the metadata to find the live files and their IDs. */
WT_ERR(__recovery_file_scan(&r));
/*
* We no longer need the metadata cursor: close it to avoid pinning any
* resources that could block eviction during recovery.
*/
r.files[0].c = NULL;
WT_ERR(metac->close(metac));
/*
* Now, recover all the files apart from the metadata.
* Pass WT_LOGSCAN_RECOVER so that old logs get truncated.
*/
r.metadata_only = false;
WT_ERR(__wt_verbose(session, WT_VERB_RECOVERY,
"Main recovery loop: starting at %u/%u",
r.ckpt_lsn.l.file, r.ckpt_lsn.l.offset));
WT_ERR(__wt_log_needs_recovery(session, &r.ckpt_lsn, &needs_rec));
/*
* Check if the database was shut down cleanly. If not
* return an error if the user does not want automatic
* recovery.
*/
if (needs_rec &&
(FLD_ISSET(conn->log_flags, WT_CONN_LOG_RECOVER_ERR) ||
F_ISSET(conn, WT_CONN_READONLY))) {
if (F_ISSET(conn, WT_CONN_READONLY))
WT_ERR_MSG(session, WT_RUN_RECOVERY,
"Read-only database needs recovery");
WT_ERR(WT_RUN_RECOVERY);
}
if (F_ISSET(conn, WT_CONN_READONLY))
goto done;
/*
* Recovery can touch more data than fits in cache, so it relies on
* regular eviction to manage paging. Start eviction threads for
* recovery without LAS cursors.
*/
WT_ERR(__wt_evict_create(session));
eviction_started = true;
/*
* Always run recovery even if it was a clean shutdown only if
* this is not a read-only connection.
* We can consider skipping it in the future.
*/
if (WT_IS_INIT_LSN(&r.ckpt_lsn))
WT_ERR(__wt_log_scan(session, NULL,
WT_LOGSCAN_FIRST | WT_LOGSCAN_RECOVER,
__txn_log_recover, &r));
else {
ret = __wt_log_scan(session, &r.ckpt_lsn,
WT_LOGSCAN_RECOVER, __txn_log_recover, &r);
if (ret == ENOENT)
ret = 0;
WT_ERR(ret);
}
conn->next_file_id = r.max_fileid;
/*
* If recovery ran successfully forcibly log a checkpoint so the next
* open is fast and keep the metadata up to date with the checkpoint
* LSN and archiving.
*/
WT_ERR(session->iface.checkpoint(&session->iface, "force=1"));
done: FLD_SET(conn->log_flags, WT_CONN_LOG_RECOVER_DONE);
err: WT_TRET(__recovery_free(&r));
__wt_free(session, config);
if (ret != 0)
__wt_err(session, ret, "Recovery failed");
/*
* Destroy the eviction threads that were started in support of
* recovery. They will be restarted once the lookaside table is
* created.
*/
if (eviction_started)
WT_TRET(__wt_evict_destroy(session));
WT_TRET(session->iface.close(&session->iface, NULL));
return (ret);
}
/*
* __session_close --
* WT_SESSION->close method.
*/
static int
__session_close(WT_SESSION *wt_session, const char *config)
{
WT_CONNECTION_IMPL *conn;
WT_CURSOR *cursor;
WT_DECL_RET;
WT_SESSION_IMPL *session;
int tret;
conn = (WT_CONNECTION_IMPL *)wt_session->connection;
session = (WT_SESSION_IMPL *)wt_session;
SESSION_API_CALL(session, close, config, cfg);
WT_UNUSED(cfg);
/* Rollback any active transaction. */
if (F_ISSET(&session->txn, TXN_RUNNING))
WT_TRET(__session_rollback_transaction(wt_session, NULL));
/* Close all open cursors. */
while ((cursor = TAILQ_FIRST(&session->cursors)) != NULL)
WT_TRET(cursor->close(cursor));
WT_ASSERT(session, session->ncursors == 0);
/*
* Acquire the schema lock: we may be closing btree handles.
*
* Note that in some special cases, the schema may already be locked
* (e.g., if this session is an LSM tree worker and the tree is being
* dropped).
*/
WT_WITH_SCHEMA_LOCK_OPT(session, tret = __session_close_cache(session));
WT_TRET(tret);
/* Discard metadata tracking. */
__wt_meta_track_discard(session);
/* Discard scratch buffers. */
__wt_scr_discard(session);
/* Free transaction information. */
__wt_txn_destroy(session);
/* Confirm we're not holding any hazard references. */
__wt_hazard_close(session);
/* Free the reconciliation information. */
__wt_rec_destroy(session, &session->reconcile);
/* Free the eviction exclusive-lock information. */
__wt_free(session, session->excl);
/* Destroy the thread's mutex. */
if (session->cond != NULL)
(void)__wt_cond_destroy(session, session->cond);
/* The API lock protects opening and closing of sessions. */
__wt_spin_lock(session, &conn->api_lock);
/*
* Sessions are re-used, clear the structure: this code sets the active
* field to 0, which will exclude the hazard array from review by the
* eviction thread. Note: there's no serialization support around the
* review of the hazard array, which means threads checking for hazard
* references first check the active field (which may be 0) and then use
* the hazard pointer (which cannot be NULL). For this reason, clear
* the session structure carefully.
*
* We don't need to publish here, because regardless of the active field
* being non-zero, the hazard reference is always valid.
*/
WT_SESSION_CLEAR(session);
session = conn->default_session;
/*
* Decrement the count of active sessions if that's possible: a session
* being closed may or may not be at the end of the array, step toward
* the beginning of the array until we reach an active session.
*/
while (conn->sessions[conn->session_cnt - 1].active == 0)
if (--conn->session_cnt == 0)
break;
__wt_spin_unlock(session, &conn->api_lock);
err: API_END_NOTFOUND_MAP(session, ret);
}
/*
* __meta_track_unroll --
* Undo the changes in a metadata tracking record.
*/
static int
__meta_track_unroll(WT_SESSION_IMPL *session, WT_META_TRACK *trk)
{
WT_DECL_RET;
int tret;
switch (trk->op) {
case WT_ST_EMPTY: /* Unused slot */
break;
case WT_ST_CHECKPOINT: /* Checkpoint, see above */
break;
case WT_ST_DROP_COMMIT:
break;
case WT_ST_LOCK: /* Handle lock, see above */
if (trk->created)
F_SET(trk->dhandle, WT_DHANDLE_DISCARD);
WT_WITH_DHANDLE(session, trk->dhandle,
WT_TRET(__wt_session_release_btree(session)));
break;
case WT_ST_FILEOP: /* File operation */
/*
* For renames, both a and b are set.
* For creates, a is NULL.
* For removes, b is NULL.
*/
if (trk->a != NULL && trk->b != NULL &&
(tret = __wt_rename(session,
trk->b + strlen("file:"),
trk->a + strlen("file:"))) != 0) {
__wt_err(session, tret,
"metadata unroll rename %s to %s",
trk->b, trk->a);
WT_TRET(tret);
} else if (trk->a == NULL) {
if ((tret = __wt_remove(session,
trk->b + strlen("file:"))) != 0) {
__wt_err(session, tret,
"metadata unroll create %s",
trk->b);
WT_TRET(tret);
}
}
/*
* We can't undo removes yet: that would imply
* some kind of temporary rename and remove in
* roll forward.
*/
break;
case WT_ST_REMOVE: /* Remove trk.a */
if ((tret = __wt_metadata_remove(session, trk->a)) != 0) {
__wt_err(session, tret,
"metadata unroll remove: %s",
trk->a);
WT_TRET(tret);
}
break;
case WT_ST_SET: /* Set trk.a to trk.b */
if ((tret = __wt_metadata_update(
session, trk->a, trk->b)) != 0) {
__wt_err(session, tret,
"metadata unroll update %s to %s",
trk->a, trk->b);
WT_TRET(tret);
}
break;
WT_ILLEGAL_VALUE(session);
}
__meta_track_clear(session, trk);
return (ret);
}
/*
* __las_page_instantiate --
* Instantiate lookaside update records in a recently read page.
*/
static int
__las_page_instantiate(WT_SESSION_IMPL *session,
WT_REF *ref, uint32_t read_id, const uint8_t *addr, size_t addr_size)
{
WT_CURSOR *cursor;
WT_CURSOR_BTREE cbt;
WT_DECL_ITEM(current_key);
WT_DECL_ITEM(las_addr);
WT_DECL_ITEM(las_key);
WT_DECL_ITEM(las_value);
WT_DECL_RET;
WT_PAGE *page;
WT_UPDATE *first_upd, *last_upd, *upd;
size_t incr, total_incr;
uint64_t current_recno, las_counter, las_txnid, recno, upd_txnid;
uint32_t las_id, upd_size, session_flags;
int exact;
const uint8_t *p;
cursor = NULL;
page = ref->page;
first_upd = last_upd = upd = NULL;
total_incr = 0;
current_recno = recno = WT_RECNO_OOB;
session_flags = 0; /* [-Werror=maybe-uninitialized] */
__wt_btcur_init(session, &cbt);
__wt_btcur_open(&cbt);
WT_ERR(__wt_scr_alloc(session, 0, ¤t_key));
WT_ERR(__wt_scr_alloc(session, 0, &las_addr));
WT_ERR(__wt_scr_alloc(session, 0, &las_key));
WT_ERR(__wt_scr_alloc(session, 0, &las_value));
/* Open a lookaside table cursor. */
WT_ERR(__wt_las_cursor(session, &cursor, &session_flags));
/*
* The lookaside records are in key and update order, that is, there
* will be a set of in-order updates for a key, then another set of
* in-order updates for a subsequent key. We process all of the updates
* for a key and then insert those updates into the page, then all the
* updates for the next key, and so on.
*
* Search for the block's unique prefix, stepping through any matching
* records.
*/
las_addr->data = addr;
las_addr->size = addr_size;
las_key->size = 0;
cursor->set_key(
cursor, read_id, las_addr, (uint64_t)0, (uint32_t)0, las_key);
if ((ret = cursor->search_near(cursor, &exact)) == 0 && exact < 0)
ret = cursor->next(cursor);
for (; ret == 0; ret = cursor->next(cursor)) {
WT_ERR(cursor->get_key(cursor,
&las_id, las_addr, &las_counter, &las_txnid, las_key));
/*
* Confirm the search using the unique prefix; if not a match,
* we're done searching for records for this page.
*/
if (las_id != read_id ||
las_addr->size != addr_size ||
memcmp(las_addr->data, addr, addr_size) != 0)
break;
/*
* If the on-page value has become globally visible, this record
* is no longer needed.
*/
if (__wt_txn_visible_all(session, las_txnid))
continue;
/* Allocate the WT_UPDATE structure. */
WT_ERR(cursor->get_value(
cursor, &upd_txnid, &upd_size, las_value));
WT_ERR(__wt_update_alloc(session,
(upd_size == WT_UPDATE_DELETED_VALUE) ? NULL : las_value,
&upd, &incr));
total_incr += incr;
upd->txnid = upd_txnid;
switch (page->type) {
case WT_PAGE_COL_FIX:
case WT_PAGE_COL_VAR:
p = las_key->data;
WT_ERR(__wt_vunpack_uint(&p, 0, &recno));
if (current_recno == recno)
break;
WT_ASSERT(session, current_recno < recno);
if (first_upd != NULL) {
WT_ERR(__col_instantiate(session,
current_recno, ref, &cbt, first_upd));
first_upd = NULL;
}
current_recno = recno;
break;
case WT_PAGE_ROW_LEAF:
if (current_key->size == las_key->size &&
memcmp(current_key->data,
las_key->data, las_key->size) == 0)
break;
if (first_upd != NULL) {
WT_ERR(__row_instantiate(session,
current_key, ref, &cbt, first_upd));
first_upd = NULL;
}
WT_ERR(__wt_buf_set(session,
current_key, las_key->data, las_key->size));
break;
WT_ILLEGAL_VALUE_ERR(session);
}
/* Append the latest update to the list. */
if (first_upd == NULL)
first_upd = last_upd = upd;
else {
last_upd->next = upd;
last_upd = upd;
}
upd = NULL;
}
WT_ERR_NOTFOUND_OK(ret);
/* Insert the last set of updates, if any. */
if (first_upd != NULL)
switch (page->type) {
case WT_PAGE_COL_FIX:
case WT_PAGE_COL_VAR:
WT_ERR(__col_instantiate(session,
current_recno, ref, &cbt, first_upd));
first_upd = NULL;
break;
case WT_PAGE_ROW_LEAF:
WT_ERR(__row_instantiate(session,
current_key, ref, &cbt, first_upd));
first_upd = NULL;
break;
WT_ILLEGAL_VALUE_ERR(session);
}
/* Discard the cursor. */
WT_ERR(__wt_las_cursor_close(session, &cursor, session_flags));
if (total_incr != 0) {
__wt_cache_page_inmem_incr(session, page, total_incr);
/*
* We've modified/dirtied the page, but that's not necessary and
* if we keep the page clean, it's easier to evict. We leave the
* lookaside table updates in place, so if we evict this page
* without dirtying it, any future instantiation of it will find
* the records it needs. If the page is dirtied before eviction,
* then we'll write any needed lookaside table records for the
* new location of the page.
*/
__wt_page_modify_clear(session, page);
}
err:
WT_TRET(__wt_las_cursor_close(session, &cursor, session_flags));
WT_TRET(__wt_btcur_close(&cbt, true));
/*
* On error, upd points to a single unlinked WT_UPDATE structure,
* first_upd points to a list.
*/
if (upd != NULL)
__wt_free(session, upd);
if (first_upd != NULL)
__wt_free_update_list(session, first_upd);
__wt_scr_free(session, ¤t_key);
__wt_scr_free(session, &las_addr);
__wt_scr_free(session, &las_key);
__wt_scr_free(session, &las_value);
return (ret);
}
