/*
* __wt_delete_page_skip --
* If iterating a cursor, skip deleted pages that are either visible to
* us or globally visible.
*/
bool
__wt_delete_page_skip(WT_SESSION_IMPL *session, WT_REF *ref, bool visible_all)
{
bool skip;
/*
* Deleted pages come from two sources: either it's a fast-delete as
* described above, or the page has been emptied by other operations
* and eviction deleted it.
*
* In both cases, the WT_REF state will be WT_REF_DELETED. In the case
* of a fast-delete page, there will be a WT_PAGE_DELETED structure with
* the transaction ID of the transaction that deleted the page, and the
* page is visible if that transaction ID is visible. In the case of an
* empty page, there will be no WT_PAGE_DELETED structure and the delete
* is by definition visible, eviction could not have deleted the page if
* there were changes on it that were not globally visible.
*
* We're here because we found a WT_REF state set to WT_REF_DELETED. It
* is possible the page is being read into memory right now, though, and
* the page could switch to an in-memory state at any time. Lock down
* the structure, just to be safe.
*/
if (ref->page_del == NULL)
return (true);
if (!__wt_atomic_casv32(&ref->state, WT_REF_DELETED, WT_REF_LOCKED))
return (false);
skip = ref->page_del == NULL || (visible_all ?
__wt_txn_visible_all(session, ref->page_del->txnid,
WT_TIMESTAMP_NULL(&ref->page_del->timestamp)):
__wt_txn_visible(session, ref->page_del->txnid,
WT_TIMESTAMP_NULL(&ref->page_del->timestamp)));
/*
* The page_del structure can be freed as soon as the delete is stable:
* it is only read when the ref state is WT_REF_DELETED. It is worth
* checking every time we come through because once this is freed, we
* no longer need synchronization to check the ref.
*/
if (skip && ref->page_del != NULL && (visible_all ||
__wt_txn_visible_all(session, ref->page_del->txnid,
WT_TIMESTAMP_NULL(&ref->page_del->timestamp)))) {
__wt_free(session, ref->page_del->update_list);
__wt_free(session, ref->page_del);
}
WT_PUBLISH(ref->state, WT_REF_DELETED);
return (skip);
}
/*
* __wt_session_fotxn_discard --
* Discard any memory from the session's free-on-transaction generation
* list that we can.
*/
void
__wt_session_fotxn_discard(WT_SESSION_IMPL *session_safe,
WT_SESSION_IMPL *session, int connection_close)
{
WT_FOTXN *fotxn;
size_t i;
/*
* This function is called during WT_CONNECTION.close to discard any
* memory that remains. For that reason, we take two WT_SESSION_IMPL
* arguments: session_safe is still linked to the WT_CONNECTION and
* can be safely used for calls to other WiredTiger functions, while
* session is the WT_SESSION_IMPL we're cleaning up.
*/
for (i = 0, fotxn = session->fotxn;
session->fotxn_cnt > 0 &&
i < session->fotxn_size / sizeof(session->fotxn[0]); ++i, ++fotxn)
if (fotxn->p != NULL && (connection_close ||
__wt_txn_visible_all(session_safe, fotxn->txnid))) {
--session->fotxn_cnt;
/*
* It's a bad thing if another thread is in this memory
* after we free it, make sure nothing good happens to
* that thread.
*/
__wt_overwrite_and_free_len(
session_safe, fotxn->p, fotxn->len);
}
if (connection_close)
__wt_free(session_safe, session->fotxn);
}
/*
* __wt_update_obsolete_check --
* Check for obsolete updates.
*/
WT_UPDATE *
__wt_update_obsolete_check(WT_SESSION_IMPL *session, WT_UPDATE *upd)
{
WT_UPDATE *first, *next;
/*
* This function identifies obsolete updates, and truncates them from
* the rest of the chain; because this routine is called from inside
* a serialization function, the caller has responsibility for actually
* freeing the memory.
*
* Walk the list of updates, looking for obsolete updates at the end.
*/
for (first = NULL; upd != NULL; upd = upd->next)
if (__wt_txn_visible_all(session, upd->txnid)) {
if (first == NULL)
first = upd;
} else if (upd->txnid != WT_TXN_ABORTED)
first = NULL;
/*
* We cannot discard this WT_UPDATE structure, we can only discard
* WT_UPDATE structures subsequent to it, other threads of control will
* terminate their walk in this element. Save a reference to the list
* we will discard, and terminate the list.
*/
if (first != NULL &&
(next = first->next) != NULL &&
WT_ATOMIC_CAS(first->next, next, NULL))
return (next);
return (NULL);
}
/*
* __cursor_var_append_prev --
* Return the previous variable-length entry on the append list.
*/
static inline int
__cursor_var_append_prev(WT_CURSOR_BTREE *cbt, bool newpage)
{
WT_ITEM *val;
WT_SESSION_IMPL *session;
WT_UPDATE *upd;
session = (WT_SESSION_IMPL *)cbt->iface.session;
val = &cbt->iface.value;
if (newpage) {
cbt->ins = WT_SKIP_LAST(cbt->ins_head);
goto new_page;
}
for (;;) {
WT_RET(__cursor_skip_prev(cbt));
new_page: if (cbt->ins == NULL)
return (WT_NOTFOUND);
__cursor_set_recno(cbt, WT_INSERT_RECNO(cbt->ins));
if ((upd = __wt_txn_read(session, cbt->ins->upd)) == NULL)
continue;
if (WT_UPDATE_DELETED_ISSET(upd)) {
if (__wt_txn_visible_all(session, upd->txnid))
++cbt->page_deleted_count;
continue;
}
val->data = WT_UPDATE_DATA(upd);
val->size = upd->size;
return (0);
}
/* NOTREACHED */
}
/*
* __ovfl_txnc_wrapup --
* Resolve the page's transaction-cache list.
*/
static int
__ovfl_txnc_wrapup(WT_SESSION_IMPL *session, WT_PAGE *page)
{
WT_OVFL_TXNC **e, **head, *txnc;
size_t decr;
int i;
head = page->modify->ovfl_track->ovfl_txnc;
/*
* Discard any transaction-cache records with transaction IDs earlier
* than any in the system.
*
* First, walk the overflow transaction-cache skip lists (except for
* the lowest level), fixing up links.
*/
for (i = WT_SKIP_MAXDEPTH - 1; i > 0; --i)
for (e = &head[i]; *e != NULL;) {
if (!__wt_txn_visible_all(session, (*e)->current)) {
e = &(*e)->next[i];
continue;
}
*e = (*e)->next[i];
}
/* Second, discard any no longer needed transaction-cache records. */
decr = 0;
for (e = &head[0]; (txnc = *e) != NULL;) {
if (!__wt_txn_visible_all(session, txnc->current)) {
e = &(*e)->next[0];
continue;
}
*e = (*e)->next[0];
decr += WT_OVFL_SIZE(WT_OVFL_TXNC) +
txnc->addr_size + txnc->value_size;
if (WT_VERBOSE_ISSET(session, WT_VERB_OVERFLOW))
WT_RET(
__ovfl_txnc_verbose(session, page, txnc, "free"));
__wt_free(session, txnc);
}
if (decr != 0)
__wt_cache_page_inmem_decr(session, page, decr);
return (0);
}
/*
* __ovfl_cache_row_visible --
* row-store: check for a globally visible update.
*/
static bool
__ovfl_cache_row_visible(WT_SESSION_IMPL *session, WT_PAGE *page, WT_ROW *rip)
{
WT_UPDATE *upd;
/* Check to see if there's a globally visible update. */
for (upd = WT_ROW_UPDATE(page, rip); upd != NULL; upd = upd->next)
if (__wt_txn_visible_all(session, upd->txnid))
return (true);
return (false);
}
/*
* __wt_txn_release_snapshot --
* Release the snapshot in the current transaction.
*/
void
__wt_txn_release_snapshot(WT_SESSION_IMPL *session)
{
WT_TXN_STATE *txn_state;
txn_state = &S2C(session)->txn_global.states[session->id];
if (txn_state->snap_min != WT_TXN_NONE) {
WT_ASSERT(session,
session->txn.isolation == TXN_ISO_READ_UNCOMMITTED ||
!__wt_txn_visible_all(session, txn_state->snap_min));
txn_state->snap_min = WT_TXN_NONE;
}
}
/*
* __wt_txn_release_snapshot --
* Release the snapshot in the current transaction.
*/
void
__wt_txn_release_snapshot(WT_SESSION_IMPL *session)
{
WT_TXN *txn;
WT_TXN_STATE *txn_state;
txn = &session->txn;
txn_state = WT_SESSION_TXN_STATE(session);
WT_ASSERT(session,
txn_state->snap_min == WT_TXN_NONE ||
session->txn.isolation == WT_ISO_READ_UNCOMMITTED ||
!__wt_txn_visible_all(session, txn_state->snap_min));
txn_state->snap_min = WT_TXN_NONE;
F_CLR(txn, WT_TXN_HAS_SNAPSHOT);
}
/*
* __wt_update_obsolete_check --
* Check for obsolete updates.
*/
WT_UPDATE *
__wt_update_obsolete_check(
WT_SESSION_IMPL *session, WT_PAGE *page, WT_UPDATE *upd)
{
WT_UPDATE *first, *next;
u_int count;
/*
* This function identifies obsolete updates, and truncates them from
* the rest of the chain; because this routine is called from inside
* a serialization function, the caller has responsibility for actually
* freeing the memory.
*
* Walk the list of updates, looking for obsolete updates at the end.
*/
for (first = NULL, count = 0; upd != NULL; upd = upd->next, count++)
if (__wt_txn_visible_all(session, upd->txnid)) {
if (first == NULL)
first = upd;
} else if (upd->txnid != WT_TXN_ABORTED)
first = NULL;
/*
* We cannot discard this WT_UPDATE structure, we can only discard
* WT_UPDATE structures subsequent to it, other threads of control will
* terminate their walk in this element. Save a reference to the list
* we will discard, and terminate the list.
*/
if (first != NULL &&
(next = first->next) != NULL &&
__wt_atomic_cas_ptr(&first->next, next, NULL))
return (next);
/*
* If the list is long, don't retry checks on this page until the
* transaction state has moved forwards.
*/
if (count > 20)
page->modify->obsolete_check_txn =
S2C(session)->txn_global.last_running;
return (NULL);
}
/*
* __wt_update_obsolete_check --
* Check for obsolete updates.
*/
WT_UPDATE *
__wt_update_obsolete_check(WT_SESSION_IMPL *session, WT_UPDATE *upd)
{
WT_TXN *txn;
WT_UPDATE *next;
/*
* This function identifies obsolete updates, and truncates them from
* the rest of the chain; because this routine is called from inside
* a serialization function, the caller has responsibility for actually
* freeing the memory.
*/
txn = &session->txn;
if (txn->isolation != TXN_ISO_SNAPSHOT &&
txn->isolation != TXN_ISO_READ_COMMITTED)
return (NULL);
/*
* Walk the list of updates, looking for obsolete updates. If we find
* an update no session will ever move past, we can discard any updates
* that appear after it.
*/
for (; upd != NULL; upd = upd->next)
if (__wt_txn_visible_all(session, upd->txnid)) {
/*
* We cannot discard this WT_UPDATE structure, we can
* only discard WT_UPDATE structures subsequent to it,
* other threads of control will terminate their walk
* in this element. Save a reference to the list we
* will discard, and terminate the list.
*/
if ((next = upd->next) == NULL)
return (NULL);
if (!WT_ATOMIC_CAS(upd->next, next, NULL))
return (NULL);
return (next);
}
return (NULL);
}
/*
* __ovfl_cache_col_visible --
* column-store: check for a globally visible update.
*/
static bool
__ovfl_cache_col_visible(
WT_SESSION_IMPL *session, WT_UPDATE *upd, WT_CELL_UNPACK *unpack)
{
/*
* Column-store is harder than row_store: we're here because there's a
* reader in the system that might read the original version of an
* overflow record, which might match a number of records. For example,
* the original overflow value was for records 100-200, we've replaced
* each of those records individually, but there exists a reader that
* might read any one of those records, and all of those records have
* different update entries with different transaction IDs. Since it's
* infeasible to determine if there's a globally visible update for each
* reader for each record, we test the simple case where a single record
* has a single, globally visible update. If that's not the case, cache
* the value.
*/
if (__wt_cell_rle(unpack) == 1 &&
upd != NULL && /* Sanity: upd should always be set. */
__wt_txn_visible_all(session, upd->txnid))
return (true);
return (false);
}
/*
* __wt_session_fotxn_add --
* Add a new entry into the session's free-on-transaction generation list.
*/
int
__wt_session_fotxn_add(WT_SESSION_IMPL *session, void *p, size_t len)
{
WT_FOTXN *fotxn;
size_t i;
/*
* Make sure the current thread has a transaction pinned so that
* we don't immediately free the memory we are stashing.
*/
WT_ASSERT(session,
WT_SESSION_TXN_STATE(session)->snap_min != WT_TXN_NONE);
/* Grow the list as necessary. */
WT_RET(__wt_realloc_def(session,
&session->fotxn_size, session->fotxn_cnt + 1, &session->fotxn));
/* Find an empty slot. */
for (i = 0, fotxn = session->fotxn;
i < session->fotxn_size / sizeof(session->fotxn[0]); ++i, ++fotxn)
if (fotxn->p == NULL) {
fotxn->txnid = S2C(session)->txn_global.current + 1;
WT_ASSERT(session,
!__wt_txn_visible_all(session, fotxn->txnid));
fotxn->p = p;
fotxn->len = len;
break;
}
++session->fotxn_cnt;
/* See if we can free any previous entries. */
if (session->fotxn_cnt > 1)
__wt_session_fotxn_discard(session, session, 0);
return (0);
}
/*
* __cursor_row_prev --
* Move to the previous row-store item.
*/
static inline int
__cursor_row_prev(WT_CURSOR_BTREE *cbt, bool newpage)
{
WT_INSERT *ins;
WT_ITEM *key, *val;
WT_PAGE *page;
WT_ROW *rip;
WT_SESSION_IMPL *session;
WT_UPDATE *upd;
session = (WT_SESSION_IMPL *)cbt->iface.session;
page = cbt->ref->page;
key = &cbt->iface.key;
val = &cbt->iface.value;
/*
* For row-store pages, we need a single item that tells us the part
* of the page we're walking (otherwise switching from next to prev
* and vice-versa is just too complicated), so we map the WT_ROW and
* WT_INSERT_HEAD insert array slots into a single name space: slot 1
* is the "smallest key insert list", slot 2 is WT_ROW[0], slot 3 is
* WT_INSERT_HEAD[0], and so on. This means WT_INSERT lists are
* odd-numbered slots, and WT_ROW array slots are even-numbered slots.
*
* New page configuration.
*/
if (newpage) {
/*
* If we haven't instantiated keys on this page, do so, else it
* is a very, very slow traversal.
*/
if (!F_ISSET_ATOMIC(page, WT_PAGE_BUILD_KEYS))
WT_RET(__wt_row_leaf_keys(session, page));
if (page->pg_row_entries == 0)
cbt->ins_head = WT_ROW_INSERT_SMALLEST(page);
else
cbt->ins_head =
WT_ROW_INSERT_SLOT(page, page->pg_row_entries - 1);
cbt->ins = WT_SKIP_LAST(cbt->ins_head);
cbt->row_iteration_slot = page->pg_row_entries * 2 + 1;
goto new_insert;
}
/* Move to the previous entry and return the item. */
for (;;) {
/*
* Continue traversing any insert list. Maintain the reference
* to the current insert element in case we switch to a cursor
* next movement.
*/
if (cbt->ins != NULL)
WT_RET(__cursor_skip_prev(cbt));
new_insert: if ((ins = cbt->ins) != NULL) {
if ((upd = __wt_txn_read(session, ins->upd)) == NULL)
continue;
if (WT_UPDATE_DELETED_ISSET(upd)) {
if (__wt_txn_visible_all(session, upd->txnid))
++cbt->page_deleted_count;
continue;
}
key->data = WT_INSERT_KEY(ins);
key->size = WT_INSERT_KEY_SIZE(ins);
val->data = WT_UPDATE_DATA(upd);
val->size = upd->size;
return (0);
}
/* Check for the beginning of the page. */
if (cbt->row_iteration_slot == 1)
return (WT_NOTFOUND);
--cbt->row_iteration_slot;
/*
* Odd-numbered slots configure as WT_INSERT_HEAD entries,
* even-numbered slots configure as WT_ROW entries.
*/
if (cbt->row_iteration_slot & 0x01) {
cbt->ins_head = cbt->row_iteration_slot == 1 ?
WT_ROW_INSERT_SMALLEST(page) :
WT_ROW_INSERT_SLOT(
page, cbt->row_iteration_slot / 2 - 1);
cbt->ins = WT_SKIP_LAST(cbt->ins_head);
goto new_insert;
}
cbt->ins_head = NULL;
cbt->ins = NULL;
cbt->slot = cbt->row_iteration_slot / 2 - 1;
rip = &page->pg_row_d[cbt->slot];
upd = __wt_txn_read(session, WT_ROW_UPDATE(page, rip));
if (upd != NULL && WT_UPDATE_DELETED_ISSET(upd)) {
if (__wt_txn_visible_all(session, upd->txnid))
++cbt->page_deleted_count;
continue;
}
return (__cursor_row_slot_return(cbt, rip, upd));
}
/* NOTREACHED */
}
/*
* __cursor_var_prev --
* Move to the previous, variable-length column-store item.
*/
static inline int
__cursor_var_prev(WT_CURSOR_BTREE *cbt, bool newpage)
{
WT_CELL *cell;
WT_CELL_UNPACK unpack;
WT_COL *cip;
WT_INSERT *ins;
WT_ITEM *val;
WT_PAGE *page;
WT_SESSION_IMPL *session;
WT_UPDATE *upd;
uint64_t rle_start;
session = (WT_SESSION_IMPL *)cbt->iface.session;
page = cbt->ref->page;
val = &cbt->iface.value;
rle_start = 0; /* -Werror=maybe-uninitialized */
/* Initialize for each new page. */
if (newpage) {
cbt->last_standard_recno = __col_var_last_recno(page);
if (cbt->last_standard_recno == 0)
return (WT_NOTFOUND);
__cursor_set_recno(cbt, cbt->last_standard_recno);
goto new_page;
}
/* Move to the previous entry and return the item. */
for (;;) {
__cursor_set_recno(cbt, cbt->recno - 1);
new_page: if (cbt->recno < page->pg_var_recno)
return (WT_NOTFOUND);
/* Find the matching WT_COL slot. */
if ((cip =
__col_var_search(page, cbt->recno, &rle_start)) == NULL)
return (WT_NOTFOUND);
cbt->slot = WT_COL_SLOT(page, cip);
/* Check any insert list for a matching record. */
cbt->ins_head = WT_COL_UPDATE_SLOT(page, cbt->slot);
cbt->ins = __col_insert_search_match(cbt->ins_head, cbt->recno);
upd = cbt->ins == NULL ?
NULL : __wt_txn_read(session, cbt->ins->upd);
if (upd != NULL) {
if (WT_UPDATE_DELETED_ISSET(upd)) {
if (__wt_txn_visible_all(session, upd->txnid))
++cbt->page_deleted_count;
continue;
}
val->data = WT_UPDATE_DATA(upd);
val->size = upd->size;
return (0);
}
/*
* If we're at the same slot as the last reference and there's
* no matching insert list item, re-use the return information
* (so encoded items with large repeat counts aren't repeatedly
* decoded). Otherwise, unpack the cell and build the return
* information.
*/
if (cbt->cip_saved != cip) {
if ((cell = WT_COL_PTR(page, cip)) == NULL)
continue;
__wt_cell_unpack(cell, &unpack);
if (unpack.type == WT_CELL_DEL) {
if (__wt_cell_rle(&unpack) == 1)
continue;
/*
* There can be huge gaps in the variable-length
* column-store name space appearing as deleted
* records. If more than one deleted record, do
* the work of finding the next record to return
* instead of looping through the records.
*
* First, find the largest record in the update
* list that's smaller than the current record.
*/
ins = __col_insert_search_lt(
cbt->ins_head, cbt->recno);
/*
* Second, for records with RLEs greater than 1,
* the above call to __col_var_search located
* this record in the page's list of repeating
* records, and returned the starting record.
* The starting record - 1 is the record to
* which we could skip, if there was no larger
* record in the update list.
*/
cbt->recno = rle_start - 1;
if (ins != NULL &&
WT_INSERT_RECNO(ins) > cbt->recno)
cbt->recno = WT_INSERT_RECNO(ins);
/* Adjust for the outer loop decrement. */
++cbt->recno;
continue;
}
WT_RET(__wt_page_cell_data_ref(
session, page, &unpack, cbt->tmp));
cbt->cip_saved = cip;
}
val->data = cbt->tmp->data;
val->size = cbt->tmp->size;
return (0);
}
/* NOTREACHED */
}
/*
* __clsm_enter --
* Start an operation on an LSM cursor, update if the tree has changed.
*/
static inline int
__clsm_enter(WT_CURSOR_LSM *clsm, bool reset, bool update)
{
WT_DECL_RET;
WT_LSM_TREE *lsm_tree;
WT_SESSION_IMPL *session;
WT_TXN *txn;
uint64_t *switch_txnp;
uint64_t snap_min;
lsm_tree = clsm->lsm_tree;
session = (WT_SESSION_IMPL *)clsm->iface.session;
txn = &session->txn;
/* Merge cursors never update. */
if (F_ISSET(clsm, WT_CLSM_MERGE))
return (0);
if (reset) {
WT_ASSERT(session, !F_ISSET(&clsm->iface,
WT_CURSTD_KEY_INT | WT_CURSTD_VALUE_INT));
WT_RET(__clsm_reset_cursors(clsm, NULL));
}
for (;;) {
/*
* If the cursor looks up-to-date, check if the cache is full.
* In case this call blocks, the check will be repeated before
* proceeding.
*/
if (clsm->dsk_gen != lsm_tree->dsk_gen &&
lsm_tree->nchunks != 0)
goto open;
if (clsm->dsk_gen != lsm_tree->dsk_gen &&
lsm_tree->nchunks != 0)
goto open;
/* Update the maximum transaction ID in the primary chunk. */
if (update) {
/*
* Ensure that there is a transaction snapshot active.
*/
WT_RET(__wt_txn_autocommit_check(session));
WT_RET(__wt_txn_id_check(session));
WT_RET(__clsm_enter_update(clsm));
if (clsm->dsk_gen != clsm->lsm_tree->dsk_gen)
goto open;
if (txn->isolation == WT_ISO_SNAPSHOT)
__wt_txn_cursor_op(session);
/*
* Figure out how many updates are required for
* snapshot isolation.
*
* This is not a normal visibility check on the maximum
* transaction ID in each chunk: any transaction ID
* that overlaps with our snapshot is a potential
* conflict.
*/
clsm->nupdates = 1;
if (txn->isolation == WT_ISO_SNAPSHOT &&
F_ISSET(clsm, WT_CLSM_OPEN_SNAPSHOT)) {
WT_ASSERT(session,
F_ISSET(txn, WT_TXN_HAS_SNAPSHOT));
snap_min = txn->snap_min;
for (switch_txnp =
&clsm->switch_txn[clsm->nchunks - 2];
clsm->nupdates < clsm->nchunks;
clsm->nupdates++, switch_txnp--) {
if (WT_TXNID_LT(*switch_txnp, snap_min))
break;
WT_ASSERT(session,
!__wt_txn_visible_all(
session, *switch_txnp));
}
}
}
/*
* Stop when we are up-to-date, as long as this is:
* - a snapshot isolation update and the cursor is set up for
* that;
* - an update operation with a primary chunk, or
* - a read operation and the cursor is open for reading.
*/
if ((!update ||
txn->isolation != WT_ISO_SNAPSHOT ||
F_ISSET(clsm, WT_CLSM_OPEN_SNAPSHOT)) &&
((update && clsm->primary_chunk != NULL) ||
(!update && F_ISSET(clsm, WT_CLSM_OPEN_READ))))
break;
open: WT_WITH_SCHEMA_LOCK(session,
ret = __clsm_open_cursors(clsm, update, 0, 0));
WT_RET(ret);
}
if (!F_ISSET(clsm, WT_CLSM_ACTIVE)) {
WT_RET(__cursor_enter(session));
F_SET(clsm, WT_CLSM_ACTIVE);
}
return (0);
}
/*
* __clsm_open_cursors --
* Open cursors for the current set of files.
*/
static int
__clsm_open_cursors(
WT_CURSOR_LSM *clsm, bool update, u_int start_chunk, uint32_t start_id)
{
WT_BTREE *btree;
WT_CURSOR *c, **cp, *primary;
WT_DECL_RET;
WT_LSM_CHUNK *chunk;
WT_LSM_TREE *lsm_tree;
WT_SESSION_IMPL *session;
WT_TXN *txn;
const char *checkpoint, *ckpt_cfg[3];
uint64_t saved_gen;
u_int i, nchunks, ngood, nupdates;
u_int close_range_end, close_range_start;
bool locked;
c = &clsm->iface;
session = (WT_SESSION_IMPL *)c->session;
txn = &session->txn;
chunk = NULL;
locked = false;
lsm_tree = clsm->lsm_tree;
/*
* Ensure that any snapshot update has cursors on the right set of
* chunks to guarantee visibility is correct.
*/
if (update && txn->isolation == WT_ISO_SNAPSHOT)
F_SET(clsm, WT_CLSM_OPEN_SNAPSHOT);
/*
* Query operations need a full set of cursors. Overwrite cursors
* do queries in service of updates.
*/
if (!update || !F_ISSET(c, WT_CURSTD_OVERWRITE))
F_SET(clsm, WT_CLSM_OPEN_READ);
if (lsm_tree->nchunks == 0)
return (0);
ckpt_cfg[0] = WT_CONFIG_BASE(session, WT_SESSION_open_cursor);
ckpt_cfg[1] = "checkpoint=" WT_CHECKPOINT ",raw";
ckpt_cfg[2] = NULL;
/*
* If the key is pointing to memory that is pinned by a chunk
* cursor, take a copy before closing cursors.
*/
if (F_ISSET(c, WT_CURSTD_KEY_INT))
WT_CURSOR_NEEDKEY(c);
F_CLR(clsm, WT_CLSM_ITERATE_NEXT | WT_CLSM_ITERATE_PREV);
WT_RET(__wt_lsm_tree_readlock(session, lsm_tree));
locked = true;
/* Merge cursors have already figured out how many chunks they need. */
retry: if (F_ISSET(clsm, WT_CLSM_MERGE)) {
nchunks = clsm->nchunks;
ngood = 0;
/*
* We may have raced with another merge completing. Check that
* we're starting at the right offset in the chunk array.
*/
if (start_chunk >= lsm_tree->nchunks ||
lsm_tree->chunk[start_chunk]->id != start_id) {
for (start_chunk = 0;
start_chunk < lsm_tree->nchunks;
start_chunk++) {
chunk = lsm_tree->chunk[start_chunk];
if (chunk->id == start_id)
break;
}
/* We have to find the start chunk: merge locked it. */
WT_ASSERT(session, start_chunk < lsm_tree->nchunks);
}
WT_ASSERT(session, start_chunk + nchunks <= lsm_tree->nchunks);
} else {
nchunks = lsm_tree->nchunks;
/*
* If we are only opening the cursor for updates, only open the
* primary chunk, plus any other chunks that might be required
* to detect snapshot isolation conflicts.
*/
if (F_ISSET(clsm, WT_CLSM_OPEN_SNAPSHOT))
WT_ERR(__wt_realloc_def(session,
&clsm->txnid_alloc, nchunks,
&clsm->switch_txn));
if (F_ISSET(clsm, WT_CLSM_OPEN_READ))
ngood = nupdates = 0;
else if (F_ISSET(clsm, WT_CLSM_OPEN_SNAPSHOT)) {
/*
* Keep going until all updates in the next
* chunk are globally visible. Copy the maximum
* transaction IDs into the cursor as we go.
*/
for (ngood = nchunks - 1, nupdates = 1;
ngood > 0;
ngood--, nupdates++) {
chunk = lsm_tree->chunk[ngood - 1];
clsm->switch_txn[ngood - 1] = chunk->switch_txn;
if (__wt_txn_visible_all(
session, chunk->switch_txn))
break;
}
} else {
nupdates = 1;
ngood = nchunks - 1;
}
/* Check how many cursors are already open. */
for (cp = clsm->cursors + ngood;
ngood < clsm->nchunks && ngood < nchunks;
cp++, ngood++) {
chunk = lsm_tree->chunk[ngood];
/* If the cursor isn't open yet, we're done. */
if (*cp == NULL)
break;
/* Easy case: the URIs don't match. */
if (strcmp((*cp)->uri, chunk->uri) != 0)
break;
/* Make sure the checkpoint config matches. */
checkpoint = ((WT_CURSOR_BTREE *)*cp)->
btree->dhandle->checkpoint;
if (checkpoint == NULL &&
F_ISSET(chunk, WT_LSM_CHUNK_ONDISK) &&
!chunk->empty)
break;
/* Make sure the Bloom config matches. */
if (clsm->blooms[ngood] == NULL &&
F_ISSET(chunk, WT_LSM_CHUNK_BLOOM))
break;
}
/* Spurious generation bump? */
if (ngood == clsm->nchunks && clsm->nchunks == nchunks) {
clsm->dsk_gen = lsm_tree->dsk_gen;
goto err;
}
/*
* Close any cursors we no longer need.
*
* Drop the LSM tree lock while we do this: if the cache is
* full, we may block while closing a cursor. Save the
* generation number and retry if it has changed under us.
*/
if (clsm->cursors != NULL && ngood < clsm->nchunks) {
close_range_start = ngood;
close_range_end = clsm->nchunks;
} else if (!F_ISSET(clsm, WT_CLSM_OPEN_READ) && nupdates > 0 ) {
close_range_start = 0;
close_range_end = WT_MIN(nchunks, clsm->nchunks);
if (close_range_end > nupdates)
close_range_end -= nupdates;
else
close_range_end = 0;
WT_ASSERT(session, ngood >= close_range_end);
} else {
close_range_end = 0;
close_range_start = 0;
}
if (close_range_end > close_range_start) {
saved_gen = lsm_tree->dsk_gen;
locked = false;
WT_ERR(__wt_lsm_tree_readunlock(session, lsm_tree));
WT_ERR(__clsm_close_cursors(
clsm, close_range_start, close_range_end));
WT_ERR(__wt_lsm_tree_readlock(session, lsm_tree));
locked = true;
if (lsm_tree->dsk_gen != saved_gen)
goto retry;
}
/* Detach from our old primary. */
clsm->primary_chunk = NULL;
clsm->current = NULL;
}
WT_ERR(__wt_realloc_def(session,
&clsm->bloom_alloc, nchunks, &clsm->blooms));
WT_ERR(__wt_realloc_def(session,
&clsm->cursor_alloc, nchunks, &clsm->cursors));
clsm->nchunks = nchunks;
/* Open the cursors for chunks that have changed. */
for (i = ngood, cp = clsm->cursors + i; i != nchunks; i++, cp++) {
chunk = lsm_tree->chunk[i + start_chunk];
/* Copy the maximum transaction ID. */
if (F_ISSET(clsm, WT_CLSM_OPEN_SNAPSHOT))
clsm->switch_txn[i] = chunk->switch_txn;
/*
* Read from the checkpoint if the file has been written.
* Once all cursors switch, the in-memory tree can be evicted.
*/
WT_ASSERT(session, *cp == NULL);
ret = __wt_open_cursor(session, chunk->uri, c,
(F_ISSET(chunk, WT_LSM_CHUNK_ONDISK) && !chunk->empty) ?
ckpt_cfg : NULL, cp);
/*
* XXX kludge: we may have an empty chunk where no checkpoint
* was written. If so, try to open the ordinary handle on that
* chunk instead.
*/
if (ret == WT_NOTFOUND && F_ISSET(chunk, WT_LSM_CHUNK_ONDISK)) {
ret = __wt_open_cursor(
session, chunk->uri, c, NULL, cp);
if (ret == 0)
chunk->empty = 1;
}
WT_ERR(ret);
/*
* Setup all cursors other than the primary to only do conflict
* checks on insert operations. This allows us to execute
* inserts on non-primary chunks as a way of checking for
* write conflicts with concurrent updates.
*/
if (i != nchunks - 1)
(*cp)->insert = __wt_curfile_update_check;
if (!F_ISSET(clsm, WT_CLSM_MERGE) &&
F_ISSET(chunk, WT_LSM_CHUNK_BLOOM))
WT_ERR(__wt_bloom_open(session, chunk->bloom_uri,
lsm_tree->bloom_bit_count,
lsm_tree->bloom_hash_count,
c, &clsm->blooms[i]));
/* Child cursors always use overwrite and raw mode. */
F_SET(*cp, WT_CURSTD_OVERWRITE | WT_CURSTD_RAW);
}
/* The last chunk is our new primary. */
if (chunk != NULL &&
!F_ISSET(chunk, WT_LSM_CHUNK_ONDISK) &&
chunk->switch_txn == WT_TXN_NONE) {
clsm->primary_chunk = chunk;
primary = clsm->cursors[clsm->nchunks - 1];
/*
* Disable eviction for the in-memory chunk. Also clear the
* bulk load flag here, otherwise eviction will be enabled by
* the first update.
*/
btree = ((WT_CURSOR_BTREE *)(primary))->btree;
if (btree->bulk_load_ok) {
btree->bulk_load_ok = false;
WT_WITH_BTREE(session, btree,
__wt_btree_evictable(session, false));
}
}
clsm->dsk_gen = lsm_tree->dsk_gen;
err:
#ifdef HAVE_DIAGNOSTIC
/* Check that all cursors are open as expected. */
if (ret == 0 && F_ISSET(clsm, WT_CLSM_OPEN_READ)) {
for (i = 0, cp = clsm->cursors; i != clsm->nchunks; cp++, i++) {
chunk = lsm_tree->chunk[i + start_chunk];
/* Make sure the cursor is open. */
WT_ASSERT(session, *cp != NULL);
/* Easy case: the URIs should match. */
WT_ASSERT(session, strcmp((*cp)->uri, chunk->uri) == 0);
/* Make sure the checkpoint config matches. */
checkpoint = ((WT_CURSOR_BTREE *)*cp)->
btree->dhandle->checkpoint;
WT_ASSERT(session,
(F_ISSET(chunk, WT_LSM_CHUNK_ONDISK) &&
!chunk->empty) ?
checkpoint != NULL : checkpoint == NULL);
/* Make sure the Bloom config matches. */
WT_ASSERT(session,
(F_ISSET(chunk, WT_LSM_CHUNK_BLOOM) &&
!F_ISSET(clsm, WT_CLSM_MERGE)) ?
clsm->blooms[i] != NULL : clsm->blooms[i] == NULL);
}
}
#endif
if (locked)
WT_TRET(__wt_lsm_tree_readunlock(session, lsm_tree));
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);
}
/*
* __wt_las_sweep --
* Sweep the lookaside table.
*/
int
__wt_las_sweep(WT_SESSION_IMPL *session)
{
WT_CONNECTION_IMPL *conn;
WT_CURSOR *cursor;
WT_DECL_ITEM(las_addr);
WT_DECL_ITEM(las_key);
WT_DECL_RET;
WT_ITEM *key;
uint64_t cnt, las_counter, las_txnid;
uint32_t las_id, session_flags;
int notused;
conn = S2C(session);
cursor = NULL;
key = &conn->las_sweep_key;
session_flags = 0; /* [-Werror=maybe-uninitialized] */
WT_ERR(__wt_scr_alloc(session, 0, &las_addr));
WT_ERR(__wt_scr_alloc(session, 0, &las_key));
WT_ERR(__wt_las_cursor(session, &cursor, &session_flags));
/*
* If we're not starting a new sweep, position the cursor using the key
* from the last call (we don't care if we're before or after the key,
* just roughly in the same spot is fine).
*/
if (conn->las_sweep_call != 0 && key->data != NULL) {
__wt_cursor_set_raw_key(cursor, key);
if ((ret = cursor->search_near(cursor, ¬used)) != 0)
goto srch_notfound;
}
/*
* The sweep server wakes up every 10 seconds (by default), it's a slow
* moving thread. Try to review the entire lookaside table once every 5
* minutes, or every 30 calls.
*
* The reason is because the lookaside table exists because we're seeing
* cache/eviction pressure (it allows us to trade performance and disk
* space for cache space), and it's likely lookaside blocks are being
* evicted, and reading them back in doesn't help things. A trickier,
* but possibly better, alternative might be to review all lookaside
* blocks in the cache in order to get rid of them, and slowly review
* lookaside blocks that have already been evicted.
*
* We can't know for sure how many records are in the lookaside table,
* the cursor insert and remove statistics aren't updated atomically.
* Start with reviewing 100 rows, and if it takes more than the target
* number of calls to finish, increase the number of rows checked on
* each call; if it takes less than the target calls to finish, then
* decrease the number of rows reviewed on each call (but never less
* than 100).
*/
#define WT_SWEEP_LOOKASIDE_MIN_CNT 100
#define WT_SWEEP_LOOKASIDE_PASS_TARGET 30
++conn->las_sweep_call;
if ((cnt = conn->las_sweep_cnt) < WT_SWEEP_LOOKASIDE_MIN_CNT)
cnt = conn->las_sweep_cnt = WT_SWEEP_LOOKASIDE_MIN_CNT;
/* Walk the file. */
for (; cnt > 0 && (ret = cursor->next(cursor)) == 0; --cnt) {
/*
* If the loop terminates after completing a work unit, we will
* continue the table sweep next time. Get a local copy of the
* sweep key, we're going to reset the cursor; do so before
* calling cursor.remove, cursor.remove can discard our hazard
* pointer and the page could be evicted from underneath us.
*/
if (cnt == 1) {
WT_ERR(__wt_cursor_get_raw_key(cursor, key));
if (!WT_DATA_IN_ITEM(key))
WT_ERR(__wt_buf_set(
session, key, key->data, key->size));
}
WT_ERR(cursor->get_key(cursor,
&las_id, las_addr, &las_counter, &las_txnid, las_key));
/*
* If the on-page record transaction ID associated with the
* record is globally visible, the record can be discarded.
*
* Cursor opened overwrite=true: won't return WT_NOTFOUND should
* another thread remove the record before we do, and the cursor
* remains positioned in that case.
*/
if (__wt_txn_visible_all(session, las_txnid))
WT_ERR(cursor->remove(cursor));
}
/*
* When reaching the lookaside table end or the target number of calls,
* adjust the row count. Decrease/increase the row count depending on
* if the number of calls is less/more than the target.
*/
if (ret == WT_NOTFOUND ||
conn->las_sweep_call > WT_SWEEP_LOOKASIDE_PASS_TARGET) {
if (conn->las_sweep_call < WT_SWEEP_LOOKASIDE_PASS_TARGET &&
conn->las_sweep_cnt > WT_SWEEP_LOOKASIDE_MIN_CNT)
conn->las_sweep_cnt -= WT_SWEEP_LOOKASIDE_MIN_CNT;
if (conn->las_sweep_call > WT_SWEEP_LOOKASIDE_PASS_TARGET)
conn->las_sweep_cnt += WT_SWEEP_LOOKASIDE_MIN_CNT;
}
srch_notfound:
if (ret == WT_NOTFOUND)
conn->las_sweep_call = 0;
WT_ERR_NOTFOUND_OK(ret);
if (0) {
err: __wt_buf_free(session, key);
}
WT_TRET(__wt_las_cursor_close(session, &cursor, session_flags));
__wt_scr_free(session, &las_addr);
__wt_scr_free(session, &las_key);
return (ret);
}
/*
* __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_las_sweep --
* Sweep the lookaside table.
*/
int
__wt_las_sweep(WT_SESSION_IMPL *session)
{
WT_CONNECTION_IMPL *conn;
WT_CURSOR *cursor;
WT_DECL_ITEM(las_addr);
WT_DECL_ITEM(las_key);
WT_DECL_RET;
WT_ITEM *key;
uint64_t cnt, las_counter, las_txnid;
int64_t remove_cnt;
uint32_t las_id, session_flags;
int notused;
conn = S2C(session);
cursor = NULL;
key = &conn->las_sweep_key;
remove_cnt = 0;
session_flags = 0; /* [-Werror=maybe-uninitialized] */
WT_ERR(__wt_scr_alloc(session, 0, &las_addr));
WT_ERR(__wt_scr_alloc(session, 0, &las_key));
WT_ERR(__wt_las_cursor(session, &cursor, &session_flags));
/*
* If we're not starting a new sweep, position the cursor using the key
* from the last call (we don't care if we're before or after the key,
* just roughly in the same spot is fine).
*/
if (key->size != 0) {
__wt_cursor_set_raw_key(cursor, key);
ret = cursor->search_near(cursor, ¬used);
/*
* Don't search for the same key twice; if we don't set a new
* key below, it's because we've reached the end of the table
* and we want the next pass to start at the beginning of the
* table. Searching for the same key could leave us stuck at
* the end of the table, repeatedly checking the same rows.
*/
key->size = 0;
if (ret != 0)
goto srch_notfound;
}
/*
* The sweep server wakes up every 10 seconds (by default), it's a slow
* moving thread. Try to review the entire lookaside table once every 5
* minutes, or every 30 calls.
*
* The reason is because the lookaside table exists because we're seeing
* cache/eviction pressure (it allows us to trade performance and disk
* space for cache space), and it's likely lookaside blocks are being
* evicted, and reading them back in doesn't help things. A trickier,
* but possibly better, alternative might be to review all lookaside
* blocks in the cache in order to get rid of them, and slowly review
* lookaside blocks that have already been evicted.
*/
cnt = (uint64_t)WT_MAX(100, conn->las_record_cnt / 30);
/* Discard pages we read as soon as we're done with them. */
F_SET(session, WT_SESSION_NO_CACHE);
/* Walk the file. */
for (; cnt > 0 && (ret = cursor->next(cursor)) == 0; --cnt) {
/*
* If the loop terminates after completing a work unit, we will
* continue the table sweep next time. Get a local copy of the
* sweep key, we're going to reset the cursor; do so before
* calling cursor.remove, cursor.remove can discard our hazard
* pointer and the page could be evicted from underneath us.
*/
if (cnt == 1) {
WT_ERR(__wt_cursor_get_raw_key(cursor, key));
if (!WT_DATA_IN_ITEM(key))
WT_ERR(__wt_buf_set(
session, key, key->data, key->size));
}
WT_ERR(cursor->get_key(cursor,
&las_id, las_addr, &las_counter, &las_txnid, las_key));
/*
* If the on-page record transaction ID associated with the
* record is globally visible, the record can be discarded.
*
* Cursor opened overwrite=true: won't return WT_NOTFOUND should
* another thread remove the record before we do, and the cursor
* remains positioned in that case.
*/
if (__wt_txn_visible_all(session, las_txnid)) {
WT_ERR(cursor->remove(cursor));
++remove_cnt;
}
}
srch_notfound:
WT_ERR_NOTFOUND_OK(ret);
if (0) {
err: __wt_buf_free(session, key);
}
WT_TRET(__wt_las_cursor_close(session, &cursor, session_flags));
/*
* If there were races to remove records, we can over-count. All
* arithmetic is signed, so underflow isn't fatal, but check anyway so
* we don't skew low over time.
*/
if (remove_cnt > S2C(session)->las_record_cnt)
S2C(session)->las_record_cnt = 0;
else if (remove_cnt > 0)
(void)__wt_atomic_subi64(&conn->las_record_cnt, remove_cnt);
F_CLR(session, WT_SESSION_NO_CACHE);
__wt_scr_free(session, &las_addr);
__wt_scr_free(session, &las_key);
return (ret);
}
/*
* __clsm_open_cursors --
* Open cursors for the current set of files.
*/
static int
__clsm_open_cursors(
WT_CURSOR_LSM *clsm, int update, u_int start_chunk, uint32_t start_id)
{
WT_CURSOR *c, **cp, *primary;
WT_DECL_RET;
WT_LSM_CHUNK *chunk;
WT_LSM_TREE *lsm_tree;
WT_SESSION_IMPL *session;
WT_TXN *txn;
const char *checkpoint, *ckpt_cfg[3];
uint64_t saved_gen;
u_int i, nchunks, ngood, nupdates;
int locked;
c = &clsm->iface;
session = (WT_SESSION_IMPL *)c->session;
txn = &session->txn;
lsm_tree = clsm->lsm_tree;
chunk = NULL;
ckpt_cfg[0] = WT_CONFIG_BASE(session, session_open_cursor);
ckpt_cfg[1] = "checkpoint=" WT_CHECKPOINT ",raw";
ckpt_cfg[2] = NULL;
/* Copy the key, so we don't lose the cursor position. */
if (F_ISSET(c, WT_CURSTD_KEY_INT) && !WT_DATA_IN_ITEM(&c->key))
WT_RET(__wt_buf_set(
session, &c->key, c->key.data, c->key.size));
F_CLR(clsm, WT_CLSM_ITERATE_NEXT | WT_CLSM_ITERATE_PREV);
if (update) {
if (txn->isolation == TXN_ISO_SNAPSHOT)
F_SET(clsm, WT_CLSM_OPEN_SNAPSHOT);
} else
F_SET(clsm, WT_CLSM_OPEN_READ);
WT_RET(__wt_lsm_tree_lock(session, lsm_tree, 0));
locked = 1;
/*
* If there is no in-memory chunk in the tree for an update operation,
* create one.
*
* !!!
* It is exceeding unlikely that we get here at all, but if there is a
* transaction in progress and it rolls back, it would leave the
* metadata inconsistent.
*/
if (update && (lsm_tree->nchunks == 0 ||
(chunk = lsm_tree->chunk[lsm_tree->nchunks - 1]) == NULL ||
F_ISSET(chunk, WT_LSM_CHUNK_ONDISK))) {
/* Release our lock because switch will get a write lock. */
locked = 0;
WT_ERR(__wt_lsm_tree_unlock(session, lsm_tree));
WT_ERR(__wt_lsm_tree_switch(session, lsm_tree));
WT_ERR(__wt_lsm_tree_lock(session, lsm_tree, 0));
locked = 1;
}
F_SET(session, WT_SESSION_NO_CACHE_CHECK);
/* Merge cursors have already figured out how many chunks they need. */
retry: if (F_ISSET(clsm, WT_CLSM_MERGE)) {
nchunks = clsm->nchunks;
ngood = 0;
/*
* We may have raced with another merge completing. Check that
* we're starting at the right offset in the chunk array.
*/
if (start_chunk >= lsm_tree->nchunks ||
lsm_tree->chunk[start_chunk]->id != start_id) {
for (start_chunk = 0;
start_chunk < lsm_tree->nchunks;
start_chunk++) {
chunk = lsm_tree->chunk[start_chunk];
if (chunk->id == start_id)
break;
}
/* We have to find the start chunk: merge locked it. */
WT_ASSERT(session, start_chunk < lsm_tree->nchunks);
}
WT_ASSERT(session, start_chunk + nchunks <= lsm_tree->nchunks);
} else {
nchunks = lsm_tree->nchunks;
/*
* If we are only opening the cursor for updates, only open the
* primary chunk, plus any other chunks that might be required
* to detect snapshot isolation conflicts.
*/
if (F_ISSET(clsm, WT_CLSM_OPEN_SNAPSHOT))
WT_ERR(__wt_realloc_def(session,
&clsm->txnid_alloc, nchunks,
&clsm->txnid_max));
if (F_ISSET(clsm, WT_CLSM_OPEN_READ))
ngood = nupdates = 0;
else if (F_ISSET(clsm, WT_CLSM_OPEN_SNAPSHOT)) {
/*
* Keep going until all updates in the next
* chunk are globally visible. Copy the maximum
* transaction IDs into the cursor as we go.
*/
for (ngood = nchunks - 1, nupdates = 1;
ngood > 0;
ngood--, nupdates++) {
chunk = lsm_tree->chunk[ngood - 1];
clsm->txnid_max[ngood - 1] =
chunk->txnid_max;
if (__wt_txn_visible_all(
session, chunk->txnid_max))
break;
}
} else {
nupdates = 1;
ngood = nchunks - 1;
}
/* Check how many cursors are already open. */
for (cp = clsm->cursors + ngood;
ngood < clsm->nchunks && ngood < nchunks;
cp++, ngood++) {
chunk = lsm_tree->chunk[ngood];
/* If the cursor isn't open yet, we're done. */
if (*cp == NULL)
break;
/* Easy case: the URIs don't match. */
if (strcmp((*cp)->uri, chunk->uri) != 0)
break;
/* Make sure the checkpoint config matches. */
checkpoint = ((WT_CURSOR_BTREE *)*cp)->
btree->dhandle->checkpoint;
if (checkpoint == NULL &&
F_ISSET(chunk, WT_LSM_CHUNK_ONDISK) &&
!chunk->empty)
break;
/* Make sure the Bloom config matches. */
if (clsm->blooms[ngood] == NULL &&
F_ISSET(chunk, WT_LSM_CHUNK_BLOOM))
break;
}
/* Spurious generation bump? */
if (ngood == clsm->nchunks && clsm->nchunks == nchunks) {
clsm->dsk_gen = lsm_tree->dsk_gen;
goto err;
}
/*
* Close any cursors we no longer need.
*
* Drop the LSM tree lock while we do this: if the cache is
* full, we may block while closing a cursor. Save the
* generation number and retry if it has changed under us.
*/
if (clsm->cursors != NULL && (ngood < clsm->nchunks ||
(!F_ISSET(clsm, WT_CLSM_OPEN_READ) && nupdates > 0))) {
saved_gen = lsm_tree->dsk_gen;
locked = 0;
WT_ERR(__wt_lsm_tree_unlock(session, lsm_tree));
if (!F_ISSET(clsm, WT_CLSM_OPEN_READ) && nupdates > 0)
WT_ERR(__clsm_close_cursors(
clsm, 0, nchunks - nupdates));
WT_ERR(__clsm_close_cursors(
clsm, ngood, clsm->nchunks));
WT_ERR(__wt_lsm_tree_lock(session, lsm_tree, 0));
locked = 1;
if (lsm_tree->dsk_gen != saved_gen)
goto retry;
}
/* Detach from our old primary. */
clsm->primary_chunk = NULL;
clsm->current = NULL;
}
WT_ERR(__wt_realloc_def(session,
&clsm->bloom_alloc, nchunks, &clsm->blooms));
WT_ERR(__wt_realloc_def(session,
&clsm->cursor_alloc, nchunks, &clsm->cursors));
clsm->nchunks = nchunks;
/* Open the cursors for chunks that have changed. */
for (i = ngood, cp = clsm->cursors + i; i != nchunks; i++, cp++) {
chunk = lsm_tree->chunk[i + start_chunk];
/* Copy the maximum transaction ID. */
if (F_ISSET(clsm, WT_CLSM_OPEN_SNAPSHOT))
clsm->txnid_max[i] = chunk->txnid_max;
/*
* Read from the checkpoint if the file has been written.
* Once all cursors switch, the in-memory tree can be evicted.
*/
WT_ASSERT(session, *cp == NULL);
ret = __wt_open_cursor(session, chunk->uri, c,
(F_ISSET(chunk, WT_LSM_CHUNK_ONDISK) && !chunk->empty) ?
ckpt_cfg : NULL, cp);
/*
* XXX kludge: we may have an empty chunk where no checkpoint
* was written. If so, try to open the ordinary handle on that
* chunk instead.
*/
if (ret == WT_NOTFOUND &&
F_ISSET(chunk, WT_LSM_CHUNK_ONDISK)) {
ret = __wt_open_cursor(
session, chunk->uri, c, NULL, cp);
if (ret == 0)
chunk->empty = 1;
}
WT_ERR(ret);
if (F_ISSET(chunk, WT_LSM_CHUNK_BLOOM) &&
!F_ISSET(clsm, WT_CLSM_MERGE))
WT_ERR(__wt_bloom_open(session, chunk->bloom_uri,
lsm_tree->bloom_bit_count,
lsm_tree->bloom_hash_count,
c, &clsm->blooms[i]));
/* Child cursors always use overwrite and raw mode. */
F_SET(*cp, WT_CURSTD_OVERWRITE | WT_CURSTD_RAW);
}
/* The last chunk is our new primary. */
if (chunk != NULL && !F_ISSET(chunk, WT_LSM_CHUNK_ONDISK)) {
clsm->primary_chunk = chunk;
primary = clsm->cursors[clsm->nchunks - 1];
WT_WITH_BTREE(session, ((WT_CURSOR_BTREE *)(primary))->btree,
__wt_btree_evictable(session, 0));
}
clsm->dsk_gen = lsm_tree->dsk_gen;
err: F_CLR(session, WT_SESSION_NO_CACHE_CHECK);
#ifdef HAVE_DIAGNOSTIC
/* Check that all cursors are open as expected. */
if (ret == 0 && F_ISSET(clsm, WT_CLSM_OPEN_READ)) {
for (i = 0, cp = clsm->cursors; i != clsm->nchunks; cp++, i++) {
chunk = lsm_tree->chunk[i + start_chunk];
/* Make sure the cursor is open. */
WT_ASSERT(session, *cp != NULL);
/* Easy case: the URIs should match. */
WT_ASSERT(session, strcmp((*cp)->uri, chunk->uri) == 0);
/* Make sure the checkpoint config matches. */
checkpoint = ((WT_CURSOR_BTREE *)*cp)->
btree->dhandle->checkpoint;
WT_ASSERT(session,
(F_ISSET(chunk, WT_LSM_CHUNK_ONDISK) &&
!chunk->empty) ?
checkpoint != NULL : checkpoint == NULL);
/* Make sure the Bloom config matches. */
WT_ASSERT(session,
(F_ISSET(chunk, WT_LSM_CHUNK_BLOOM) &&
!F_ISSET(clsm, WT_CLSM_MERGE)) ?
clsm->blooms[i] != NULL : clsm->blooms[i] == NULL);
}
}
#endif
if (locked)
WT_TRET(__wt_lsm_tree_unlock(session, lsm_tree));
return (ret);
}
/*
* __rec_review --
* Get exclusive access to the page and review the page and its subtree
* for conditions that would block its eviction.
*
* The ref and page arguments may appear to be redundant, because usually
* ref->page == page and page->ref == ref. However, we need both because
* (a) there are cases where ref == NULL (e.g., for root page or during
* salvage), and (b) we can't safely look at page->ref until we have a
* hazard pointer.
*/
static int
__rec_review(WT_SESSION_IMPL *session, WT_REF *ref, WT_PAGE *page,
int exclusive, int merge, int top, int *inmem_split, int *istree)
{
WT_BTREE *btree;
WT_DECL_RET;
WT_PAGE_MODIFY *mod;
WT_PAGE *t;
uint32_t i;
btree = S2BT(session);
/*
* Get exclusive access to the page if our caller doesn't have the tree
* locked down.
*/
if (!exclusive) {
WT_RET(__hazard_exclusive(session, ref, top));
/*
* Now the page is locked, remove it from the LRU eviction
* queue. We have to do this before freeing the page memory or
* otherwise touching the reference because eviction paths
* assume a non-NULL reference on the queue is pointing at
* valid memory.
*/
__wt_evict_list_clr_page(session, page);
}
/*
* Recurse through the page's subtree: this happens first because we
* have to write pages in depth-first order, otherwise we'll dirty
* pages after we've written them.
*/
if (page->type == WT_PAGE_COL_INT || page->type == WT_PAGE_ROW_INT)
WT_REF_FOREACH(page, ref, i)
switch (ref->state) {
case WT_REF_DISK: /* On-disk */
case WT_REF_DELETED: /* On-disk, deleted */
break;
case WT_REF_MEM: /* In-memory */
/*
* Tell our caller if there's a subtree so we
* know to do a full walk when discarding the
* page.
*/
*istree = 1;
WT_RET(__rec_review(session, ref, ref->page,
exclusive, merge, 0, inmem_split, istree));
break;
case WT_REF_EVICT_WALK: /* Walk point */
case WT_REF_LOCKED: /* Being evicted */
case WT_REF_READING: /* Being read */
return (EBUSY);
}
/*
* If the file is being checkpointed, we cannot evict dirty pages,
* because that may free a page that appears on an internal page in the
* checkpoint. Don't rely on new updates being skipped by the
* transaction used for transaction reads: (1) there are paths that
* dirty pages for artificial reasons; (2) internal pages aren't
* transactional; and (3) if an update was skipped during the
* checkpoint (leaving the page dirty), then rolled back, we could
* still successfully overwrite a page and corrupt the checkpoint.
*
* Further, even for clean pages, the checkpoint's reconciliation of an
* internal page might race with us as we evict a child in the page's
* subtree.
*
* One half of that test is in the reconciliation code: the checkpoint
* thread waits for eviction-locked pages to settle before determining
* their status. The other half of the test is here: after acquiring
* the exclusive eviction lock on a page, confirm no page in the page's
* stack of pages from the root is being reconciled in a checkpoint.
* This ensures we either see the checkpoint-walk state here, or the
* reconciliation of the internal page sees our exclusive lock on the
* child page and waits until we're finished evicting the child page
* (or give up if eviction isn't possible).
*
* We must check the full stack (we might be attempting to evict a leaf
* page multiple levels beneath the internal page being reconciled as
* part of the checkpoint, and all of the intermediate nodes are being
* merged into the internal page).
*
* There's no simple test for knowing if a page in our page stack is
* involved in a checkpoint. The internal page's checkpoint-walk flag
* is the best test, but it's not set anywhere for the root page, it's
* not a complete test.
*
* Quit for any page that's not a simple, in-memory page. (Almost the
* same as checking for the checkpoint-walk flag. I don't think there
* are code paths that change the page's status from checkpoint-walk,
* but these races are hard enough I'm not going to proceed if there's
* anything other than a vanilla, in-memory tree stack.) Climb until
* we find a page which can't be merged into its parent, and failing if
* we never find such a page.
*/
if (btree->checkpointing && !merge && __wt_page_is_modified(page)) {
ckpt: WT_STAT_FAST_CONN_INCR(session, cache_eviction_checkpoint);
WT_STAT_FAST_DATA_INCR(session, cache_eviction_checkpoint);
return (EBUSY);
}
if (btree->checkpointing && top)
for (t = page->parent;; t = t->parent) {
if (t == NULL || t->ref == NULL) /* root */
goto ckpt;
if (t->ref->state != WT_REF_MEM) /* scary */
goto ckpt;
if (t->modify == NULL || /* not merged */
!F_ISSET(t->modify, WT_PM_REC_EMPTY |
WT_PM_REC_SPLIT | WT_PM_REC_SPLIT_MERGE))
break;
}
/*
* If we are merging internal pages, we just need exclusive access, we
* don't need to write everything.
*/
if (merge)
return (0);
/*
* Fail if any page in the top-level page's subtree won't be merged into
* its parent, the page that cannot be merged must be evicted first.
* The test is necessary but should not fire much: the eviction code is
* biased for leaf pages, an internal page shouldn't be selected for
* eviction until its children have been evicted.
*
* We have to write dirty pages to know their final state, a page marked
* empty may have had records added since reconciliation, a page marked
* split may have had records deleted and no longer need to split.
* Split-merge pages are the exception: they can never be change into
* anything other than a split-merge page and are merged regardless of
* being clean or dirty.
*
* Writing the page is expensive, do a cheap test first: if it doesn't
* appear a subtree page can be merged, quit. It's possible the page
* has been emptied since it was last reconciled, and writing it before
* testing might be worthwhile, but it's more probable we're attempting
* to evict an internal page with live children, and that's a waste of
* time.
*/
mod = page->modify;
if (!top && (mod == NULL || !F_ISSET(mod,
WT_PM_REC_EMPTY | WT_PM_REC_SPLIT | WT_PM_REC_SPLIT_MERGE)))
return (EBUSY);
/*
* If the page is dirty and can possibly change state, write it so we
* know the final state.
*/
if (__wt_page_is_modified(page) &&
!F_ISSET(mod, WT_PM_REC_SPLIT_MERGE)) {
ret = __wt_rec_write(session, page,
NULL, WT_EVICTION_SERVER_LOCKED | WT_SKIP_UPDATE_QUIT);
/*
* Update the page's modification reference, reconciliation
* might have changed it.
*/
mod = page->modify;
/*
* If reconciliation failed due to active modifications and
* the page is a lot larger than the maximum allowed, it is
* likely that we are having trouble reconciling it due to
* contention, attempt to split the page in memory.
*
* Note, we won't be here if recursively descending a tree of
* pages: dirty row-store leaf pages can't be merged into their
* parents, which means if top wasn't true in this test, we'd
* have returned busy before attempting reconciliation.
*/
if (ret == EBUSY &&
page->type == WT_PAGE_ROW_LEAF &&
__wt_eviction_force_check(session, page)) {
*inmem_split = 1;
return (0);
}
if (ret == EBUSY) {
/* Give up if there are unwritten changes */
WT_VERBOSE_RET(session, evict,
"eviction failed, reconciled page"
" contained active updates");
/*
* We may be able to discard any "update" memory the
* page no longer needs.
*/
switch (page->type) {
case WT_PAGE_COL_FIX:
case WT_PAGE_COL_VAR:
__wt_col_leaf_obsolete(session, page);
break;
case WT_PAGE_ROW_LEAF:
__wt_row_leaf_obsolete(session, page);
break;
}
}
WT_RET(ret);
WT_ASSERT(session, !__wt_page_is_modified(page));
}
/*
* If the page is clean, but was ever modified, make sure all of the
* updates on the page are old enough that they can be discarded from
* cache.
*/
if (!exclusive && mod != NULL &&
!__wt_txn_visible_all(session, mod->disk_txn))
return (EBUSY);
/*
* Repeat the test: fail if any page in the top-level page's subtree
* won't be merged into its parent.
*/
if (!top && (mod == NULL || !F_ISSET(mod,
WT_PM_REC_EMPTY | WT_PM_REC_SPLIT | WT_PM_REC_SPLIT_MERGE)))
return (EBUSY);
return (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;
/*
* 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);
}
/*
* __cursor_var_prev --
* Move to the previous, variable-length column-store item.
*/
static inline int
__cursor_var_prev(WT_CURSOR_BTREE *cbt, bool newpage)
{
WT_CELL *cell;
WT_CELL_UNPACK unpack;
WT_COL *cip;
WT_ITEM *val;
WT_PAGE *page;
WT_SESSION_IMPL *session;
WT_UPDATE *upd;
session = (WT_SESSION_IMPL *)cbt->iface.session;
page = cbt->ref->page;
val = &cbt->iface.value;
/* Initialize for each new page. */
if (newpage) {
cbt->last_standard_recno = __col_var_last_recno(page);
if (cbt->last_standard_recno == 0)
return (WT_NOTFOUND);
__cursor_set_recno(cbt, cbt->last_standard_recno);
goto new_page;
}
/* Move to the previous entry and return the item. */
for (;;) {
__cursor_set_recno(cbt, cbt->recno - 1);
new_page: if (cbt->recno < page->pg_var_recno)
return (WT_NOTFOUND);
/* Find the matching WT_COL slot. */
if ((cip = __col_var_search(page, cbt->recno)) == NULL)
return (WT_NOTFOUND);
cbt->slot = WT_COL_SLOT(page, cip);
/* Check any insert list for a matching record. */
cbt->ins_head = WT_COL_UPDATE_SLOT(page, cbt->slot);
cbt->ins = __col_insert_search_match(cbt->ins_head, cbt->recno);
upd = cbt->ins == NULL ?
NULL : __wt_txn_read(session, cbt->ins->upd);
if (upd != NULL) {
if (WT_UPDATE_DELETED_ISSET(upd)) {
if (__wt_txn_visible_all(session, upd->txnid))
++cbt->page_deleted_count;
continue;
}
val->data = WT_UPDATE_DATA(upd);
val->size = upd->size;
return (0);
}
/*
* If we're at the same slot as the last reference and there's
* no matching insert list item, re-use the return information
* (so encoded items with large repeat counts aren't repeatedly
* decoded). Otherwise, unpack the cell and build the return
* information.
*/
if (cbt->cip_saved != cip) {
if ((cell = WT_COL_PTR(page, cip)) == NULL)
continue;
__wt_cell_unpack(cell, &unpack);
if (unpack.type == WT_CELL_DEL)
continue;
WT_RET(__wt_page_cell_data_ref(
session, page, &unpack, &cbt->tmp));
cbt->cip_saved = cip;
}
val->data = cbt->tmp.data;
val->size = cbt->tmp.size;
return (0);
}
/* NOTREACHED */
}
/*
* __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);
}
/*
* __las_page_instantiate --
* Instantiate lookaside update records in a recently read page.
*/
static int
__las_page_instantiate(WT_SESSION_IMPL *session,
WT_REF *ref, uint32_t read_id, const uint8_t *addr, size_t addr_size)
{
WT_CURSOR *cursor;
WT_CURSOR_BTREE cbt;
WT_DECL_ITEM(current_key);
WT_DECL_ITEM(las_addr);
WT_DECL_ITEM(las_key);
WT_DECL_ITEM(las_value);
WT_DECL_RET;
WT_PAGE *page;
WT_UPDATE *first_upd, *last_upd, *upd;
size_t incr, total_incr;
uint64_t current_recno, las_counter, las_txnid, recno, upd_txnid;
uint32_t las_id, upd_size, session_flags;
int exact;
const uint8_t *p;
cursor = NULL;
page = ref->page;
first_upd = last_upd = upd = NULL;
total_incr = 0;
current_recno = recno = WT_RECNO_OOB;
session_flags = 0; /* [-Werror=maybe-uninitialized] */
__wt_btcur_init(session, &cbt);
__wt_btcur_open(&cbt);
WT_ERR(__wt_scr_alloc(session, 0, ¤t_key));
WT_ERR(__wt_scr_alloc(session, 0, &las_addr));
WT_ERR(__wt_scr_alloc(session, 0, &las_key));
WT_ERR(__wt_scr_alloc(session, 0, &las_value));
/* Open a lookaside table cursor. */
WT_ERR(__wt_las_cursor(session, &cursor, &session_flags));
/*
* The lookaside records are in key and update order, that is, there
* will be a set of in-order updates for a key, then another set of
* in-order updates for a subsequent key. We process all of the updates
* for a key and then insert those updates into the page, then all the
* updates for the next key, and so on.
*
* Search for the block's unique prefix, stepping through any matching
* records.
*/
las_addr->data = addr;
las_addr->size = addr_size;
las_key->size = 0;
cursor->set_key(
cursor, read_id, las_addr, (uint64_t)0, (uint32_t)0, las_key);
if ((ret = cursor->search_near(cursor, &exact)) == 0 && exact < 0)
ret = cursor->next(cursor);
for (; ret == 0; ret = cursor->next(cursor)) {
WT_ERR(cursor->get_key(cursor,
&las_id, las_addr, &las_counter, &las_txnid, las_key));
/*
* Confirm the search using the unique prefix; if not a match,
* we're done searching for records for this page.
*/
if (las_id != read_id ||
las_addr->size != addr_size ||
memcmp(las_addr->data, addr, addr_size) != 0)
break;
/*
* If the on-page value has become globally visible, this record
* is no longer needed.
*/
if (__wt_txn_visible_all(session, las_txnid))
continue;
/* Allocate the WT_UPDATE structure. */
WT_ERR(cursor->get_value(
cursor, &upd_txnid, &upd_size, las_value));
WT_ERR(__wt_update_alloc(session,
(upd_size == WT_UPDATE_DELETED_VALUE) ? NULL : las_value,
&upd, &incr));
total_incr += incr;
upd->txnid = upd_txnid;
switch (page->type) {
case WT_PAGE_COL_FIX:
case WT_PAGE_COL_VAR:
p = las_key->data;
WT_ERR(__wt_vunpack_uint(&p, 0, &recno));
if (current_recno == recno)
break;
WT_ASSERT(session, current_recno < recno);
if (first_upd != NULL) {
WT_ERR(__col_instantiate(session,
current_recno, ref, &cbt, first_upd));
first_upd = NULL;
}
current_recno = recno;
break;
case WT_PAGE_ROW_LEAF:
if (current_key->size == las_key->size &&
memcmp(current_key->data,
las_key->data, las_key->size) == 0)
break;
if (first_upd != NULL) {
WT_ERR(__row_instantiate(session,
current_key, ref, &cbt, first_upd));
first_upd = NULL;
}
WT_ERR(__wt_buf_set(session,
current_key, las_key->data, las_key->size));
break;
WT_ILLEGAL_VALUE_ERR(session);
}
/* Append the latest update to the list. */
if (first_upd == NULL)
first_upd = last_upd = upd;
else {
last_upd->next = upd;
last_upd = upd;
}
upd = NULL;
}
WT_ERR_NOTFOUND_OK(ret);
/* Insert the last set of updates, if any. */
if (first_upd != NULL)
switch (page->type) {
case WT_PAGE_COL_FIX:
case WT_PAGE_COL_VAR:
WT_ERR(__col_instantiate(session,
current_recno, ref, &cbt, first_upd));
first_upd = NULL;
break;
case WT_PAGE_ROW_LEAF:
WT_ERR(__row_instantiate(session,
current_key, ref, &cbt, first_upd));
first_upd = NULL;
break;
WT_ILLEGAL_VALUE_ERR(session);
}
/* Discard the cursor. */
WT_ERR(__wt_las_cursor_close(session, &cursor, session_flags));
if (total_incr != 0) {
__wt_cache_page_inmem_incr(session, page, total_incr);
/*
* We've modified/dirtied the page, but that's not necessary and
* if we keep the page clean, it's easier to evict. We leave the
* lookaside table updates in place, so if we evict this page
* without dirtying it, any future instantiation of it will find
* the records it needs. If the page is dirtied before eviction,
* then we'll write any needed lookaside table records for the
* new location of the page.
*/
__wt_page_modify_clear(session, page);
}
err: WT_TRET(__wt_las_cursor_close(session, &cursor, session_flags));
WT_TRET(__wt_btcur_close(&cbt, 1));
/*
* On error, upd points to a single unlinked WT_UPDATE structure,
* first_upd points to a list.
*/
if (upd != NULL)
__wt_free(session, upd);
if (first_upd != NULL)
__wt_free_update_list(session, first_upd);
__wt_scr_free(session, ¤t_key);
__wt_scr_free(session, &las_addr);
__wt_scr_free(session, &las_key);
__wt_scr_free(session, &las_value);
return (ret);
}
/*
* __wt_evict_file --
* Discard pages for a specific file.
*/
int
__wt_evict_file(WT_SESSION_IMPL *session, int syncop)
{
WT_BTREE *btree;
WT_DECL_RET;
WT_PAGE *page;
WT_REF *next_ref, *ref;
int eviction_enabled;
btree = S2BT(session);
eviction_enabled = !F_ISSET(btree, WT_BTREE_NO_EVICTION);
/*
* We need exclusive access to the file -- disable ordinary eviction
* and drain any blocks already queued.
*/
if (eviction_enabled)
WT_RET(__wt_evict_file_exclusive_on(session));
/* Make sure the oldest transaction ID is up-to-date. */
__wt_txn_update_oldest(session);
/* Walk the tree, discarding pages. */
next_ref = NULL;
WT_ERR(__wt_tree_walk(
session, &next_ref, WT_READ_CACHE | WT_READ_NO_EVICT));
while ((ref = next_ref) != NULL) {
page = ref->page;
/*
* Eviction can fail when a page in the evicted page's subtree
* switches state. For example, if we don't evict a page marked
* empty, because we expect it to be merged into its parent, it
* might no longer be empty after it's reconciled, in which case
* eviction of its parent would fail. We can either walk the
* tree multiple times (until it's finally empty), or reconcile
* each page to get it to its final state before considering if
* it's an eviction target or will be merged into its parent.
*
* Don't limit this test to any particular page type, that tends
* to introduce bugs when the reconciliation of other page types
* changes, and there's no advantage to doing so.
*
* Eviction can also fail because an update cannot be written.
* If sessions have disjoint sets of files open, updates in a
* no-longer-referenced file may not yet be globally visible,
* and the write will fail with EBUSY. Our caller handles that
* error, retrying later.
*/
if (syncop == WT_SYNC_CLOSE && __wt_page_is_modified(page))
WT_ERR(__wt_reconcile(session, ref, NULL, WT_EVICTING));
/*
* We can't evict the page just returned to us (it marks our
* place in the tree), so move the walk to one page ahead of
* the page being evicted. Note, we reconciled the returned
* page first: if reconciliation of that page were to change
* the shape of the tree, and we did the next walk call before
* the reconciliation, the next walk call could miss a page in
* the tree.
*/
WT_ERR(__wt_tree_walk(
session, &next_ref, WT_READ_CACHE | WT_READ_NO_EVICT));
switch (syncop) {
case WT_SYNC_CLOSE:
/*
* Evict the page.
* Do not attempt to evict pages expected to be merged
* into their parents, with the exception that the root
* page can't be merged, it must be written.
*/
if (__wt_ref_is_root(ref) ||
page->modify == NULL ||
!F_ISSET(page->modify, WT_PM_REC_EMPTY))
WT_ERR(__wt_evict(session, ref, 1));
break;
case WT_SYNC_DISCARD:
/*
* Ordinary discard of the page, whether clean or dirty.
* If we see a dirty page in an ordinary discard (e.g.,
* from sweep), give up: an update must have happened
* since the file was selected for sweeping.
*/
if (__wt_page_is_modified(page))
WT_ERR(EBUSY);
/*
* If the page contains an update that is too recent to
* evict, stop. This should never happen during
* connection close, but in other paths our caller
* should be prepared to deal with this case.
*/
if (page->modify != NULL &&
!__wt_txn_visible_all(session,
page->modify->rec_max_txn))
WT_ERR(EBUSY);
__wt_evict_page_clean_update(session, ref);
break;
case WT_SYNC_DISCARD_FORCE:
/*
* Forced discard of the page, whether clean or dirty.
* If we see a dirty page in a forced discard, clean
* the page, both to keep statistics correct, and to
* let the page-discard function assert no dirty page
* is ever discarded.
*/
if (__wt_page_is_modified(page)) {
page->modify->write_gen = 0;
__wt_cache_dirty_decr(session, page);
}
F_SET(session, WT_SESSION_DISCARD_FORCE);
__wt_evict_page_clean_update(session, ref);
F_CLR(session, WT_SESSION_DISCARD_FORCE);
break;
WT_ILLEGAL_VALUE_ERR(session);
}
}
if (0) {
err: /* On error, clear any left-over tree walk. */
if (next_ref != NULL)
WT_TRET(__wt_page_release(
session, next_ref, WT_READ_NO_EVICT));
}
if (eviction_enabled)
__wt_evict_file_exclusive_off(session);
return (ret);
}
