/*
* __ovfl_cache --
* Cache an overflow value.
*/
static int
__ovfl_cache(WT_SESSION_IMPL *session, WT_PAGE *page, WT_CELL_UNPACK *unpack)
{
WT_DECL_ITEM(tmp);
WT_DECL_RET;
WT_OVFL_TRACK *track;
/* Read the overflow value. */
WT_RET(__wt_scr_alloc(session, 1024, &tmp));
WT_ERR(__wt_dsk_cell_data_ref(session, page->type, unpack, tmp));
/* Allocating tracking structures as necessary. */
if (page->modify->ovfl_track == NULL)
WT_ERR(__wt_ovfl_track_init(session, page));
track = page->modify->ovfl_track;
/* Copy the overflow item into place. */
WT_ERR(__wt_realloc_def(session,
&track->remove_allocated, track->remove_next + 1, &track->remove));
track->remove[track->remove_next].cell = unpack->cell;
WT_ERR(__wt_memdup(session,
tmp->data, tmp->size, &track->remove[track->remove_next].data));
track->remove[track->remove_next].size = tmp->size;
++track->remove_next;
err: __wt_scr_free(session, &tmp);
return (ret);
}
/*
* __verify_dsk_row --
* Walk a WT_PAGE_ROW_INT or WT_PAGE_ROW_LEAF disk page and verify it.
*/
static int
__verify_dsk_row(
WT_SESSION_IMPL *session, const char *tag, const WT_PAGE_HEADER *dsk)
{
WT_BM *bm;
WT_BTREE *btree;
WT_CELL *cell;
WT_CELL_UNPACK *unpack, _unpack;
WT_DECL_ITEM(current);
WT_DECL_ITEM(last_ovfl);
WT_DECL_ITEM(last_pfx);
WT_DECL_RET;
WT_ITEM *last;
enum { FIRST, WAS_KEY, WAS_VALUE } last_cell_type;
void *huffman;
uint32_t cell_num, cell_type, i, key_cnt, prefix;
uint8_t *end;
int cmp;
btree = S2BT(session);
bm = btree->bm;
unpack = &_unpack;
huffman = dsk->type == WT_PAGE_ROW_INT ? NULL : btree->huffman_key;
WT_ERR(__wt_scr_alloc(session, 0, ¤t));
WT_ERR(__wt_scr_alloc(session, 0, &last_pfx));
WT_ERR(__wt_scr_alloc(session, 0, &last_ovfl));
last = last_ovfl;
end = (uint8_t *)dsk + dsk->mem_size;
last_cell_type = FIRST;
cell_num = 0;
key_cnt = 0;
WT_CELL_FOREACH(btree, dsk, cell, unpack, i) {
++cell_num;
/* Carefully unpack the cell. */
if (__wt_cell_unpack_safe(cell, unpack, end) != 0) {
ret = __err_cell_corrupted(session, cell_num, tag);
goto err;
}
/* Check the raw and collapsed cell types. */
WT_ERR(__err_cell_type(
session, cell_num, tag, unpack->raw, dsk->type));
WT_ERR(__err_cell_type(
session, cell_num, tag, unpack->type, dsk->type));
cell_type = unpack->type;
/*
* Check ordering relationships between the WT_CELL entries.
* For row-store internal pages, check for:
* two values in a row,
* two keys in a row,
* a value as the first cell on a page.
* For row-store leaf pages, check for:
* two values in a row,
* a value as the first cell on a page.
*/
switch (cell_type) {
case WT_CELL_KEY:
case WT_CELL_KEY_OVFL:
++key_cnt;
switch (last_cell_type) {
case FIRST:
case WAS_VALUE:
break;
case WAS_KEY:
if (dsk->type == WT_PAGE_ROW_LEAF)
break;
WT_ERR_VRFY(session,
"cell %" PRIu32 " on page at %s is the "
"first of two adjacent keys",
cell_num - 1, tag);
}
last_cell_type = WAS_KEY;
break;
case WT_CELL_ADDR_DEL:
case WT_CELL_ADDR_INT:
case WT_CELL_ADDR_LEAF:
case WT_CELL_ADDR_LEAF_NO:
case WT_CELL_VALUE:
case WT_CELL_VALUE_OVFL:
switch (last_cell_type) {
case FIRST:
WT_ERR_VRFY(session,
"page at %s begins with a value", tag);
case WAS_KEY:
break;
case WAS_VALUE:
WT_ERR_VRFY(session,
"cell %" PRIu32 " on page at %s is the "
"first of two adjacent values",
cell_num - 1, tag);
}
last_cell_type = WAS_VALUE;
break;
}
/* Check if any referenced item has a valid address. */
switch (cell_type) {
case WT_CELL_ADDR_DEL:
case WT_CELL_ADDR_INT:
case WT_CELL_ADDR_LEAF:
case WT_CELL_ADDR_LEAF_NO:
case WT_CELL_KEY_OVFL:
case WT_CELL_VALUE_OVFL:
if (!bm->addr_valid(bm,
session, unpack->data, unpack->size))
goto eof;
break;
}
/*
* Remaining checks are for key order and prefix compression.
* If this cell isn't a key, we're done, move to the next cell.
* If this cell is an overflow item, instantiate the key and
* compare it with the last key. Otherwise, we have to deal with
* prefix compression.
*/
switch (cell_type) {
case WT_CELL_KEY:
break;
case WT_CELL_KEY_OVFL:
WT_ERR(__wt_dsk_cell_data_ref(
session, dsk->type, unpack, current));
goto key_compare;
default:
/* Not a key -- continue with the next cell. */
continue;
}
/*
* Prefix compression checks.
*
* Confirm the first non-overflow key on a page has a zero
* prefix compression count.
*/
prefix = unpack->prefix;
if (last_pfx->size == 0 && prefix != 0)
WT_ERR_VRFY(session,
"the %" PRIu32 " key on page at %s is the first "
"non-overflow key on the page and has a non-zero "
"prefix compression value",
cell_num, tag);
/* Confirm the prefix compression count is possible. */
if (cell_num > 1 && prefix > last->size)
WT_ERR_VRFY(session,
"key %" PRIu32 " on page at %s has a prefix "
"compression count of %" PRIu32 ", larger than "
"the length of the previous key, %" WT_SIZET_FMT,
cell_num, tag, prefix, last->size);
/*
* If Huffman decoding required, unpack the cell to build the
* key, then resolve the prefix. Else, we can do it faster
* internally because we don't have to shuffle memory around as
* much.
*/
if (huffman != NULL) {
WT_ERR(__wt_dsk_cell_data_ref(
session, dsk->type, unpack, current));
/*
* If there's a prefix, make sure there's enough buffer
* space, then shift the decoded data past the prefix
* and copy the prefix into place. Take care with the
* pointers: current->data may be pointing inside the
* buffer.
*/
if (prefix != 0) {
WT_ERR(__wt_buf_grow(
session, current, prefix + current->size));
memmove((uint8_t *)current->mem + prefix,
current->data, current->size);
memcpy(current->mem, last->data, prefix);
current->data = current->mem;
current->size += prefix;
}
} else {
/*
* Get the cell's data/length and make sure we have
* enough buffer space.
*/
WT_ERR(__wt_buf_init(
session, current, prefix + unpack->size));
/* Copy the prefix then the data into place. */
if (prefix != 0)
memcpy(current->mem, last->data, prefix);
memcpy((uint8_t *)current->mem + prefix, unpack->data,
unpack->size);
current->size = prefix + unpack->size;
}
key_compare: /*
* Compare the current key against the last key.
*
* Be careful about the 0th key on internal pages: we only store
* the first byte and custom collators may not be able to handle
* truncated keys.
*/
if ((dsk->type == WT_PAGE_ROW_INT && cell_num > 3) ||
(dsk->type != WT_PAGE_ROW_INT && cell_num > 1)) {
WT_ERR(__wt_compare(
session, btree->collator, last, current, &cmp));
if (cmp >= 0)
WT_ERR_VRFY(session,
"the %" PRIu32 " and %" PRIu32 " keys on "
"page at %s are incorrectly sorted",
cell_num - 2, cell_num, tag);
}
/*
* Swap the buffers: last always references the last key entry,
* last_pfx and last_ovfl reference the last prefix-compressed
* and last overflow key entries. Current gets pointed to the
* buffer we're not using this time around, which is where the
* next key goes.
*/
last = current;
if (cell_type == WT_CELL_KEY) {
current = last_pfx;
last_pfx = last;
} else {
current = last_ovfl;
last_ovfl = last;
}
WT_ASSERT(session, last != current);
}
