/*
* __curds_txn_leave --
* Do transactional cleanup when ending an operation.
*/
static void
__curds_txn_leave(WT_SESSION_IMPL *session)
{
if (--session->ncursors == 0) /* XXX */
__wt_txn_read_last(session);
}
/*
* __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 reference.
*/
static int
__rec_review(WT_SESSION_IMPL *session,
WT_REF *ref, WT_PAGE *page, uint32_t flags, int top)
{
WT_DECL_RET;
WT_PAGE_MODIFY *mod;
WT_TXN *txn;
uint32_t i;
txn = &session->txn;
/*
* Get exclusive access to the page if our caller doesn't have the tree
* locked down.
*/
if (!LF_ISSET(WT_REC_SINGLE))
WT_RET(__hazard_exclusive(session, ref, top));
/*
* 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 */
WT_RET(__rec_review(
session, ref, ref->page, flags, 0));
break;
case WT_REF_EVICT_WALK: /* Walk point */
case WT_REF_LOCKED: /* Being evicted */
case WT_REF_READING: /* Being read */
return (EBUSY);
}
/*
* Check if this page can be evicted:
*
* Fail if the top-level page is a page expected to be removed from the
* tree as part of eviction (an empty page or a split-merge page). Note
* "split" pages are NOT included in this test, because a split page can
* be separately evicted, at which point it's replaced in its parent by
* a reference to a split-merge page. That's a normal part of the leaf
* page life-cycle if it grows too large and must be pushed out of the
* cache. There is also an exception for empty pages, the root page may
* be empty when evicted, but that only happens when the tree is closed.
*
* Fail if any page in the top-level page's subtree can't be merged into
* its parent. You can't evict a page that references such in-memory
* pages, they must be evicted first. The test is necessary but should
* not fire much: the LRU-based eviction code is biased for leaf pages,
* an internal page shouldn't be selected for LRU-based eviction until
* its children have been evicted. Empty, split and split-merge pages
* are all included in this test, they can all be merged into a parent.
*
* 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.
*
* We don't do a cheap test for the top-level page: we're not called
* to evict split-merge pages, which means the only interesting case
* is an empty page. If the eviction thread picked an "empty" page
* for eviction, it must have had reason, probably the empty page got
* really, really full.
*/
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, 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, flags);
/* If there are unwritten changes on the page, give up. */
if (ret == 0 &&
!LF_ISSET(WT_REC_SINGLE) && __wt_page_is_modified(page))
ret = EBUSY;
if (ret == EBUSY) {
WT_VERBOSE_RET(session, evict,
"page %p written but not clean", page);
if (F_ISSET(txn, TXN_RUNNING) &&
++txn->eviction_fails >= 100) {
txn->eviction_fails = 0;
ret = WT_DEADLOCK;
WT_STAT_INCR(
S2C(session)->stats, txn_fail_cache);
}
/*
* If there aren't multiple cursors active, there
* are no consistency issues: try to bump our snapshot.
*/
if (session->ncursors <= 1) {
__wt_txn_read_last(session);
__wt_txn_read_first(session);
}
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);
txn->eviction_fails = 0;
}
/*
* Repeat the eviction tests.
*
* Fail if the top-level page should be merged into its parent, and it's
* not the root page.
*
* Fail if a page in the top-level page's subtree can't be merged into
* its parent.
*/
if (top) {
/*
* We never get a top-level split-merge page to evict, they are
* ignored by the eviction thread. Check out of sheer paranoia.
*/
if (mod != NULL) {
if (F_ISSET(mod, WT_PM_REC_SPLIT_MERGE))
return (EBUSY);
if (F_ISSET(mod, WT_PM_REC_EMPTY) &&
!WT_PAGE_IS_ROOT(page))
return (EBUSY);
}
} else if (mod == NULL || !F_ISSET(mod,
WT_PM_REC_EMPTY | WT_PM_REC_SPLIT | WT_PM_REC_SPLIT_MERGE))
return (EBUSY);
return (0);
}
