#include "db_config.h"
#include "db_int.h"
#include "dbinc/db_page.h"
#include "dbinc/db_verify.h"
#include "dbinc/db_am.h"
static int __db_vrfy_childinc __P((DBC *, VRFY_CHILDINFO *));
static int __db_vrfy_pageinfo_create __P((DB_ENV *, VRFY_PAGEINFO **));
int
__db_vrfy_dbinfo_create(dbenv, pgsize, vdpp)
DB_ENV *dbenv;
u_int32_t pgsize;
VRFY_DBINFO **vdpp;
{
DB *cdbp, *pgdbp, *pgset;
VRFY_DBINFO *vdp;
int ret;
vdp = NULL;
cdbp = pgdbp = pgset = NULL;
if ((ret = __os_calloc(NULL, 1, sizeof(VRFY_DBINFO), &vdp)) != 0)
goto err;
if ((ret = __db_create_internal(&cdbp, dbenv, 0)) != 0)
goto err;
if ((ret = __db_set_flags(cdbp, DB_DUP)) != 0)
goto err;
if ((ret = __db_set_pagesize(cdbp, pgsize)) != 0)
goto err;
if (TXN_ON(dbenv) &&
(ret = __db_set_flags(cdbp, DB_TXN_NOT_DURABLE)) != 0)
goto err;
if ((ret = __db_open(cdbp,
NULL, NULL, NULL, DB_BTREE, DB_CREATE, 0600, PGNO_BASE_MD)) != 0)
goto err;
if ((ret = __db_create_internal(&pgdbp, dbenv, 0)) != 0)
goto err;
if ((ret = __db_set_pagesize(pgdbp, pgsize)) != 0)
goto err;
if (TXN_ON(dbenv) &&
(ret = __db_set_flags(pgdbp, DB_TXN_NOT_DURABLE)) != 0)
goto err;
if ((ret = __db_open(pgdbp,
NULL, NULL, NULL, DB_BTREE, DB_CREATE, 0600, PGNO_BASE_MD)) != 0)
goto err;
if ((ret = __db_vrfy_pgset(dbenv, pgsize, &pgset)) != 0)
goto err;
LIST_INIT(&vdp->subdbs);
LIST_INIT(&vdp->activepips);
vdp->cdbp = cdbp;
vdp->pgdbp = pgdbp;
vdp->pgset = pgset;
*vdpp = vdp;
return (0);
err: if (cdbp != NULL)
(void)__db_close(cdbp, NULL, 0);
if (pgdbp != NULL)
(void)__db_close(pgdbp, NULL, 0);
if (vdp != NULL)
__os_free(dbenv, vdp);
return (ret);
}
int
__db_vrfy_dbinfo_destroy(dbenv, vdp)
DB_ENV *dbenv;
VRFY_DBINFO *vdp;
{
VRFY_CHILDINFO *c;
int t_ret, ret;
ret = 0;
while (LIST_FIRST(&vdp->activepips) != NULL)
if ((t_ret = __db_vrfy_putpageinfo(
dbenv, vdp, LIST_FIRST(&vdp->activepips))) != 0) {
if (ret == 0)
ret = t_ret;
break;
}
while ((c = LIST_FIRST(&vdp->subdbs)) != NULL) {
LIST_REMOVE(c, links);
__os_free(NULL, c);
}
if ((t_ret = __db_close(vdp->pgdbp, NULL, 0)) != 0)
ret = t_ret;
if ((t_ret = __db_close(vdp->cdbp, NULL, 0)) != 0 && ret == 0)
ret = t_ret;
if ((t_ret = __db_close(vdp->pgset, NULL, 0)) != 0 && ret == 0)
ret = t_ret;
if (vdp->extents != NULL)
__os_free(dbenv, vdp->extents);
__os_free(dbenv, vdp);
return (ret);
}
int
__db_vrfy_getpageinfo(vdp, pgno, pipp)
VRFY_DBINFO *vdp;
db_pgno_t pgno;
VRFY_PAGEINFO **pipp;
{
DB_ENV *dbenv;
DBT key, data;
DB *pgdbp;
VRFY_PAGEINFO *pip;
int ret;
LIST_FOREACH(pip, &vdp->activepips, links)
if (pip->pgno == pgno)
goto found;
pgdbp = vdp->pgdbp;
dbenv = pgdbp->dbenv;
memset(&key, 0, sizeof(DBT));
memset(&data, 0, sizeof(DBT));
F_SET(&data, DB_DBT_MALLOC);
key.data = &pgno;
key.size = sizeof(db_pgno_t);
if ((ret = __db_get(pgdbp, NULL, &key, &data, 0)) == 0) {
DB_ASSERT(dbenv, data.size == sizeof(VRFY_PAGEINFO));
pip = data.data;
LIST_INSERT_HEAD(&vdp->activepips, pip, links);
goto found;
} else if (ret != DB_NOTFOUND)
return (ret);
if ((ret = __db_vrfy_pageinfo_create(dbenv, &pip)) != 0)
return (ret);
LIST_INSERT_HEAD(&vdp->activepips, pip, links);
found: pip->pi_refcount++;
*pipp = pip;
return (0);
}
int
__db_vrfy_putpageinfo(dbenv, vdp, pip)
DB_ENV *dbenv;
VRFY_DBINFO *vdp;
VRFY_PAGEINFO *pip;
{
DBT key, data;
DB *pgdbp;
VRFY_PAGEINFO *p;
int ret;
if (--pip->pi_refcount > 0)
return (0);
pgdbp = vdp->pgdbp;
memset(&key, 0, sizeof(DBT));
memset(&data, 0, sizeof(DBT));
key.data = &pip->pgno;
key.size = sizeof(db_pgno_t);
data.data = pip;
data.size = sizeof(VRFY_PAGEINFO);
if ((ret = __db_put(pgdbp, NULL, &key, &data, 0)) != 0)
return (ret);
LIST_FOREACH(p, &vdp->activepips, links)
if (p == pip)
break;
if (p != NULL)
LIST_REMOVE(p, links);
__os_ufree(dbenv, p);
return (0);
}
int
__db_vrfy_pgset(dbenv, pgsize, dbpp)
DB_ENV *dbenv;
u_int32_t pgsize;
DB **dbpp;
{
DB *dbp;
int ret;
if ((ret = __db_create_internal(&dbp, dbenv, 0)) != 0)
return (ret);
if ((ret = __db_set_pagesize(dbp, pgsize)) != 0)
goto err;
if (TXN_ON(dbenv) &&
(ret = __db_set_flags(dbp, DB_TXN_NOT_DURABLE)) != 0)
goto err;
if ((ret = __db_open(dbp,
NULL, NULL, NULL, DB_BTREE, DB_CREATE, 0600, PGNO_BASE_MD)) == 0)
*dbpp = dbp;
else
err: (void)__db_close(dbp, NULL, 0);
return (ret);
}
int
__db_vrfy_pgset_get(dbp, pgno, valp)
DB *dbp;
db_pgno_t pgno;
int *valp;
{
DBT key, data;
int ret, val;
memset(&key, 0, sizeof(DBT));
memset(&data, 0, sizeof(DBT));
key.data = &pgno;
key.size = sizeof(db_pgno_t);
data.data = &val;
data.ulen = sizeof(int);
F_SET(&data, DB_DBT_USERMEM);
if ((ret = __db_get(dbp, NULL, &key, &data, 0)) == 0) {
DB_ASSERT(dbp->dbenv, data.size == sizeof(int));
} else if (ret == DB_NOTFOUND)
val = 0;
else
return (ret);
*valp = val;
return (0);
}
int
__db_vrfy_pgset_inc(dbp, pgno)
DB *dbp;
db_pgno_t pgno;
{
DBT key, data;
int ret;
int val;
memset(&key, 0, sizeof(DBT));
memset(&data, 0, sizeof(DBT));
val = 0;
key.data = &pgno;
key.size = sizeof(db_pgno_t);
data.data = &val;
data.ulen = sizeof(int);
F_SET(&data, DB_DBT_USERMEM);
if ((ret = __db_get(dbp, NULL, &key, &data, 0)) == 0) {
DB_ASSERT(dbp->dbenv, data.size == sizeof(int));
} else if (ret != DB_NOTFOUND)
return (ret);
data.size = sizeof(int);
++val;
return (__db_put(dbp, NULL, &key, &data, 0));
}
int
__db_vrfy_pgset_next(dbc, pgnop)
DBC *dbc;
db_pgno_t *pgnop;
{
DBT key, data;
db_pgno_t pgno;
int ret;
memset(&key, 0, sizeof(DBT));
memset(&data, 0, sizeof(DBT));
F_SET(&data, DB_DBT_USERMEM | DB_DBT_PARTIAL);
F_SET(&key, DB_DBT_USERMEM);
key.data = &pgno;
key.ulen = sizeof(db_pgno_t);
if ((ret = __dbc_get(dbc, &key, &data, DB_NEXT)) != 0)
return (ret);
DB_ASSERT(dbc->dbp->dbenv, key.size == sizeof(db_pgno_t));
*pgnop = pgno;
return (0);
}
int
__db_vrfy_childcursor(vdp, dbcp)
VRFY_DBINFO *vdp;
DBC **dbcp;
{
DB *cdbp;
DBC *dbc;
int ret;
cdbp = vdp->cdbp;
if ((ret = __db_cursor(cdbp, NULL, &dbc, 0)) == 0)
*dbcp = dbc;
return (ret);
}
int
__db_vrfy_childput(vdp, pgno, cip)
VRFY_DBINFO *vdp;
db_pgno_t pgno;
VRFY_CHILDINFO *cip;
{
DB *cdbp;
DBC *cc;
DBT key, data;
VRFY_CHILDINFO *oldcip;
int ret;
cdbp = vdp->cdbp;
memset(&key, 0, sizeof(DBT));
memset(&data, 0, sizeof(DBT));
key.data = &pgno;
key.size = sizeof(db_pgno_t);
if ((ret = __db_vrfy_childcursor(vdp, &cc)) != 0)
return (ret);
for (ret = __db_vrfy_ccset(cc, pgno, &oldcip); ret == 0;
ret = __db_vrfy_ccnext(cc, &oldcip))
if (oldcip->pgno == cip->pgno) {
if ((ret = __db_vrfy_childinc(cc, oldcip)) != 0 ||
(ret = __db_vrfy_ccclose(cc)) != 0)
return (ret);
return (0);
}
if (ret != DB_NOTFOUND) {
(void)__db_vrfy_ccclose(cc);
return (ret);
}
if ((ret = __db_vrfy_ccclose(cc)) != 0)
return (ret);
cip->refcnt = 1;
data.data = cip;
data.size = sizeof(VRFY_CHILDINFO);
return (__db_put(cdbp, NULL, &key, &data, 0));
}
static int
__db_vrfy_childinc(dbc, cip)
DBC *dbc;
VRFY_CHILDINFO *cip;
{
DBT key, data;
memset(&key, 0, sizeof(DBT));
memset(&data, 0, sizeof(DBT));
cip->refcnt++;
data.data = cip;
data.size = sizeof(VRFY_CHILDINFO);
return (__dbc_put(dbc, &key, &data, DB_CURRENT));
}
int
__db_vrfy_ccset(dbc, pgno, cipp)
DBC *dbc;
db_pgno_t pgno;
VRFY_CHILDINFO **cipp;
{
DBT key, data;
int ret;
memset(&key, 0, sizeof(DBT));
memset(&data, 0, sizeof(DBT));
key.data = &pgno;
key.size = sizeof(db_pgno_t);
if ((ret = __dbc_get(dbc, &key, &data, DB_SET)) != 0)
return (ret);
DB_ASSERT(dbc->dbp->dbenv, data.size == sizeof(VRFY_CHILDINFO));
*cipp = (VRFY_CHILDINFO *)data.data;
return (0);
}
int
__db_vrfy_ccnext(dbc, cipp)
DBC *dbc;
VRFY_CHILDINFO **cipp;
{
DBT key, data;
int ret;
memset(&key, 0, sizeof(DBT));
memset(&data, 0, sizeof(DBT));
if ((ret = __dbc_get(dbc, &key, &data, DB_NEXT_DUP)) != 0)
return (ret);
DB_ASSERT(dbc->dbp->dbenv, data.size == sizeof(VRFY_CHILDINFO));
*cipp = (VRFY_CHILDINFO *)data.data;
return (0);
}
int
__db_vrfy_ccclose(dbc)
DBC *dbc;
{
return (__dbc_close(dbc));
}
static int
__db_vrfy_pageinfo_create(dbenv, pipp)
DB_ENV *dbenv;
VRFY_PAGEINFO **pipp;
{
VRFY_PAGEINFO *pip;
int ret;
if ((ret = __os_umalloc(dbenv, sizeof(VRFY_PAGEINFO), &pip)) != 0)
return (ret);
memset(pip, 0, sizeof(VRFY_PAGEINFO));
*pipp = pip;
return (0);
}
int
__db_salvage_init(vdp)
VRFY_DBINFO *vdp;
{
DB *dbp;
int ret;
if ((ret = __db_create_internal(&dbp, NULL, 0)) != 0)
return (ret);
if ((ret = __db_set_pagesize(dbp, 1024)) != 0)
goto err;
if ((ret = __db_open(dbp,
NULL, NULL, NULL, DB_BTREE, DB_CREATE, 0, PGNO_BASE_MD)) != 0)
goto err;
vdp->salvage_pages = dbp;
return (0);
err: (void)__db_close(dbp, NULL, 0);
return (ret);
}
void
__db_salvage_destroy(vdp)
VRFY_DBINFO *vdp;
{
(void)__db_close(vdp->salvage_pages, NULL, 0);
}
int
__db_salvage_getnext(vdp, dbcp, pgnop, pgtypep, skip_overflow)
VRFY_DBINFO *vdp;
DBC **dbcp;
db_pgno_t *pgnop;
u_int32_t *pgtypep;
int skip_overflow;
{
DB *dbp;
DBT key, data;
int ret;
u_int32_t pgtype;
dbp = vdp->salvage_pages;
memset(&key, 0, sizeof(DBT));
memset(&data, 0, sizeof(DBT));
if (*dbcp == NULL &&
(ret = __db_cursor(dbp, NULL, dbcp, 0)) != 0)
return (ret);
while ((ret = __dbc_get(*dbcp, &key, &data, DB_NEXT)) == 0) {
DB_ASSERT(dbp->dbenv, data.size == sizeof(u_int32_t));
memcpy(&pgtype, data.data, sizeof(pgtype));
if (skip_overflow && pgtype == SALVAGE_OVERFLOW)
continue;
if ((ret = __dbc_del(*dbcp, 0)) != 0)
return (ret);
if (pgtype != SALVAGE_IGNORE) {
DB_ASSERT(dbp->dbenv, key.size == sizeof(db_pgno_t));
DB_ASSERT(dbp->dbenv, data.size == sizeof(u_int32_t));
*pgnop = *(db_pgno_t *)key.data;
*pgtypep = *(u_int32_t *)data.data;
break;
}
}
return (ret);
}
int
__db_salvage_isdone(vdp, pgno)
VRFY_DBINFO *vdp;
db_pgno_t pgno;
{
DBT key, data;
DB *dbp;
int ret;
u_int32_t currtype;
dbp = vdp->salvage_pages;
memset(&key, 0, sizeof(DBT));
memset(&data, 0, sizeof(DBT));
currtype = SALVAGE_INVALID;
data.data = &currtype;
data.ulen = sizeof(u_int32_t);
data.flags = DB_DBT_USERMEM;
key.data = &pgno;
key.size = sizeof(db_pgno_t);
if ((ret = __db_get(dbp, NULL, &key, &data, 0)) == 0) {
if (currtype == SALVAGE_IGNORE)
return (DB_KEYEXIST);
else
return (0);
} else if (ret != DB_NOTFOUND)
return (ret);
return (0);
}
int
__db_salvage_markdone(vdp, pgno)
VRFY_DBINFO *vdp;
db_pgno_t pgno;
{
DBT key, data;
DB *dbp;
int pgtype, ret;
u_int32_t currtype;
pgtype = SALVAGE_IGNORE;
dbp = vdp->salvage_pages;
memset(&key, 0, sizeof(DBT));
memset(&data, 0, sizeof(DBT));
currtype = SALVAGE_INVALID;
data.data = &currtype;
data.ulen = sizeof(u_int32_t);
data.flags = DB_DBT_USERMEM;
key.data = &pgno;
key.size = sizeof(db_pgno_t);
if ((ret = __db_salvage_isdone(vdp, pgno)) != 0)
return (ret == DB_KEYEXIST ? DB_VERIFY_BAD : ret);
data.size = sizeof(u_int32_t);
data.data = &pgtype;
return (__db_put(dbp, NULL, &key, &data, 0));
}
int
__db_salvage_markneeded(vdp, pgno, pgtype)
VRFY_DBINFO *vdp;
db_pgno_t pgno;
u_int32_t pgtype;
{
DB *dbp;
DBT key, data;
int ret;
dbp = vdp->salvage_pages;
memset(&key, 0, sizeof(DBT));
memset(&data, 0, sizeof(DBT));
key.data = &pgno;
key.size = sizeof(db_pgno_t);
data.data = &pgtype;
data.size = sizeof(u_int32_t);
ret = __db_put(dbp, NULL, &key, &data, DB_NOOVERWRITE);
return (ret == DB_KEYEXIST ? 0 : ret);
}
int
__db_vrfy_prdbt(dbtp, checkprint, prefix, handle, callback, is_recno, vdp)
DBT *dbtp;
int checkprint;
const char *prefix;
void *handle;
int (*callback) __P((void *, const void *));
int is_recno;
VRFY_DBINFO *vdp;
{
if (vdp != NULL) {
if (F_ISSET(vdp, SALVAGE_PRINTHEADER)) {
(void)__db_prheader(
NULL, "__OTHER__", 0, 0, handle, callback, vdp, 0);
F_CLR(vdp, SALVAGE_PRINTHEADER);
F_SET(vdp, SALVAGE_PRINTFOOTER);
}
if (F_ISSET(vdp, SALVAGE_PRINTABLE))
checkprint = 1;
}
return (
__db_prdbt(dbtp, checkprint, prefix, handle, callback, is_recno));
}