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