/*
* __ckpt_update --
* Update a checkpoint.
*/
static int
__ckpt_update(WT_SESSION_IMPL *session,
WT_BLOCK *block, WT_CKPT *ckpt, WT_BLOCK_CKPT *ci, bool is_live)
{
WT_DECL_ITEM(tmp);
WT_DECL_RET;
uint8_t *endp;
#ifdef HAVE_DIAGNOSTIC
/* Check the extent list combinations for overlaps. */
WT_RET(__wt_block_extlist_check(session, &ci->alloc, &ci->avail));
WT_RET(__wt_block_extlist_check(session, &ci->discard, &ci->avail));
WT_RET(__wt_block_extlist_check(session, &ci->alloc, &ci->discard));
#endif
/*
* Write the checkpoint's alloc and discard extent lists. After each
* write, remove any allocated blocks from the system's allocation
* list, checkpoint extent blocks don't appear on any extent lists.
*/
WT_RET(__wt_block_extlist_write(session, block, &ci->alloc, NULL));
WT_RET(__wt_block_extlist_write(session, block, &ci->discard, NULL));
/*
* We only write an avail list for the live system, other checkpoint's
* avail lists are static and never change.
*
* Write the avail list last so it reflects changes due to allocating
* blocks for the alloc and discard lists. Second, when we write the
* live system's avail list, it's two lists: the current avail list
* plus the list of blocks to be made available when the new checkpoint
* completes. We can't merge that second list into the real list yet,
* it's not truly available until the new checkpoint locations have been
* saved to the metadata.
*/
if (is_live)
WT_RET(__wt_block_extlist_write(
session, block, &ci->avail, &ci->ckpt_avail));
/*
* Set the file size for the live system.
*
* !!!
* We do NOT set the file size when re-writing checkpoints because we
* want to test the checkpoint's blocks against a reasonable maximum
* file size during verification. This is bad: imagine a checkpoint
* appearing early in the file, re-written, and then the checkpoint
* requires blocks at the end of the file, blocks after the listed file
* size. If the application opens that checkpoint for writing
* (discarding subsequent checkpoints), we would truncate the file to
* the early chunk, discarding the re-written checkpoint information.
* The alternative, updating the file size has its own problems, in
* that case we'd work correctly, but we'd lose all of the blocks
* between the original checkpoint and the re-written checkpoint.
* Currently, there's no API to roll-forward intermediate checkpoints,
* if there ever is, this will need to be fixed.
*/
if (is_live)
ci->file_size = block->size;
/*
* Copy the checkpoint information into the checkpoint array's address
* cookie.
*/
WT_RET(__wt_buf_init(session, &ckpt->raw, WT_BTREE_MAX_ADDR_COOKIE));
endp = ckpt->raw.mem;
WT_RET(__wt_block_ckpt_to_buffer(session, block, &endp, ci));
ckpt->raw.size = WT_PTRDIFF(endp, ckpt->raw.mem);
if (WT_VERBOSE_ISSET(session, WT_VERB_CHECKPOINT)) {
WT_RET(__wt_scr_alloc(session, 0, &tmp));
WT_ERR(__ckpt_string(session, block, ckpt->raw.data, tmp));
__wt_verbose(session, WT_VERB_CHECKPOINT,
"%s: create-checkpoint: %s: %s",
block->name, ckpt->name, (const char *)tmp->data);
}
err: __wt_scr_free(session, &tmp);
return (ret);
}
/*
* __snapshot_update --
* Update a snapshot.
*/
static int
__snapshot_update(
WT_SESSION_IMPL *session, WT_BLOCK *block, WT_SNAPSHOT *snap,
WT_BLOCK_SNAPSHOT *si, uint64_t snapshot_size, int is_live)
{
WT_DECL_ITEM(tmp);
WT_DECL_RET;
uint8_t *endp;
#ifdef HAVE_DIAGNOSTIC
/* Check the extent list combinations for overlaps. */
WT_RET(__wt_block_extlist_check(session, &si->alloc, &si->avail));
WT_RET(__wt_block_extlist_check(session, &si->discard, &si->avail));
WT_RET(__wt_block_extlist_check(session, &si->alloc, &si->discard));
#endif
/*
* Write the snapshot's extent lists; we only write an avail list for
* the live system, other snapshot's avail lists are static and never
* change. When we do write the avail list for the live system it's
* two lists: the current avail list plus the list of blocks that are
* being made available as of the new snapshot. We can't merge that
* second list into the real list yet, it's not truly available until
* the new snapshot location has been saved to the metadata.
*/
WT_RET(__wt_block_extlist_write(session, block, &si->alloc, NULL));
if (is_live)
WT_RET(__wt_block_extlist_write(
session, block, &si->avail, &si->snapshot_avail));
WT_RET(__wt_block_extlist_write(session, block, &si->discard, NULL));
/*
* Set the file size for the live system.
*
* XXX
* We do NOT set the file size when re-writing snapshots because we want
* to test the snapshot's blocks against a reasonable maximum file size
* during verification. This is not good: imagine a snapshot appearing
* early in the file, re-written, and then the snapshot requires blocks
* at the end of the file, blocks after the listed file size. If the
* application opens that snapshot for writing (discarding subsequent
* snapshots), we would truncate the file to the early chunk, discarding
* the re-written snapshot information. The alternative, updating the
* file size has its own problems, in that case we'd work correctly, but
* we'd lose all of the blocks between the original snapshot and the
* re-written snapshot. Currently, there's no API to roll-forward
* intermediate snapshots, if there ever is, this will need to be fixed.
*/
if (is_live)
WT_RET(__wt_filesize(session, block->fh, &si->file_size));
/* Set the snapshot size for the live system. */
if (is_live)
si->snapshot_size = snapshot_size;
/*
* Copy the snapshot information into the snapshot array's address
* cookie.
*/
WT_RET(__wt_buf_init(session, &snap->raw, WT_BTREE_MAX_ADDR_COOKIE));
endp = snap->raw.mem;
WT_RET(__wt_block_snapshot_to_buffer(session, block, &endp, si));
snap->raw.size = WT_PTRDIFF32(endp, snap->raw.mem);
if (WT_VERBOSE_ISSET(session, snapshot)) {
WT_RET(__wt_scr_alloc(session, 0, &tmp));
WT_ERR(__snapshot_string(session, block, snap->raw.data, tmp));
WT_VERBOSE_ERR(session, snapshot,
"%s: create-snapshot: %s: %s",
block->name, snap->name, (char *)tmp->data);
}
err: __wt_scr_free(&tmp);
return (ret);
}
