/*
* __wt_update_alloc --
* Allocate a WT_UPDATE structure and associated value and fill it in.
*/
int
__wt_update_alloc(WT_SESSION_IMPL *session,
WT_ITEM *value, WT_UPDATE **updp, size_t *sizep)
{
WT_UPDATE *upd;
size_t size;
/*
* Allocate the WT_UPDATE structure and room for the value, then copy
* the value into place.
*/
size = value == NULL ? 0 : value->size;
WT_RET(__wt_calloc(session, 1, sizeof(WT_UPDATE) + size, &upd));
if (value == NULL)
WT_UPDATE_DELETED_SET(upd);
else {
upd->size = WT_STORE_SIZE(size);
memcpy(WT_UPDATE_DATA(upd), value->data, size);
}
*updp = upd;
if (sizep != NULL)
*sizep = sizeof(WT_UPDATE) + size;
return (0);
}
/*
* __wt_update_alloc --
* Allocate a WT_UPDATE structure and associated value from the session's
* buffer and fill it in.
*/
int
__wt_update_alloc(WT_SESSION_IMPL *session,
WT_ITEM *value, WT_UPDATE **updp, size_t *sizep)
{
WT_DECL_RET;
WT_UPDATE *upd;
size_t size;
/*
* Allocate the WT_UPDATE structure and room for the value, then copy
* the value into place.
*/
size = value == NULL ? 0 : value->size;
WT_RET(__wt_calloc(session, 1, sizeof(WT_UPDATE) + size, &upd));
if (value == NULL)
WT_UPDATE_DELETED_SET(upd);
else {
upd->size = WT_STORE_SIZE(size);
memcpy(WT_UPDATE_DATA(upd), value->data, size);
}
/*
* This must come last: after __wt_txn_modify succeeds, we must return
* a non-NULL upd so our callers can call __wt_txn_unmodify on any
* subsequent failure.
*/
if ((ret = __wt_txn_modify(session, &upd->txnid)) != 0) {
__wt_free(session, upd);
return (ret);
}
*updp = upd;
if (sizep != NULL)
*sizep = sizeof(WT_UPDATE) + size;
return (0);
}
/*
* __wt_delete_page_instantiate --
* Instantiate an entirely deleted row-store leaf page.
*/
int
__wt_delete_page_instantiate(WT_SESSION_IMPL *session, WT_REF *ref)
{
WT_BTREE *btree;
WT_DECL_RET;
WT_PAGE *page;
WT_PAGE_DELETED *page_del;
WT_UPDATE **upd_array, *upd;
size_t size;
uint32_t i;
btree = S2BT(session);
page = ref->page;
page_del = ref->page_del;
/*
* Give the page a modify structure.
*
* If the tree is already dirty and so will be written, mark the page
* dirty. (We'd like to free the deleted pages, but if the handle is
* read-only or if the application never modifies the tree, we're not
* able to do so.)
*/
if (btree->modified) {
WT_RET(__wt_page_modify_init(session, page));
__wt_page_modify_set(session, page);
}
/*
* An operation is accessing a "deleted" page, and we're building an
* in-memory version of the page (making it look like all entries in
* the page were individually updated by a remove operation). There
* are two cases where we end up here:
*
* First, a running transaction used a truncate call to delete the page
* without reading it, in which case the page reference includes a
* structure with a transaction ID; the page we're building might split
* in the future, so we update that structure to include references to
* all of the update structures we create, so the transaction can abort.
*
* Second, a truncate call deleted a page and the truncate committed,
* but an older transaction in the system forced us to keep the old
* version of the page around, then we crashed and recovered, and now
* we're being forced to read that page.
*
* In the first case, we have a page reference structure, in the second
* second, we don't.
*
* Allocate the per-reference update array; in the case of instantiating
* a page, deleted by a running transaction that might eventually abort,
* we need a list of the update structures so we can do that abort. The
* hard case is if a page splits: the update structures might be moved
* to different pages, and we still have to find them all for an abort.
*/
if (page_del != NULL)
WT_RET(__wt_calloc_def(
session, page->pg_row_entries + 1, &page_del->update_list));
/* Allocate the per-page update array. */
WT_ERR(__wt_calloc_def(session, page->pg_row_entries, &upd_array));
page->pg_row_upd = upd_array;
/*
* Fill in the per-reference update array with references to update
* structures, fill in the per-page update array with references to
* deleted items.
*/
for (i = 0, size = 0; i < page->pg_row_entries; ++i) {
WT_ERR(__wt_calloc_one(session, &upd));
WT_UPDATE_DELETED_SET(upd);
if (page_del == NULL)
upd->txnid = WT_TXN_NONE; /* Globally visible */
else {
upd->txnid = page_del->txnid;
page_del->update_list[i] = upd;
}
upd->next = upd_array[i];
upd_array[i] = upd;
size += sizeof(WT_UPDATE *) + WT_UPDATE_MEMSIZE(upd);
}
__wt_cache_page_inmem_incr(session, page, size);
return (0);
err: /*
* There's no need to free the page update structures on error, our
* caller will discard the page and do that work for us. We could
* similarly leave the per-reference update array alone because it
* won't ever be used by any page that's not in-memory, but cleaning
* it up makes sense, especially if we come back in to this function
* attempting to instantiate this page again.
*/
if (page_del != NULL)
__wt_free(session, page_del->update_list);
return (ret);
}