1N/A/*-
1N/A * See the file LICENSE for redistribution information.
1N/A *
1N/A * Copyright (c) 1996, 1997, 1998
1N/A * Sleepycat Software. All rights reserved.
1N/A */
1N/A/*
1N/A * Copyright (c) 1995, 1996
1N/A * Margo Seltzer. All rights reserved.
1N/A */
1N/A/*
1N/A * Copyright (c) 1995, 1996
1N/A * The President and Fellows of Harvard University. All rights reserved.
1N/A *
1N/A * This code is derived from software contributed to Berkeley by
1N/A * Margo Seltzer.
1N/A *
1N/A * Redistribution and use in source and binary forms, with or without
1N/A * modification, are permitted provided that the following conditions
1N/A * are met:
1N/A * 1. Redistributions of source code must retain the above copyright
1N/A * notice, this list of conditions and the following disclaimer.
1N/A * 2. Redistributions in binary form must reproduce the above copyright
1N/A * notice, this list of conditions and the following disclaimer in the
1N/A * documentation and/or other materials provided with the distribution.
1N/A * 3. All advertising materials mentioning features or use of this software
1N/A * must display the following acknowledgement:
1N/A * This product includes software developed by the University of
1N/A * California, Berkeley and its contributors.
1N/A * 4. Neither the name of the University nor the names of its contributors
1N/A * may be used to endorse or promote products derived from this software
1N/A * without specific prior written permission.
1N/A *
1N/A * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
1N/A * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
1N/A * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
1N/A * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
1N/A * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
1N/A * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
1N/A * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
1N/A * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
1N/A * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
1N/A * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
1N/A * SUCH DAMAGE.
1N/A */
1N/A
1N/A#include "config.h"
1N/A
1N/A#ifndef lint
1N/Astatic const char sccsid[] = "@(#)hash_rec.c 10.22 (Sleepycat) 10/21/98";
1N/A#endif /* not lint */
1N/A
1N/A#ifndef NO_SYSTEM_INCLUDES
1N/A#include <sys/types.h>
1N/A
1N/A#include <errno.h>
1N/A#include <string.h>
1N/A#endif
1N/A
1N/A#include "db_int.h"
1N/A#include "shqueue.h"
1N/A#include "db_page.h"
1N/A#include "hash.h"
1N/A#include "btree.h"
1N/A#include "log.h"
1N/A#include "common_ext.h"
1N/A
1N/A/*
1N/A * __ham_insdel_recover --
1N/A *
1N/A * PUBLIC: int __ham_insdel_recover
1N/A * PUBLIC: __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
1N/A */
1N/Aint
1N/A__ham_insdel_recover(logp, dbtp, lsnp, redo, info)
1N/A DB_LOG *logp;
1N/A DBT *dbtp;
1N/A DB_LSN *lsnp;
1N/A int redo;
1N/A void *info;
1N/A{
1N/A __ham_insdel_args *argp;
1N/A DB *file_dbp;
1N/A DBC *dbc;
1N/A HASH_CURSOR *hcp;
1N/A DB_MPOOLFILE *mpf;
1N/A PAGE *pagep;
1N/A u_int32_t op;
1N/A int cmp_n, cmp_p, getmeta, ret;
1N/A
1N/A getmeta = 0;
1N/A hcp = NULL;
1N/A REC_PRINT(__ham_insdel_print);
1N/A REC_INTRO(__ham_insdel_read);
1N/A hcp = (HASH_CURSOR *)dbc->internal;
1N/A
1N/A ret = memp_fget(mpf, &argp->pgno, 0, &pagep);
1N/A if (ret != 0)
1N/A if (!redo) {
1N/A /*
1N/A * We are undoing and the page doesn't exist. That
1N/A * is equivalent to having a pagelsn of 0, so we
1N/A * would not have to undo anything. In this case,
1N/A * don't bother creating a page.
1N/A */
1N/A goto done;
1N/A } else if ((ret = memp_fget(mpf, &argp->pgno,
1N/A DB_MPOOL_CREATE, &pagep)) != 0)
1N/A goto out;
1N/A
1N/A
1N/A GET_META(file_dbp, hcp, ret);
1N/A if (ret != 0)
1N/A goto out;
1N/A getmeta = 1;
1N/A
1N/A cmp_n = log_compare(lsnp, &LSN(pagep));
1N/A cmp_p = log_compare(&LSN(pagep), &argp->pagelsn);
1N/A /*
1N/A * Two possible things going on:
1N/A * redo a delete/undo a put: delete the item from the page.
1N/A * redo a put/undo a delete: add the item to the page.
1N/A * If we are undoing a delete, then the information logged is the
1N/A * entire entry off the page, not just the data of a dbt. In
1N/A * this case, we want to copy it back onto the page verbatim.
1N/A * We do this by calling __putitem with the type H_OFFPAGE instead
1N/A * of H_KEYDATA.
1N/A */
1N/A op = OPCODE_OF(argp->opcode);
1N/A
1N/A if ((op == DELPAIR && cmp_n == 0 && !redo) ||
1N/A (op == PUTPAIR && cmp_p == 0 && redo)) {
1N/A /*
1N/A * Need to redo a PUT or undo a delete. If we are undoing a
1N/A * delete, we've got to restore the item back to its original
1N/A * position. That's a royal pain in the butt (because we do
1N/A * not store item lengths on the page), but there's no choice.
1N/A */
1N/A if (op != DELPAIR ||
1N/A argp->ndx == (u_int32_t)H_NUMPAIRS(pagep)) {
1N/A __ham_putitem(pagep, &argp->key,
1N/A !redo || PAIR_ISKEYBIG(argp->opcode) ?
1N/A H_OFFPAGE : H_KEYDATA);
1N/A __ham_putitem(pagep, &argp->data,
1N/A !redo || PAIR_ISDATABIG(argp->opcode) ?
1N/A H_OFFPAGE : H_KEYDATA);
1N/A } else
1N/A (void) __ham_reputpair(pagep, hcp->hdr->pagesize,
1N/A argp->ndx, &argp->key, &argp->data);
1N/A
1N/A LSN(pagep) = redo ? *lsnp : argp->pagelsn;
1N/A if ((ret = __ham_put_page(file_dbp, pagep, 1)) != 0)
1N/A goto out;
1N/A
1N/A } else if ((op == DELPAIR && cmp_p == 0 && redo)
1N/A || (op == PUTPAIR && cmp_n == 0 && !redo)) {
1N/A /* Need to undo a put or redo a delete. */
1N/A __ham_dpair(file_dbp, pagep, argp->ndx);
1N/A LSN(pagep) = redo ? *lsnp : argp->pagelsn;
1N/A if ((ret = __ham_put_page(file_dbp, (PAGE *)pagep, 1)) != 0)
1N/A goto out;
1N/A } else
1N/A if ((ret = __ham_put_page(file_dbp, (PAGE *)pagep, 0)) != 0)
1N/A goto out;
1N/A
1N/A /* Return the previous LSN. */
1N/Adone: *lsnp = argp->prev_lsn;
1N/A ret = 0;
1N/A
1N/Aout: if (getmeta)
1N/A RELEASE_META(file_dbp, hcp);
1N/A REC_CLOSE;
1N/A}
1N/A
1N/A/*
1N/A * __ham_newpage_recover --
1N/A * This log message is used when we add/remove overflow pages. This
1N/A * message takes care of the pointer chains, not the data on the pages.
1N/A *
1N/A * PUBLIC: int __ham_newpage_recover
1N/A * PUBLIC: __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
1N/A */
1N/Aint
1N/A__ham_newpage_recover(logp, dbtp, lsnp, redo, info)
1N/A DB_LOG *logp;
1N/A DBT *dbtp;
1N/A DB_LSN *lsnp;
1N/A int redo;
1N/A void *info;
1N/A{
1N/A __ham_newpage_args *argp;
1N/A DB *file_dbp;
1N/A DBC *dbc;
1N/A HASH_CURSOR *hcp;
1N/A DB_MPOOLFILE *mpf;
1N/A PAGE *pagep;
1N/A int cmp_n, cmp_p, change, getmeta, ret;
1N/A
1N/A getmeta = 0;
1N/A hcp = NULL;
1N/A REC_PRINT(__ham_newpage_print);
1N/A REC_INTRO(__ham_newpage_read);
1N/A hcp = (HASH_CURSOR *)dbc->internal;
1N/A
1N/A ret = memp_fget(mpf, &argp->new_pgno, 0, &pagep);
1N/A if (ret != 0)
1N/A if (!redo) {
1N/A /*
1N/A * We are undoing and the page doesn't exist. That
1N/A * is equivalent to having a pagelsn of 0, so we
1N/A * would not have to undo anything. In this case,
1N/A * don't bother creating a page.
1N/A */
1N/A ret = 0;
1N/A goto ppage;
1N/A } else if ((ret = memp_fget(mpf, &argp->new_pgno,
1N/A DB_MPOOL_CREATE, &pagep)) != 0)
1N/A goto out;
1N/A
1N/A GET_META(file_dbp, (HASH_CURSOR *)dbc->internal, ret);
1N/A if (ret != 0)
1N/A goto out;
1N/A getmeta = 1;
1N/A
1N/A /*
1N/A * There are potentially three pages we need to check: the one
1N/A * that we created/deleted, the one before it and the one after
1N/A * it.
1N/A */
1N/A
1N/A cmp_n = log_compare(lsnp, &LSN(pagep));
1N/A cmp_p = log_compare(&LSN(pagep), &argp->pagelsn);
1N/A change = 0;
1N/A
1N/A if ((cmp_p == 0 && redo && argp->opcode == PUTOVFL) ||
1N/A (cmp_n == 0 && !redo && argp->opcode == DELOVFL)) {
1N/A /* Redo a create new page or undo a delete new page. */
1N/A P_INIT(pagep, file_dbp->pgsize, argp->new_pgno,
1N/A argp->prev_pgno, argp->next_pgno, 0, P_HASH);
1N/A change = 1;
1N/A } else if ((cmp_p == 0 && redo && argp->opcode == DELOVFL) ||
1N/A (cmp_n == 0 && !redo && argp->opcode == PUTOVFL)) {
1N/A /*
1N/A * Redo a delete or undo a create new page. All we
1N/A * really need to do is change the LSN.
1N/A */
1N/A change = 1;
1N/A }
1N/A
1N/A if (!change) {
1N/A if ((ret = __ham_put_page(file_dbp, (PAGE *)pagep, 0)) != 0)
1N/A goto out;
1N/A } else {
1N/A LSN(pagep) = redo ? *lsnp : argp->pagelsn;
1N/A if ((ret = __ham_put_page(file_dbp, (PAGE *)pagep, 1)) != 0)
1N/A goto out;
1N/A }
1N/A
1N/A /* Now do the prev page. */
1N/Appage: if (argp->prev_pgno != PGNO_INVALID) {
1N/A ret = memp_fget(mpf, &argp->prev_pgno, 0, &pagep);
1N/A
1N/A if (ret != 0)
1N/A if (!redo) {
1N/A /*
1N/A * We are undoing and the page doesn't exist.
1N/A * That is equivalent to having a pagelsn of 0,
1N/A * so we would not have to undo anything. In
1N/A * this case, don't bother creating a page.
1N/A */
1N/A ret = 0;
1N/A goto npage;
1N/A } else if ((ret =
1N/A memp_fget(mpf, &argp->prev_pgno,
1N/A DB_MPOOL_CREATE, &pagep)) != 0)
1N/A goto out;
1N/A
1N/A cmp_n = log_compare(lsnp, &LSN(pagep));
1N/A cmp_p = log_compare(&LSN(pagep), &argp->prevlsn);
1N/A change = 0;
1N/A
1N/A if ((cmp_p == 0 && redo && argp->opcode == PUTOVFL) ||
1N/A (cmp_n == 0 && !redo && argp->opcode == DELOVFL)) {
1N/A /* Redo a create new page or undo a delete new page. */
1N/A pagep->next_pgno = argp->new_pgno;
1N/A change = 1;
1N/A } else if ((cmp_p == 0 && redo && argp->opcode == DELOVFL) ||
1N/A (cmp_n == 0 && !redo && argp->opcode == PUTOVFL)) {
1N/A /* Redo a delete or undo a create new page. */
1N/A pagep->next_pgno = argp->next_pgno;
1N/A change = 1;
1N/A }
1N/A
1N/A if (!change) {
1N/A if ((ret =
1N/A __ham_put_page(file_dbp, (PAGE *)pagep, 0)) != 0)
1N/A goto out;
1N/A } else {
1N/A LSN(pagep) = redo ? *lsnp : argp->prevlsn;
1N/A if ((ret =
1N/A __ham_put_page(file_dbp, (PAGE *)pagep, 1)) != 0)
1N/A goto out;
1N/A }
1N/A }
1N/A
1N/A /* Now time to do the next page */
1N/Anpage: if (argp->next_pgno != PGNO_INVALID) {
1N/A ret = memp_fget(mpf, &argp->next_pgno, 0, &pagep);
1N/A
1N/A if (ret != 0)
1N/A if (!redo) {
1N/A /*
1N/A * We are undoing and the page doesn't exist.
1N/A * That is equivalent to having a pagelsn of 0,
1N/A * so we would not have to undo anything. In
1N/A * this case, don't bother creating a page.
1N/A */
1N/A goto done;
1N/A } else if ((ret =
1N/A memp_fget(mpf, &argp->next_pgno,
1N/A DB_MPOOL_CREATE, &pagep)) != 0)
1N/A goto out;
1N/A
1N/A cmp_n = log_compare(lsnp, &LSN(pagep));
1N/A cmp_p = log_compare(&LSN(pagep), &argp->nextlsn);
1N/A change = 0;
1N/A
1N/A if ((cmp_p == 0 && redo && argp->opcode == PUTOVFL) ||
1N/A (cmp_n == 0 && !redo && argp->opcode == DELOVFL)) {
1N/A /* Redo a create new page or undo a delete new page. */
1N/A pagep->prev_pgno = argp->new_pgno;
1N/A change = 1;
1N/A } else if ((cmp_p == 0 && redo && argp->opcode == DELOVFL) ||
1N/A (cmp_n == 0 && !redo && argp->opcode == PUTOVFL)) {
1N/A /* Redo a delete or undo a create new page. */
1N/A pagep->prev_pgno = argp->prev_pgno;
1N/A change = 1;
1N/A }
1N/A
1N/A if (!change) {
1N/A if ((ret =
1N/A __ham_put_page(file_dbp, (PAGE *)pagep, 0)) != 0)
1N/A goto out;
1N/A } else {
1N/A LSN(pagep) = redo ? *lsnp : argp->nextlsn;
1N/A if ((ret =
1N/A __ham_put_page(file_dbp, (PAGE *)pagep, 1)) != 0)
1N/A goto out;
1N/A }
1N/A }
1N/Adone: *lsnp = argp->prev_lsn;
1N/A ret = 0;
1N/A
1N/Aout: if (getmeta)
1N/A RELEASE_META(file_dbp, hcp);
1N/A REC_CLOSE;
1N/A}
1N/A
1N/A
1N/A/*
1N/A * __ham_replace_recover --
1N/A * This log message refers to partial puts that are local to a single
1N/A * page. You can think of them as special cases of the more general
1N/A * insdel log message.
1N/A *
1N/A * PUBLIC: int __ham_replace_recover
1N/A * PUBLIC: __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
1N/A */
1N/Aint
1N/A__ham_replace_recover(logp, dbtp, lsnp, redo, info)
1N/A DB_LOG *logp;
1N/A DBT *dbtp;
1N/A DB_LSN *lsnp;
1N/A int redo;
1N/A void *info;
1N/A{
1N/A __ham_replace_args *argp;
1N/A DB *file_dbp;
1N/A DBC *dbc;
1N/A HASH_CURSOR *hcp;
1N/A DB_MPOOLFILE *mpf;
1N/A DBT dbt;
1N/A PAGE *pagep;
1N/A int32_t grow;
1N/A int change, cmp_n, cmp_p, getmeta, ret;
1N/A u_int8_t *hk;
1N/A
1N/A getmeta = 0;
1N/A hcp = NULL;
1N/A REC_PRINT(__ham_replace_print);
1N/A REC_INTRO(__ham_replace_read);
1N/A hcp = (HASH_CURSOR *)dbc->internal;
1N/A
1N/A ret = memp_fget(mpf, &argp->pgno, 0, &pagep);
1N/A if (ret != 0)
1N/A if (!redo) {
1N/A /*
1N/A * We are undoing and the page doesn't exist. That
1N/A * is equivalent to having a pagelsn of 0, so we
1N/A * would not have to undo anything. In this case,
1N/A * don't bother creating a page.
1N/A */
1N/A goto done;
1N/A } else if ((ret = memp_fget(mpf, &argp->pgno,
1N/A DB_MPOOL_CREATE, &pagep)) != 0)
1N/A goto out;
1N/A
1N/A GET_META(file_dbp, (HASH_CURSOR *)dbc->internal, ret);
1N/A if (ret != 0)
1N/A goto out;
1N/A getmeta = 1;
1N/A
1N/A cmp_n = log_compare(lsnp, &LSN(pagep));
1N/A cmp_p = log_compare(&LSN(pagep), &argp->pagelsn);
1N/A
1N/A if (cmp_p == 0 && redo) {
1N/A change = 1;
1N/A /* Reapply the change as specified. */
1N/A dbt.data = argp->newitem.data;
1N/A dbt.size = argp->newitem.size;
1N/A grow = argp->newitem.size - argp->olditem.size;
1N/A LSN(pagep) = *lsnp;
1N/A } else if (cmp_n == 0 && !redo) {
1N/A change = 1;
1N/A /* Undo the already applied change. */
1N/A dbt.data = argp->olditem.data;
1N/A dbt.size = argp->olditem.size;
1N/A grow = argp->olditem.size - argp->newitem.size;
1N/A LSN(pagep) = argp->pagelsn;
1N/A } else {
1N/A change = 0;
1N/A grow = 0;
1N/A }
1N/A
1N/A if (change) {
1N/A __ham_onpage_replace(pagep,
1N/A file_dbp->pgsize, argp->ndx, argp->off, grow, &dbt);
1N/A if (argp->makedup) {
1N/A hk = P_ENTRY(pagep, argp->ndx);
1N/A if (redo)
1N/A HPAGE_PTYPE(hk) = H_DUPLICATE;
1N/A else
1N/A HPAGE_PTYPE(hk) = H_KEYDATA;
1N/A }
1N/A }
1N/A
1N/A if ((ret = __ham_put_page(file_dbp, pagep, change)) != 0)
1N/A goto out;
1N/A
1N/Adone: *lsnp = argp->prev_lsn;
1N/A ret = 0;
1N/A
1N/Aout: if (getmeta)
1N/A RELEASE_META(file_dbp, hcp);
1N/A REC_CLOSE;
1N/A}
1N/A
1N/A/*
1N/A * __ham_newpgno_recover --
1N/A * This log message is used when allocating or deleting an overflow
1N/A * page. It takes care of modifying the meta data.
1N/A *
1N/A * PUBLIC: int __ham_newpgno_recover
1N/A * PUBLIC: __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
1N/A */
1N/Aint
1N/A__ham_newpgno_recover(logp, dbtp, lsnp, redo, info)
1N/A DB_LOG *logp;
1N/A DBT *dbtp;
1N/A DB_LSN *lsnp;
1N/A int redo;
1N/A void *info;
1N/A{
1N/A __ham_newpgno_args *argp;
1N/A DB *file_dbp;
1N/A DBC *dbc;
1N/A HASH_CURSOR *hcp;
1N/A DB_MPOOLFILE *mpf;
1N/A PAGE *pagep;
1N/A int change, cmp_n, cmp_p, getmeta, ret;
1N/A
1N/A getmeta = 0;
1N/A hcp = NULL;
1N/A REC_PRINT(__ham_newpgno_print);
1N/A REC_INTRO(__ham_newpgno_read);
1N/A hcp = (HASH_CURSOR *)dbc->internal;
1N/A
1N/A GET_META(file_dbp, (HASH_CURSOR *)dbc->internal, ret);
1N/A if (ret != 0)
1N/A goto out;
1N/A getmeta = 1;
1N/A
1N/A /*
1N/A * There are two phases to the recovery here. First we need
1N/A * to update the meta data; then we need to update the page.
1N/A * We'll do the meta-data first.
1N/A */
1N/A cmp_n = log_compare(lsnp, &hcp->hdr->lsn);
1N/A cmp_p = log_compare(&hcp->hdr->lsn, &argp->metalsn);
1N/A
1N/A change = 0;
1N/A if ((cmp_p == 0 && redo && argp->opcode == ALLOCPGNO) ||
1N/A (cmp_n == 0 && !redo && argp->opcode == DELPGNO)) {
1N/A /* Need to redo an allocation or undo a deletion. */
1N/A hcp->hdr->last_freed = argp->free_pgno;
1N/A if (redo && argp->old_pgno != 0) /* Must be ALLOCPGNO */
1N/A hcp->hdr->spares[hcp->hdr->ovfl_point]++;
1N/A change = 1;
1N/A } else if (cmp_p == 0 && redo && argp->opcode == DELPGNO) {
1N/A /* Need to redo a deletion */
1N/A hcp->hdr->last_freed = argp->pgno;
1N/A change = 1;
1N/A } else if (cmp_n == 0 && !redo && argp->opcode == ALLOCPGNO) {
1N/A /* undo an allocation. */
1N/A if (argp->old_pgno == 0)
1N/A hcp->hdr->last_freed = argp->pgno;
1N/A else {
1N/A hcp->hdr->spares[hcp->hdr->ovfl_point]--;
1N/A hcp->hdr->last_freed = 0;
1N/A }
1N/A change = 1;
1N/A }
1N/A if (change) {
1N/A hcp->hdr->lsn = redo ? *lsnp : argp->metalsn;
1N/A F_SET(hcp, H_DIRTY);
1N/A }
1N/A
1N/A
1N/A /* Now check the newly allocated/freed page. */
1N/A ret = memp_fget(mpf, &argp->pgno, 0, &pagep);
1N/A
1N/A if (ret != 0)
1N/A if (!redo) {
1N/A /*
1N/A * We are undoing and the page doesn't exist. That
1N/A * is equivalent to having a pagelsn of 0, so we
1N/A * would not have to undo anything. In this case,
1N/A * don't bother creating a page.
1N/A */
1N/A goto done;
1N/A } else if ((ret = memp_fget(mpf, &argp->pgno,
1N/A DB_MPOOL_CREATE, &pagep)) != 0)
1N/A goto out;
1N/A
1N/A cmp_n = log_compare(lsnp, &LSN(pagep));
1N/A cmp_p = log_compare(&LSN(pagep), &argp->pagelsn);
1N/A
1N/A change = 0;
1N/A if (cmp_p == 0 && redo && argp->opcode == ALLOCPGNO) {
1N/A /* Need to redo an allocation. */
1N/A P_INIT(pagep, file_dbp->pgsize, argp->pgno, PGNO_INVALID,
1N/A PGNO_INVALID, 0, argp->new_type);
1N/A change = 1;
1N/A } else if (cmp_n == 0 && !redo && argp->opcode == DELPGNO) {
1N/A /* Undoing a delete. */
1N/A P_INIT(pagep, file_dbp->pgsize, argp->pgno, PGNO_INVALID,
1N/A argp->old_pgno, 0, argp->old_type);
1N/A change = 1;
1N/A } else if ((cmp_p == 0 && redo && argp->opcode == DELPGNO) ||
1N/A (cmp_n == 0 && !redo && argp->opcode == ALLOCPGNO)) {
1N/A /* Need to redo a deletion or undo an allocation. */
1N/A NEXT_PGNO(pagep) = argp->free_pgno;
1N/A TYPE(pagep) = P_INVALID;
1N/A change = 1;
1N/A }
1N/A if (change)
1N/A LSN(pagep) = redo ? *lsnp : argp->pagelsn;
1N/A
1N/A if ((ret = __ham_put_page(file_dbp, pagep, change)) != 0)
1N/A goto out;
1N/A
1N/Adone: *lsnp = argp->prev_lsn;
1N/A ret = 0;
1N/A
1N/Aout: if (getmeta)
1N/A RELEASE_META(file_dbp, hcp);
1N/A REC_CLOSE;
1N/A
1N/A}
1N/A
1N/A/*
1N/A * __ham_splitmeta_recover --
1N/A * This is the meta-data part of the split. Records the new and old
1N/A * bucket numbers and the new/old mask information.
1N/A *
1N/A * PUBLIC: int __ham_splitmeta_recover
1N/A * PUBLIC: __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
1N/A */
1N/Aint
1N/A__ham_splitmeta_recover(logp, dbtp, lsnp, redo, info)
1N/A DB_LOG *logp;
1N/A DBT *dbtp;
1N/A DB_LSN *lsnp;
1N/A int redo;
1N/A void *info;
1N/A{
1N/A __ham_splitmeta_args *argp;
1N/A DB *file_dbp;
1N/A DBC *dbc;
1N/A HASH_CURSOR *hcp;
1N/A DB_MPOOLFILE *mpf;
1N/A int change, cmp_n, cmp_p, getmeta, ret;
1N/A u_int32_t pow;
1N/A
1N/A getmeta = 0;
1N/A hcp = NULL;
1N/A REC_PRINT(__ham_splitmeta_print);
1N/A REC_INTRO(__ham_splitmeta_read);
1N/A hcp = (HASH_CURSOR *)dbc->internal;
1N/A
1N/A GET_META(file_dbp, (HASH_CURSOR *)dbc->internal, ret);
1N/A if (ret != 0)
1N/A goto out;
1N/A getmeta = 1;
1N/A
1N/A /*
1N/A * There are two phases to the recovery here. First we need
1N/A * to update the meta data; then we need to update the page.
1N/A * We'll do the meta-data first.
1N/A */
1N/A cmp_n = log_compare(lsnp, &hcp->hdr->lsn);
1N/A cmp_p = log_compare(&hcp->hdr->lsn, &argp->metalsn);
1N/A
1N/A change = 0;
1N/A if (cmp_p == 0 && redo) {
1N/A /* Need to redo the split information. */
1N/A hcp->hdr->max_bucket = argp->bucket + 1;
1N/A pow = __db_log2(hcp->hdr->max_bucket + 1);
1N/A if (pow > hcp->hdr->ovfl_point) {
1N/A hcp->hdr->spares[pow] =
1N/A hcp->hdr->spares[hcp->hdr->ovfl_point];
1N/A hcp->hdr->ovfl_point = pow;
1N/A }
1N/A if (hcp->hdr->max_bucket > hcp->hdr->high_mask) {
1N/A hcp->hdr->low_mask = hcp->hdr->high_mask;
1N/A hcp->hdr->high_mask =
1N/A hcp->hdr->max_bucket | hcp->hdr->low_mask;
1N/A }
1N/A change = 1;
1N/A } else if (cmp_n == 0 && !redo) {
1N/A /* Need to undo the split information. */
1N/A hcp->hdr->max_bucket = argp->bucket;
1N/A hcp->hdr->ovfl_point = argp->ovflpoint;
1N/A hcp->hdr->spares[hcp->hdr->ovfl_point] = argp->spares;
1N/A pow = 1 << __db_log2(hcp->hdr->max_bucket + 1);
1N/A hcp->hdr->high_mask = pow - 1;
1N/A hcp->hdr->low_mask = (pow >> 1) - 1;
1N/A change = 1;
1N/A }
1N/A if (change) {
1N/A hcp->hdr->lsn = redo ? *lsnp : argp->metalsn;
1N/A F_SET(hcp, H_DIRTY);
1N/A }
1N/A
1N/Adone: *lsnp = argp->prev_lsn;
1N/A ret = 0;
1N/A
1N/Aout: if (getmeta)
1N/A RELEASE_META(file_dbp, hcp);
1N/A REC_CLOSE;
1N/A}
1N/A
1N/A/*
1N/A * __ham_splitdata_recover --
1N/A *
1N/A * PUBLIC: int __ham_splitdata_recover
1N/A * PUBLIC: __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
1N/A */
1N/Aint
1N/A__ham_splitdata_recover(logp, dbtp, lsnp, redo, info)
1N/A DB_LOG *logp;
1N/A DBT *dbtp;
1N/A DB_LSN *lsnp;
1N/A int redo;
1N/A void *info;
1N/A{
1N/A __ham_splitdata_args *argp;
1N/A DB *file_dbp;
1N/A DBC *dbc;
1N/A HASH_CURSOR *hcp;
1N/A DB_MPOOLFILE *mpf;
1N/A PAGE *pagep;
1N/A int change, cmp_n, cmp_p, getmeta, ret;
1N/A
1N/A getmeta = 0;
1N/A hcp = NULL;
1N/A REC_PRINT(__ham_splitdata_print);
1N/A REC_INTRO(__ham_splitdata_read);
1N/A hcp = (HASH_CURSOR *)dbc->internal;
1N/A
1N/A ret = memp_fget(mpf, &argp->pgno, 0, &pagep);
1N/A if (ret != 0)
1N/A if (!redo) {
1N/A /*
1N/A * We are undoing and the page doesn't exist. That
1N/A * is equivalent to having a pagelsn of 0, so we
1N/A * would not have to undo anything. In this case,
1N/A * don't bother creating a page.
1N/A */
1N/A goto done;
1N/A } else if ((ret = memp_fget(mpf, &argp->pgno,
1N/A DB_MPOOL_CREATE, &pagep)) != 0)
1N/A goto out;
1N/A
1N/A GET_META(file_dbp, (HASH_CURSOR *)dbc->internal, ret);
1N/A if (ret != 0)
1N/A goto out;
1N/A getmeta = 1;
1N/A
1N/A cmp_n = log_compare(lsnp, &LSN(pagep));
1N/A cmp_p = log_compare(&LSN(pagep), &argp->pagelsn);
1N/A
1N/A /*
1N/A * There are two types of log messages here, one for the old page
1N/A * and one for the new pages created. The original image in the
1N/A * SPLITOLD record is used for undo. The image in the SPLITNEW
1N/A * is used for redo. We should never have a case where there is
1N/A * a redo operation and the SPLITOLD record is on disk, but not
1N/A * the SPLITNEW record. Therefore, we only have work to do when
1N/A * redo NEW messages and undo OLD messages, but we have to update
1N/A * LSNs in both cases.
1N/A */
1N/A change = 0;
1N/A if (cmp_p == 0 && redo) {
1N/A if (argp->opcode == SPLITNEW)
1N/A /* Need to redo the split described. */
1N/A memcpy(pagep, argp->pageimage.data,
1N/A argp->pageimage.size);
1N/A LSN(pagep) = *lsnp;
1N/A change = 1;
1N/A } else if (cmp_n == 0 && !redo) {
1N/A if (argp->opcode == SPLITOLD) {
1N/A /* Put back the old image. */
1N/A memcpy(pagep, argp->pageimage.data,
1N/A argp->pageimage.size);
1N/A } else
1N/A P_INIT(pagep, file_dbp->pgsize, argp->pgno,
1N/A PGNO_INVALID, PGNO_INVALID, 0, P_HASH);
1N/A LSN(pagep) = argp->pagelsn;
1N/A change = 1;
1N/A }
1N/A if ((ret = __ham_put_page(file_dbp, pagep, change)) != 0)
1N/A goto out;
1N/A
1N/Adone: *lsnp = argp->prev_lsn;
1N/A ret = 0;
1N/A
1N/Aout: if (getmeta)
1N/A RELEASE_META(file_dbp, hcp);
1N/A REC_CLOSE;
1N/A}
1N/A
1N/A/*
1N/A * __ham_ovfl_recover --
1N/A * This message is generated when we initialize a set of overflow pages.
1N/A *
1N/A * PUBLIC: int __ham_ovfl_recover
1N/A * PUBLIC: __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
1N/A */
1N/Aint
1N/A__ham_ovfl_recover(logp, dbtp, lsnp, redo, info)
1N/A DB_LOG *logp;
1N/A DBT *dbtp;
1N/A DB_LSN *lsnp;
1N/A int redo;
1N/A void *info;
1N/A{
1N/A __ham_ovfl_args *argp;
1N/A DB *file_dbp;
1N/A DBC *dbc;
1N/A HASH_CURSOR *hcp;
1N/A DB_MPOOLFILE *mpf;
1N/A PAGE *pagep;
1N/A db_pgno_t max_pgno, pgno;
1N/A int cmp_n, cmp_p, getmeta, ret;
1N/A
1N/A getmeta = 0;
1N/A hcp = NULL;
1N/A REC_PRINT(__ham_ovfl_print);
1N/A REC_INTRO(__ham_ovfl_read);
1N/A hcp = (HASH_CURSOR *)dbc->internal;
1N/A
1N/A GET_META(file_dbp, (HASH_CURSOR *)dbc->internal, ret);
1N/A if (ret != 0)
1N/A goto out;
1N/A getmeta = 1;
1N/A
1N/A cmp_n = log_compare(lsnp, &hcp->hdr->lsn);
1N/A cmp_p = log_compare(&hcp->hdr->lsn, &argp->metalsn);
1N/A
1N/A if (cmp_p == 0 && redo) {
1N/A /* Redo the allocation. */
1N/A hcp->hdr->last_freed = argp->start_pgno;
1N/A hcp->hdr->spares[argp->ovflpoint] += argp->npages;
1N/A hcp->hdr->lsn = *lsnp;
1N/A F_SET(hcp, H_DIRTY);
1N/A } else if (cmp_n == 0 && !redo) {
1N/A hcp->hdr->last_freed = argp->free_pgno;
1N/A hcp->hdr->spares[argp->ovflpoint] -= argp->npages;
1N/A hcp->hdr->lsn = argp->metalsn;
1N/A F_SET(hcp, H_DIRTY);
1N/A }
1N/A
1N/A max_pgno = argp->start_pgno + argp->npages - 1;
1N/A ret = 0;
1N/A for (pgno = argp->start_pgno; pgno <= max_pgno; pgno++) {
1N/A if ((ret = memp_fget(mpf, &pgno, 0, &pagep)) != 0) {
1N/A if (!redo) {
1N/A ret = 0;
1N/A continue;
1N/A }
1N/A if ((ret = memp_fget(mpf,
1N/A &pgno, DB_MPOOL_CREATE, &pagep)) != 0)
1N/A goto out;
1N/A }
1N/A if (redo && log_compare((const DB_LSN *)lsnp,
1N/A (const DB_LSN *)&LSN(pagep)) > 0) {
1N/A P_INIT(pagep, file_dbp->pgsize, pgno, PGNO_INVALID,
1N/A pgno == max_pgno ? argp->free_pgno : pgno + 1,
1N/A 0, P_HASH);
1N/A LSN(pagep) = *lsnp;
1N/A ret = __ham_put_page(file_dbp, pagep, 1);
1N/A } else if (!redo) {
1N/A ZERO_LSN(pagep->lsn);
1N/A ret = __ham_put_page(file_dbp, pagep, 1);
1N/A } else
1N/A ret = __ham_put_page(file_dbp, pagep, 0);
1N/A if (ret)
1N/A goto out;
1N/A }
1N/A
1N/Adone: *lsnp = argp->prev_lsn;
1N/A ret = 0;
1N/A
1N/Aout: if (getmeta)
1N/A RELEASE_META(file_dbp, hcp);
1N/A REC_CLOSE;
1N/A}
1N/A
1N/A/*
1N/A * __ham_copypage_recover --
1N/A * Recovery function for copypage.
1N/A *
1N/A * PUBLIC: int __ham_copypage_recover
1N/A * PUBLIC: __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
1N/A */
1N/Aint
1N/A__ham_copypage_recover(logp, dbtp, lsnp, redo, info)
1N/A DB_LOG *logp;
1N/A DBT *dbtp;
1N/A DB_LSN *lsnp;
1N/A int redo;
1N/A void *info;
1N/A{
1N/A __ham_copypage_args *argp;
1N/A DB *file_dbp;
1N/A DBC *dbc;
1N/A HASH_CURSOR *hcp;
1N/A DB_MPOOLFILE *mpf;
1N/A PAGE *pagep;
1N/A int cmp_n, cmp_p, getmeta, modified, ret;
1N/A
1N/A getmeta = 0;
1N/A hcp = NULL;
1N/A REC_PRINT(__ham_copypage_print);
1N/A REC_INTRO(__ham_copypage_read);
1N/A hcp = (HASH_CURSOR *)dbc->internal;
1N/A
1N/A GET_META(file_dbp, (HASH_CURSOR *)dbc->internal, ret);
1N/A if (ret != 0)
1N/A goto out;
1N/A getmeta = 1;
1N/A modified = 0;
1N/A
1N/A /* This is the bucket page. */
1N/A ret = memp_fget(mpf, &argp->pgno, 0, &pagep);
1N/A if (ret != 0)
1N/A if (!redo) {
1N/A /*
1N/A * We are undoing and the page doesn't exist. That
1N/A * is equivalent to having a pagelsn of 0, so we
1N/A * would not have to undo anything. In this case,
1N/A * don't bother creating a page.
1N/A */
1N/A ret = 0;
1N/A goto donext;
1N/A } else if ((ret = memp_fget(mpf, &argp->pgno,
1N/A DB_MPOOL_CREATE, &pagep)) != 0)
1N/A goto out;
1N/A
1N/A cmp_n = log_compare(lsnp, &LSN(pagep));
1N/A cmp_p = log_compare(&LSN(pagep), &argp->pagelsn);
1N/A
1N/A if (cmp_p == 0 && redo) {
1N/A /* Need to redo update described. */
1N/A memcpy(pagep, argp->page.data, argp->page.size);
1N/A LSN(pagep) = *lsnp;
1N/A modified = 1;
1N/A } else if (cmp_n == 0 && !redo) {
1N/A /* Need to undo update described. */
1N/A P_INIT(pagep, hcp->hdr->pagesize, argp->pgno, PGNO_INVALID,
1N/A argp->next_pgno, 0, P_HASH);
1N/A LSN(pagep) = argp->pagelsn;
1N/A modified = 1;
1N/A }
1N/A if ((ret = memp_fput(mpf, pagep, modified ? DB_MPOOL_DIRTY : 0)) != 0)
1N/A goto out;
1N/A
1N/A /* Now fix up the "next" page. */
1N/Adonext: ret = memp_fget(mpf, &argp->next_pgno, 0, &pagep);
1N/A if (ret != 0)
1N/A if (!redo) {
1N/A /*
1N/A * We are undoing and the page doesn't exist. That
1N/A * is equivalent to having a pagelsn of 0, so we
1N/A * would not have to undo anything. In this case,
1N/A * don't bother creating a page.
1N/A */
1N/A ret = 0;
1N/A goto do_nn;
1N/A } else if ((ret = memp_fget(mpf, &argp->next_pgno,
1N/A DB_MPOOL_CREATE, &pagep)) != 0)
1N/A goto out;
1N/A
1N/A /* There is nothing to do in the REDO case; only UNDO. */
1N/A
1N/A cmp_n = log_compare(lsnp, &LSN(pagep));
1N/A if (cmp_n == 0 && !redo) {
1N/A /* Need to undo update described. */
1N/A memcpy(pagep, argp->page.data, argp->page.size);
1N/A modified = 1;
1N/A }
1N/A if ((ret = memp_fput(mpf, pagep, modified ? DB_MPOOL_DIRTY : 0)) != 0)
1N/A goto out;
1N/A
1N/A /* Now fix up the next's next page. */
1N/Ado_nn: if (argp->nnext_pgno == PGNO_INVALID)
1N/A goto done;
1N/A
1N/A ret = memp_fget(mpf, &argp->nnext_pgno, 0, &pagep);
1N/A if (ret != 0)
1N/A if (!redo) {
1N/A /*
1N/A * We are undoing and the page doesn't exist. That
1N/A * is equivalent to having a pagelsn of 0, so we
1N/A * would not have to undo anything. In this case,
1N/A * don't bother creating a page.
1N/A */
1N/A goto done;
1N/A } else if ((ret = memp_fget(mpf, &argp->nnext_pgno,
1N/A DB_MPOOL_CREATE, &pagep)) != 0)
1N/A goto out;
1N/A
1N/A cmp_n = log_compare(lsnp, &LSN(pagep));
1N/A cmp_p = log_compare(&LSN(pagep), &argp->nnextlsn);
1N/A
1N/A if (cmp_p == 0 && redo) {
1N/A /* Need to redo update described. */
1N/A PREV_PGNO(pagep) = argp->pgno;
1N/A LSN(pagep) = *lsnp;
1N/A modified = 1;
1N/A } else if (cmp_n == 0 && !redo) {
1N/A /* Need to undo update described. */
1N/A PREV_PGNO(pagep) = argp->next_pgno;
1N/A LSN(pagep) = argp->nnextlsn;
1N/A modified = 1;
1N/A }
1N/A if ((ret = memp_fput(mpf, pagep, modified ? DB_MPOOL_DIRTY : 0)) != 0)
1N/A goto out;
1N/A
1N/Adone: *lsnp = argp->prev_lsn;
1N/A ret = 0;
1N/A
1N/Aout: if (getmeta)
1N/A RELEASE_META(file_dbp, hcp);
1N/A REC_CLOSE;
1N/A}