/*-
* See the file LICENSE for redistribution information.
*
* Copyright (c) 1996, 1997, 1998
* Sleepycat Software. All rights reserved.
*/
#include "config.h"
#ifndef lint
static const char sccsid[] = "@(#)db_pr.c 10.40 (Sleepycat) 11/22/98";
#endif /* not lint */
#ifndef NO_SYSTEM_INCLUDES
#include <sys/types.h>
#include <ctype.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#endif
#include "db_int.h"
#include "db_page.h"
#include "btree.h"
#include "hash.h"
#include "db_am.h"
static void __db_proff __P((void *));
static void __db_psize __P((DB_MPOOLFILE *));
/*
* __db_loadme --
* Force loading of this file.
*
* PUBLIC: void __db_loadme __P((void));
*/
void
__db_loadme()
{
getpid();
}
static FILE *set_fp;
/*
* 64K is the maximum page size, so by default we check for offsets
* larger than that, and, where possible, we refine the test.
*/
#define PSIZE_BOUNDARY (64 * 1024 + 1)
static size_t set_psize = PSIZE_BOUNDARY;
/*
* __db_prinit --
* Initialize tree printing routines.
*
* PUBLIC: FILE *__db_prinit __P((FILE *));
*/
FILE *
__db_prinit(fp)
FILE *fp;
{
if (set_fp == NULL)
set_fp = fp == NULL ? stdout : fp;
return (set_fp);
}
/*
* __db_dump --
* Dump the tree to a file.
*
* PUBLIC: int __db_dump __P((DB *, char *, int));
*/
int
__db_dump(dbp, name, all)
DB *dbp;
char *name;
int all;
{
FILE *fp, *save_fp;
COMPQUIET(save_fp, NULL);
if (set_psize == PSIZE_BOUNDARY)
__db_psize(dbp->mpf);
if (name != NULL) {
if ((fp = fopen(name, "w")) == NULL)
return (errno);
save_fp = set_fp;
set_fp = fp;
} else
fp = __db_prinit(NULL);
(void)__db_prdb(dbp);
if (dbp->type == DB_HASH)
(void)__db_prhash(dbp);
else
(void)__db_prbtree(dbp);
fprintf(fp, "%s\n", DB_LINE);
__db_prtree(dbp->mpf, all);
if (name != NULL) {
(void)fclose(fp);
set_fp = save_fp;
}
return (0);
}
/*
* __db_prdb --
* Print out the DB structure information.
*
* PUBLIC: int __db_prdb __P((DB *));
*/
int
__db_prdb(dbp)
DB *dbp;
{
static const FN fn[] = {
{ DB_AM_DUP, "duplicates" },
{ DB_AM_INMEM, "in-memory" },
{ DB_AM_LOCKING, "locking" },
{ DB_AM_LOGGING, "logging" },
{ DB_AM_MLOCAL, "local mpool" },
{ DB_AM_PGDEF, "default page size" },
{ DB_AM_RDONLY, "read-only" },
{ DB_AM_SWAP, "needswap" },
{ DB_AM_THREAD, "thread" },
{ DB_BT_RECNUM, "btree:recnum" },
{ DB_DBM_ERROR, "dbm/ndbm error" },
{ DB_RE_DELIMITER, "recno:delimiter" },
{ DB_RE_FIXEDLEN, "recno:fixed-length" },
{ DB_RE_PAD, "recno:pad" },
{ DB_RE_RENUMBER, "recno:renumber" },
{ DB_RE_SNAPSHOT, "recno:snapshot" },
{ 0 },
};
FILE *fp;
const char *t;
fp = __db_prinit(NULL);
switch (dbp->type) {
case DB_BTREE:
t = "btree";
break;
case DB_HASH:
t = "hash";
break;
case DB_RECNO:
t = "recno";
break;
default:
t = "UNKNOWN";
break;
}
fprintf(fp, "%s ", t);
__db_prflags(dbp->flags, fn, fp);
fprintf(fp, "\n");
return (0);
}
/*
* __db_prbtree --
* Print out the btree internal information.
*
* PUBLIC: int __db_prbtree __P((DB *));
*/
int
__db_prbtree(dbp)
DB *dbp;
{
static const FN mfn[] = {
{ BTM_DUP, "duplicates" },
{ BTM_RECNO, "recno" },
{ BTM_RECNUM, "btree:recnum" },
{ BTM_FIXEDLEN, "recno:fixed-length" },
{ BTM_RENUMBER, "recno:renumber" },
{ 0 },
};
DBC *dbc;
BTMETA *mp;
BTREE *t;
FILE *fp;
PAGE *h;
RECNO *rp;
db_pgno_t i;
int cnt, ret;
const char *sep;
t = dbp->internal;
fp = __db_prinit(NULL);
if ((ret = dbp->cursor(dbp, NULL, &dbc, 0)) != 0)
return (ret);
(void)fprintf(fp, "%s\nOn-page metadata:\n", DB_LINE);
i = PGNO_METADATA;
if ((ret = memp_fget(dbp->mpf, &i, 0, (PAGE **)&mp)) != 0) {
(void)dbc->c_close(dbc);
return (ret);
}
fprintf(fp, "lsn.file: %lu lsn.offset: %lu\n",
(u_long)LSN(mp).file, (u_long)LSN(mp).offset);
(void)fprintf(fp, "magic %#lx\n", (u_long)mp->magic);
(void)fprintf(fp, "version %#lx\n", (u_long)mp->version);
(void)fprintf(fp, "pagesize %lu\n", (u_long)mp->pagesize);
(void)fprintf(fp, "maxkey: %lu minkey: %lu\n",
(u_long)mp->maxkey, (u_long)mp->minkey);
(void)fprintf(fp, "free list: %lu", (u_long)mp->free);
for (i = mp->free, cnt = 0, sep = ", "; i != PGNO_INVALID;) {
if ((ret = memp_fget(dbp->mpf, &i, 0, &h)) != 0)
return (ret);
i = h->next_pgno;
(void)memp_fput(dbp->mpf, h, 0);
(void)fprintf(fp, "%s%lu", sep, (u_long)i);
if (++cnt % 10 == 0) {
(void)fprintf(fp, "\n");
cnt = 0;
sep = "";
} else
sep = ", ";
}
(void)fprintf(fp, "\n");
(void)fprintf(fp, "flags %#lx", (u_long)mp->flags);
__db_prflags(mp->flags, mfn, fp);
(void)fprintf(fp, "\n");
(void)memp_fput(dbp->mpf, mp, 0);
(void)fprintf(fp, "%s\nDB_INFO:\n", DB_LINE);
(void)fprintf(fp, "bt_maxkey: %lu bt_minkey: %lu\n",
(u_long)t->bt_maxkey, (u_long)t->bt_minkey);
(void)fprintf(fp, "bt_compare: %#lx bt_prefix: %#lx\n",
(u_long)t->bt_compare, (u_long)t->bt_prefix);
if ((rp = t->recno) != NULL) {
(void)fprintf(fp,
"re_delim: %#lx re_pad: %#lx re_len: %lu re_source: %s\n",
(u_long)rp->re_delim, (u_long)rp->re_pad,
(u_long)rp->re_len,
rp->re_source == NULL ? "" : rp->re_source);
(void)fprintf(fp,
"cmap: %#lx smap: %#lx emap: %#lx msize: %lu\n",
(u_long)rp->re_cmap, (u_long)rp->re_smap,
(u_long)rp->re_emap, (u_long)rp->re_msize);
}
(void)fprintf(fp, "ovflsize: %lu\n", (u_long)t->bt_ovflsize);
(void)fflush(fp);
return (dbc->c_close(dbc));
}
/*
* __db_prhash --
* Print out the hash internal information.
*
* PUBLIC: int __db_prhash __P((DB *));
*/
int
__db_prhash(dbp)
DB *dbp;
{
FILE *fp;
DBC *dbc;
HASH_CURSOR *hcp;
int i, put_page, ret;
db_pgno_t pgno;
fp = __db_prinit(NULL);
if ((ret = dbp->cursor(dbp, NULL, &dbc, 0)) != 0)
return (ret);
hcp = (HASH_CURSOR *)dbc->internal;
/*
* In this case, hcp->hdr will never be null, if we decide
* to pass dbc's to this routine instead, then it could be.
*/
if (hcp->hdr == NULL) {
pgno = PGNO_METADATA;
if ((ret = memp_fget(dbp->mpf, &pgno, 0, &hcp->hdr)) != 0)
return (ret);
put_page = 1;
} else
put_page = 0;
fprintf(fp, "\tmagic %#lx\n", (u_long)hcp->hdr->magic);
fprintf(fp, "\tversion %lu\n", (u_long)hcp->hdr->version);
fprintf(fp, "\tpagesize %lu\n", (u_long)hcp->hdr->pagesize);
fprintf(fp, "\tovfl_point %lu\n", (u_long)hcp->hdr->ovfl_point);
fprintf(fp, "\tlast_freed %lu\n", (u_long)hcp->hdr->last_freed);
fprintf(fp, "\tmax_bucket %lu\n", (u_long)hcp->hdr->max_bucket);
fprintf(fp, "\thigh_mask %#lx\n", (u_long)hcp->hdr->high_mask);
fprintf(fp, "\tlow_mask %#lx\n", (u_long)hcp->hdr->low_mask);
fprintf(fp, "\tffactor %lu\n", (u_long)hcp->hdr->ffactor);
fprintf(fp, "\tnelem %lu\n", (u_long)hcp->hdr->nelem);
fprintf(fp, "\th_charkey %#lx\n", (u_long)hcp->hdr->h_charkey);
for (i = 0; i < NCACHED; i++)
fprintf(fp, "%lu ", (u_long)hcp->hdr->spares[i]);
fprintf(fp, "\n");
(void)fflush(fp);
if (put_page) {
(void)memp_fput(dbp->mpf, (PAGE *)hcp->hdr, 0);
hcp->hdr = NULL;
}
return (dbc->c_close(dbc));
}
/*
* __db_prtree --
* Print out the entire tree.
*
* PUBLIC: int __db_prtree __P((DB_MPOOLFILE *, int));
*/
int
__db_prtree(mpf, all)
DB_MPOOLFILE *mpf;
int all;
{
PAGE *h;
db_pgno_t i;
if (set_psize == PSIZE_BOUNDARY)
__db_psize(mpf);
for (i = PGNO_ROOT;; ++i) {
if (memp_fget(mpf, &i, 0, &h) != 0)
break;
(void)__db_prpage(h, all);
(void)memp_fput(mpf, h, 0);
}
(void)fflush(__db_prinit(NULL));
return (0);
}
/*
* __db_prnpage
* -- Print out a specific page.
*
* PUBLIC: int __db_prnpage __P((DB_MPOOLFILE *, db_pgno_t));
*/
int
__db_prnpage(mpf, pgno)
DB_MPOOLFILE *mpf;
db_pgno_t pgno;
{
PAGE *h;
int ret;
if (set_psize == PSIZE_BOUNDARY)
__db_psize(mpf);
if ((ret = memp_fget(mpf, &pgno, 0, &h)) != 0)
return (ret);
ret = __db_prpage(h, 1);
(void)fflush(__db_prinit(NULL));
(void)memp_fput(mpf, h, 0);
return (ret);
}
/*
* __db_prpage
* -- Print out a page.
*
* PUBLIC: int __db_prpage __P((PAGE *, int));
*/
int
__db_prpage(h, all)
PAGE *h;
int all;
{
BINTERNAL *bi;
BKEYDATA *bk;
HOFFPAGE a_hkd;
FILE *fp;
RINTERNAL *ri;
db_indx_t dlen, len, i;
db_pgno_t pgno;
int deleted, ret;
const char *s;
u_int8_t *ep, *hk, *p;
void *sp;
fp = __db_prinit(NULL);
switch (TYPE(h)) {
case P_DUPLICATE:
s = "duplicate";
break;
case P_HASH:
s = "hash";
break;
case P_IBTREE:
s = "btree internal";
break;
case P_INVALID:
s = "invalid";
break;
case P_IRECNO:
s = "recno internal";
break;
case P_LBTREE:
s = "btree leaf";
break;
case P_LRECNO:
s = "recno leaf";
break;
case P_OVERFLOW:
s = "overflow";
break;
default:
fprintf(fp, "ILLEGAL PAGE TYPE: page: %lu type: %lu\n",
(u_long)h->pgno, (u_long)TYPE(h));
return (1);
}
fprintf(fp, "page %4lu: (%s)\n", (u_long)h->pgno, s);
fprintf(fp, " lsn.file: %lu lsn.offset: %lu",
(u_long)LSN(h).file, (u_long)LSN(h).offset);
if (TYPE(h) == P_IBTREE || TYPE(h) == P_IRECNO ||
(TYPE(h) == P_LRECNO && h->pgno == PGNO_ROOT))
fprintf(fp, " total records: %4lu", (u_long)RE_NREC(h));
fprintf(fp, "\n");
if (TYPE(h) != P_IBTREE && TYPE(h) != P_IRECNO)
fprintf(fp, " prev: %4lu next: %4lu",
(u_long)PREV_PGNO(h), (u_long)NEXT_PGNO(h));
if (TYPE(h) == P_IBTREE || TYPE(h) == P_LBTREE)
fprintf(fp, " level: %2lu", (u_long)h->level);
if (TYPE(h) == P_OVERFLOW) {
fprintf(fp, " ref cnt: %4lu ", (u_long)OV_REF(h));
__db_pr((u_int8_t *)h + P_OVERHEAD, OV_LEN(h));
return (0);
}
fprintf(fp, " entries: %4lu", (u_long)NUM_ENT(h));
fprintf(fp, " offset: %4lu\n", (u_long)HOFFSET(h));
if (!all || TYPE(h) == P_INVALID)
return (0);
ret = 0;
for (i = 0; i < NUM_ENT(h); i++) {
if (P_ENTRY(h, i) - (u_int8_t *)h < P_OVERHEAD ||
(size_t)(P_ENTRY(h, i) - (u_int8_t *)h) >= set_psize) {
fprintf(fp,
"ILLEGAL PAGE OFFSET: indx: %lu of %lu\n",
(u_long)i, (u_long)h->inp[i]);
ret = EINVAL;
continue;
}
deleted = 0;
switch (TYPE(h)) {
case P_HASH:
case P_IBTREE:
case P_IRECNO:
sp = P_ENTRY(h, i);
break;
case P_LBTREE:
sp = P_ENTRY(h, i);
deleted = i % 2 == 0 &&
B_DISSET(GET_BKEYDATA(h, i + O_INDX)->type);
break;
case P_LRECNO:
case P_DUPLICATE:
sp = P_ENTRY(h, i);
deleted = B_DISSET(GET_BKEYDATA(h, i)->type);
break;
default:
fprintf(fp,
"ILLEGAL PAGE ITEM: %lu\n", (u_long)TYPE(h));
ret = EINVAL;
continue;
}
fprintf(fp, " %s[%03lu] %4lu ",
deleted ? "D" : " ", (u_long)i, (u_long)h->inp[i]);
switch (TYPE(h)) {
case P_HASH:
hk = sp;
switch (HPAGE_PTYPE(hk)) {
case H_OFFDUP:
memcpy(&pgno,
HOFFDUP_PGNO(hk), sizeof(db_pgno_t));
fprintf(fp,
"%4lu [offpage dups]\n", (u_long)pgno);
break;
case H_DUPLICATE:
/*
* If this is the first item on a page, then
* we cannot figure out how long it is, so
* we only print the first one in the duplicate
* set.
*/
if (i != 0)
len = LEN_HKEYDATA(h, 0, i);
else
len = 1;
fprintf(fp, "Duplicates:\n");
for (p = HKEYDATA_DATA(hk),
ep = p + len; p < ep;) {
memcpy(&dlen, p, sizeof(db_indx_t));
p += sizeof(db_indx_t);
fprintf(fp, "\t\t");
__db_pr(p, dlen);
p += sizeof(db_indx_t) + dlen;
}
break;
case H_KEYDATA:
if (i != 0)
__db_pr(HKEYDATA_DATA(hk),
LEN_HKEYDATA(h, 0, i));
else
fprintf(fp, "%s\n", HKEYDATA_DATA(hk));
break;
case H_OFFPAGE:
memcpy(&a_hkd, hk, HOFFPAGE_SIZE);
fprintf(fp,
"overflow: total len: %4lu page: %4lu\n",
(u_long)a_hkd.tlen, (u_long)a_hkd.pgno);
break;
}
break;
case P_IBTREE:
bi = sp;
fprintf(fp, "count: %4lu pgno: %4lu ",
(u_long)bi->nrecs, (u_long)bi->pgno);
switch (B_TYPE(bi->type)) {
case B_KEYDATA:
__db_pr(bi->data, bi->len);
break;
case B_DUPLICATE:
case B_OVERFLOW:
__db_proff(bi->data);
break;
default:
fprintf(fp, "ILLEGAL BINTERNAL TYPE: %lu\n",
(u_long)B_TYPE(bi->type));
ret = EINVAL;
break;
}
break;
case P_IRECNO:
ri = sp;
fprintf(fp, "entries %4lu pgno %4lu\n",
(u_long)ri->nrecs, (u_long)ri->pgno);
break;
case P_LBTREE:
case P_LRECNO:
case P_DUPLICATE:
bk = sp;
switch (B_TYPE(bk->type)) {
case B_KEYDATA:
__db_pr(bk->data, bk->len);
break;
case B_DUPLICATE:
case B_OVERFLOW:
__db_proff(bk);
break;
default:
fprintf(fp,
"ILLEGAL DUPLICATE/LBTREE/LRECNO TYPE: %lu\n",
(u_long)B_TYPE(bk->type));
ret = EINVAL;
break;
}
break;
}
}
(void)fflush(fp);
return (ret);
}
/*
* __db_isbad
* -- Decide if a page is corrupted.
*
* PUBLIC: int __db_isbad __P((PAGE *, int));
*/
int
__db_isbad(h, die)
PAGE *h;
int die;
{
BINTERNAL *bi;
BKEYDATA *bk;
FILE *fp;
db_indx_t i;
u_int type;
fp = __db_prinit(NULL);
switch (TYPE(h)) {
case P_DUPLICATE:
case P_HASH:
case P_IBTREE:
case P_INVALID:
case P_IRECNO:
case P_LBTREE:
case P_LRECNO:
case P_OVERFLOW:
break;
default:
fprintf(fp, "ILLEGAL PAGE TYPE: page: %lu type: %lu\n",
(u_long)h->pgno, (u_long)TYPE(h));
goto bad;
}
for (i = 0; i < NUM_ENT(h); i++) {
if (P_ENTRY(h, i) - (u_int8_t *)h < P_OVERHEAD ||
(size_t)(P_ENTRY(h, i) - (u_int8_t *)h) >= set_psize) {
fprintf(fp,
"ILLEGAL PAGE OFFSET: indx: %lu of %lu\n",
(u_long)i, (u_long)h->inp[i]);
goto bad;
}
switch (TYPE(h)) {
case P_HASH:
type = HPAGE_TYPE(h, i);
if (type != H_OFFDUP &&
type != H_DUPLICATE &&
type != H_KEYDATA &&
type != H_OFFPAGE) {
fprintf(fp, "ILLEGAL HASH TYPE: %lu\n",
(u_long)type);
goto bad;
}
break;
case P_IBTREE:
bi = GET_BINTERNAL(h, i);
if (B_TYPE(bi->type) != B_KEYDATA &&
B_TYPE(bi->type) != B_DUPLICATE &&
B_TYPE(bi->type) != B_OVERFLOW) {
fprintf(fp, "ILLEGAL BINTERNAL TYPE: %lu\n",
(u_long)B_TYPE(bi->type));
goto bad;
}
break;
case P_IRECNO:
case P_LBTREE:
case P_LRECNO:
break;
case P_DUPLICATE:
bk = GET_BKEYDATA(h, i);
if (B_TYPE(bk->type) != B_KEYDATA &&
B_TYPE(bk->type) != B_DUPLICATE &&
B_TYPE(bk->type) != B_OVERFLOW) {
fprintf(fp,
"ILLEGAL DUPLICATE/LBTREE/LRECNO TYPE: %lu\n",
(u_long)B_TYPE(bk->type));
goto bad;
}
break;
default:
fprintf(fp,
"ILLEGAL PAGE ITEM: %lu\n", (u_long)TYPE(h));
goto bad;
}
}
return (0);
bad: if (die) {
abort();
/* NOTREACHED */
}
return (1);
}
/*
* __db_pr --
* Print out a data element.
*
* PUBLIC: void __db_pr __P((u_int8_t *, u_int32_t));
*/
void
__db_pr(p, len)
u_int8_t *p;
u_int32_t len;
{
FILE *fp;
u_int lastch;
int i;
fp = __db_prinit(NULL);
fprintf(fp, "len: %3lu", (u_long)len);
lastch = '.';
if (len != 0) {
fprintf(fp, " data: ");
for (i = len <= 20 ? len : 20; i > 0; --i, ++p) {
lastch = *p;
if (isprint(*p) || *p == '\n')
fprintf(fp, "%c", *p);
else
fprintf(fp, "0x%.2x", (u_int)*p);
}
if (len > 20) {
fprintf(fp, "...");
lastch = '.';
}
}
if (lastch != '\n')
fprintf(fp, "\n");
}
/*
* __db_prdbt --
* Print out a DBT data element.
*
* PUBLIC: int __db_prdbt __P((DBT *, int, FILE *));
*/
int
__db_prdbt(dbtp, checkprint, fp)
DBT *dbtp;
int checkprint;
FILE *fp;
{
static const char hex[] = "0123456789abcdef";
u_int8_t *p;
u_int32_t len;
/*
* !!!
* This routine is the routine that dumps out items in the format
* used by db_dump(1) and db_load(1). This means that the format
* cannot change.
*/
if (checkprint) {
for (len = dbtp->size, p = dbtp->data; len--; ++p)
if (isprint(*p)) {
if (*p == '\\' && fprintf(fp, "\\") != 1)
return (EIO);
if (fprintf(fp, "%c", *p) != 1)
return (EIO);
} else
if (fprintf(fp, "\\%c%c",
hex[(u_int8_t)(*p & 0xf0) >> 4],
hex[*p & 0x0f]) != 3)
return (EIO);
} else
for (len = dbtp->size, p = dbtp->data; len--; ++p)
if (fprintf(fp, "%c%c",
hex[(u_int8_t)(*p & 0xf0) >> 4],
hex[*p & 0x0f]) != 2)
return (EIO);
return (fprintf(fp, "\n") == 1 ? 0 : EIO);
}
/*
* __db_proff --
* Print out an off-page element.
*/
static void
__db_proff(vp)
void *vp;
{
FILE *fp;
BOVERFLOW *bo;
fp = __db_prinit(NULL);
bo = vp;
switch (B_TYPE(bo->type)) {
case B_OVERFLOW:
fprintf(fp, "overflow: total len: %4lu page: %4lu\n",
(u_long)bo->tlen, (u_long)bo->pgno);
break;
case B_DUPLICATE:
fprintf(fp, "duplicate: page: %4lu\n", (u_long)bo->pgno);
break;
}
}
/*
* __db_prflags --
* Print out flags values.
*
* PUBLIC: void __db_prflags __P((u_int32_t, const FN *, FILE *));
*/
void
__db_prflags(flags, fn, fp)
u_int32_t flags;
FN const *fn;
FILE *fp;
{
const FN *fnp;
int found;
const char *sep;
sep = " (";
for (found = 0, fnp = fn; fnp->mask != 0; ++fnp)
if (LF_ISSET(fnp->mask)) {
fprintf(fp, "%s%s", sep, fnp->name);
sep = ", ";
found = 1;
}
if (found)
fprintf(fp, ")");
}
/*
* __db_psize --
* Get the page size.
*/
static void
__db_psize(mpf)
DB_MPOOLFILE *mpf;
{
BTMETA *mp;
db_pgno_t pgno;
set_psize = PSIZE_BOUNDARY - 1;
pgno = PGNO_METADATA;
if (memp_fget(mpf, &pgno, 0, &mp) != 0)
return;
switch (mp->magic) {
case DB_BTREEMAGIC:
case DB_HASHMAGIC:
set_psize = mp->pagesize;
break;
}
(void)memp_fput(mpf, mp, 0);
}