diff options
Diffstat (limited to 'debian/htdig/htdig-3.2.0b6/db/hash_rec.c')
| -rw-r--r-- | debian/htdig/htdig-3.2.0b6/db/hash_rec.c | 1073 |
1 files changed, 1073 insertions, 0 deletions
diff --git a/debian/htdig/htdig-3.2.0b6/db/hash_rec.c b/debian/htdig/htdig-3.2.0b6/db/hash_rec.c new file mode 100644 index 00000000..d1d36c1a --- /dev/null +++ b/debian/htdig/htdig-3.2.0b6/db/hash_rec.c @@ -0,0 +1,1073 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 1996, 1997, 1998, 1999 + * 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. 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 "db_config.h" + +#ifndef lint +static const char sccsid[] = "@(#)hash_rec.c 11.12 (Sleepycat) 10/19/99"; +#endif /* not lint */ + +#ifndef NO_SYSTEM_INCLUDES +#include <sys/types.h> + +#include <errno.h> +#include <string.h> +#endif + +#include "db_int.h" +#include "db_page.h" +#include "db_shash.h" +#include "btree.h" +#include "hash.h" +#include "lock.h" +#include "log.h" +#include "mp.h" + +static int CDB___ham_alloc_pages __P((DB *, HMETA *, db_pgno_t, db_pgno_t)); +static int CDB___ham_free_pages __P((DB *, __ham_groupalloc_args *)); + +/* + * CDB___ham_insdel_recover -- + * + * PUBLIC: int CDB___ham_insdel_recover + * PUBLIC: __P((DB_ENV *, DBT *, DB_LSN *, int, void *)); + */ +int +CDB___ham_insdel_recover(dbenv, dbtp, lsnp, redo, info) + DB_ENV *dbenv; + DBT *dbtp; + DB_LSN *lsnp; + int redo; + void *info; +{ + __ham_insdel_args *argp; + DB *file_dbp; + DBC *dbc; + DB_MPOOLFILE *mpf; + PAGE *pagep; + u_int32_t op; + int cmp_n, cmp_p, getmeta, ret; + + COMPQUIET(info, NULL); + + getmeta = 0; + REC_PRINT(CDB___ham_insdel_print); + REC_INTRO(CDB___ham_insdel_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; + } + + if ((ret = CDB___ham_get_meta(dbc)) != 0) + goto out; + getmeta = 1; + + cmp_n = CDB_log_compare(lsnp, &LSN(pagep)); + cmp_p = CDB_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)) { + CDB___ham_putitem(pagep, &argp->key, + !redo || PAIR_ISKEYBIG(argp->opcode) ? + H_OFFPAGE : H_KEYDATA); + CDB___ham_putitem(pagep, &argp->data, + !redo || PAIR_ISDATABIG(argp->opcode) ? + H_OFFPAGE : H_KEYDATA); + } else + (void) CDB___ham_reputpair(pagep, file_dbp->pgsize, + argp->ndx, &argp->key, &argp->data); + + LSN(pagep) = redo ? *lsnp : argp->pagelsn; + if ((ret = CDB___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. */ + CDB___ham_dpair(file_dbp, pagep, argp->ndx); + LSN(pagep) = redo ? *lsnp : argp->pagelsn; + if ((ret = CDB___ham_put_page(file_dbp, (PAGE *)pagep, 1)) != 0) + goto out; + } else + if ((ret = CDB___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) + (void)CDB___ham_release_meta(dbc); + REC_CLOSE; +} + +/* + * CDB___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 CDB___ham_newpage_recover + * PUBLIC: __P((DB_ENV *, DBT *, DB_LSN *, int, void *)); + */ +int +CDB___ham_newpage_recover(dbenv, dbtp, lsnp, redo, info) + DB_ENV *dbenv; + DBT *dbtp; + DB_LSN *lsnp; + int redo; + void *info; +{ + __ham_newpage_args *argp; + DB *file_dbp; + DBC *dbc; + DB_MPOOLFILE *mpf; + PAGE *pagep; + int cmp_n, cmp_p, change, getmeta, ret; + + COMPQUIET(info, NULL); + + getmeta = 0; + REC_PRINT(CDB___ham_newpage_print); + REC_INTRO(CDB___ham_newpage_read, 1); + + if ((ret = CDB_memp_fget(mpf, &argp->new_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->new_pgno, + DB_MPOOL_CREATE, &pagep)) != 0) + goto out; + } + + if ((ret = CDB___ham_get_meta(dbc)) != 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 = CDB_log_compare(lsnp, &LSN(pagep)); + cmp_p = CDB_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 = CDB___ham_put_page(file_dbp, (PAGE *)pagep, 0)) != 0) + goto out; + } else { + LSN(pagep) = redo ? *lsnp : argp->pagelsn; + if ((ret = CDB___ham_put_page(file_dbp, (PAGE *)pagep, 1)) != 0) + goto out; + } + + /* Now do the prev page. */ +ppage: if (argp->prev_pgno != PGNO_INVALID) { + 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. + */ + 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); + 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 = + CDB___ham_put_page(file_dbp, (PAGE *)pagep, 0)) != 0) + goto out; + } else { + LSN(pagep) = redo ? *lsnp : argp->prevlsn; + if ((ret = + CDB___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) { + 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); + 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 = + CDB___ham_put_page(file_dbp, (PAGE *)pagep, 0)) != 0) + goto out; + } else { + LSN(pagep) = redo ? *lsnp : argp->nextlsn; + if ((ret = + CDB___ham_put_page(file_dbp, (PAGE *)pagep, 1)) != 0) + goto out; + } + } +done: *lsnp = argp->prev_lsn; + ret = 0; + +out: if (getmeta) + (void)CDB___ham_release_meta(dbc); + REC_CLOSE; +} + + +/* + * CDB___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 CDB___ham_replace_recover + * PUBLIC: __P((DB_ENV *, DBT *, DB_LSN *, int, void *)); + */ +int +CDB___ham_replace_recover(dbenv, dbtp, lsnp, redo, info) + DB_ENV *dbenv; + DBT *dbtp; + DB_LSN *lsnp; + int redo; + void *info; +{ + __ham_replace_args *argp; + DB *file_dbp; + DBC *dbc; + DB_MPOOLFILE *mpf; + DBT dbt; + PAGE *pagep; + int32_t grow; + int change, cmp_n, cmp_p, getmeta, ret; + u_int8_t *hk; + + COMPQUIET(info, NULL); + + getmeta = 0; + REC_PRINT(CDB___ham_replace_print); + REC_INTRO(CDB___ham_replace_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; + } + + if ((ret = CDB___ham_get_meta(dbc)) != 0) + goto out; + getmeta = 1; + + cmp_n = CDB_log_compare(lsnp, &LSN(pagep)); + cmp_p = CDB_log_compare(&LSN(pagep), &argp->pagelsn); + + memset(&dbt, 0, sizeof(dbt)); + 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) { + CDB___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 = CDB___ham_put_page(file_dbp, pagep, change)) != 0) + goto out; + +done: *lsnp = argp->prev_lsn; + ret = 0; + +out: if (getmeta) + (void)CDB___ham_release_meta(dbc); + REC_CLOSE; +} + +/* + * CDB___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 CDB___ham_newpgno_recover + * PUBLIC: __P((DB_ENV *, DBT *, DB_LSN *, int, void *)); + */ +int +CDB___ham_newpgno_recover(dbenv, dbtp, lsnp, redo, info) + DB_ENV *dbenv; + DBT *dbtp; + DB_LSN *lsnp; + int redo; + void *info; +{ + COMPQUIET(dbenv, NULL); + COMPQUIET(dbtp, NULL); + COMPQUIET(lsnp, NULL); + COMPQUIET(redo, 0); + COMPQUIET(info, NULL); + return (EINVAL); +} + +/* + * CDB___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 CDB___ham_splitmeta_recover + * PUBLIC: __P((DB_ENV *, DBT *, DB_LSN *, int, void *)); + */ +int +CDB___ham_splitmeta_recover(dbenv, dbtp, lsnp, redo, info) + DB_ENV *dbenv; + DBT *dbtp; + DB_LSN *lsnp; + int redo; + void *info; +{ + COMPQUIET(dbenv, NULL); + COMPQUIET(dbtp, NULL); + COMPQUIET(lsnp, NULL); + COMPQUIET(redo, 0); + COMPQUIET(info, NULL); + return (EINVAL); +} + +/* + * CDB___ham_splitdata_recover -- + * + * PUBLIC: int CDB___ham_splitdata_recover + * PUBLIC: __P((DB_ENV *, DBT *, DB_LSN *, int, void *)); + */ +int +CDB___ham_splitdata_recover(dbenv, dbtp, lsnp, redo, info) + DB_ENV *dbenv; + DBT *dbtp; + DB_LSN *lsnp; + int redo; + void *info; +{ + __ham_splitdata_args *argp; + DB *file_dbp; + DBC *dbc; + DB_MPOOLFILE *mpf; + PAGE *pagep; + int change, cmp_n, cmp_p, getmeta, ret; + + COMPQUIET(info, NULL); + + getmeta = 0; + REC_PRINT(CDB___ham_splitdata_print); + REC_INTRO(CDB___ham_splitdata_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; + } + + if ((ret = CDB___ham_get_meta(dbc)) != 0) + goto out; + getmeta = 1; + + cmp_n = CDB_log_compare(lsnp, &LSN(pagep)); + cmp_p = CDB_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 = CDB___ham_put_page(file_dbp, pagep, change)) != 0) + goto out; + +done: *lsnp = argp->prev_lsn; + ret = 0; + +out: if (getmeta) + (void)CDB___ham_release_meta(dbc); + REC_CLOSE; +} + +/* + * CDB___ham_ovfl_recover -- + * This message is generated when we initialize a set of overflow pages. + * + * PUBLIC: int CDB___ham_ovfl_recover + * PUBLIC: __P((DB_ENV *, DBT *, DB_LSN *, int, void *)); + */ +int +CDB___ham_ovfl_recover(dbenv, dbtp, lsnp, redo, info) + DB_ENV *dbenv; + DBT *dbtp; + DB_LSN *lsnp; + int redo; + void *info; +{ + COMPQUIET(dbenv, NULL); + COMPQUIET(dbtp, NULL); + COMPQUIET(lsnp, NULL); + COMPQUIET(redo, 0); + COMPQUIET(info, NULL); + return (EINVAL); +} + +/* + * CDB___ham_copypage_recover -- + * Recovery function for copypage. + * + * PUBLIC: int CDB___ham_copypage_recover + * PUBLIC: __P((DB_ENV *, DBT *, DB_LSN *, int, void *)); + */ +int +CDB___ham_copypage_recover(dbenv, dbtp, lsnp, redo, info) + DB_ENV *dbenv; + DBT *dbtp; + DB_LSN *lsnp; + int redo; + void *info; +{ + __ham_copypage_args *argp; + DB *file_dbp; + DBC *dbc; + DB_MPOOLFILE *mpf; + PAGE *pagep; + int cmp_n, cmp_p, getmeta, modified, ret; + + COMPQUIET(info, NULL); + + getmeta = 0; + REC_PRINT(CDB___ham_copypage_print); + REC_INTRO(CDB___ham_copypage_read, 1); + + if ((ret = CDB___ham_get_meta(dbc)) != 0) + goto out; + getmeta = 1; + modified = 0; + + /* This is the bucket page. */ + 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 donext; + } 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); + + 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, file_dbp->pgsize, argp->pgno, PGNO_INVALID, + argp->next_pgno, 0, P_HASH); + LSN(pagep) = argp->pagelsn; + modified = 1; + } + if ((ret = CDB_memp_fput(mpf, pagep, modified ? DB_MPOOL_DIRTY : 0)) != 0) + goto out; + +donext: /* Now fix up the "next" page. */ + 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. + */ + ret = 0; + goto do_nn; + } else if ((ret = CDB_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 = CDB_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 = CDB_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; + + if ((ret = CDB_memp_fget(mpf, &argp->nnext_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->nnext_pgno, + DB_MPOOL_CREATE, &pagep)) != 0) + goto out; + } + + cmp_n = CDB_log_compare(lsnp, &LSN(pagep)); + cmp_p = CDB_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 = CDB_memp_fput(mpf, pagep, modified ? DB_MPOOL_DIRTY : 0)) != 0) + goto out; + +done: *lsnp = argp->prev_lsn; + ret = 0; + +out: if (getmeta) + (void)CDB___ham_release_meta(dbc); + REC_CLOSE; +} + +/* + * CDB___ham_metagroup_recover -- + * Recovery function for metagroup. + * + * PUBLIC: int CDB___ham_metagroup_recover + * PUBLIC: __P((DB_ENV *, DBT *, DB_LSN *, int, void *)); + */ +int +CDB___ham_metagroup_recover(dbenv, dbtp, lsnp, redo, info) + DB_ENV *dbenv; + DBT *dbtp; + DB_LSN *lsnp; + int redo; + void *info; +{ + __ham_metagroup_args *argp; + HASH_CURSOR *hcp; + DB *file_dbp; + DBC *dbc; + DB_MPOOLFILE *mpf; + PAGE *pagep; + db_pgno_t last_pgno; + int cmp_n, cmp_p, groupgrow, modified, ret; + + COMPQUIET(info, NULL); + REC_PRINT(CDB___ham_metagroup_print); + REC_INTRO(CDB___ham_metagroup_read, 1); + + /* + * This logs the virtual create of pages pgno to pgno + bucket + * Since the mpool page-allocation is not really able to be + * transaction protected, we can never undo it. Even in an abort, + * we have to allocate these pages to the hash table. + * The log record contains: + * bucket: new bucket being allocated. + * pgno: page number of the new bucket. + * if bucket is a power of 2, then we allocated a whole batch of + * pages; if it's not, then we simply allocated one new page. + */ + groupgrow = + (u_int32_t)(1 << CDB___db_log2(argp->bucket + 1)) == argp->bucket + 1; + + last_pgno = argp->pgno; + if (groupgrow) + /* Read the last page. */ + last_pgno += argp->bucket; + + if ((ret = CDB_memp_fget(mpf, &last_pgno, DB_MPOOL_CREATE, &pagep)) != 0) + goto out; + + modified = 0; + cmp_n = CDB_log_compare(lsnp, &LSN(pagep)); + cmp_p = CDB_log_compare(&argp->pagelsn, &LSN(pagep)); + + if ((cmp_p == 0 && redo) || (cmp_n == 0 && !redo)) { + /* + * We need to make sure that we redo the allocation of the + * pages. + */ + if (redo) + pagep->lsn = *lsnp; + else + pagep->lsn = argp->pagelsn; + modified = 1; + } + if ((ret = CDB_memp_fput(mpf, pagep, modified ? DB_MPOOL_DIRTY : 0)) != 0) + goto out; + + /* Now we have to update the meta-data page. */ + hcp = dbc->internal; + if ((ret = CDB___ham_get_meta(dbc)) != 0) + goto out; + cmp_n = CDB_log_compare(lsnp, &hcp->hdr->dbmeta.lsn); + cmp_p = CDB_log_compare(&argp->metalsn, &hcp->hdr->dbmeta.lsn); + if ((cmp_p == 0 && redo) || (cmp_n == 0 && !redo)) { + if (redo) { + /* Redo the actual updating of bucket counts. */ + ++hcp->hdr->max_bucket; + if (groupgrow) { + hcp->hdr->low_mask = hcp->hdr->high_mask; + hcp->hdr->high_mask = + (argp->bucket + 1) | hcp->hdr->low_mask; + } + hcp->hdr->dbmeta.lsn = *lsnp; + } else { + /* Undo the actual updating of bucket counts. */ + --hcp->hdr->max_bucket; + if (groupgrow) { + hcp->hdr->high_mask = hcp->hdr->low_mask; + hcp->hdr->low_mask = hcp->hdr->high_mask >> 1; + } + hcp->hdr->dbmeta.lsn = argp->metalsn; + } + if (groupgrow && + hcp->hdr->spares[CDB___db_log2(argp->bucket + 1) + 1] == + PGNO_INVALID) + hcp->hdr->spares[CDB___db_log2(argp->bucket + 1) + 1] = + argp->pgno - argp->bucket - 1; + F_SET(hcp, H_DIRTY); + } + if ((ret = CDB___ham_release_meta(dbc)) != 0) + goto out; + +done: *lsnp = argp->prev_lsn; + ret = 0; + +out: REC_CLOSE; +} + +/* + * CDB___ham_groupalloc_recover -- + * Recover the batch creation of a set of pages for a new database. + * + * PUBLIC: int CDB___ham_groupalloc_recover + * PUBLIC: __P((DB_ENV *, DBT *, DB_LSN *, int, void *)); + */ +int +CDB___ham_groupalloc_recover(dbenv, dbtp, lsnp, redo, info) + DB_ENV *dbenv; + DBT *dbtp; + DB_LSN *lsnp; + int redo; + void *info; +{ + __ham_groupalloc_args *argp; + DBMETA *mmeta; + DB_MPOOLFILE *mpf; + DB *file_dbp; + DBC *dbc; + PAGE *pagep; + db_pgno_t pgno; + int cmp_n, cmp_p, modified, ret; + + modified = 0; + COMPQUIET(info, NULL); + REC_PRINT(CDB___ham_groupalloc_print); + REC_INTRO(CDB___ham_groupalloc_read, 0); + + if ((ret = CDB_memp_fget(mpf, &argp->pgno, 0, &pagep)) != 0) { + if (redo) { + /* Page should have existed. */ + (void)CDB___db_pgerr(file_dbp, argp->pgno); + goto out; + } else { + ret = 0; + goto done; + } + } + + cmp_n = CDB_log_compare(lsnp, &LSN(pagep)); + cmp_p = CDB_log_compare(&LSN(pagep), &argp->metalsn); + + if (cmp_p == 0 && redo) { + LSN(pagep) = *lsnp; + modified = 1; + } else if (cmp_n == 0 && !redo) { + LSN(pagep) = argp->metalsn; + modified = 1; + } + + /* + * Basically, we used mpool to allocate a chunk of pages. + * We need to either add those to a free list (in the undo + * case) or initialize them (in the redo case). + * + * If we are redoing and this is a hash subdatabase, it's possible + * that the pages were never allocated, so we'd better check for + * that and handle it here. + */ + if (redo) { + if ((ret = CDB___ham_alloc_pages(file_dbp, + (HMETA *)pagep, argp->start_pgno, argp->num)) != 0) + goto out1; + + /* Update the master meta data page LSN. */ + if (argp->pgno != PGNO_BASE_MD) { + pgno = PGNO_BASE_MD; + if ((ret = CDB_memp_fget(mpf, &pgno, 0, &mmeta)) != 0) + goto out1; + mmeta->lsn = *lsnp; + if ((ret = CDB_memp_fput(mpf, mmeta, DB_MPOOL_DIRTY)) != 0) + goto out1; + } + } + + /* + * If we are undoing and this is a subdatabase then we need to + * put the pages on the free list. If it's not a subdatabase, + * then we can simply do nothing because we're about to delete + * the file. + */ + if (!redo && argp->pgno != PGNO_BASE_MD) { + if ((ret = CDB___ham_free_pages(file_dbp, argp)) != 0) + goto out1; + LSN(pagep) = argp->metalsn; + modified = 1; + } + +out1: if ((ret = CDB_memp_fput(mpf, pagep, modified ? DB_MPOOL_DIRTY : 0)) != 0) + goto out; + +done: if (ret == 0) + *lsnp = argp->prev_lsn; + +out: REC_CLOSE; +} + +/* + * CDB___ham_free_pages -- + * + * Called during abort/undo of a file create. We create new pages in the file + * using the MPOOL_NEW_GROUP flag. We then log the meta-data page with a + * __crdel_metasub message. If we fail we need to take those newly allocated + * pages and put them on a free list. Normally this would happen in the + * recovery for CDB___db_new, but that doesn't get called in this case. + */ +static int +CDB___ham_free_pages(dbp, argp) + DB *dbp; + __ham_groupalloc_args *argp; +{ + DBMETA *mmeta; + DB_MPOOLFILE *mpf; + PAGE *pagep; + u_int32_t i; + db_pgno_t last_free, pgno; + int mod_meta, ret, t_ret; + + mod_meta = 0; + + /* Get the master meta-data page. */ + mpf = dbp->mpf; + pgno = PGNO_BASE_MD; + if ((ret = CDB_memp_fget(mpf, &pgno, 0, &mmeta)) != 0) + return (ret); + + last_free = mmeta->free; + + for (i = 0; i <= argp->num; i++) { + pgno = argp->start_pgno + i; + if ((ret = + CDB_memp_fget(mpf, &pgno, DB_MPOOL_CREATE, &pagep)) != 0) { + (void)CDB___db_pgerr(dbp, pgno); + goto out; + } + + /* Fix up the allocated page. */ + P_INIT(pagep, + dbp->pgsize, pgno, PGNO_INVALID, last_free, 0, P_INVALID); + ZERO_LSN(pagep->lsn); + + if ((ret = CDB_memp_fput(mpf, pagep, DB_MPOOL_DIRTY)) != 0) + goto out; + } + + mmeta->free = last_free; + mmeta->lsn = argp->mmetalsn; + mod_meta = 1; + +out: if ((t_ret = CDB_memp_fput(mpf, mmeta, mod_meta ? DB_MPOOL_DIRTY : 0)) != 0 + && ret == 0) + ret = t_ret; + + return (ret); +} + +/* + * CDB___ham_alloc_pages -- + * + * Called during redo of a file create. We create new pages in the file + * using the MPOOL_NEW_GROUP flag. We then log the meta-data page with a + * __crdel_metasub message. If we manage to crash without the newly written + * pages getting to disk (I'm not sure this can happen anywhere except our + * test suite?!), then we need to go through a recreate the final pages. + * Hash normally has holes in its files and handles them appropriately. + */ +static int +CDB___ham_alloc_pages(dbp, meta, start, npages) + DB *dbp; + HMETA *meta; + db_pgno_t start, npages; +{ + DB_MPOOLFILE *mpf; + PAGE *pagep; + db_pgno_t pgno; + int ret; + + mpf = dbp->mpf; + + /* Read the last page of the allocation. */ + pgno = meta->spares[0] + meta->max_bucket; + + /* If the page exists, and it has been initialized, then we're done. */ + if ((ret = CDB_memp_fget(mpf, &pgno, 0, &pagep)) == 0) { + if (pagep->type == P_INVALID && pagep->lsn.file == 0) + goto reinit_page; + if ((ret = CDB_memp_fput(mpf, pagep, 0)) != 0) + return (ret); + return (0); + } + + /* + * Had to create the page. On some systems (read "Windows"), + * you can find random garbage on pages to which you haven't + * yet written. So, we have an os layer that will do the + * right thing for group allocations. We call that directly + * to make sure all the pages are allocated and then continue + * merrily on our way with normal recovery. + */ + if ((ret = CDB___os_fpinit(&mpf->fh, start, npages, dbp->pgsize)) != 0) + return (ret); + + if ((ret = CDB_memp_fget(mpf, &pgno, DB_MPOOL_CREATE, &pagep)) != 0) { + (void)CDB___db_pgerr(dbp, pgno); + return (ret); + } + +reinit_page: + /* Initialize the newly allocated page. */ + P_INIT(pagep, + dbp->pgsize, pgno, PGNO_INVALID, PGNO_INVALID, 0, P_HASH); + ZERO_LSN(pagep->lsn); + + if ((ret = CDB_memp_fput(mpf, pagep, DB_MPOOL_DIRTY)) != 0) + return (ret); + + return (0); +} |