/*
* __wt_txn_release --
* Release the resources associated with the current transaction.
*/
void
__wt_txn_release(WT_SESSION_IMPL *session)
{
WT_TXN *txn;
WT_TXN_GLOBAL *txn_global;
WT_TXN_STATE *txn_state;
txn = &session->txn;
txn->mod_count = 0;
txn->notify = NULL;
txn_global = &S2C(session)->txn_global;
txn_state = &txn_global->states[session->id];
/* Clear the transaction's ID from the global table. */
WT_ASSERT(session, txn_state->id != WT_TXN_NONE &&
txn->id != WT_TXN_NONE);
WT_PUBLISH(txn_state->id, WT_TXN_NONE);
txn->id = WT_TXN_NONE;
/*
* Reset the transaction state to not running.
*
* Auto-commit transactions (identified by having active cursors)
* handle this at a higher level.
*/
if (session->ncursors == 0)
__wt_txn_release_snapshot(session);
txn->isolation = session->isolation;
F_CLR(txn, TXN_ERROR | TXN_OLDEST | TXN_RUNNING);
}
/*
* __wt_txn_release --
* Release the resources associated with the current transaction.
*/
void
__wt_txn_release(WT_SESSION_IMPL *session)
{
WT_TXN *txn;
WT_TXN_GLOBAL *txn_global;
WT_TXN_STATE *txn_state;
txn = &session->txn;
txn_global = &S2C(session)->txn_global;
txn_state = WT_SESSION_TXN_STATE(session);
WT_ASSERT(session, txn->mod_count == 0);
txn->notify = NULL;
/* Clear the transaction's ID from the global table. */
if (WT_SESSION_IS_CHECKPOINT(session)) {
WT_ASSERT(session, txn_state->id == WT_TXN_NONE);
txn->id = txn_global->checkpoint_state.id =
txn_global->checkpoint_state.pinned_id = WT_TXN_NONE;
/*
* Be extra careful to cleanup everything for checkpoints: once
* the global checkpoint ID is cleared, we can no longer tell
* if this session is doing a checkpoint.
*/
txn_global->checkpoint_id = 0;
} else if (F_ISSET(txn, WT_TXN_HAS_ID)) {
WT_ASSERT(session,
!WT_TXNID_LT(txn->id, txn_global->last_running));
WT_ASSERT(session, txn_state->id != WT_TXN_NONE &&
txn->id != WT_TXN_NONE);
WT_PUBLISH(txn_state->id, WT_TXN_NONE);
txn->id = WT_TXN_NONE;
}
__wt_txn_clear_commit_timestamp(session);
__wt_txn_clear_read_timestamp(session);
/* Free the scratch buffer allocated for logging. */
__wt_logrec_free(session, &txn->logrec);
/* Discard any memory from the session's stash that we can. */
WT_ASSERT(session, __wt_session_gen(session, WT_GEN_SPLIT) == 0);
__wt_stash_discard(session);
/*
* Reset the transaction state to not running and release the snapshot.
*/
__wt_txn_release_snapshot(session);
txn->isolation = session->isolation;
/* Ensure the transaction flags are cleared on exit */
txn->flags = 0;
}
/*
* __wt_txn_release --
* Release the resources associated with the current transaction.
*/
void
__wt_txn_release(WT_SESSION_IMPL *session)
{
WT_TXN *txn;
WT_TXN_GLOBAL *txn_global;
WT_TXN_STATE *txn_state;
txn = &session->txn;
WT_ASSERT(session, txn->mod_count == 0);
txn->notify = NULL;
txn_global = &S2C(session)->txn_global;
txn_state = WT_SESSION_TXN_STATE(session);
/* Clear the transaction's ID from the global table. */
if (WT_SESSION_IS_CHECKPOINT(session)) {
WT_ASSERT(session, txn_state->id == WT_TXN_NONE);
txn->id = WT_TXN_NONE;
/* Clear the global checkpoint transaction IDs. */
txn_global->checkpoint_id = 0;
txn_global->checkpoint_pinned = WT_TXN_NONE;
} else if (F_ISSET(txn, WT_TXN_HAS_ID)) {
WT_ASSERT(session,
!WT_TXNID_LT(txn->id, txn_global->last_running));
WT_ASSERT(session, txn_state->id != WT_TXN_NONE &&
txn->id != WT_TXN_NONE);
WT_PUBLISH(txn_state->id, WT_TXN_NONE);
txn->id = WT_TXN_NONE;
}
/* Free the scratch buffer allocated for logging. */
__wt_logrec_free(session, &txn->logrec);
/* Discard any memory from the session's split stash that we can. */
WT_ASSERT(session, session->split_gen == 0);
if (session->split_stash_cnt > 0)
__wt_split_stash_discard(session);
/*
* Reset the transaction state to not running and release the snapshot.
*/
__wt_txn_release_snapshot(session);
txn->isolation = session->isolation;
/* Ensure the transaction flags are cleared on exit */
txn->flags = 0;
}
/*
* __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_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, NULL, 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);
}
/*
* __sync_file --
* Flush pages for a specific file.
*/
static int
__sync_file(WT_SESSION_IMPL *session, WT_CACHE_OP syncop)
{
WT_BTREE *btree;
WT_CONNECTION_IMPL *conn;
WT_DECL_RET;
WT_PAGE *page;
WT_PAGE_MODIFY *mod;
WT_REF *prev, *walk;
WT_TXN *txn;
uint64_t internal_bytes, internal_pages, leaf_bytes, leaf_pages;
uint64_t oldest_id, saved_pinned_id, time_start, time_stop;
uint32_t flags;
bool timer, tried_eviction;
conn = S2C(session);
btree = S2BT(session);
prev = walk = NULL;
txn = &session->txn;
tried_eviction = false;
time_start = time_stop = 0;
/* Only visit pages in cache and don't bump page read generations. */
flags = WT_READ_CACHE | WT_READ_NO_GEN;
/*
* Skip all deleted pages. For a page to be marked deleted, it must
* have been evicted from cache and marked clean. Checkpoint should
* never instantiate deleted pages: if a truncate is not visible to the
* checkpoint, the on-disk version is correct. If the truncate is
* visible, we skip over the child page when writing its parent. We
* check whether a truncate is visible in the checkpoint as part of
* reconciling internal pages (specifically in __rec_child_modify).
*/
LF_SET(WT_READ_DELETED_SKIP);
internal_bytes = leaf_bytes = 0;
internal_pages = leaf_pages = 0;
saved_pinned_id = WT_SESSION_TXN_STATE(session)->pinned_id;
timer = WT_VERBOSE_ISSET(session, WT_VERB_CHECKPOINT);
if (timer)
time_start = __wt_clock(session);
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);
LF_SET(WT_READ_NO_WAIT | WT_READ_SKIP_INTL);
for (;;) {
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, WT_REC_CHECKPOINT, NULL));
}
}
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
* a 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 the
* metadata shouldn't have many pages. Instead, read-committed
* isolation ensures that all metadata updates completed before
* the checkpoint are included.
*/
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_ASSERT(session, btree->syncing == WT_BTREE_SYNC_OFF &&
btree->sync_session == NULL);
btree->sync_session = session;
btree->syncing = WT_BTREE_SYNC_WAIT;
(void)__wt_gen_next_drain(session, WT_GEN_EVICT);
btree->syncing = WT_BTREE_SYNC_RUNNING;
/* Write all dirty in-cache pages. */
LF_SET(WT_READ_NO_EVICT);
/* Read pages with lookaside entries and evict them asap. */
LF_SET(WT_READ_LOOKASIDE | WT_READ_WONT_NEED);
for (;;) {
WT_ERR(__sync_dup_walk(session, walk, flags, &prev));
WT_ERR(__wt_tree_walk(session, &walk, flags));
if (walk == NULL)
break;
/*
* Skip clean pages, but need to make sure maximum
* transaction ID is always updated.
*/
if (!__wt_page_is_modified(walk->page)) {
if (((mod = walk->page->modify) != NULL) &&
mod->rec_max_txn > btree->rec_max_txn)
btree->rec_max_txn = mod->rec_max_txn;
if (mod != NULL &&
btree->rec_max_timestamp <
mod->rec_max_timestamp)
btree->rec_max_timestamp =
mod->rec_max_timestamp;
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;
/*
* Write dirty pages, if we can't skip them. If we skip
* a page, mark the tree dirty. The checkpoint marked it
* clean and we can't skip future checkpoints until this
* page is written.
*/
if (__sync_checkpoint_can_skip(session, page)) {
__wt_tree_modify_set(session);
continue;
}
if (WT_PAGE_IS_INTERNAL(page)) {
internal_bytes += page->memory_footprint;
++internal_pages;
} else {
leaf_bytes += page->memory_footprint;
++leaf_pages;
}
/*
* If the page was pulled into cache by our read, try
* to evict it now.
*
* For eviction to have a chance, we first need to move
* the walk point to the next page checkpoint will
* visit. We want to avoid this code being too special
* purpose, so try to reuse the ordinary eviction path.
*
* Regardless of whether eviction succeeds or fails,
* the walk continues from the previous location. We
* remember whether we tried eviction, and don't try
* again. Even if eviction fails (the page may stay in
* cache clean but with history that cannot be
* discarded), that is not wasted effort because
* checkpoint doesn't need to write the page again.
*/
if (!WT_PAGE_IS_INTERNAL(page) &&
page->read_gen == WT_READGEN_WONT_NEED &&
!tried_eviction) {
WT_ERR_BUSY_OK(
__wt_page_release_evict(session, walk));
walk = prev;
prev = NULL;
tried_eviction = true;
continue;
}
tried_eviction = false;
WT_ERR(__wt_reconcile(
session, walk, NULL, WT_REC_CHECKPOINT, NULL));
/*
* Update checkpoint IO tracking data if configured
* to log verbose progress messages.
*/
if (conn->ckpt_timer_start.tv_sec > 0) {
conn->ckpt_write_bytes +=
page->memory_footprint;
++conn->ckpt_write_pages;
/* Periodically log checkpoint progress. */
if (conn->ckpt_write_pages % 5000 == 0)
__wt_checkpoint_progress(
session, false);
}
}
break;
case WT_SYNC_CLOSE:
case WT_SYNC_DISCARD:
WT_ERR(__wt_illegal_value(session, syncop));
break;
}
if (timer) {
time_stop = __wt_clock(session);
__wt_verbose(session, WT_VERB_CHECKPOINT,
"__sync_file WT_SYNC_%s wrote: %" PRIu64
" leaf pages (%" PRIu64 "B), %" PRIu64
" internal pages (%" PRIu64 "B), and took %" PRIu64 "ms",
syncop == WT_SYNC_WRITE_LEAVES ?
"WRITE_LEAVES" : "CHECKPOINT",
leaf_pages, leaf_bytes, internal_pages, internal_bytes,
WT_CLOCKDIFF_MS(time_stop, time_start));
}
err: /* On error, clear any left-over tree walk. */
WT_TRET(__wt_page_release(session, walk, flags));
WT_TRET(__wt_page_release(session, prev, 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_pinned_id == WT_TXN_NONE)
__wt_txn_release_snapshot(session);
/* Clear the checkpoint flag. */
btree->syncing = WT_BTREE_SYNC_OFF;
btree->sync_session = NULL;
__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, false));
return (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.
*/
btree->checkpointing = 1;
WT_FULL_BARRIER();
WT_ERR(__wt_evict_file_exclusive_on(session, &evict_reset));
if (evict_reset)
__wt_evict_file_exclusive_off(session);
/* Write all dirty in-cache pages. */
flags |= WT_READ_NO_EVICT;
for (walk = NULL;;) {
/*
* If we have a page, and it was ever modified, track
* the highest transaction ID in the tree. We do this
* here because we want the value after reconciling
* dirty pages.
*/
if (walk != NULL && walk->page != NULL &&
(mod = walk->page->modify) != NULL &&
WT_TXNID_LT(btree->rec_max_txn, mod->rec_max_txn))
btree->rec_max_txn = mod->rec_max_txn;
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) &&
mod->rec_result != WT_PM_REC_REWRITE) {
__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) {
/*
* 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 = 0;
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);
}
/*
* __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_txn_commit --
* Commit the current transaction.
*/
int
__wt_txn_commit(WT_SESSION_IMPL *session, const char *cfg[])
{
WT_CONFIG_ITEM cval;
WT_CONNECTION_IMPL *conn;
WT_DECL_RET;
WT_TXN *txn;
WT_TXN_OP *op;
u_int i;
txn = &session->txn;
conn = S2C(session);
WT_ASSERT(session, !F_ISSET(txn, WT_TXN_ERROR) || txn->mod_count == 0);
if (!F_ISSET(txn, WT_TXN_RUNNING))
WT_RET_MSG(session, EINVAL, "No transaction is active");
/*
* The default sync setting is inherited from the connection, but can
* be overridden by an explicit "sync" setting for this transaction.
*/
WT_RET(__wt_config_gets_def(session, cfg, "sync", 0, &cval));
/*
* If the user chose the default setting, check whether sync is enabled
* for this transaction (either inherited or via begin_transaction).
* If sync is disabled, clear the field to avoid the log write being
* flushed.
*
* Otherwise check for specific settings. We don't need to check for
* "on" because that is the default inherited from the connection. If
* the user set anything in begin_transaction, we only override with an
* explicit setting.
*/
if (cval.len == 0) {
if (!FLD_ISSET(txn->txn_logsync, WT_LOG_FLUSH) &&
!F_ISSET(txn, WT_TXN_SYNC_SET))
txn->txn_logsync = 0;
} else {
/*
* If the caller already set sync on begin_transaction then
* they should not be using sync on commit_transaction.
* Flag that as an error.
*/
if (F_ISSET(txn, WT_TXN_SYNC_SET))
WT_RET_MSG(session, EINVAL,
"Sync already set during begin_transaction.");
if (WT_STRING_MATCH("background", cval.str, cval.len))
txn->txn_logsync = WT_LOG_BACKGROUND;
else if (WT_STRING_MATCH("off", cval.str, cval.len))
txn->txn_logsync = 0;
/*
* We don't need to check for "on" here because that is the
* default to inherit from the connection setting.
*/
}
/* Commit notification. */
if (txn->notify != NULL)
WT_TRET(txn->notify->notify(txn->notify,
(WT_SESSION *)session, txn->id, 1));
/* If we are logging, write a commit log record. */
if (ret == 0 && txn->mod_count > 0 &&
FLD_ISSET(conn->log_flags, WT_CONN_LOG_ENABLED) &&
!F_ISSET(session, WT_SESSION_NO_LOGGING)) {
/*
* We are about to block on I/O writing the log.
* Release our snapshot in case it is keeping data pinned.
* This is particularly important for checkpoints.
*/
__wt_txn_release_snapshot(session);
ret = __wt_txn_log_commit(session, cfg);
WT_ASSERT(session, ret == 0);
}
/*
* If anything went wrong, roll back.
*
* !!!
* Nothing can fail after this point.
*/
if (ret != 0) {
WT_TRET(__wt_txn_rollback(session, cfg));
return (ret);
}
/* Free memory associated with updates. */
for (i = 0, op = txn->mod; i < txn->mod_count; i++, op++)
__wt_txn_op_free(session, op);
txn->mod_count = 0;
/*
* We are about to release the snapshot: copy values into any
* positioned cursors so they don't point to updates that could be
* freed once we don't have a transaction ID pinned.
*/
if (session->ncursors > 0)
WT_RET(__wt_session_copy_values(session));
__wt_txn_release(session);
return (0);
}
/*
* __wt_txn_release --
* Release the resources associated with the current transaction.
*/
void
__wt_txn_release(WT_SESSION_IMPL *session)
{
WT_TXN *txn;
WT_TXN_GLOBAL *txn_global;
WT_TXN_STATE *txn_state;
int was_oldest;
txn = &session->txn;
WT_ASSERT(session, txn->mod_count == 0);
txn->notify = NULL;
txn_global = &S2C(session)->txn_global;
txn_state = WT_SESSION_TXN_STATE(session);
was_oldest = 0;
/* Clear the transaction's ID from the global table. */
if (WT_SESSION_IS_CHECKPOINT(session)) {
WT_ASSERT(session, txn_state->id == WT_TXN_NONE);
txn->id = WT_TXN_NONE;
/* Clear the global checkpoint transaction IDs. */
txn_global->checkpoint_id = 0;
txn_global->checkpoint_pinned = WT_TXN_NONE;
} else if (F_ISSET(txn, WT_TXN_HAS_ID)) {
WT_ASSERT(session,
!WT_TXNID_LT(txn->id, txn_global->last_running));
WT_ASSERT(session, txn_state->id != WT_TXN_NONE &&
txn->id != WT_TXN_NONE);
WT_PUBLISH(txn_state->id, WT_TXN_NONE);
/* Quick check for the oldest transaction. */
was_oldest = (txn->id == txn_global->last_running);
txn->id = WT_TXN_NONE;
}
/* Free the scratch buffer allocated for logging. */
__wt_logrec_free(session, &txn->logrec);
/* Discard any memory from the session's split stash that we can. */
WT_ASSERT(session, session->split_gen == 0);
if (session->split_stash_cnt > 0)
__wt_split_stash_discard(session);
/*
* Reset the transaction state to not running and release the snapshot.
*/
__wt_txn_release_snapshot(session);
txn->isolation = session->isolation;
/* Ensure the transaction flags are cleared on exit */
txn->flags = 0;
/*
* When the oldest transaction in the system completes, bump the oldest
* ID. This is racy and so not guaranteed, but in practice it keeps
* the oldest ID from falling too far behind.
*/
if (was_oldest)
__wt_txn_update_oldest(session, 1);
}
/*
* __wt_lsm_checkpoint_worker --
* A worker thread for an LSM tree, responsible for flushing new chunks to
* disk.
*/
void *
__wt_lsm_checkpoint_worker(void *arg)
{
WT_DECL_RET;
WT_LSM_CHUNK *chunk;
WT_LSM_TREE *lsm_tree;
WT_LSM_WORKER_COOKIE cookie;
WT_SESSION_IMPL *session;
WT_TXN_ISOLATION saved_isolation;
u_int i, j;
int locked;
lsm_tree = arg;
session = lsm_tree->ckpt_session;
WT_CLEAR(cookie);
while (F_ISSET(lsm_tree, WT_LSM_TREE_WORKING)) {
if (F_ISSET(lsm_tree, WT_LSM_TREE_NEED_SWITCH)) {
WT_WITH_SCHEMA_LOCK(session, ret =
__wt_lsm_tree_switch(session, lsm_tree));
WT_ERR(ret);
}
WT_ERR(__lsm_copy_chunks(session, lsm_tree, &cookie, 0));
/* Write checkpoints in all completed files. */
for (i = 0, j = 0; i < cookie.nchunks - 1; i++) {
if (!F_ISSET(lsm_tree, WT_LSM_TREE_WORKING))
goto err;
if (F_ISSET(lsm_tree, WT_LSM_TREE_NEED_SWITCH))
break;
chunk = cookie.chunk_array[i];
/* Stop if a running transaction needs the chunk. */
__wt_txn_update_oldest(session);
if (!__wt_txn_visible_all(session, chunk->txnid_max))
break;
/*
* 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_ATOMIC(chunk, WT_LSM_CHUNK_ONDISK)) {
if (F_ISSET_ATOMIC(chunk, WT_LSM_CHUNK_EVICTED))
continue;
if ((ret = __lsm_discard_handle(
session, chunk->uri, NULL)) == 0)
F_SET_ATOMIC(
chunk, WT_LSM_CHUNK_EVICTED);
else if (ret == EBUSY)
ret = 0;
else
WT_ERR_MSG(session, ret,
"discard handle");
continue;
}
WT_VERBOSE_ERR(session, lsm,
"LSM worker flushing %u", i);
/*
* Flush the file before checkpointing: this is the
* expensive part in terms of I/O: do it without
* holding the schema lock.
*
* 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.
*
* Don't keep waiting for the lock if application
* threads are waiting for a switch. Don't skip
* flushing the leaves either: that just means we'll
* hold the schema lock for (much) longer, which blocks
* the world.
*/
WT_ERR(__wt_session_get_btree(
session, chunk->uri, NULL, NULL, 0));
for (locked = 0;
!locked && ret == 0 &&
!F_ISSET(lsm_tree, WT_LSM_TREE_NEED_SWITCH);) {
if ((ret = __wt_spin_trylock(session,
&S2C(session)->checkpoint_lock)) == 0)
locked = 1;
else if (ret == EBUSY) {
__wt_yield();
ret = 0;
}
}
if (locked) {
saved_isolation = session->txn.isolation;
session->txn.isolation = TXN_ISO_EVICTION;
ret = __wt_bt_cache_op(
session, NULL, WT_SYNC_WRITE_LEAVES);
session->txn.isolation = saved_isolation;
__wt_spin_unlock(
session, &S2C(session)->checkpoint_lock);
}
WT_TRET(__wt_session_release_btree(session));
WT_ERR(ret);
if (F_ISSET(lsm_tree, WT_LSM_TREE_NEED_SWITCH))
break;
WT_VERBOSE_ERR(session, lsm,
"LSM worker checkpointing %u", i);
WT_WITH_SCHEMA_LOCK(session,
ret = __wt_schema_worker(session, chunk->uri,
__wt_checkpoint, NULL, NULL, 0));
if (ret != 0) {
__wt_err(session, ret, "LSM checkpoint");
break;
}
WT_ERR(__wt_lsm_tree_set_chunk_size(session, chunk));
/*
* Clear the "cache resident" 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, 1);
WT_ERR(__wt_session_release_btree(session));
++j;
WT_ERR(__wt_lsm_tree_lock(session, lsm_tree, 1));
F_SET_ATOMIC(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);
WT_TRET(__wt_lsm_tree_unlock(session, lsm_tree));
/* Make sure we aren't pinning a transaction ID. */
__wt_txn_release_snapshot(session);
if (ret != 0) {
__wt_err(session, ret,
"LSM checkpoint metadata write");
break;
}
WT_VERBOSE_ERR(session, lsm,
"LSM worker checkpointed %u", i);
}
__lsm_unpin_chunks(session, &cookie);
if (j == 0 && F_ISSET(lsm_tree, WT_LSM_TREE_WORKING) &&
!F_ISSET(lsm_tree, WT_LSM_TREE_NEED_SWITCH))
WT_ERR_TIMEDOUT_OK(__wt_cond_wait(
session, lsm_tree->work_cond, 100000));
}
err: __lsm_unpin_chunks(session, &cookie);
__wt_free(session, cookie.chunk_array);
/*
* The thread will only exit with failure if we run out of memory or
* there is some other system driven failure. We can't keep going
* after such a failure - ensure WiredTiger shuts down.
*/
if (ret != 0 && ret != WT_NOTFOUND)
WT_PANIC_ERR(session, ret,
"Shutting down LSM checkpoint utility thread");
return (NULL);
}
/*
* __wt_txn_commit --
* Commit the current transaction.
*/
int
__wt_txn_commit(WT_SESSION_IMPL *session, const char *cfg[])
{
WT_CONFIG_ITEM cval;
WT_CONNECTION_IMPL *conn;
WT_DECL_RET;
WT_TXN *txn;
WT_TXN_GLOBAL *txn_global;
WT_TXN_OP *op;
u_int i;
bool locked, readonly;
#ifdef HAVE_TIMESTAMPS
wt_timestamp_t prev_commit_timestamp, ts;
bool update_timestamp;
#endif
txn = &session->txn;
conn = S2C(session);
txn_global = &conn->txn_global;
locked = false;
WT_ASSERT(session, F_ISSET(txn, WT_TXN_RUNNING));
WT_ASSERT(session, !F_ISSET(txn, WT_TXN_ERROR) ||
txn->mod_count == 0);
readonly = txn->mod_count == 0;
/*
* Look for a commit timestamp.
*/
WT_ERR(
__wt_config_gets_def(session, cfg, "commit_timestamp", 0, &cval));
if (cval.len != 0) {
#ifdef HAVE_TIMESTAMPS
WT_ERR(__wt_txn_parse_timestamp(session, "commit", &ts, &cval));
WT_ERR(__wt_timestamp_validate(session,
"commit", &ts, &cval, true, true, true));
__wt_timestamp_set(&txn->commit_timestamp, &ts);
__wt_txn_set_commit_timestamp(session);
#else
WT_ERR_MSG(session, EINVAL, "commit_timestamp requires a "
"version of WiredTiger built with timestamp support");
#endif
}
#ifdef HAVE_TIMESTAMPS
/*
* Debugging checks on timestamps, if user requested them.
*/
if (F_ISSET(txn, WT_TXN_TS_COMMIT_ALWAYS) &&
!F_ISSET(txn, WT_TXN_HAS_TS_COMMIT) &&
txn->mod_count != 0)
WT_ERR_MSG(session, EINVAL, "commit_timestamp required and "
"none set on this transaction");
if (F_ISSET(txn, WT_TXN_TS_COMMIT_NEVER) &&
F_ISSET(txn, WT_TXN_HAS_TS_COMMIT) &&
txn->mod_count != 0)
WT_ERR_MSG(session, EINVAL, "no commit_timestamp required and "
"timestamp set on this transaction");
#endif
/*
* The default sync setting is inherited from the connection, but can
* be overridden by an explicit "sync" setting for this transaction.
*/
WT_ERR(__wt_config_gets_def(session, cfg, "sync", 0, &cval));
/*
* If the user chose the default setting, check whether sync is enabled
* for this transaction (either inherited or via begin_transaction).
* If sync is disabled, clear the field to avoid the log write being
* flushed.
*
* Otherwise check for specific settings. We don't need to check for
* "on" because that is the default inherited from the connection. If
* the user set anything in begin_transaction, we only override with an
* explicit setting.
*/
if (cval.len == 0) {
if (!FLD_ISSET(txn->txn_logsync, WT_LOG_SYNC_ENABLED) &&
!F_ISSET(txn, WT_TXN_SYNC_SET))
txn->txn_logsync = 0;
} else {
/*
* If the caller already set sync on begin_transaction then
* they should not be using sync on commit_transaction.
* Flag that as an error.
*/
if (F_ISSET(txn, WT_TXN_SYNC_SET))
WT_ERR_MSG(session, EINVAL,
"Sync already set during begin_transaction");
if (WT_STRING_MATCH("background", cval.str, cval.len))
txn->txn_logsync = WT_LOG_BACKGROUND;
else if (WT_STRING_MATCH("off", cval.str, cval.len))
txn->txn_logsync = 0;
/*
* We don't need to check for "on" here because that is the
* default to inherit from the connection setting.
*/
}
/* Commit notification. */
if (txn->notify != NULL)
WT_ERR(txn->notify->notify(txn->notify,
(WT_SESSION *)session, txn->id, 1));
/*
* We are about to release the snapshot: copy values into any
* positioned cursors so they don't point to updates that could be
* freed once we don't have a snapshot.
*/
if (session->ncursors > 0) {
WT_DIAGNOSTIC_YIELD;
WT_ERR(__wt_session_copy_values(session));
}
/* If we are logging, write a commit log record. */
if (txn->logrec != NULL &&
FLD_ISSET(conn->log_flags, WT_CONN_LOG_ENABLED) &&
!F_ISSET(session, WT_SESSION_NO_LOGGING)) {
/*
* We are about to block on I/O writing the log.
* Release our snapshot in case it is keeping data pinned.
* This is particularly important for checkpoints.
*/
__wt_txn_release_snapshot(session);
/*
* We hold the visibility lock for reading from the time
* we write our log record until the time we release our
* transaction so that the LSN any checkpoint gets will
* always reflect visible data.
*/
__wt_readlock(session, &txn_global->visibility_rwlock);
locked = true;
WT_ERR(__wt_txn_log_commit(session, cfg));
}
/* Note: we're going to commit: nothing can fail after this point. */
/* Process and free updates. */
for (i = 0, op = txn->mod; i < txn->mod_count; i++, op++) {
switch (op->type) {
case WT_TXN_OP_BASIC:
case WT_TXN_OP_BASIC_TS:
case WT_TXN_OP_INMEM:
/*
* Switch reserved operations to abort to
* simplify obsolete update list truncation.
*/
if (op->u.upd->type == WT_UPDATE_RESERVED) {
op->u.upd->txnid = WT_TXN_ABORTED;
break;
}
/*
* Writes to the lookaside file can be evicted as soon
* as they commit.
*/
if (conn->cache->las_fileid != 0 &&
op->fileid == conn->cache->las_fileid) {
op->u.upd->txnid = WT_TXN_NONE;
break;
}
#ifdef HAVE_TIMESTAMPS
if (F_ISSET(txn, WT_TXN_HAS_TS_COMMIT) &&
op->type != WT_TXN_OP_BASIC_TS) {
WT_ASSERT(session,
op->fileid != WT_METAFILE_ID);
__wt_timestamp_set(&op->u.upd->timestamp,
&txn->commit_timestamp);
}
#endif
break;
case WT_TXN_OP_REF:
#ifdef HAVE_TIMESTAMPS
if (F_ISSET(txn, WT_TXN_HAS_TS_COMMIT))
__wt_timestamp_set(
&op->u.ref->page_del->timestamp,
&txn->commit_timestamp);
#endif
break;
case WT_TXN_OP_TRUNCATE_COL:
case WT_TXN_OP_TRUNCATE_ROW:
/* Other operations don't need timestamps. */
break;
}
__wt_txn_op_free(session, op);
}
txn->mod_count = 0;
#ifdef HAVE_TIMESTAMPS
/*
* Track the largest commit timestamp we have seen.
*
* We don't actually clear the local commit timestamp, just the flag.
* That said, we can't update the global commit timestamp until this
* transaction is visible, which happens when we release it.
*/
update_timestamp = F_ISSET(txn, WT_TXN_HAS_TS_COMMIT);
#endif
__wt_txn_release(session);
if (locked)
__wt_readunlock(session, &txn_global->visibility_rwlock);
#ifdef HAVE_TIMESTAMPS
/* First check if we've already committed something in the future. */
if (update_timestamp) {
WT_WITH_TIMESTAMP_READLOCK(session, &txn_global->rwlock,
__wt_timestamp_set(
&prev_commit_timestamp, &txn_global->commit_timestamp));
update_timestamp = __wt_timestamp_cmp(
&txn->commit_timestamp, &prev_commit_timestamp) > 0;
}
/*
* If it looks like we need to move the global commit timestamp,
* write lock and re-check.
*/
if (update_timestamp) {
#if WT_TIMESTAMP_SIZE == 8
while (__wt_timestamp_cmp(
&txn->commit_timestamp, &prev_commit_timestamp) > 0) {
if (__wt_atomic_cas64(
&txn_global->commit_timestamp.val,
prev_commit_timestamp.val,
txn->commit_timestamp.val)) {
txn_global->has_commit_timestamp = true;
break;
}
__wt_timestamp_set(
&prev_commit_timestamp, &txn_global->commit_timestamp);
}
#else
__wt_writelock(session, &txn_global->rwlock);
if (__wt_timestamp_cmp(&txn->commit_timestamp,
&txn_global->commit_timestamp) > 0) {
__wt_timestamp_set(&txn_global->commit_timestamp,
&txn->commit_timestamp);
txn_global->has_commit_timestamp = true;
}
__wt_writeunlock(session, &txn_global->rwlock);
#endif
}
#endif
/*
* We're between transactions, if we need to block for eviction, it's
* a good time to do so. Note that we must ignore any error return
* because the user's data is committed.
*/
if (!readonly)
(void)__wt_cache_eviction_check(session, false, false, NULL);
return (0);
err: /*
* If anything went wrong, roll back.
*
* !!!
* Nothing can fail after this point.
*/
if (locked)
__wt_readunlock(session, &txn_global->visibility_rwlock);
WT_TRET(__wt_txn_rollback(session, cfg));
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;
/*
* 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);
}
