You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1074 lines
28 KiB
1074 lines
28 KiB
3 years ago
|
/*-
|
||
|
|
* 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);
|
||
|
|
}
|