/*
* __wt_block_checkpoint_resolve --
* Resolve a checkpoint.
*/
int
__wt_block_checkpoint_resolve(WT_SESSION_IMPL *session, WT_BLOCK *block)
{
WT_BLOCK_CKPT *ci;
WT_DECL_RET;
ci = &block->live;
/*
* Resolve the checkpoint after our caller has written the checkpoint
* information to stable storage.
*/
__wt_spin_lock(session, &block->live_lock);
if (!block->ckpt_inprogress)
WT_ERR(__wt_block_panic(session, WT_ERROR,
"%s: checkpoint resolution with no checkpoint in progress",
block->name));
if ((ret = __wt_block_extlist_merge(
session, block, &ci->ckpt_avail, &ci->avail)) != 0)
WT_ERR(__wt_block_panic(session, ret,
"%s: fatal checkpoint failure", block->name));
__wt_spin_unlock(session, &block->live_lock);
/* Discard the lists remaining after the checkpoint call. */
__wt_block_extlist_free(session, &ci->ckpt_avail);
__wt_block_extlist_free(session, &ci->ckpt_alloc);
__wt_block_extlist_free(session, &ci->ckpt_discard);
__wt_spin_lock(session, &block->live_lock);
block->ckpt_inprogress = 0;
err: __wt_spin_unlock(session, &block->live_lock);
return (ret);
}
/*
* __wt_block_checkpoint_resolve --
* Resolve a checkpoint.
*/
int
__wt_block_checkpoint_resolve(
WT_SESSION_IMPL *session, WT_BLOCK *block, bool failed)
{
WT_BLOCK_CKPT *ci;
WT_DECL_RET;
ci = &block->live;
/*
* Resolve the checkpoint after our caller has written the checkpoint
* information to stable storage.
*/
__wt_spin_lock(session, &block->live_lock);
switch (block->ckpt_state) {
case WT_CKPT_INPROGRESS:
/* Something went wrong, but it's recoverable at our level. */
goto done;
case WT_CKPT_NONE:
case WT_CKPT_SALVAGE:
__wt_err(session, EINVAL,
"%s: an unexpected checkpoint resolution: the checkpoint "
"was never started or completed, or configured for salvage",
block->name);
ret = __wt_block_panic(session);
break;
case WT_CKPT_PANIC_ON_FAILURE:
if (!failed)
break;
__wt_err(session, EINVAL,
"%s: the checkpoint failed, the system must restart",
block->name);
ret = __wt_block_panic(session);
break;
}
WT_ERR(ret);
if ((ret = __wt_block_extlist_merge(
session, block, &ci->ckpt_avail, &ci->avail)) != 0) {
__wt_err(session, ret,
"%s: fatal checkpoint failure during extent list merge",
block->name);
ret = __wt_block_panic(session);
}
__wt_spin_unlock(session, &block->live_lock);
/* Discard the lists remaining after the checkpoint call. */
__wt_block_extlist_free(session, &ci->ckpt_avail);
__wt_block_extlist_free(session, &ci->ckpt_alloc);
__wt_block_extlist_free(session, &ci->ckpt_discard);
__wt_spin_lock(session, &block->live_lock);
done: block->ckpt_state = WT_CKPT_NONE;
err: __wt_spin_unlock(session, &block->live_lock);
return (ret);
}
/*
* __wt_block_checkpoint_start --
* Start a checkpoint.
*/
int
__wt_block_checkpoint_start(WT_SESSION_IMPL *session, WT_BLOCK *block)
{
WT_DECL_RET;
__wt_spin_lock(session, &block->live_lock);
switch (block->ckpt_state) {
case WT_CKPT_INPROGRESS:
case WT_CKPT_PANIC_ON_FAILURE:
case WT_CKPT_SALVAGE:
__wt_err(session, EINVAL,
"%s: an unexpected checkpoint start: the checkpoint "
"has already started or was configured for salvage",
block->name);
ret = __wt_block_panic(session);
break;
case WT_CKPT_NONE:
block->ckpt_state = WT_CKPT_INPROGRESS;
break;
}
__wt_spin_unlock(session, &block->live_lock);
return (ret);
}
/*
* __ckpt_process --
* Process the list of checkpoints.
*/
static int
__ckpt_process(WT_SESSION_IMPL *session, WT_BLOCK *block, WT_CKPT *ckptbase)
{
WT_BLOCK_CKPT *a, *b, *ci;
WT_CKPT *ckpt, *next_ckpt;
WT_DECL_ITEM(tmp);
WT_DECL_RET;
uint64_t ckpt_size;
bool deleting, fatal, locked;
ci = &block->live;
fatal = locked = false;
#ifdef HAVE_DIAGNOSTIC
WT_RET(__ckpt_verify(session, ckptbase));
#endif
/*
* Checkpoints are a two-step process: first, write a new checkpoint to
* disk (including all the new extent lists for modified checkpoints
* and the live system). As part of this, create a list of file blocks
* newly available for reallocation, based on checkpoints being deleted.
* We then return the locations of the new checkpoint information to our
* caller. Our caller has to write that information into some kind of
* stable storage, and once that's done, we can actually allocate from
* that list of newly available file blocks. (We can't allocate from
* that list immediately because the allocation might happen before our
* caller saves the new checkpoint information, and if we crashed before
* the new checkpoint location was saved, we'd have overwritten blocks
* still referenced by checkpoints in the system.) In summary, there is
* a second step: after our caller saves the checkpoint information, we
* are called to add the newly available blocks into the live system's
* available list.
*
* This function is the first step, the second step is in the resolve
* function.
*
* If we're called to checkpoint the same file twice (without the second
* resolution step), or re-entered for any reason, it's an error in our
* caller, and our choices are all bad: leak blocks or potentially crash
* with our caller not yet having saved previous checkpoint information
* to stable storage.
*/
__wt_spin_lock(session, &block->live_lock);
if (block->ckpt_inprogress)
ret = __wt_block_panic(session, EINVAL,
"%s: unexpected checkpoint ordering", block->name);
else
block->ckpt_inprogress = true;
__wt_spin_unlock(session, &block->live_lock);
WT_RET(ret);
/*
* Extents newly available as a result of deleting previous checkpoints
* are added to a list of extents. The list should be empty, but as
* described above, there is no "free the checkpoint information" call
* into the block manager; if there was an error in an upper level that
* resulted in some previous checkpoint never being resolved, the list
* may not be empty. We should have caught that with the "checkpoint
* in progress" test, but it doesn't cost us anything to be cautious.
*
* We free the checkpoint's allocation and discard extent lists as part
* of the resolution step, not because they're needed at that time, but
* because it's potentially a lot of work, and waiting allows the btree
* layer to continue eviction sooner. As for the checkpoint-available
* list, make sure they get cleaned out.
*/
__wt_block_extlist_free(session, &ci->ckpt_avail);
WT_RET(__wt_block_extlist_init(
session, &ci->ckpt_avail, "live", "ckpt_avail", true));
__wt_block_extlist_free(session, &ci->ckpt_alloc);
__wt_block_extlist_free(session, &ci->ckpt_discard);
/*
* To delete a checkpoint, we'll need checkpoint information for it and
* the subsequent checkpoint into which it gets rolled; read them from
* disk before we lock things down.
*/
deleting = false;
WT_CKPT_FOREACH(ckptbase, ckpt) {
if (F_ISSET(ckpt, WT_CKPT_FAKE) ||
!F_ISSET(ckpt, WT_CKPT_DELETE))
continue;
deleting = true;
/*
* Read the checkpoint and next checkpoint extent lists if we
* haven't already read them (we may have already read these
* extent blocks if there is more than one deleted checkpoint).
*/
if (ckpt->bpriv == NULL)
WT_ERR(__ckpt_extlist_read(session, block, ckpt));
for (next_ckpt = ckpt + 1;; ++next_ckpt)
if (!F_ISSET(next_ckpt, WT_CKPT_FAKE))
break;
/*
* The "next" checkpoint may be the live tree which has no
* extent blocks to read.
*/
if (next_ckpt->bpriv == NULL &&
!F_ISSET(next_ckpt, WT_CKPT_ADD))
WT_ERR(__ckpt_extlist_read(session, block, next_ckpt));
}
/*
* Failures are now fatal: we can't currently back out the merge of any
* deleted checkpoint extent lists into the live system's extent lists,
* so continuing after error would leave the live system's extent lists
* corrupted for any subsequent checkpoint (and potentially, should a
* subsequent checkpoint succeed, for recovery).
*/
fatal = true;
/*
* Hold a lock so the live extent lists and the file size can't change
* underneath us. I suspect we'll tighten this if checkpoints take too
* much time away from real work: we read the historic checkpoint
* information without a lock, but we could also merge and re-write the
* deleted and merged checkpoint information without a lock, except for
* the final merge of ranges into the live tree.
*/
__wt_spin_lock(session, &block->live_lock);
locked = true;
/*
* We've allocated our last page, update the checkpoint size. We need
* to calculate the live system's checkpoint size before merging
* checkpoint allocation and discard information from the checkpoints
* we're deleting, those operations change the underlying byte counts.
*/
ckpt_size = ci->ckpt_size;
ckpt_size += ci->alloc.bytes;
ckpt_size -= ci->discard.bytes;
/* Skip the additional processing if we aren't deleting checkpoints. */
if (!deleting)
goto live_update;
/*
* Delete any no-longer-needed checkpoints: we do this first as it frees
* blocks to the live lists, and the freed blocks will then be included
* when writing the live extent lists.
*/
WT_CKPT_FOREACH(ckptbase, ckpt) {
if (F_ISSET(ckpt, WT_CKPT_FAKE) ||
!F_ISSET(ckpt, WT_CKPT_DELETE))
continue;
#ifdef HAVE_VERBOSE
if (WT_VERBOSE_ISSET(session, WT_VERB_CHECKPOINT)) {
if (tmp == NULL)
WT_ERR(__wt_scr_alloc(session, 0, &tmp));
WT_ERR(__ckpt_string(
session, block, ckpt->raw.data, tmp));
__wt_verbose(session, WT_VERB_CHECKPOINT,
"%s: delete-checkpoint: %s: %s",
block->name, ckpt->name, (const char *)tmp->data);
}
#endif
/*
* Find the checkpoint into which we'll roll this checkpoint's
* blocks: it's the next real checkpoint in the list, and it
* better have been read in (if it's not the add slot).
*/
for (next_ckpt = ckpt + 1;; ++next_ckpt)
if (!F_ISSET(next_ckpt, WT_CKPT_FAKE))
break;
/*
* Set the from/to checkpoint structures, where the "to" value
* may be the live tree.
*/
a = ckpt->bpriv;
if (F_ISSET(next_ckpt, WT_CKPT_ADD))
b = &block->live;
else
b = next_ckpt->bpriv;
/*
* Free the root page: there's nothing special about this free,
* the root page is allocated using normal rules, that is, it
* may have been taken from the avail list, and was entered on
* the live system's alloc list at that time. We free it into
* the checkpoint's discard list, however, not the live system's
* list because it appears on the checkpoint's alloc list and so
* must be paired in the checkpoint.
*/
if (a->root_offset != WT_BLOCK_INVALID_OFFSET)
WT_ERR(__wt_block_insert_ext(session, block,
&a->discard, a->root_offset, a->root_size));
/*
* Free the blocks used to hold the "from" checkpoint's extent
* lists, including the avail list.
*/
WT_ERR(__ckpt_extlist_fblocks(session, block, &a->alloc));
WT_ERR(__ckpt_extlist_fblocks(session, block, &a->avail));
WT_ERR(__ckpt_extlist_fblocks(session, block, &a->discard));
/*
* Roll the "from" alloc and discard extent lists into the "to"
* checkpoint's lists.
*/
if (a->alloc.entries != 0)
WT_ERR(__wt_block_extlist_merge(
session, block, &a->alloc, &b->alloc));
if (a->discard.entries != 0)
WT_ERR(__wt_block_extlist_merge(
session, block, &a->discard, &b->discard));
/*
* If the "to" checkpoint is also being deleted, we're done with
* it, it's merged into some other checkpoint in the next loop.
* This means the extent lists may aggregate over a number of
* checkpoints, but that's OK, they're disjoint sets of ranges.
*/
if (F_ISSET(next_ckpt, WT_CKPT_DELETE))
continue;
/*
* Find blocks for re-use: wherever the "to" checkpoint's
* allocate and discard lists overlap, move the range to
* the live system's checkpoint available list.
*/
WT_ERR(__wt_block_extlist_overlap(session, block, b));
/*
* If we're updating the live system's information, we're done.
*/
if (F_ISSET(next_ckpt, WT_CKPT_ADD))
continue;
/*
* We have to write the "to" checkpoint's extent lists out in
* new blocks, and update its cookie.
*
* Free the blocks used to hold the "to" checkpoint's extent
* lists; don't include the avail list, it's not changing.
*/
WT_ERR(__ckpt_extlist_fblocks(session, block, &b->alloc));
WT_ERR(__ckpt_extlist_fblocks(session, block, &b->discard));
F_SET(next_ckpt, WT_CKPT_UPDATE);
}
/* Update checkpoints marked for update. */
WT_CKPT_FOREACH(ckptbase, ckpt)
if (F_ISSET(ckpt, WT_CKPT_UPDATE))
WT_ERR(__ckpt_update(
session, block, ckpt, ckpt->bpriv, false));
live_update:
/* Truncate the file if that's possible. */
WT_ERR(__wt_block_extlist_truncate(session, block, &ci->avail));
/* Update the final, added checkpoint based on the live system. */
WT_CKPT_FOREACH(ckptbase, ckpt)
if (F_ISSET(ckpt, WT_CKPT_ADD)) {
/*
* !!!
* Our caller wants the final checkpoint size. Setting
* the size here violates layering, but the alternative
* is a call for the btree layer to crack the checkpoint
* cookie into its components, and that's a fair amount
* of work.
*/
ckpt->ckpt_size = ckpt_size;
/*
* Set the rolling checkpoint size for the live system.
* The current size includes the current checkpoint's
* root page size (root pages are on the checkpoint's
* block allocation list as root pages are allocated
* with the usual block allocation functions). That's
* correct, but we don't want to include it in the size
* for the next checkpoint.
*/
ckpt_size -= ci->root_size;
/*
* Additionally, we had a bug for awhile where the live
* checkpoint size grew without bound. We can't sanity
* check the value, that would require walking the tree
* as part of the checkpoint. Bound any bug at the size
* of the file.
* It isn't practical to assert that the value is within
* bounds since databases created with older versions
* of WiredTiger (2.8.0) would likely see an error.
*/
ci->ckpt_size =
WT_MIN(ckpt_size, (uint64_t)block->size);
WT_ERR(__ckpt_update(session, block, ckpt, ci, true));
}
/*
* Reset the live system's alloc and discard extent lists, leave the
* avail list alone. This includes freeing a lot of extents, so do it
* outside of the system's lock by copying and resetting the original,
* then doing the work later.
*/
ci->ckpt_alloc = ci->alloc;
WT_ERR(__wt_block_extlist_init(
session, &ci->alloc, "live", "alloc", false));
ci->ckpt_discard = ci->discard;
WT_ERR(__wt_block_extlist_init(
session, &ci->discard, "live", "discard", false));
#ifdef HAVE_DIAGNOSTIC
/*
* The first checkpoint in the system should always have an empty
* discard list. If we've read that checkpoint and/or created it,
* check.
*/
WT_CKPT_FOREACH(ckptbase, ckpt)
if (!F_ISSET(ckpt, WT_CKPT_DELETE))
break;
if ((a = ckpt->bpriv) == NULL)
a = &block->live;
if (a->discard.entries != 0)
WT_ERR_MSG(session, WT_ERROR,
"first checkpoint incorrectly has blocks on the discard "
"list");
#endif
err: if (ret != 0 && fatal)
ret = __wt_block_panic(session, ret,
"%s: fatal checkpoint failure", block->name);
if (locked)
__wt_spin_unlock(session, &block->live_lock);
/* Discard any checkpoint information we loaded. */
WT_CKPT_FOREACH(ckptbase, ckpt)
if ((ci = ckpt->bpriv) != NULL)
__wt_block_ckpt_destroy(session, ci);
__wt_scr_free(session, &tmp);
return (ret);
}