diff options
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.c | 666 |
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; +} |