mirror/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-01-19 13:32:33 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions
mariadb/bdb/db/db_pr.c
ram@mysql.r18.ru 5e09392faa BDB 4.1.24
2002-10-30 15:57:05 +04:00

1294 lines
30 KiB
C
Raw Blame History

/*-
* See the file LICENSE for redistribution information.
*
* Copyright (c) 1996-2002
* Sleepycat Software. All rights reserved.
*/
#include "db_config.h"
#ifndef lint
static const char revid[] = "$Id: db_pr.c,v 11.84 2002/09/10 02:45:20 bostic Exp $";
#endif /* not lint */
#ifndef NO_SYSTEM_INCLUDES
#include <sys/types.h>
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#endif
#include "db_int.h"
#include "dbinc/db_page.h"
#include "dbinc/db_shash.h"
#include "dbinc/btree.h"
#include "dbinc/hash.h"
#include "dbinc/mp.h"
#include "dbinc/qam.h"
#include "dbinc/db_verify.h"
static int __db_bmeta __P((DB *, FILE *, BTMETA *, u_int32_t));
static int __db_hmeta __P((DB *, FILE *, HMETA *, u_int32_t));
static void __db_meta __P((DB *, DBMETA *, FILE *, FN const *, u_int32_t));
static const char *__db_pagetype_to_string __P((u_int32_t));
static void __db_prdb __P((DB *, FILE *));
static void __db_proff __P((void *, FILE *));
static int __db_prtree __P((DB *, FILE *, u_int32_t));
static int __db_qmeta __P((DB *, FILE *, QMETA *, u_int32_t));
/*
* __db_loadme --
* A nice place to put a breakpoint.
*
* PUBLIC: void __db_loadme __P((void));
*/
void
__db_loadme()
{
u_int32_t id;
__os_id(&id);
}
/*
* __db_dump --
* Dump the tree to a file.
*
* PUBLIC: int __db_dump __P((DB *, char *, char *));
*/
int
__db_dump(dbp, op, name)
DB *dbp;
char *op, *name;
{
FILE *fp;
u_int32_t flags;
int ret;
for (flags = 0; *op != '\0'; ++op)
switch (*op) {
case 'a':
LF_SET(DB_PR_PAGE);
break;
case 'h':
break;
case 'r':
LF_SET(DB_PR_RECOVERYTEST);
break;
default:
return (EINVAL);
}
if (name == NULL)
fp = stdout;
else {
if ((fp = fopen(name, "w")) == NULL)
return (__os_get_errno());
}
__db_prdb(dbp, fp);
fprintf(fp, "%s\n", DB_LINE);
ret = __db_prtree(dbp, fp, flags);
fflush(fp);
if (name != NULL)
fclose(fp);
return (ret);
}
/*
* __db_inmemdbflags --
* Call a callback for printing or other handling of strings associated
* with whatever in-memory DB structure flags are set.
*
* PUBLIC: void __db_inmemdbflags __P((u_int32_t, void *,
* PUBLIC: void (*)(u_int32_t, const FN *, void *)));
*/
void
__db_inmemdbflags(flags, cookie, callback)
u_int32_t flags;
void *cookie;
void (*callback) __P((u_int32_t, const FN *, void *));
{
static const FN fn[] = {
{ DB_AM_CHKSUM, "checksumming" },
{ DB_AM_CL_WRITER, "client replica writer" },
{ DB_AM_COMPENSATE, "created by compensating transaction" },
{ DB_AM_CREATED, "database created" },
{ DB_AM_CREATED_MSTR, "encompassing file created" },
{ DB_AM_DBM_ERROR, "dbm/ndbm error" },
{ DB_AM_DELIMITER, "variable length" },
{ DB_AM_DIRTY, "dirty reads" },
{ DB_AM_DISCARD, "discard cached pages" },
{ DB_AM_DUP, "duplicates" },
{ DB_AM_DUPSORT, "sorted duplicates" },
{ DB_AM_ENCRYPT, "encrypted" },
{ DB_AM_FIXEDLEN, "fixed-length records" },
{ DB_AM_INMEM, "in-memory" },
{ DB_AM_IN_RENAME, "file is being renamed" },
{ DB_AM_OPEN_CALLED, "DB->open called" },
{ DB_AM_PAD, "pad value" },
{ DB_AM_PGDEF, "default page size" },
{ DB_AM_RDONLY, "read-only" },
{ DB_AM_RECNUM, "Btree record numbers" },
{ DB_AM_RECOVER, "opened for recovery" },
{ DB_AM_RENUMBER, "renumber" },
{ DB_AM_REVSPLITOFF, "no reverse splits" },
{ DB_AM_SECONDARY, "secondary" },
{ DB_AM_SNAPSHOT, "load on open" },
{ DB_AM_SUBDB, "subdatabases" },
{ DB_AM_SWAP, "needswap" },
{ DB_AM_TXN, "transactional" },
{ DB_AM_VERIFYING, "verifier" },
{ 0, NULL }
};
callback(flags, fn, cookie);
}
/*
* __db_prdb --
* Print out the DB structure information.
*/
static void
__db_prdb(dbp, fp)
DB *dbp;
FILE *fp;
{
BTREE *bt;
HASH *h;
QUEUE *q;
fprintf(fp,
"In-memory DB structure:\n%s: %#lx",
__db_dbtype_to_string(dbp->type), (u_long)dbp->flags);
__db_inmemdbflags(dbp->flags, fp, __db_prflags);
fprintf(fp, "\n");
switch (dbp->type) {
case DB_BTREE:
case DB_RECNO:
bt = dbp->bt_internal;
fprintf(fp, "bt_meta: %lu bt_root: %lu\n",
(u_long)bt->bt_meta, (u_long)bt->bt_root);
fprintf(fp, "bt_maxkey: %lu bt_minkey: %lu\n",
(u_long)bt->bt_maxkey, (u_long)bt->bt_minkey);
fprintf(fp, "bt_compare: %#lx bt_prefix: %#lx\n",
P_TO_ULONG(bt->bt_compare), P_TO_ULONG(bt->bt_prefix));
fprintf(fp, "bt_lpgno: %lu\n", (u_long)bt->bt_lpgno);
if (dbp->type == DB_RECNO) {
fprintf(fp,
"re_pad: %#lx re_delim: %#lx re_len: %lu re_source: %s\n",
(u_long)bt->re_pad, (u_long)bt->re_delim,
(u_long)bt->re_len,
bt->re_source == NULL ? "" : bt->re_source);
fprintf(fp, "re_modified: %d re_eof: %d re_last: %lu\n",
bt->re_modified, bt->re_eof, (u_long)bt->re_last);
}
break;
case DB_HASH:
h = dbp->h_internal;
fprintf(fp, "meta_pgno: %lu\n", (u_long)h->meta_pgno);
fprintf(fp, "h_ffactor: %lu\n", (u_long)h->h_ffactor);
fprintf(fp, "h_nelem: %lu\n", (u_long)h->h_nelem);
fprintf(fp, "h_hash: %#lx\n", P_TO_ULONG(h->h_hash));
break;
case DB_QUEUE:
q = dbp->q_internal;
fprintf(fp, "q_meta: %lu\n", (u_long)q->q_meta);
fprintf(fp, "q_root: %lu\n", (u_long)q->q_root);
fprintf(fp, "re_pad: %#lx re_len: %lu\n",
(u_long)q->re_pad, (u_long)q->re_len);
fprintf(fp, "rec_page: %lu\n", (u_long)q->rec_page);
fprintf(fp, "page_ext: %lu\n", (u_long)q->page_ext);
break;
default:
break;
}
}
/*
* __db_prtree --
* Print out the entire tree.
*/
static int
__db_prtree(dbp, fp, flags)
DB *dbp;
FILE *fp;
u_int32_t flags;
{
DB_MPOOLFILE *mpf;
PAGE *h;
db_pgno_t i, last;
int ret;
mpf = dbp->mpf;
if (dbp->type == DB_QUEUE)
return (__db_prqueue(dbp, fp, flags));
/*
* Find out the page number of the last page in the database, then
* dump each page.
*/
mpf->last_pgno(mpf, &last);
for (i = 0; i <= last; ++i) {
if ((ret = mpf->get(mpf, &i, 0, &h)) != 0)
return (ret);
(void)__db_prpage(dbp, h, fp, flags);
if ((ret = mpf->put(mpf, h, 0)) != 0)
return (ret);
}
return (0);
}
/*
* __db_meta --
* Print out common metadata information.
*/
static void
__db_meta(dbp, dbmeta, fp, fn, flags)
DB *dbp;
DBMETA *dbmeta;
FILE *fp;
FN const *fn;
u_int32_t flags;
{
DB_MPOOLFILE *mpf;
PAGE *h;
db_pgno_t pgno;
u_int8_t *p;
int cnt, ret;
const char *sep;
mpf = dbp->mpf;
fprintf(fp, "\tmagic: %#lx\n", (u_long)dbmeta->magic);
fprintf(fp, "\tversion: %lu\n", (u_long)dbmeta->version);
fprintf(fp, "\tpagesize: %lu\n", (u_long)dbmeta->pagesize);
fprintf(fp, "\ttype: %lu\n", (u_long)dbmeta->type);
fprintf(fp, "\tkeys: %lu\trecords: %lu\n",
(u_long)dbmeta->key_count, (u_long)dbmeta->record_count);
if (!LF_ISSET(DB_PR_RECOVERYTEST)) {
/*
* If we're doing recovery testing, don't display the free
* list, it may have changed and that makes the dump diff
* not work.
*/
fprintf(fp, "\tfree list: %lu", (u_long)dbmeta->free);
for (pgno = dbmeta->free,
cnt = 0, sep = ", "; pgno != PGNO_INVALID;) {
if ((ret = mpf->get(mpf, &pgno, 0, &h)) != 0) {
fprintf(fp,
"Unable to retrieve free-list page: %lu: %s\n",
(u_long)pgno, db_strerror(ret));
break;
}
pgno = h->next_pgno;
(void)mpf->put(mpf, h, 0);
fprintf(fp, "%s%lu", sep, (u_long)pgno);
if (++cnt % 10 == 0) {
fprintf(fp, "\n");
cnt = 0;
sep = "\t";
} else
sep = ", ";
}
fprintf(fp, "\n");
fprintf(fp, "\tlast_pgno: %lu\n", (u_long)dbmeta->last_pgno);
}
if (fn != NULL) {
fprintf(fp, "\tflags: %#lx", (u_long)dbmeta->flags);
__db_prflags(dbmeta->flags, fn, fp);
fprintf(fp, "\n");
}
fprintf(fp, "\tuid: ");
for (p = (u_int8_t *)dbmeta->uid,
cnt = 0; cnt < DB_FILE_ID_LEN; ++cnt) {
fprintf(fp, "%x", *p++);
if (cnt < DB_FILE_ID_LEN - 1)
fprintf(fp, " ");
}
fprintf(fp, "\n");
}
/*
* __db_bmeta --
* Print out the btree meta-data page.
*/
static int
__db_bmeta(dbp, fp, h, flags)
DB *dbp;
FILE *fp;
BTMETA *h;
u_int32_t flags;
{
static const FN mfn[] = {
{ BTM_DUP, "duplicates" },
{ BTM_RECNO, "recno" },
{ BTM_RECNUM, "btree:recnum" },
{ BTM_FIXEDLEN, "recno:fixed-length" },
{ BTM_RENUMBER, "recno:renumber" },
{ BTM_SUBDB, "multiple-databases" },
{ 0, NULL }
};
__db_meta(dbp, (DBMETA *)h, fp, mfn, flags);
fprintf(fp, "\tmaxkey: %lu minkey: %lu\n",
(u_long)h->maxkey, (u_long)h->minkey);
if (dbp->type == DB_RECNO)
fprintf(fp, "\tre_len: %#lx re_pad: %lu\n",
(u_long)h->re_len, (u_long)h->re_pad);
fprintf(fp, "\troot: %lu\n", (u_long)h->root);
return (0);
}
/*
* __db_hmeta --
* Print out the hash meta-data page.
*/
static int
__db_hmeta(dbp, fp, h, flags)
DB *dbp;
FILE *fp;
HMETA *h;
u_int32_t flags;
{
static const FN mfn[] = {
{ DB_HASH_DUP, "duplicates" },
{ DB_HASH_SUBDB, "multiple-databases" },
{ 0, NULL }
};
int i;
__db_meta(dbp, (DBMETA *)h, fp, mfn, flags);
fprintf(fp, "\tmax_bucket: %lu\n", (u_long)h->max_bucket);
fprintf(fp, "\thigh_mask: %#lx\n", (u_long)h->high_mask);
fprintf(fp, "\tlow_mask: %#lx\n", (u_long)h->low_mask);
fprintf(fp, "\tffactor: %lu\n", (u_long)h->ffactor);
fprintf(fp, "\tnelem: %lu\n", (u_long)h->nelem);
fprintf(fp, "\th_charkey: %#lx\n", (u_long)h->h_charkey);
fprintf(fp, "\tspare points: ");
for (i = 0; i < NCACHED; i++)
fprintf(fp, "%lu ", (u_long)h->spares[i]);
fprintf(fp, "\n");
return (0);
}
/*
* __db_qmeta --
* Print out the queue meta-data page.
*/
static int
__db_qmeta(dbp, fp, h, flags)
DB *dbp;
FILE *fp;
QMETA *h;
u_int32_t flags;
{
__db_meta(dbp, (DBMETA *)h, fp, NULL, flags);
fprintf(fp, "\tfirst_recno: %lu\n", (u_long)h->first_recno);
fprintf(fp, "\tcur_recno: %lu\n", (u_long)h->cur_recno);
fprintf(fp, "\tre_len: %#lx re_pad: %lu\n",
(u_long)h->re_len, (u_long)h->re_pad);
fprintf(fp, "\trec_page: %lu\n", (u_long)h->rec_page);
fprintf(fp, "\tpage_ext: %lu\n", (u_long)h->page_ext);
return (0);
}
/*
* __db_prnpage
* -- Print out a specific page.
*
* PUBLIC: int __db_prnpage __P((DB *, db_pgno_t, FILE *));
*/
int
__db_prnpage(dbp, pgno, fp)
DB *dbp;
db_pgno_t pgno;
FILE *fp;
{
DB_MPOOLFILE *mpf;
PAGE *h;
int ret, t_ret;
mpf = dbp->mpf;
if ((ret = mpf->get(mpf, &pgno, 0, &h)) != 0)
return (ret);
ret = __db_prpage(dbp, h, fp, DB_PR_PAGE);
if ((t_ret = mpf->put(mpf, h, 0)) != 0 && ret == 0)
ret = t_ret;
return (ret);
}
/*
* __db_prpage
* -- Print out a page.
*
* PUBLIC: int __db_prpage __P((DB *, PAGE *, FILE *, u_int32_t));
*/
int
__db_prpage(dbp, h, fp, flags)
DB *dbp;
PAGE *h;
FILE *fp;
u_int32_t flags;
{
BINTERNAL *bi;
BKEYDATA *bk;
HOFFPAGE a_hkd;
QAMDATA *qp, *qep;
RINTERNAL *ri;
db_indx_t dlen, len, i, *inp;
db_pgno_t pgno;
db_recno_t recno;
u_int32_t pagesize, qlen;
u_int8_t *ep, *hk, *p;
int deleted, ret;
const char *s;
void *sp;
/*
* If we're doing recovery testing and this page is P_INVALID,
* assume it's a page that's on the free list, and don't display it.
*/
if (LF_ISSET(DB_PR_RECOVERYTEST) && TYPE(h) == P_INVALID)
return (0);
s = __db_pagetype_to_string(TYPE(h));
if (s == NULL) {
fprintf(fp, "ILLEGAL PAGE TYPE: page: %lu type: %lu\n",
(u_long)h->pgno, (u_long)TYPE(h));
return (1);
}
/*
* !!!
* Find out the page size. We don't want to do it the "right" way,
* by reading the value from the meta-data page, that's going to be
* slow. Reach down into the mpool region.
*/
pagesize = (u_int32_t)dbp->mpf->mfp->stat.st_pagesize;
/* Page number, page type. */
fprintf(fp, "page %lu: %s level: %lu",
(u_long)h->pgno, s, (u_long)h->level);
/* Record count. */
if (TYPE(h) == P_IBTREE ||
TYPE(h) == P_IRECNO || (TYPE(h) == P_LRECNO &&
h->pgno == ((BTREE *)dbp->bt_internal)->bt_root))
fprintf(fp, " records: %lu", (u_long)RE_NREC(h));
/* LSN. */
if (!LF_ISSET(DB_PR_RECOVERYTEST))
fprintf(fp, " (lsn.file: %lu lsn.offset: %lu)\n",
(u_long)LSN(h).file, (u_long)LSN(h).offset);
switch (TYPE(h)) {
case P_BTREEMETA:
return (__db_bmeta(dbp, fp, (BTMETA *)h, flags));
case P_HASHMETA:
return (__db_hmeta(dbp, fp, (HMETA *)h, flags));
case P_QAMMETA:
return (__db_qmeta(dbp, fp, (QMETA *)h, flags));
case P_QAMDATA: /* Should be meta->start. */
if (!LF_ISSET(DB_PR_PAGE))
return (0);
qlen = ((QUEUE *)dbp->q_internal)->re_len;
recno = (h->pgno - 1) * QAM_RECNO_PER_PAGE(dbp) + 1;
i = 0;
qep = (QAMDATA *)((u_int8_t *)h + pagesize - qlen);
for (qp = QAM_GET_RECORD(dbp, h, i); qp < qep;
recno++, i++, qp = QAM_GET_RECORD(dbp, h, i)) {
if (!F_ISSET(qp, QAM_SET))
continue;
fprintf(fp, "%s",
F_ISSET(qp, QAM_VALID) ? "\t" : " D");
fprintf(fp, "[%03lu] %4lu ", (u_long)recno,
(u_long)((u_int8_t *)qp - (u_int8_t *)h));
__db_pr(qp->data, qlen, fp);
}
return (0);
}
/* LSN. */
if (LF_ISSET(DB_PR_RECOVERYTEST))
fprintf(fp, " (lsn.file: %lu lsn.offset: %lu)\n",
(u_long)LSN(h).file, (u_long)LSN(h).offset);
s = "\t";
if (TYPE(h) != P_IBTREE && TYPE(h) != P_IRECNO) {
fprintf(fp, "%sprev: %4lu next: %4lu",
s, (u_long)PREV_PGNO(h), (u_long)NEXT_PGNO(h));
s = " ";
}
if (TYPE(h) == P_OVERFLOW) {
fprintf(fp, "%sref cnt: %4lu ", s, (u_long)OV_REF(h));
__db_pr((u_int8_t *)h + P_OVERHEAD(dbp), OV_LEN(h), fp);
return (0);
}
fprintf(fp, "%sentries: %4lu", s, (u_long)NUM_ENT(h));
fprintf(fp, " offset: %4lu\n", (u_long)HOFFSET(h));
if (TYPE(h) == P_INVALID || !LF_ISSET(DB_PR_PAGE))
return (0);
ret = 0;
inp = P_INP(dbp, h);
for (i = 0; i < NUM_ENT(h); i++) {
if ((db_alignp_t)(P_ENTRY(dbp, h, i) - (u_int8_t *)h) <
(db_alignp_t)(P_OVERHEAD(dbp)) ||
(size_t)(P_ENTRY(dbp, h, i) - (u_int8_t *)h) >= pagesize) {
fprintf(fp,
"ILLEGAL PAGE OFFSET: indx: %lu of %lu\n",
(u_long)i, (u_long)inp[i]);
ret = EINVAL;
continue;
}
deleted = 0;
switch (TYPE(h)) {
case P_HASH:
case P_IBTREE:
case P_IRECNO:
sp = P_ENTRY(dbp, h, i);
break;
case P_LBTREE:
sp = P_ENTRY(dbp, h, i);
deleted = i % 2 == 0 &&
B_DISSET(GET_BKEYDATA(dbp, h, i + O_INDX)->type);
break;
case P_LDUP:
case P_LRECNO:
sp = P_ENTRY(dbp, h, i);
deleted = B_DISSET(GET_BKEYDATA(dbp, h, i)->type);
break;
default:
fprintf(fp,
"ILLEGAL PAGE ITEM: %lu\n", (u_long)TYPE(h));
ret = EINVAL;
continue;
}
fprintf(fp, "%s", deleted ? " D" : "\t");
fprintf(fp, "[%03lu] %4lu ", (u_long)i, (u_long)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(dbp, 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, fp);
p += sizeof(db_indx_t) + dlen;
}
break;
case H_KEYDATA:
__db_pr(HKEYDATA_DATA(hk),
LEN_HKEYDATA(dbp, h, i == 0 ?
pagesize : 0, i), fp);
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 type: %4lu",
(u_long)bi->nrecs, (u_long)bi->pgno,
(u_long)bi->type);
switch (B_TYPE(bi->type)) {
case B_KEYDATA:
__db_pr(bi->data, bi->len, fp);
break;
case B_DUPLICATE:
case B_OVERFLOW:
__db_proff(bi->data, fp);
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_LDUP:
case P_LRECNO:
bk = sp;
switch (B_TYPE(bk->type)) {
case B_KEYDATA:
__db_pr(bk->data, bk->len, fp);
break;
case B_DUPLICATE:
case B_OVERFLOW:
__db_proff(bk, fp);
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_pr --
* Print out a data element.
*
* PUBLIC: void __db_pr __P((u_int8_t *, u_int32_t, FILE *));
*/
void
__db_pr(p, len, fp)
u_int8_t *p;
u_int32_t len;
FILE *fp;
{
u_int lastch;
int i;
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((int)*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, const char *, void *,
* PUBLIC: int (*)(void *, const void *), int, VRFY_DBINFO *));
*/
int
__db_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;
{
static const char hex[] = "0123456789abcdef";
db_recno_t recno;
u_int32_t len;
int ret;
#define DBTBUFLEN 100
char *p, *hp, buf[DBTBUFLEN], hbuf[DBTBUFLEN];
if (vdp != NULL) {
/*
* If vdp is non-NULL, we might be the first key in the
* "fake" subdatabase used for key/data pairs we can't
* associate with a known subdb.
*
* Check and clear the SALVAGE_PRINTHEADER flag; if
* it was set, print a subdatabase header.
*/
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);
/*
* Even if the printable flag wasn't set by our immediate
* caller, it may be set on a salvage-wide basis.
*/
if (F_ISSET(vdp, SALVAGE_PRINTABLE))
checkprint = 1;
}
/*
* !!!
* 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 (prefix != NULL && (ret = callback(handle, prefix)) != 0)
return (ret);
if (is_recno) {
/*
* We're printing a record number, and this has to be done
* in a platform-independent way. So we use the numeral in
* straight ASCII.
*/
(void)__ua_memcpy(&recno, dbtp->data, sizeof(recno));
snprintf(buf, DBTBUFLEN, "%lu", (u_long)recno);
/* If we're printing data as hex, print keys as hex too. */
if (!checkprint) {
for (len = (u_int32_t)strlen(buf), p = buf, hp = hbuf;
len-- > 0; ++p) {
*hp++ = hex[(u_int8_t)(*p & 0xf0) >> 4];
*hp++ = hex[*p & 0x0f];
}
*hp = '\0';
ret = callback(handle, hbuf);
} else
ret = callback(handle, buf);
if (ret != 0)
return (ret);
} else if (checkprint) {
for (len = dbtp->size, p = dbtp->data; len--; ++p)
if (isprint((int)*p)) {
if (*p == '\\' &&
(ret = callback(handle, "\\")) != 0)
return (ret);
snprintf(buf, DBTBUFLEN, "%c", *p);
if ((ret = callback(handle, buf)) != 0)
return (ret);
} else {
snprintf(buf, DBTBUFLEN, "\\%c%c",
hex[(u_int8_t)(*p & 0xf0) >> 4],
hex[*p & 0x0f]);
if ((ret = callback(handle, buf)) != 0)
return (ret);
}
} else
for (len = dbtp->size, p = dbtp->data; len--; ++p) {
snprintf(buf, DBTBUFLEN, "%c%c",
hex[(u_int8_t)(*p & 0xf0) >> 4],
hex[*p & 0x0f]);
if ((ret = callback(handle, buf)) != 0)
return (ret);
}
return (callback(handle, "\n"));
}
/*
* __db_proff --
* Print out an off-page element.
*/
static void
__db_proff(vp, fp)
void *vp;
FILE *fp;
{
BOVERFLOW *bo;
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 *, void *));
*/
void
__db_prflags(flags, fn, vfp)
u_int32_t flags;
FN const *fn;
void *vfp;
{
FILE *fp;
const FN *fnp;
int found;
const char *sep;
/*
* We pass the FILE * through a void * so that we can use
* this function as as a callback.
*/
fp = (FILE *)vfp;
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_dbtype_to_string --
* Return the name of the database type.
* PUBLIC: const char * __db_dbtype_to_string __P((DBTYPE));
*/
const char *
__db_dbtype_to_string(type)
DBTYPE type;
{
switch (type) {
case DB_BTREE:
return ("btree");
case DB_HASH:
return ("hash");
case DB_RECNO:
return ("recno");
case DB_QUEUE:
return ("queue");
default:
return ("UNKNOWN TYPE");
}
/* NOTREACHED */
}
/*
* __db_pagetype_to_string --
* Return the name of the specified page type.
*/
static const char *
__db_pagetype_to_string(type)
u_int32_t type;
{
char *s;
s = NULL;
switch (type) {
case P_BTREEMETA:
s = "btree metadata";
break;
case P_LDUP:
s = "duplicate";
break;
case P_HASH:
s = "hash";
break;
case P_HASHMETA:
s = "hash metadata";
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;
case P_QAMMETA:
s = "queue metadata";
break;
case P_QAMDATA:
s = "queue";
break;
default:
/* Just return a NULL. */
break;
}
return (s);
}
/*
* __db_prheader --
* Write out header information in the format expected by db_load.
*
* PUBLIC: int __db_prheader __P((DB *, char *, int, int, void *,
* PUBLIC: int (*)(void *, const void *), VRFY_DBINFO *, db_pgno_t));
*/
int
__db_prheader(dbp, subname, pflag, keyflag, handle, callback, vdp, meta_pgno)
DB *dbp;
char *subname;
int pflag, keyflag;
void *handle;
int (*callback) __P((void *, const void *));
VRFY_DBINFO *vdp;
db_pgno_t meta_pgno;
{
DB_BTREE_STAT *btsp;
DB_ENV *dbenv;
DB_HASH_STAT *hsp;
DB_QUEUE_STAT *qsp;
DBT dbt;
VRFY_PAGEINFO *pip;
char *buf;
int buflen, ret, t_ret;
u_int32_t dbtype;
btsp = NULL;
hsp = NULL;
qsp = NULL;
ret = 0;
buf = NULL;
COMPQUIET(buflen, 0);
if (dbp == NULL)
dbenv = NULL;
else
dbenv = dbp->dbenv;
/*
* If we've been passed a verifier statistics object, use
* that; we're being called in a context where dbp->stat
* is unsafe.
*
* Also, the verifier may set the pflag on a per-salvage basis.
* If so, respect that.
*/
if (vdp != NULL) {
if ((ret = __db_vrfy_getpageinfo(vdp, meta_pgno, &pip)) != 0)
return (ret);
if (F_ISSET(vdp, SALVAGE_PRINTABLE))
pflag = 1;
} else
pip = NULL;
/*
* If dbp is NULL, we're being called from inside __db_prdbt,
* and this is a special subdatabase for "lost" items. Make it a btree.
* Otherwise, set dbtype to the appropriate type for the specified
* meta page, or the type of the dbp.
*/
if (dbp == NULL)
dbtype = DB_BTREE;
else if (pip != NULL)
switch (pip->type) {
case P_BTREEMETA:
if (F_ISSET(pip, VRFY_IS_RECNO))
dbtype = DB_RECNO;
else
dbtype = DB_BTREE;
break;
case P_HASHMETA:
dbtype = DB_HASH;
break;
default:
/*
* If the meta page is of a bogus type, it's
* because we have a badly corrupt database.
* (We must be in the verifier for pip to be non-NULL.)
* Pretend we're a Btree and salvage what we can.
*/
DB_ASSERT(F_ISSET(dbp, DB_AM_VERIFYING));
dbtype = DB_BTREE;
break;
}
else
dbtype = dbp->type;
if ((ret = callback(handle, "VERSION=3\n")) != 0)
goto err;
if (pflag) {
if ((ret = callback(handle, "format=print\n")) != 0)
goto err;
} else if ((ret = callback(handle, "format=bytevalue\n")) != 0)
goto err;
/*
* 64 bytes is long enough, as a minimum bound, for any of the
* fields besides subname. Subname uses __db_prdbt and therefore
* does not need buffer space here.
*/
buflen = 64;
if ((ret = __os_malloc(dbenv, buflen, &buf)) != 0)
goto err;
if (subname != NULL) {
snprintf(buf, buflen, "database=");
if ((ret = callback(handle, buf)) != 0)
goto err;
memset(&dbt, 0, sizeof(dbt));
dbt.data = subname;
dbt.size = (u_int32_t)strlen(subname);
if ((ret = __db_prdbt(&dbt,
1, NULL, handle, callback, 0, NULL)) != 0)
goto err;
}
switch (dbtype) {
case DB_BTREE:
if ((ret = callback(handle, "type=btree\n")) != 0)
goto err;
if (pip != NULL) {
if (F_ISSET(pip, VRFY_HAS_RECNUMS))
if ((ret =
callback(handle, "recnum=1\n")) != 0)
goto err;
if (pip->bt_maxkey != 0) {
snprintf(buf, buflen,
"bt_maxkey=%lu\n", (u_long)pip->bt_maxkey);
if ((ret = callback(handle, buf)) != 0)
goto err;
}
if (pip->bt_minkey != 0 &&
pip->bt_minkey != DEFMINKEYPAGE) {
snprintf(buf, buflen,
"bt_minkey=%lu\n", (u_long)pip->bt_minkey);
if ((ret = callback(handle, buf)) != 0)
goto err;
}
break;
}
if ((ret = dbp->stat(dbp, &btsp, 0)) != 0) {
dbp->err(dbp, ret, "DB->stat");
goto err;
}
if (F_ISSET(dbp, DB_AM_RECNUM))
if ((ret = callback(handle, "recnum=1\n")) != 0)
goto err;
if (btsp->bt_maxkey != 0) {
snprintf(buf, buflen,
"bt_maxkey=%lu\n", (u_long)btsp->bt_maxkey);
if ((ret = callback(handle, buf)) != 0)
goto err;
}
if (btsp->bt_minkey != 0 && btsp->bt_minkey != DEFMINKEYPAGE) {
snprintf(buf, buflen,
"bt_minkey=%lu\n", (u_long)btsp->bt_minkey);
if ((ret = callback(handle, buf)) != 0)
goto err;
}
break;
case DB_HASH:
if ((ret = callback(handle, "type=hash\n")) != 0)
goto err;
if (pip != NULL) {
if (pip->h_ffactor != 0) {
snprintf(buf, buflen,
"h_ffactor=%lu\n", (u_long)pip->h_ffactor);
if ((ret = callback(handle, buf)) != 0)
goto err;
}
if (pip->h_nelem != 0) {
snprintf(buf, buflen,
"h_nelem=%lu\n", (u_long)pip->h_nelem);
if ((ret = callback(handle, buf)) != 0)
goto err;
}
break;
}
if ((ret = dbp->stat(dbp, &hsp, 0)) != 0) {
dbp->err(dbp, ret, "DB->stat");
goto err;
}
if (hsp->hash_ffactor != 0) {
snprintf(buf, buflen,
"h_ffactor=%lu\n", (u_long)hsp->hash_ffactor);
if ((ret = callback(handle, buf)) != 0)
goto err;
}
if (hsp->hash_nkeys != 0) {
snprintf(buf, buflen,
"h_nelem=%lu\n", (u_long)hsp->hash_nkeys);
if ((ret = callback(handle, buf)) != 0)
goto err;
}
break;
case DB_QUEUE:
if ((ret = callback(handle, "type=queue\n")) != 0)
goto err;
if (vdp != NULL) {
snprintf(buf,
buflen, "re_len=%lu\n", (u_long)vdp->re_len);
if ((ret = callback(handle, buf)) != 0)
goto err;
break;
}
if ((ret = dbp->stat(dbp, &qsp, 0)) != 0) {
dbp->err(dbp, ret, "DB->stat");
goto err;
}
snprintf(buf, buflen, "re_len=%lu\n", (u_long)qsp->qs_re_len);
if ((ret = callback(handle, buf)) != 0)
goto err;
if (qsp->qs_re_pad != 0 && qsp->qs_re_pad != ' ') {
snprintf(buf, buflen, "re_pad=%#x\n", qsp->qs_re_pad);
if ((ret = callback(handle, buf)) != 0)
goto err;
}
if (qsp->qs_extentsize != 0) {
snprintf(buf, buflen,
"extentsize=%lu\n", (u_long)qsp->qs_extentsize);
if ((ret = callback(handle, buf)) != 0)
goto err;
}
break;
case DB_RECNO:
if ((ret = callback(handle, "type=recno\n")) != 0)
goto err;
if (pip != NULL) {
if (F_ISSET(pip, VRFY_IS_RRECNO))
if ((ret =
callback(handle, "renumber=1\n")) != 0)
goto err;
if (pip->re_len > 0) {
snprintf(buf, buflen,
"re_len=%lu\n", (u_long)pip->re_len);
if ((ret = callback(handle, buf)) != 0)
goto err;
}
break;
}
if ((ret = dbp->stat(dbp, &btsp, 0)) != 0) {
dbp->err(dbp, ret, "DB->stat");
goto err;
}
if (F_ISSET(dbp, DB_AM_RENUMBER))
if ((ret = callback(handle, "renumber=1\n")) != 0)
goto err;
if (F_ISSET(dbp, DB_AM_FIXEDLEN)) {
snprintf(buf, buflen,
"re_len=%lu\n", (u_long)btsp->bt_re_len);
if ((ret = callback(handle, buf)) != 0)
goto err;
}
if (btsp->bt_re_pad != 0 && btsp->bt_re_pad != ' ') {
snprintf(buf, buflen, "re_pad=%#x\n", btsp->bt_re_pad);
if ((ret = callback(handle, buf)) != 0)
goto err;
}
break;
case DB_UNKNOWN:
DB_ASSERT(0); /* Impossible. */
__db_err(dbp->dbenv, "Impossible DB type in __db_prheader");
ret = EINVAL;
goto err;
}
if (pip != NULL) {
if (F_ISSET(pip, VRFY_HAS_DUPS))
if ((ret = callback(handle, "duplicates=1\n")) != 0)
goto err;
if (F_ISSET(pip, VRFY_HAS_DUPSORT))
if ((ret = callback(handle, "dupsort=1\n")) != 0)
goto err;
/* We should handle page size. XXX */
} else {
if (F_ISSET(dbp, DB_AM_CHKSUM))
if ((ret = callback(handle, "chksum=1\n")) != 0)
goto err;
if (F_ISSET(dbp, DB_AM_DUP))
if ((ret = callback(handle, "duplicates=1\n")) != 0)
goto err;
if (F_ISSET(dbp, DB_AM_DUPSORT))
if ((ret = callback(handle, "dupsort=1\n")) != 0)
goto err;
if (!F_ISSET(dbp, DB_AM_PGDEF)) {
snprintf(buf, buflen,
"db_pagesize=%lu\n", (u_long)dbp->pgsize);
if ((ret = callback(handle, buf)) != 0)
goto err;
}
}
if (keyflag && (ret = callback(handle, "keys=1\n")) != 0)
goto err;
ret = callback(handle, "HEADER=END\n");
err: if (pip != NULL &&
(t_ret = __db_vrfy_putpageinfo(dbenv, vdp, pip)) != 0 && ret == 0)
ret = t_ret;
if (btsp != NULL)
__os_ufree(dbenv, btsp);
if (hsp != NULL)
__os_ufree(dbenv, hsp);
if (qsp != NULL)
__os_ufree(dbenv, qsp);
if (buf != NULL)
__os_free(dbenv, buf);
return (ret);
}
/*
* __db_prfooter --
* Print the footer that marks the end of a DB dump. This is trivial,
* but for consistency's sake we don't want to put its literal contents
* in multiple places.
*
* PUBLIC: int __db_prfooter __P((void *, int (*)(void *, const void *)));
*/
int
__db_prfooter(handle, callback)
void *handle;
int (*callback) __P((void *, const void *));
{
return (callback(handle, "DATA=END\n"));
}
Reference in a new issue View git blame Copy permalink