/*
* __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_CONNECTION_IMPL *conn;
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 oldest_id, saved_snap_min;
uint32_t flags;
conn = S2C(session);
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);
}
/*
* Save the oldest transaction ID we need to keep around.
* Otherwise, in a busy system, we could be updating pages so
* fast that write leaves never catches up. We deliberately
* have no transaction running at this point that would keep
* the oldest ID from moving forwards as we walk the tree.
*/
oldest_id = __wt_txn_oldest_id(session);
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 hot pages (defined as pages that have
* been updated since the write phase leaves started):
* checkpoint will have to visit them anyway.
*/
page = walk->page;
if (__wt_page_is_modified(page) &&
WT_TXNID_LT(page->modify->update_txn, oldest_id)) {
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);
/*
* In the final checkpoint pass, child pages cannot be evicted
* from underneath internal pages nor can underlying blocks be
* freed until the checkpoint's block lists are stable. Also,
* we cannot split child pages into parents unless we know the
* final pass will write a consistent view of that namespace.
* Set the checkpointing flag to block such actions and wait for
* any problematic eviction or page splits to complete.
*/
WT_PUBLISH(btree->checkpointing, WT_CKPT_PREPARE);
WT_ERR(__wt_evict_file_exclusive_on(session));
__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,
conn->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 && F_ISSET(conn, WT_CONN_CKPT_SYNC))
WT_RET(btree->bm->sync(btree->bm, session, true));
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_RET(__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, true));
if (chunk->switch_txn == WT_TXN_NONE ||
!__wt_txn_visible_all(session, chunk->switch_txn)) {
WT_RET(__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_ERR(__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_ERR(__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_ERR(__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_ERR(__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_TRET(__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_ERR(__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);
}
/*
* __lsm_merge_aggressive_update --
* Update the merge aggressiveness for an LSM tree.
*/
static int
__lsm_merge_aggressive_update(WT_SESSION_IMPL *session, WT_LSM_TREE *lsm_tree)
{
struct timespec now;
uint64_t msec_since_last_merge, msec_to_create_merge;
u_int new_aggressive;
new_aggressive = 0;
/*
* If the tree is open read-only or we are compacting, be very
* aggressive. Otherwise, we can spend a long time waiting for merges
* to start in read-only applications.
*/
if (!lsm_tree->modified ||
F_ISSET(lsm_tree, WT_LSM_TREE_COMPACTING)) {
lsm_tree->merge_aggressiveness = 10;
return (0);
}
/*
* Only get aggressive if a reasonable number of flushes have been
* completed since opening the tree.
*/
if (lsm_tree->chunks_flushed <= lsm_tree->merge_min)
return (__lsm_merge_aggressive_clear(lsm_tree));
/*
* Start the timer if it isn't running. Use a flag to define whether
* the timer is running - since clearing and checking a special
* timer value isn't simple.
*/
if (!F_ISSET(lsm_tree, WT_LSM_TREE_AGGRESSIVE_TIMER)) {
F_SET(lsm_tree, WT_LSM_TREE_AGGRESSIVE_TIMER);
return (__wt_epoch(session, &lsm_tree->merge_aggressive_ts));
}
WT_RET(__wt_epoch(session, &now));
msec_since_last_merge =
WT_TIMEDIFF_MS(now, lsm_tree->merge_aggressive_ts);
/*
* If there is no estimate for how long it's taking to fill chunks
* pick 10 seconds.
*/
msec_to_create_merge = lsm_tree->merge_min *
(lsm_tree->chunk_fill_ms == 0 ? 10000 : lsm_tree->chunk_fill_ms);
/*
* Don't consider getting aggressive until enough time has passed that
* we should have created enough chunks to trigger a new merge. We
* track average chunk-creation time - hence the "should"; the average
* fill time may not reflect the actual state if an application
* generates a variable load.
*/
if (msec_since_last_merge < msec_to_create_merge)
return (0);
/*
* Bump how aggressively we look for merges based on how long since
* the last merge complete. The aggressive setting only increases
* slowly - triggering merges across generations of chunks isn't
* an efficient use of resources.
*/
while ((msec_since_last_merge /= msec_to_create_merge) > 1)
++new_aggressive;
if (new_aggressive > lsm_tree->merge_aggressiveness) {
WT_RET(__wt_verbose(session, WT_VERB_LSM,
"LSM merge %s got aggressive (old %u new %u), "
"merge_min %d, %u / %" PRIu64,
lsm_tree->name, lsm_tree->merge_aggressiveness,
new_aggressive, lsm_tree->merge_min,
msec_since_last_merge, lsm_tree->chunk_fill_ms));
lsm_tree->merge_aggressiveness = new_aggressive;
}
return (0);
}
/*
* __log_server --
* The log server thread.
*/
static WT_THREAD_RET
__log_server(void *arg)
{
struct timespec start, now;
WT_CONNECTION_IMPL *conn;
WT_DECL_RET;
WT_LOG *log;
WT_SESSION_IMPL *session;
uint64_t timediff;
bool did_work, locked, signalled;
session = arg;
conn = S2C(session);
log = conn->log;
locked = signalled = false;
/*
* Set this to the number of milliseconds we want to run archive and
* pre-allocation. Start it so that we run on the first time through.
*/
timediff = WT_THOUSAND;
/*
* The log server thread does a variety of work. It forces out any
* buffered log writes. It pre-allocates log files and it performs
* log archiving. The reason the wrlsn thread does not force out
* the buffered writes is because we want to process and move the
* write_lsn forward as quickly as possible. The same reason applies
* to why the log file server thread does not force out the writes.
* That thread does fsync calls which can take a long time and we
* don't want log records sitting in the buffer over the time it
* takes to sync out an earlier file.
*/
did_work = true;
while (F_ISSET(conn, WT_CONN_LOG_SERVER_RUN)) {
/*
* Slots depend on future activity. Force out buffered
* writes in case we are idle. This cannot be part of the
* wrlsn thread because of interaction advancing the write_lsn
* and a buffer may need to wait for the write_lsn to advance
* in the case of a synchronous buffer. We end up with a hang.
*/
WT_ERR_BUSY_OK(__wt_log_force_write(session, 0, &did_work));
/*
* We don't want to archive or pre-allocate files as often as
* we want to force out log buffers. Only do it once per second
* or if the condition was signalled.
*/
if (timediff >= WT_THOUSAND || signalled) {
/*
* Perform log pre-allocation.
*/
if (conn->log_prealloc > 0) {
/*
* Log file pre-allocation is disabled when a
* hot backup cursor is open because we have
* agreed not to rename or remove any files in
* the database directory.
*/
WT_ERR(__wt_readlock(
session, conn->hot_backup_lock));
locked = true;
if (!conn->hot_backup)
WT_ERR(__log_prealloc_once(session));
WT_ERR(__wt_readunlock(
session, conn->hot_backup_lock));
locked = false;
}
/*
* Perform the archive.
*/
if (FLD_ISSET(conn->log_flags, WT_CONN_LOG_ARCHIVE)) {
if (__wt_try_writelock(
session, log->log_archive_lock) == 0) {
ret = __log_archive_once(session, 0);
WT_TRET(__wt_writeunlock(
session, log->log_archive_lock));
WT_ERR(ret);
} else
WT_ERR(
__wt_verbose(session, WT_VERB_LOG,
"log_archive: Blocked due to open "
"log cursor holding archive lock"));
}
}
/* Wait until the next event. */
WT_ERR(__wt_epoch(session, &start));
WT_ERR(__wt_cond_auto_wait_signal(session, conn->log_cond,
did_work, &signalled));
WT_ERR(__wt_epoch(session, &now));
timediff = WT_TIMEDIFF_MS(now, start);
}
if (0) {
err: __wt_err(session, ret, "log server error");
if (locked)
WT_TRET(__wt_readunlock(
session, conn->hot_backup_lock));
}
return (WT_THREAD_RET_VALUE);
}
/*
* __lsm_tree_open --
* Open an LSM tree structure.
*/
static int
__lsm_tree_open(
WT_SESSION_IMPL *session, const char *uri, WT_LSM_TREE **treep)
{
WT_CONNECTION_IMPL *conn;
WT_DECL_RET;
WT_LSM_TREE *lsm_tree;
conn = S2C(session);
lsm_tree = NULL;
WT_ASSERT(session, F_ISSET(session, WT_SESSION_SCHEMA_LOCKED));
/* Start the LSM manager thread if it isn't running. */
if (WT_ATOMIC_CAS4(conn->lsm_manager.lsm_workers, 0, 1))
WT_RET(__wt_lsm_manager_start(session));
/* Make sure no one beat us to it. */
TAILQ_FOREACH(lsm_tree, &S2C(session)->lsmqh, q)
if (strcmp(uri, lsm_tree->name) == 0) {
*treep = lsm_tree;
return (0);
}
/* Try to open the tree. */
WT_RET(__wt_calloc_def(session, 1, &lsm_tree));
WT_ERR(__wt_rwlock_alloc(session, &lsm_tree->rwlock, "lsm tree"));
WT_ERR(__lsm_tree_set_name(session, lsm_tree, uri));
WT_ERR(__wt_lsm_meta_read(session, lsm_tree));
/*
* Sanity check the configuration. Do it now since this is the first
* time we have the LSM tree configuration.
*/
WT_ERR(__lsm_tree_open_check(session, lsm_tree));
if (lsm_tree->nchunks == 0) {
F_SET(lsm_tree, WT_LSM_TREE_NEED_SWITCH);
WT_ERR(__wt_lsm_tree_switch(session, lsm_tree));
}
/* Set the generation number so cursors are opened on first usage. */
lsm_tree->dsk_gen = 1;
/*
* Setup reference counting. Use separate reference counts for tree
* handles and queue entries, so that queue entries don't interfere
* with getting handles exclusive.
*/
lsm_tree->refcnt = 1;
lsm_tree->queue_ref = 0;
/* Set a flush timestamp as a baseline. */
WT_ERR(__wt_epoch(session, &lsm_tree->last_flush_ts));
/* Now the tree is setup, make it visible to others. */
TAILQ_INSERT_HEAD(&S2C(session)->lsmqh, lsm_tree, q);
F_SET(lsm_tree, WT_LSM_TREE_ACTIVE | WT_LSM_TREE_OPEN);
*treep = lsm_tree;
if (0) {
err: WT_TRET(__lsm_tree_discard(session, lsm_tree));
}
return (ret);
}
/*
* __wt_eventv --
* Report a message to an event handler.
*/
int
__wt_eventv(WT_SESSION_IMPL *session, bool msg_event, int error,
const char *file_name, int line_number, const char *fmt, va_list ap)
{
WT_EVENT_HANDLER *handler;
WT_DECL_RET;
WT_SESSION *wt_session;
struct timespec ts;
size_t len, remain, wlen;
int prefix_cnt;
const char *err, *prefix;
char *end, *p, tid[128];
/*
* We're using a stack buffer because we want error messages no matter
* what, and allocating a WT_ITEM, or the memory it needs, might fail.
*
* !!!
* SECURITY:
* Buffer placed at the end of the stack in case snprintf overflows.
*/
char s[2048];
/*
* !!!
* This function MUST handle a NULL WT_SESSION_IMPL handle.
*
* Without a session, we don't have event handlers or prefixes for the
* error message. Write the error to stderr and call it a day. (It's
* almost impossible for that to happen given how early we allocate the
* first session, but if the allocation of the first session fails, for
* example, we can end up here without a session.)
*/
if (session == NULL) {
if (fprintf(stderr,
"WiredTiger Error%s%s: ",
error == 0 ? "" : ": ",
error == 0 ? "" :
__wt_strerror(session, error, NULL, 0)) < 0)
ret = EIO;
if (vfprintf(stderr, fmt, ap) < 0)
ret = EIO;
if (fprintf(stderr, "\n") < 0)
ret = EIO;
if (fflush(stderr) != 0)
ret = EIO;
return (ret);
}
p = s;
end = s + sizeof(s);
/*
* We have several prefixes for the error message: a timestamp and the
* process and thread ids, the database error prefix, the data-source's
* name, and the session's name. Write them as a comma-separate list,
* followed by a colon.
*/
prefix_cnt = 0;
if (__wt_epoch(session, &ts) == 0) {
__wt_thread_id(tid, sizeof(tid));
remain = WT_PTRDIFF(end, p);
wlen = (size_t)snprintf(p, remain,
"[%" PRIuMAX ":%" PRIuMAX "][%s]",
(uintmax_t)ts.tv_sec,
(uintmax_t)ts.tv_nsec / WT_THOUSAND, tid);
p = wlen >= remain ? end : p + wlen;
prefix_cnt = 1;
}
if ((prefix = S2C(session)->error_prefix) != NULL) {
remain = WT_PTRDIFF(end, p);
wlen = (size_t)snprintf(p, remain,
"%s%s", prefix_cnt == 0 ? "" : ", ", prefix);
p = wlen >= remain ? end : p + wlen;
prefix_cnt = 1;
}
prefix = session->dhandle == NULL ? NULL : session->dhandle->name;
if (prefix != NULL) {
remain = WT_PTRDIFF(end, p);
wlen = (size_t)snprintf(p, remain,
"%s%s", prefix_cnt == 0 ? "" : ", ", prefix);
p = wlen >= remain ? end : p + wlen;
prefix_cnt = 1;
}
if ((prefix = session->name) != NULL) {
remain = WT_PTRDIFF(end, p);
wlen = (size_t)snprintf(p, remain,
"%s%s", prefix_cnt == 0 ? "" : ", ", prefix);
p = wlen >= remain ? end : p + wlen;
prefix_cnt = 1;
}
if (prefix_cnt != 0) {
remain = WT_PTRDIFF(end, p);
wlen = (size_t)snprintf(p, remain, ": ");
p = wlen >= remain ? end : p + wlen;
}
if (file_name != NULL) {
remain = WT_PTRDIFF(end, p);
wlen = (size_t)
snprintf(p, remain, "%s, %d: ", file_name, line_number);
p = wlen >= remain ? end : p + wlen;
}
remain = WT_PTRDIFF(end, p);
wlen = (size_t)vsnprintf(p, remain, fmt, ap);
p = wlen >= remain ? end : p + wlen;
if (error != 0) {
/*
* When the engine calls __wt_err on error, it often outputs an
* error message including the string associated with the error
* it's returning. We could change the calls to call __wt_errx,
* but it's simpler to not append an error string if all we are
* doing is duplicating an existing error string.
*
* Use strcmp to compare: both strings are nul-terminated, and
* we don't want to run past the end of the buffer.
*/
err = __wt_strerror(session, error, NULL, 0);
len = strlen(err);
if (WT_PTRDIFF(p, s) < len || strcmp(p - len, err) != 0) {
remain = WT_PTRDIFF(end, p);
(void)snprintf(p, remain, ": %s", err);
}
}
/*
* If a handler fails, return the error status: if we're in the process
* of handling an error, any return value we provide will be ignored by
* our caller, our caller presumably already has an error value it will
* be returning.
*
* If an application-specified or default informational message handler
* fails, complain using the application-specified or default error
* handler.
*
* If an application-specified error message handler fails, complain
* using the default error handler. If the default error handler fails,
* there's nothing to do.
*/
wt_session = (WT_SESSION *)session;
handler = session->event_handler;
if (msg_event) {
ret = handler->handle_message(handler, wt_session, s);
if (ret != 0)
__handler_failure(session, ret, "message", false);
} else {
ret = handler->handle_error(handler, wt_session, error, s);
if (ret != 0 && handler->handle_error != __handle_error_default)
__handler_failure(session, ret, "error", true);
}
return (ret);
}
/*
* Regularly create, open a cursor and drop a table.
* Measure how long each step takes, and flag an error if it exceeds the
* configured maximum.
*/
static void *
cycle_idle_tables(void *arg)
{
struct timespec start, stop;
CONFIG *cfg;
WT_SESSION *session;
WT_CURSOR *cursor;
int cycle_count, ret;
char uri[512];
cfg = (CONFIG *)arg;
cycle_count = 0;
if ((ret = cfg->conn->open_session(
cfg->conn, NULL, cfg->sess_config, &session)) != 0) {
lprintf(cfg, ret, 0,
"Error opening a session on %s", cfg->home);
return (NULL);
}
for (cycle_count = 0; cfg->idle_cycle_run; ++cycle_count) {
snprintf(uri, 512, "%s_cycle%07d", cfg->uris[0], cycle_count);
/* Don't busy cycle in this loop. */
__wt_sleep(1, 0);
/* Setup a start timer. */
if ((ret = __wt_epoch(NULL, &start)) != 0) {
lprintf(cfg, ret, 0,
"Get time failed in cycle_idle_tables.");
cfg->error = ret;
return (NULL);
}
/* Create a table. */
if ((ret = session->create(
session, uri, cfg->table_config)) != 0) {
if (ret == EBUSY)
continue;
lprintf(cfg, ret, 0,
"Table create failed in cycle_idle_tables.");
cfg->error = ret;
return (NULL);
}
if (check_timing(cfg, "create", start, &stop) != 0)
return (NULL);
start = stop;
/* Open and close cursor. */
if ((ret = session->open_cursor(
session, uri, NULL, NULL, &cursor)) != 0) {
lprintf(cfg, ret, 0,
"Cursor open failed in cycle_idle_tables.");
cfg->error = ret;
return (NULL);
}
if ((ret = cursor->close(cursor)) != 0) {
lprintf(cfg, ret, 0,
"Cursor close failed in cycle_idle_tables.");
cfg->error = ret;
return (NULL);
}
if (check_timing(cfg, "cursor", start, &stop) != 0)
return (NULL);
start = stop;
/*
* Drop the table. Keep retrying on EBUSY failure - it is an
* expected return when checkpoints are happening.
*/
while ((ret = session->drop(
session, uri, "force,checkpoint_wait=false")) == EBUSY)
__wt_sleep(1, 0);
if (ret != 0 && ret != EBUSY) {
lprintf(cfg, ret, 0,
"Table drop failed in cycle_idle_tables.");
cfg->error = ret;
return (NULL);
}
if (check_timing(cfg, "drop", start, &stop) != 0)
return (NULL);
}
return (NULL);
}
/*
* __wt_session_compact --
* WT_SESSION.compact method.
*/
int
__wt_session_compact(
WT_SESSION *wt_session, const char *uri, const char *config)
{
WT_COMPACT_STATE compact;
WT_CONFIG_ITEM cval;
WT_DATA_SOURCE *dsrc;
WT_DECL_RET;
WT_SESSION_IMPL *session;
u_int i;
bool ignore_cache_size_set;
ignore_cache_size_set = false;
session = (WT_SESSION_IMPL *)wt_session;
SESSION_API_CALL(session, compact, config, cfg);
/*
* The compaction thread should not block when the cache is full: it is
* holding locks blocking checkpoints and once the cache is full, it can
* spend a long time doing eviction.
*/
if (!F_ISSET(session, WT_SESSION_IGNORE_CACHE_SIZE)) {
ignore_cache_size_set = true;
F_SET(session, WT_SESSION_IGNORE_CACHE_SIZE);
}
/* In-memory ignores compaction operations. */
if (F_ISSET(S2C(session), WT_CONN_IN_MEMORY))
goto err;
/*
* Non-LSM object compaction requires checkpoints, which are impossible
* in transactional contexts. Disallow in all contexts (there's no
* reason for LSM to allow this, possible or not), and check now so the
* error message isn't confusing.
*/
WT_ERR(__wt_txn_context_check(session, false));
/* Disallow objects in the WiredTiger name space. */
WT_ERR(__wt_str_name_check(session, uri));
if (!WT_PREFIX_MATCH(uri, "colgroup:") &&
!WT_PREFIX_MATCH(uri, "file:") &&
!WT_PREFIX_MATCH(uri, "index:") &&
!WT_PREFIX_MATCH(uri, "lsm:") &&
!WT_PREFIX_MATCH(uri, "table:")) {
if ((dsrc = __wt_schema_get_source(session, uri)) != NULL)
ret = dsrc->compact == NULL ?
__wt_object_unsupported(session, uri) :
dsrc->compact(
dsrc, wt_session, uri, (WT_CONFIG_ARG *)cfg);
else
ret = __wt_bad_object_type(session, uri);
goto err;
}
/* Setup the session handle's compaction state structure. */
memset(&compact, 0, sizeof(WT_COMPACT_STATE));
session->compact = &compact;
/* Compaction can be time-limited. */
WT_ERR(__wt_config_gets(session, cfg, "timeout", &cval));
session->compact->max_time = (uint64_t)cval.val;
__wt_epoch(session, &session->compact->begin);
/* Find the types of data sources being compacted. */
WT_WITH_SCHEMA_LOCK(session,
ret = __wt_schema_worker(session, uri,
__compact_handle_append, __compact_uri_analyze, cfg, 0));
WT_ERR(ret);
if (session->compact->lsm_count != 0)
WT_ERR(__wt_schema_worker(
session, uri, NULL, __wt_lsm_compact, cfg, 0));
if (session->compact->file_count != 0)
WT_ERR(__compact_worker(session));
err: session->compact = NULL;
for (i = 0; i < session->op_handle_next; ++i) {
WT_WITH_DHANDLE(session, session->op_handle[i],
WT_TRET(__compact_end(session)));
WT_WITH_DHANDLE(session, session->op_handle[i],
WT_TRET(__wt_session_release_dhandle(session)));
}
__wt_free(session, session->op_handle);
session->op_handle_allocated = session->op_handle_next = 0;
/*
* Release common session resources (for example, checkpoint may acquire
* significant reconciliation structures/memory).
*/
WT_TRET(__wt_session_release_resources(session));
if (ignore_cache_size_set)
F_CLR(session, WT_SESSION_IGNORE_CACHE_SIZE);
if (ret != 0)
WT_STAT_CONN_INCR(session, session_table_compact_fail);
else
WT_STAT_CONN_INCR(session, session_table_compact_success);
API_END_RET_NOTFOUND_MAP(session, ret);
}
/*
* __sync_file --
* Flush pages for a specific file.
*/
static int
__sync_file(WT_SESSION_IMPL *session, int 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, leaf_bytes;
uint64_t internal_pages, leaf_pages;
uint32_t flags;
bool evict_reset;
btree = S2BT(session);
flags = WT_READ_CACHE | WT_READ_NO_GEN;
walk = NULL;
txn = &session->txn;
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, NULL, 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:
/*
* 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, NULL, flags));
if (walk == NULL)
break;
page = walk->page;
mod = page->modify;
/* Skip clean pages. */
if (!__wt_page_is_modified(page))
continue;
/*
* 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;
}
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(end, start) / WT_MILLION));
}
err: /* On error, clear any left-over tree walk. */
if (walk != NULL)
WT_TRET(__wt_page_release(session, walk, flags));
if (txn->isolation == WT_ISO_READ_COMMITTED && session->ncursors == 0)
__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_meta_ckptlist_set --
* Set a file's checkpoint value from the WT_CKPT list.
*/
int
__wt_meta_ckptlist_set(
WT_SESSION_IMPL *session, const char *fname, WT_CKPT *ckptbase)
{
struct timespec ts;
WT_CKPT *ckpt;
WT_DECL_RET;
WT_ITEM *buf;
int64_t maxorder;
const char *sep;
buf = NULL;
WT_ERR(__wt_scr_alloc(session, 0, &buf));
maxorder = 0;
sep = "";
WT_ERR(__wt_buf_fmt(session, buf, "checkpoint=("));
WT_CKPT_FOREACH(ckptbase, ckpt) {
/*
* Each internal checkpoint name is appended with a generation
* to make it a unique name. We're solving two problems: when
* two checkpoints are taken quickly, the timer may not be
* unique and/or we can even see time travel on the second
* checkpoint if we snapshot the time in-between nanoseconds
* rolling over. Second, if we reset the generational counter
* when new checkpoints arrive, we could logically re-create
* specific checkpoints, racing with cursors open on those
* checkpoints. I can't think of any way to return incorrect
* results by racing with those cursors, but it's simpler not
* to worry about it.
*/
if (ckpt->order > maxorder)
maxorder = ckpt->order;
/* Skip deleted checkpoints. */
if (F_ISSET(ckpt, WT_CKPT_DELETE))
continue;
if (F_ISSET(ckpt, WT_CKPT_ADD | WT_CKPT_UPDATE)) {
/*
* We fake checkpoints for handles in the middle of a
* bulk load. If there is a checkpoint, convert the
* raw cookie to a hex string.
*/
if (ckpt->raw.size == 0)
ckpt->addr.size = 0;
else
WT_ERR(__wt_raw_to_hex(session,
ckpt->raw.data,
ckpt->raw.size, &ckpt->addr));
/* Set the order and timestamp. */
if (F_ISSET(ckpt, WT_CKPT_ADD))
ckpt->order = ++maxorder;
WT_ERR(__wt_epoch(session, &ts));
ckpt->sec = (uintmax_t)ts.tv_sec;
}
if (strcmp(ckpt->name, WT_CHECKPOINT) == 0)
WT_ERR(__wt_buf_catfmt(session, buf,
"%s%s.%" PRId64 "=(addr=\"%.*s\",order=%" PRIu64
",time=%" PRIuMAX ",size=%" PRIu64 ")",
sep, ckpt->name, ckpt->order,
(int)ckpt->addr.size, (char *)ckpt->addr.data,
ckpt->order, ckpt->sec, ckpt->ckpt_size));
else
WT_ERR(__wt_buf_catfmt(session, buf,
"%s%s=(addr=\"%.*s\",order=%" PRIu64
",time=%" PRIuMAX ",size=%" PRIu64 ")",
sep, ckpt->name,
(int)ckpt->addr.size, (char *)ckpt->addr.data,
ckpt->order, ckpt->sec, ckpt->ckpt_size));
sep = ",";
}
WT_ERR(__wt_buf_catfmt(session, buf, ")"));
WT_ERR(__ckpt_set(session, fname, buf->mem));
err: __wt_scr_free(&buf);
return (ret);
}
/*
* __snapshot_process --
* Process the list of snapshots.
*/
static int
__snapshot_process(
WT_SESSION_IMPL *session, WT_BLOCK *block, WT_SNAPSHOT *snapbase)
{
WT_BLOCK_SNAPSHOT *a, *b, *si;
WT_DECL_ITEM(tmp);
WT_DECL_RET;
WT_SNAPSHOT *snap;
uint64_t snapshot_size;
int deleting, locked;
si = &block->live;
locked = 0;
/*
* We've allocated our last page, update the snapshot size. We need to
* calculate the live system's snapshot size before reading and merging
* snapshot allocation and discard information from the snapshots we're
* deleting, those operations will change the underlying byte counts.
*/
snapshot_size = si->snapshot_size;
snapshot_size += si->alloc.bytes;
snapshot_size -= si->discard.bytes;
/*
* Extents that become newly available as a result of deleting previous
* snapshots are added to a list of extents. The list should be empty,
* but there's no explicit "free the snapshot information" call into the
* block manager; if there was an error in an upper level resulting in
* the snapshot never being "resolved", the list might not be empty.
*
* XXX
* This isn't sufficient, actually: we're going to leak all the blocks
* that were written as part of the last snapshot because it was never
* resolved.
*/
__wt_block_extlist_free(session, &si->snapshot_avail);
WT_RET(__wt_block_extlist_init(
session, &si->snapshot_avail, "live", "snapshot_avail"));
/*
* To delete a snapshot, we'll need snapshot information for it, and we
* have to read that from the disk.
*/
deleting = 0;
WT_SNAPSHOT_FOREACH(snapbase, snap) {
/*
* To delete a snapshot, we'll need snapshot information for it
* and the subsequent snapshot. The test is tricky, we have to
* load the current snapshot's information if it's marked for
* deletion, or if it follows a snapshot marked for deletion,
* where the boundary cases are the first snapshot in the list
* and the last snapshot in the list: if we're deleting the last
* snapshot in the list, there's no next snapshot, the snapshot
* will be merged into the live tree.
*/
if (!F_ISSET(snap, WT_SNAP_DELETE) &&
(snap == snapbase ||
F_ISSET(snap, WT_SNAP_ADD) ||
!F_ISSET(snap - 1, WT_SNAP_DELETE)))
continue;
deleting = 1;
/*
* Allocate a snapshot structure, crack the cookie and read the
* snapshot's extent lists.
*
* Ignore the avail list: snapshot avail lists are only useful
* if we are rolling forward from the particular snapshot and
* they represent our best understanding of what blocks can be
* allocated. If we are not operating on the live snapshot,
* subsequent snapshots might have allocated those blocks, and
* the avail list is useless. We don't discard it, because it
* is useful as part of verification, but we don't re-write it
* either.
*/
WT_ERR(__wt_calloc(
session, 1, sizeof(WT_BLOCK_SNAPSHOT), &snap->bpriv));
si = snap->bpriv;
WT_ERR(__wt_block_snap_init(session, block, si, snap->name, 0));
WT_ERR(__wt_block_buffer_to_snapshot(
session, block, snap->raw.data, si));
WT_ERR(__wt_block_extlist_read(session, block, &si->alloc));
WT_ERR(__wt_block_extlist_read(session, block, &si->discard));
}
/*
* Hold a lock so the live extent lists and the file size can't change
* underneath us. I suspect we'll tighten this if snapshots take too
* much time away from real work: we read historic snapshot information
* without a lock, but we could also merge and re-write the delete
* snapshot information without a lock, except for ranges merged into
* the live tree.
*/
__wt_spin_lock(session, &block->live_lock);
locked = 1;
/* Skip the additional processing if we aren't deleting snapshots. */
if (!deleting)
goto live_update;
/*
* Delete any no-longer-needed snapshots: we do this first as it frees
* blocks to the live lists, and the freed blocks will then be included
* when writing the live extent lists.
*/
WT_SNAPSHOT_FOREACH(snapbase, snap) {
if (!F_ISSET(snap, WT_SNAP_DELETE))
continue;
if (WT_VERBOSE_ISSET(session, snapshot)) {
if (tmp == NULL)
WT_ERR(__wt_scr_alloc(session, 0, &tmp));
WT_ERR(__snapshot_string(
session, block, snap->raw.data, tmp));
WT_VERBOSE_ERR(session, snapshot,
"%s: delete-snapshot: %s: %s",
block->name, snap->name, (char *)tmp->data);
}
/*
* Set the from/to snapshot structures, where the "to" value
* may be the live tree.
*/
a = snap->bpriv;
if (F_ISSET(snap + 1, WT_SNAP_ADD))
b = &block->live;
else
b = (snap + 1)->bpriv;
/*
* Free the root page: there's nothing special about this free,
* the root page is allocated using normal rules, that is, it
* may have been taken from the avail list, and was entered on
* the live system's alloc list at that time. We free it into
* the snapshot's discard list, however, not the live system's
* list because it appears on the snapshot's alloc list and so
* must be paired in the snapshot.
*/
if (a->root_offset != WT_BLOCK_INVALID_OFFSET)
WT_ERR(__wt_block_insert_ext(session,
&a->discard, a->root_offset, a->root_size));
/*
* Free the blocks used to hold the "from" snapshot's extent
* lists directly to the live system's avail list, they were
* never on any alloc list. Include the "from" snapshot's
* avail list, it's going away.
*/
WT_ERR(__snapshot_extlist_fblocks(session, block, &a->alloc));
WT_ERR(__snapshot_extlist_fblocks(session, block, &a->avail));
WT_ERR(__snapshot_extlist_fblocks(session, block, &a->discard));
/*
* Roll the "from" alloc and discard extent lists into the "to"
* snapshot's lists.
*/
if (a->alloc.entries != 0)
WT_ERR(__wt_block_extlist_merge(
session, &a->alloc, &b->alloc));
if (a->discard.entries != 0)
WT_ERR(__wt_block_extlist_merge(
session, &a->discard, &b->discard));
/*
* If the "to" snapshot is also being deleted, we're done with
* it, it's merged into some other snapshot in the next loop.
* This means the extent lists may aggregate over a number of
* snapshots, but that's OK, they're disjoint sets of ranges.
*/
if (F_ISSET(snap + 1, WT_SNAP_DELETE))
continue;
/*
* Find blocks for re-use: wherever the "to" snapshot's allocate
* and discard lists overlap is fair game, move ranges appearing
* on both lists to the live snapshot's newly available list.
*/
WT_ERR(__wt_block_extlist_overlap(session, block, b));
/*
* If we're updating the live system's information, we're done.
*/
if (F_ISSET(snap + 1, WT_SNAP_ADD))
continue;
/*
* We have to write the "to" snapshot's extent lists out in new
* blocks, and update its cookie.
*
* Free the blocks used to hold the "to" snapshot's extent lists
* directly to the live system's avail list, they were never on
* any alloc list. Do not include the "to" snapshot's avail
* list, it's not changing.
*/
WT_ERR(__snapshot_extlist_fblocks(session, block, &b->alloc));
WT_ERR(__snapshot_extlist_fblocks(session, block, &b->discard));
F_SET(snap + 1, WT_SNAP_UPDATE);
}
/* Update snapshots marked for update. */
WT_SNAPSHOT_FOREACH(snapbase, snap)
if (F_ISSET(snap, WT_SNAP_UPDATE)) {
WT_ASSERT(session, !F_ISSET(snap, WT_SNAP_ADD));
WT_ERR(__snapshot_update(
session, block, snap, snap->bpriv, 0, 0));
}
live_update:
si = &block->live;
/* Truncate the file if that's possible. */
WT_ERR(__wt_block_extlist_truncate(session, block, &si->avail));
/* Update the final, added snapshot based on the live system. */
WT_SNAPSHOT_FOREACH(snapbase, snap)
if (F_ISSET(snap, WT_SNAP_ADD)) {
WT_ERR(__snapshot_update(
session, block, snap, si, snapshot_size, 1));
/*
* XXX
* Our caller wants two pieces of information: the time
* the snapshot was taken and the final snapshot size.
* This violates layering but the alternative is a call
* for the btree layer to crack the snapshot cookie into
* its components, and that's a fair amount of work.
* (We could just read the system time in the session
* layer when updating the metadata file, but that won't
* work for the snapshot size, and so we do both here.)
*/
snap->snapshot_size = si->snapshot_size;
WT_ERR(__wt_epoch(session, &snap->sec, NULL));
}
/*
* Reset the live system's alloc and discard extent lists, leave the
* avail list alone.
*/
__wt_block_extlist_free(session, &si->alloc);
WT_ERR(__wt_block_extlist_init(session, &si->alloc, "live", "alloc"));
__wt_block_extlist_free(session, &si->discard);
WT_ERR(
__wt_block_extlist_init(session, &si->discard, "live", "discard"));
#ifdef HAVE_DIAGNOSTIC
/*
* The first snapshot in the system should always have an empty discard
* list. If we've read that snapshot and/or created it, check.
*/
WT_SNAPSHOT_FOREACH(snapbase, snap)
if (!F_ISSET(snap, WT_SNAP_DELETE))
break;
if ((a = snap->bpriv) == NULL)
a = &block->live;
if (a->discard.entries != 0) {
__wt_errx(session,
"snapshot incorrectly has blocks on the discard list");
WT_ERR(WT_ERROR);
}
#endif
err: if (locked)
__wt_spin_unlock(session, &block->live_lock);
/* Discard any snapshot information we loaded, we no longer need it. */
WT_SNAPSHOT_FOREACH(snapbase, snap)
if ((si = snap->bpriv) != NULL) {
__wt_block_extlist_free(session, &si->alloc);
__wt_block_extlist_free(session, &si->avail);
__wt_block_extlist_free(session, &si->discard);
}
__wt_scr_free(&tmp);
return (ret);
}
void
workgen_epoch(struct timespec *tsp)
{
__wt_epoch(NULL, tsp);
}
/*
* __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;
/*
* 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) {
if ((ret = __lsm_discard_handle(
session, chunk->uri, NULL)) == 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_RET(__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_txn_update_oldest(session);
if (chunk->switch_txn == WT_TXN_NONE ||
!__wt_txn_visible_all(session, chunk->switch_txn)) {
WT_RET(__wt_verbose(session, WT_VERB_LSM,
"LSM worker %s: running transaction, return",
chunk->uri));
return (0);
}
WT_RET(__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.
*
* Use the special eviction isolation level to avoid interfering with
* an application checkpoint: we have already checked that all of the
* updates in this chunk are globally visible.
*
* !!! We can wait here for checkpoints and fsyncs to complete, which
* can be a long time.
*/
if ((ret = __wt_session_get_btree(
session, chunk->uri, NULL, NULL, 0)) == 0) {
saved_isolation = session->txn.isolation;
session->txn.isolation = TXN_ISO_EVICTION;
ret = __wt_cache_op(session, NULL, WT_SYNC_WRITE_LEAVES);
session->txn.isolation = saved_isolation;
WT_TRET(__wt_session_release_btree(session));
}
WT_RET(ret);
WT_RET(__wt_verbose(session, WT_VERB_LSM, "LSM worker checkpointing %s",
chunk->uri));
WT_WITH_SCHEMA_LOCK(session,
ret = __wt_schema_worker(session, chunk->uri,
__wt_checkpoint, NULL, NULL, 0));
if (ret != 0)
WT_RET_MSG(session, ret, "LSM checkpoint");
/* Now the file is written, get the chunk size. */
WT_RET(__wt_lsm_tree_set_chunk_size(session, chunk));
/* Update the flush timestamp to help track ongoing progress. */
WT_RET(__wt_epoch(session, &lsm_tree->last_flush_ts));
/* Lock the tree, mark the chunk as on disk and update the metadata. */
WT_RET(__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, 1);
WT_TRET(__wt_lsm_tree_writeunlock(session, lsm_tree));
if (ret != 0)
WT_RET_MSG(session, ret, "LSM metadata write");
/*
* 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_RET(__wt_session_get_btree(session, chunk->uri, NULL, NULL, 0));
__wt_btree_evictable(session, 1);
WT_RET(__wt_session_release_btree(session));
/* Make sure we aren't pinning a transaction ID. */
__wt_txn_release_snapshot(session);
WT_RET(__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_RET(__wt_lsm_manager_push_entry(
session, WT_LSM_WORK_BLOOM, 0, lsm_tree));
else
WT_RET(__wt_lsm_manager_push_entry(
session, WT_LSM_WORK_MERGE, 0, lsm_tree));
return (0);
}