summaryrefslogtreecommitdiffstats
path: root/debian/htdig/htdig-3.2.0b6/db/db_rec.c
diff options
context:
space:
mode:
Diffstat (limited to 'debian/htdig/htdig-3.2.0b6/db/db_rec.c')
-rw-r--r--debian/htdig/htdig-3.2.0b6/db/db_rec.c666
1 files changed, 666 insertions, 0 deletions
diff --git a/debian/htdig/htdig-3.2.0b6/db/db_rec.c b/debian/htdig/htdig-3.2.0b6/db/db_rec.c
new file mode 100644
index 00000000..b2dcf3a5
--- /dev/null
+++ b/debian/htdig/htdig-3.2.0b6/db/db_rec.c
@@ -0,0 +1,666 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 1996, 1997, 1998, 1999
+ * Sleepycat Software. All rights reserved.
+ */
+
+#include "db_config.h"
+
+#ifndef lint
+static const char sccsid[] = "@(#)db_rec.c 11.4 (Sleepycat) 9/22/99";
+#endif /* not lint */
+
+#ifndef NO_SYSTEM_INCLUDES
+#include <sys/types.h>
+
+#include <string.h>
+#endif
+
+#include "db_int.h"
+#include "db_page.h"
+#include "log.h"
+#include "hash.h"
+
+/*
+ * PUBLIC: int CDB___db_addrem_recover
+ * PUBLIC: __P((DB_ENV *, DBT *, DB_LSN *, int, void *));
+ *
+ * This log message is generated whenever we add or remove a duplicate
+ * to/from a duplicate page. On recover, we just do the opposite.
+ */
+int
+CDB___db_addrem_recover(dbenv, dbtp, lsnp, redo, info)
+ DB_ENV *dbenv;
+ DBT *dbtp;
+ DB_LSN *lsnp;
+ int redo;
+ void *info;
+{
+ __db_addrem_args *argp;
+ DB *file_dbp;
+ DBC *dbc;
+ DB_MPOOLFILE *mpf;
+ PAGE *pagep;
+ u_int32_t change;
+ int cmp_n, cmp_p, ret;
+
+ COMPQUIET(info, NULL);
+ REC_PRINT(CDB___db_addrem_print);
+ REC_INTRO(CDB___db_addrem_read, 1);
+
+ if ((ret = CDB_memp_fget(mpf, &argp->pgno, 0, &pagep)) != 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 = CDB_memp_fget(mpf,
+ &argp->pgno, DB_MPOOL_CREATE, &pagep)) != 0)
+ goto out;
+ }
+
+ cmp_n = CDB_log_compare(lsnp, &LSN(pagep));
+ cmp_p = CDB_log_compare(&LSN(pagep), &argp->pagelsn);
+ change = 0;
+ if ((cmp_p == 0 && redo && argp->opcode == DB_ADD_DUP) ||
+ (cmp_n == 0 && !redo && argp->opcode == DB_REM_DUP)) {
+
+ /* Need to redo an add, or undo a delete. */
+ if ((ret = CDB___db_pitem(dbc, pagep, argp->indx, argp->nbytes,
+ argp->hdr.size == 0 ? NULL : &argp->hdr,
+ argp->dbt.size == 0 ? NULL : &argp->dbt)) != 0)
+ goto out;
+
+ change = DB_MPOOL_DIRTY;
+
+ } else if ((cmp_n == 0 && !redo && argp->opcode == DB_ADD_DUP) ||
+ (cmp_p == 0 && redo && argp->opcode == DB_REM_DUP)) {
+ /* Need to undo an add, or redo a delete. */
+ if ((ret = CDB___db_ditem(dbc,
+ pagep, argp->indx, argp->nbytes)) != 0)
+ goto out;
+ change = DB_MPOOL_DIRTY;
+ }
+
+ if (change) {
+ if (redo)
+ LSN(pagep) = *lsnp;
+ else
+ LSN(pagep) = argp->pagelsn;
+ }
+
+ if ((ret = CDB_memp_fput(mpf, pagep, change)) != 0)
+ goto out;
+
+done: *lsnp = argp->prev_lsn;
+ ret = 0;
+
+out: REC_CLOSE;
+}
+
+/*
+ * PUBLIC: int CDB___db_split_recover __P((DB_ENV *, DBT *, DB_LSN *, int, void *));
+ */
+int
+CDB___db_split_recover(dbenv, dbtp, lsnp, redo, info)
+ DB_ENV *dbenv;
+ DBT *dbtp;
+ DB_LSN *lsnp;
+ int redo;
+ void *info;
+{
+ __db_split_args *argp;
+ DB *file_dbp;
+ DBC *dbc;
+ DB_MPOOLFILE *mpf;
+ PAGE *pagep;
+ int change, cmp_n, cmp_p, ret;
+
+ COMPQUIET(info, NULL);
+ REC_PRINT(CDB___db_split_print);
+ REC_INTRO(CDB___db_split_read, 1);
+
+ if ((ret = CDB_memp_fget(mpf, &argp->pgno, 0, &pagep)) != 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 = CDB_memp_fget(mpf,
+ &argp->pgno, DB_MPOOL_CREATE, &pagep)) != 0)
+ goto out;
+ }
+
+ /*
+ * 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 redo NEW messages
+ * and only undo OLD messages.
+ */
+
+ change = 0;
+ cmp_n = CDB_log_compare(lsnp, &LSN(pagep));
+ cmp_p = CDB_log_compare(&LSN(pagep), &argp->pagelsn);
+ if (cmp_p == 0 && redo) {
+ if (argp->opcode == DB_SPLITNEW) {
+ /* Need to redo the split described. */
+ memcpy(pagep,
+ argp->pageimage.data, argp->pageimage.size);
+ }
+ LSN(pagep) = *lsnp;
+ change = DB_MPOOL_DIRTY;
+ } else if (cmp_n == 0 && !redo) {
+ if (argp->opcode == DB_SPLITOLD) {
+ /* Put back the old image. */
+ memcpy(pagep,
+ argp->pageimage.data, argp->pageimage.size);
+ }
+ LSN(pagep) = argp->pagelsn;
+ change = DB_MPOOL_DIRTY;
+ }
+ if ((ret = CDB_memp_fput(mpf, pagep, change)) != 0)
+ goto out;
+
+done: *lsnp = argp->prev_lsn;
+ ret = 0;
+
+out: REC_CLOSE;
+}
+
+/*
+ * PUBLIC: int CDB___db_big_recover __P((DB_ENV *, DBT *, DB_LSN *, int, void *));
+ */
+int
+CDB___db_big_recover(dbenv, dbtp, lsnp, redo, info)
+ DB_ENV *dbenv;
+ DBT *dbtp;
+ DB_LSN *lsnp;
+ int redo;
+ void *info;
+{
+ __db_big_args *argp;
+ DB *file_dbp;
+ DBC *dbc;
+ DB_MPOOLFILE *mpf;
+ PAGE *pagep;
+ u_int32_t change;
+ int cmp_n, cmp_p, ret;
+
+ COMPQUIET(info, NULL);
+ REC_PRINT(CDB___db_big_print);
+ REC_INTRO(CDB___db_big_read, 1);
+
+ if ((ret = CDB_memp_fget(mpf, &argp->pgno, 0, &pagep)) != 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 = CDB_memp_fget(mpf,
+ &argp->pgno, DB_MPOOL_CREATE, &pagep)) != 0)
+ goto out;
+ }
+
+ /*
+ * There are three pages we need to check. The one on which we are
+ * adding data, the previous one whose next_pointer may have
+ * been updated, and the next one whose prev_pointer may have
+ * been updated.
+ */
+ cmp_n = CDB_log_compare(lsnp, &LSN(pagep));
+ cmp_p = CDB_log_compare(&LSN(pagep), &argp->pagelsn);
+ change = 0;
+ if ((cmp_p == 0 && redo && argp->opcode == DB_ADD_BIG) ||
+ (cmp_n == 0 && !redo && argp->opcode == DB_REM_BIG)) {
+ /* We are either redo-ing an add, or undoing a delete. */
+ P_INIT(pagep, file_dbp->pgsize, argp->pgno, argp->prev_pgno,
+ argp->next_pgno, 0, P_OVERFLOW);
+ OV_LEN(pagep) = argp->dbt.size;
+ OV_REF(pagep) = 1;
+ memcpy((u_int8_t *)pagep + P_OVERHEAD, argp->dbt.data,
+ argp->dbt.size);
+ PREV_PGNO(pagep) = argp->prev_pgno;
+ change = DB_MPOOL_DIRTY;
+ } else if ((cmp_n == 0 && !redo && argp->opcode == DB_ADD_BIG) ||
+ (cmp_p == 0 && redo && argp->opcode == DB_REM_BIG)) {
+ /*
+ * We are either undo-ing an add or redo-ing a delete.
+ * The page is about to be reclaimed in either case, so
+ * there really isn't anything to do here.
+ */
+ change = DB_MPOOL_DIRTY;
+ }
+ if (change)
+ LSN(pagep) = redo ? *lsnp : argp->pagelsn;
+
+ if ((ret = CDB_memp_fput(mpf, pagep, change)) != 0)
+ goto out;
+
+ /* Now check the previous page. */
+ppage: if (argp->prev_pgno != PGNO_INVALID) {
+ change = 0;
+ if ((ret = CDB_memp_fget(mpf, &argp->prev_pgno, 0, &pagep)) != 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.
+ */
+ *lsnp = argp->prev_lsn;
+ ret = 0;
+ goto npage;
+ } else
+ if ((ret = CDB_memp_fget(mpf, &argp->prev_pgno,
+ DB_MPOOL_CREATE, &pagep)) != 0)
+ goto out;
+ }
+
+ cmp_n = CDB_log_compare(lsnp, &LSN(pagep));
+ cmp_p = CDB_log_compare(&LSN(pagep), &argp->prevlsn);
+
+ if ((cmp_p == 0 && redo && argp->opcode == DB_ADD_BIG) ||
+ (cmp_n == 0 && !redo && argp->opcode == DB_REM_BIG)) {
+ /* Redo add, undo delete. */
+ NEXT_PGNO(pagep) = argp->pgno;
+ change = DB_MPOOL_DIRTY;
+ } else if ((cmp_n == 0 &&
+ !redo && argp->opcode == DB_ADD_BIG) ||
+ (cmp_p == 0 && redo && argp->opcode == DB_REM_BIG)) {
+ /* Redo delete, undo add. */
+ NEXT_PGNO(pagep) = argp->next_pgno;
+ change = DB_MPOOL_DIRTY;
+ }
+ if (change)
+ LSN(pagep) = redo ? *lsnp : argp->prevlsn;
+ if ((ret = CDB_memp_fput(mpf, pagep, change)) != 0)
+ goto out;
+ }
+
+ /* Now check the next page. Can only be set on a delete. */
+npage: if (argp->next_pgno != PGNO_INVALID) {
+ change = 0;
+ if ((ret = CDB_memp_fget(mpf, &argp->next_pgno, 0, &pagep)) != 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 = CDB_memp_fget(mpf, &argp->next_pgno,
+ DB_MPOOL_CREATE, &pagep)) != 0)
+ goto out;
+ }
+
+ cmp_n = CDB_log_compare(lsnp, &LSN(pagep));
+ cmp_p = CDB_log_compare(&LSN(pagep), &argp->nextlsn);
+ if (cmp_p == 0 && redo) {
+ PREV_PGNO(pagep) = PGNO_INVALID;
+ change = DB_MPOOL_DIRTY;
+ } else if (cmp_n == 0 && !redo) {
+ PREV_PGNO(pagep) = argp->pgno;
+ change = DB_MPOOL_DIRTY;
+ }
+ if (change)
+ LSN(pagep) = redo ? *lsnp : argp->nextlsn;
+ if ((ret = CDB_memp_fput(mpf, pagep, change)) != 0)
+ goto out;
+ }
+
+done: *lsnp = argp->prev_lsn;
+ ret = 0;
+
+out: REC_CLOSE;
+}
+
+/*
+ * CDB___db_ovref_recover --
+ * Recovery function for CDB___db_ovref().
+ *
+ * PUBLIC: int CDB___db_ovref_recover __P((DB_ENV *, DBT *, DB_LSN *, int, void *));
+ */
+int
+CDB___db_ovref_recover(dbenv, dbtp, lsnp, redo, info)
+ DB_ENV *dbenv;
+ DBT *dbtp;
+ DB_LSN *lsnp;
+ int redo;
+ void *info;
+{
+ __db_ovref_args *argp;
+ DB *file_dbp;
+ DBC *dbc;
+ DB_MPOOLFILE *mpf;
+ PAGE *pagep;
+ int modified, ret;
+
+ COMPQUIET(info, NULL);
+ REC_PRINT(CDB___db_ovref_print);
+ REC_INTRO(CDB___db_ovref_read, 1);
+
+ if ((ret = CDB_memp_fget(mpf, &argp->pgno, 0, &pagep)) != 0) {
+ (void)CDB___db_pgerr(file_dbp, argp->pgno);
+ goto out;
+ }
+
+ modified = 0;
+ if (CDB_log_compare(&LSN(pagep), &argp->lsn) == 0 && redo) {
+ /* Need to redo update described. */
+ OV_REF(pagep) += argp->adjust;
+
+ pagep->lsn = *lsnp;
+ modified = 1;
+ } else if (CDB_log_compare(lsnp, &LSN(pagep)) == 0 && !redo) {
+ /* Need to undo update described. */
+ OV_REF(pagep) -= argp->adjust;
+
+ pagep->lsn = argp->lsn;
+ modified = 1;
+ }
+ if ((ret = CDB_memp_fput(mpf, pagep, modified ? DB_MPOOL_DIRTY : 0)) != 0)
+ goto out;
+
+done: *lsnp = argp->prev_lsn;
+ ret = 0;
+
+out: REC_CLOSE;
+}
+
+/*
+ * CDB___db_relink_recover --
+ * Recovery function for relink.
+ *
+ * PUBLIC: int CDB___db_relink_recover
+ * PUBLIC: __P((DB_ENV *, DBT *, DB_LSN *, int, void *));
+ */
+int
+CDB___db_relink_recover(dbenv, dbtp, lsnp, redo, info)
+ DB_ENV *dbenv;
+ DBT *dbtp;
+ DB_LSN *lsnp;
+ int redo;
+ void *info;
+{
+ __db_relink_args *argp;
+ DB *file_dbp;
+ DBC *dbc;
+ DB_MPOOLFILE *mpf;
+ PAGE *pagep;
+ int cmp_n, cmp_p, modified, ret;
+
+ COMPQUIET(info, NULL);
+ REC_PRINT(CDB___db_relink_print);
+ REC_INTRO(CDB___db_relink_read, 1);
+
+ /*
+ * There are up to three pages we need to check -- the page, and the
+ * previous and next pages, if they existed. For a page add operation,
+ * the current page is the result of a split and is being recovered
+ * elsewhere, so all we need do is recover the next page.
+ */
+ if ((ret = CDB_memp_fget(mpf, &argp->pgno, 0, &pagep)) != 0) {
+ if (redo) {
+ (void)CDB___db_pgerr(file_dbp, argp->pgno);
+ goto out;
+ }
+ goto next2;
+ }
+ modified = 0;
+ if (argp->opcode == DB_ADD_PAGE)
+ goto next1;
+
+ if (CDB_log_compare(&LSN(pagep), &argp->lsn) == 0 && redo) {
+ /* Redo the relink. */
+ pagep->lsn = *lsnp;
+ modified = 1;
+ } else if (CDB_log_compare(lsnp, &LSN(pagep)) == 0 && !redo) {
+ /* Undo the relink. */
+ pagep->next_pgno = argp->next;
+ pagep->prev_pgno = argp->prev;
+
+ pagep->lsn = argp->lsn;
+ modified = 1;
+ }
+next1: if ((ret = CDB_memp_fput(mpf, pagep, modified ? DB_MPOOL_DIRTY : 0)) != 0)
+ goto out;
+
+next2: if ((ret = CDB_memp_fget(mpf, &argp->next, 0, &pagep)) != 0) {
+ if (redo) {
+ (void)CDB___db_pgerr(file_dbp, argp->next);
+ goto out;
+ }
+ goto prev;
+ }
+ modified = 0;
+ cmp_n = CDB_log_compare(lsnp, &LSN(pagep));
+ cmp_p = CDB_log_compare(&LSN(pagep), &argp->lsn_next);
+ if ((argp->opcode == DB_REM_PAGE && cmp_p == 0 && redo) ||
+ (argp->opcode == DB_ADD_PAGE && cmp_n == 0 && !redo)) {
+ /* Redo the remove or undo the add. */
+ pagep->prev_pgno = argp->prev;
+
+ pagep->lsn = *lsnp;
+ modified = 1;
+ } else if ((argp->opcode == DB_REM_PAGE && cmp_n == 0 && !redo) ||
+ (argp->opcode == DB_ADD_PAGE && cmp_p == 0 && redo)) {
+ /* Undo the remove or redo the add. */
+ pagep->prev_pgno = argp->pgno;
+
+ pagep->lsn = argp->lsn_next;
+ modified = 1;
+ }
+ if ((ret = CDB_memp_fput(mpf, pagep, modified ? DB_MPOOL_DIRTY : 0)) != 0)
+ goto out;
+ if (argp->opcode == DB_ADD_PAGE)
+ goto done;
+
+prev: if ((ret = CDB_memp_fget(mpf, &argp->prev, 0, &pagep)) != 0) {
+ if (redo) {
+ (void)CDB___db_pgerr(file_dbp, argp->prev);
+ goto out;
+ }
+ goto done;
+ }
+ modified = 0;
+ if (CDB_log_compare(&LSN(pagep), &argp->lsn_prev) == 0 && redo) {
+ /* Redo the relink. */
+ pagep->next_pgno = argp->next;
+
+ pagep->lsn = *lsnp;
+ modified = 1;
+ } else if (CDB_log_compare(lsnp, &LSN(pagep)) == 0 && !redo) {
+ /* Undo the relink. */
+ pagep->next_pgno = argp->pgno;
+
+ pagep->lsn = argp->lsn_prev;
+ modified = 1;
+ }
+ if ((ret = CDB_memp_fput(mpf, pagep, modified ? DB_MPOOL_DIRTY : 0)) != 0)
+ goto out;
+
+done: *lsnp = argp->prev_lsn;
+ ret = 0;
+
+out: REC_CLOSE;
+}
+
+/*
+ * PUBLIC: int CDB___db_addpage_recover
+ * PUBLIC: __P((DB_ENV *, DBT *, DB_LSN *, int, void *));
+ */
+int
+CDB___db_addpage_recover(dbenv, dbtp, lsnp, redo, info)
+ DB_ENV *dbenv;
+ DBT *dbtp;
+ DB_LSN *lsnp;
+ int redo;
+ void *info;
+{
+ __db_addpage_args *argp;
+ DB *file_dbp;
+ DBC *dbc;
+ DB_MPOOLFILE *mpf;
+ PAGE *pagep;
+ u_int32_t change;
+ int cmp_n, cmp_p, ret;
+
+ COMPQUIET(info, NULL);
+ REC_PRINT(CDB___db_addpage_print);
+ REC_INTRO(CDB___db_addpage_read, 1);
+
+ /*
+ * We need to check two pages: the old one and the new one onto
+ * which we're going to add duplicates. Do the old one first.
+ */
+ if ((ret = CDB_memp_fget(mpf, &argp->pgno, 0, &pagep)) != 0)
+ goto out;
+
+ change = 0;
+ cmp_n = CDB_log_compare(lsnp, &LSN(pagep));
+ cmp_p = CDB_log_compare(&LSN(pagep), &argp->lsn);
+ if (cmp_p == 0 && redo) {
+ NEXT_PGNO(pagep) = argp->nextpgno;
+
+ LSN(pagep) = *lsnp;
+ change = DB_MPOOL_DIRTY;
+ } else if (cmp_n == 0 && !redo) {
+ NEXT_PGNO(pagep) = PGNO_INVALID;
+
+ LSN(pagep) = argp->lsn;
+ change = DB_MPOOL_DIRTY;
+ }
+ if ((ret = CDB_memp_fput(mpf, pagep, change)) != 0)
+ goto out;
+
+ if ((ret = CDB_memp_fget(mpf, &argp->nextpgno, 0, &pagep)) != 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 = CDB_memp_fget(mpf,
+ &argp->nextpgno, DB_MPOOL_CREATE, &pagep)) != 0)
+ goto out;
+ }
+
+ change = 0;
+ cmp_n = CDB_log_compare(lsnp, &LSN(pagep));
+ cmp_p = CDB_log_compare(&LSN(pagep), &argp->nextlsn);
+ if (cmp_p == 0 && redo) {
+ PREV_PGNO(pagep) = argp->pgno;
+
+ LSN(pagep) = *lsnp;
+ change = DB_MPOOL_DIRTY;
+ } else if (cmp_n == 0 && !redo) {
+ PREV_PGNO(pagep) = PGNO_INVALID;
+
+ LSN(pagep) = argp->nextlsn;
+ change = DB_MPOOL_DIRTY;
+ }
+ if ((ret = CDB_memp_fput(mpf, pagep, change)) != 0)
+ goto out;
+
+done: *lsnp = argp->prev_lsn;
+ ret = 0;
+
+out: REC_CLOSE;
+}
+
+/*
+ * CDB___db_debug_recover --
+ * Recovery function for debug.
+ *
+ * PUBLIC: int CDB___db_debug_recover __P((DB_ENV *, DBT *, DB_LSN *, int, void *));
+ */
+int
+CDB___db_debug_recover(dbenv, dbtp, lsnp, redo, info)
+ DB_ENV *dbenv;
+ DBT *dbtp;
+ DB_LSN *lsnp;
+ int redo;
+ void *info;
+{
+ __db_debug_args *argp;
+ int ret;
+
+ COMPQUIET(redo, 0);
+ COMPQUIET(dbenv, NULL);
+ COMPQUIET(info, NULL);
+
+ REC_PRINT(CDB___db_debug_print);
+ REC_NOOP_INTRO(CDB___db_debug_read);
+
+ *lsnp = argp->prev_lsn;
+ ret = 0;
+
+ REC_NOOP_CLOSE;
+}
+
+/*
+ * CDB___db_noop_recover --
+ * Recovery function for noop.
+ *
+ * PUBLIC: int CDB___db_noop_recover __P((DB_ENV *, DBT *, DB_LSN *, int, void *));
+ */
+int
+CDB___db_noop_recover(dbenv, dbtp, lsnp, redo, info)
+ DB_ENV *dbenv;
+ DBT *dbtp;
+ DB_LSN *lsnp;
+ int redo;
+ void *info;
+{
+ __db_noop_args *argp;
+ DB *file_dbp;
+ DBC *dbc;
+ DB_MPOOLFILE *mpf;
+ PAGE *pagep;
+ u_int32_t change;
+ int cmp_n, cmp_p, ret;
+
+ COMPQUIET(info, NULL);
+ REC_PRINT(CDB___db_noop_print);
+ REC_INTRO(CDB___db_noop_read, 0);
+
+ if ((ret = CDB_memp_fget(mpf, &argp->pgno, 0, &pagep)) != 0)
+ goto out;
+
+ cmp_n = CDB_log_compare(lsnp, &LSN(pagep));
+ cmp_p = CDB_log_compare(&LSN(pagep), &argp->prevlsn);
+ change = 0;
+ if (cmp_p == 0 && redo) {
+ LSN(pagep) = *lsnp;
+ change = DB_MPOOL_DIRTY;
+ } else if (cmp_n == 0 && !redo) {
+ LSN(pagep) = argp->prevlsn;
+ change = DB_MPOOL_DIRTY;
+ }
+ ret = CDB_memp_fput(mpf, pagep, change);
+
+done: *lsnp = argp->prev_lsn;
+out: REC_CLOSE;
+}