开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
db_vrfy.c
资源名称：mysql-3.23.35.tar.gz　[点击查看]
上传用户：tsgydb
上传日期：2007-04-14
资源大小：10674k
文件大小：59k
源码类别：

MySQL数据库

开发平台：

Visual C++

db_vrfy.c：源码内容
  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 2000
  5.  * Sleepycat Software.  All rights reserved.
  6.  *
  7.  * $Id: db_vrfy.c,v 1.53 2001/01/11 18:19:51 bostic Exp $
  8.  */
  10. #include "db_config.h"
  12. #ifndef lint
  13. static const char revid[] = "$Id: db_vrfy.c,v 1.53 2001/01/11 18:19:51 bostic Exp $";
  14. #endif /* not lint */
  16. #ifndef NO_SYSTEM_INCLUDES
  17. #include <sys/types.h>
  19. #include <string.h>
  20. #endif
  22. #include "db_int.h"
  23. #include "db_page.h"
  24. #include "db_swap.h"
  25. #include "db_verify.h"
  26. #include "db_ext.h"
  27. #include "btree.h"
  28. #include "hash.h"
  29. #include "qam.h"
  31. static int  __db_guesspgsize __P((DB_ENV *, DB_FH *));
  32. static int  __db_is_valid_magicno __P((u_int32_t, DBTYPE *));
  33. static int  __db_is_valid_pagetype __P((u_int32_t));
  34. static int  __db_meta2pgset
  35. __P((DB *, VRFY_DBINFO *, db_pgno_t, u_int32_t, DB *));
  36. static int  __db_salvage_subdbs
  37. __P((DB *, VRFY_DBINFO *, void *,
  38. int(*)(void *, const void *), u_int32_t, int *));
  39. static int  __db_salvage_unknowns
  40. __P((DB *, VRFY_DBINFO *, void *,
  41. int (*)(void *, const void *), u_int32_t));
  42. static int  __db_vrfy_common
  43. __P((DB *, VRFY_DBINFO *, PAGE *, db_pgno_t, u_int32_t));
  44. static int  __db_vrfy_freelist __P((DB *, VRFY_DBINFO *, db_pgno_t, u_int32_t));
  45. static int  __db_vrfy_invalid
  46. __P((DB *, VRFY_DBINFO *, PAGE *, db_pgno_t, u_int32_t));
  47. static int  __db_vrfy_orderchkonly __P((DB *,
  48. VRFY_DBINFO *, const char *, const char *, u_int32_t));
  49. static int  __db_vrfy_pagezero __P((DB *, VRFY_DBINFO *, DB_FH *, u_int32_t));
  50. static int  __db_vrfy_subdbs
  51. __P((DB *, VRFY_DBINFO *, const char *, u_int32_t));
  52. static int  __db_vrfy_structure
  53. __P((DB *, VRFY_DBINFO *, const char *, db_pgno_t, u_int32_t));
  54. static int  __db_vrfy_walkpages
  55. __P((DB *, VRFY_DBINFO *, void *, int (*)(void *, const void *),
  56. u_int32_t));
  58. /*
  59.  * This is the code for DB->verify, the DB database consistency checker.
  60.  * For now, it checks all subdatabases in a database, and verifies
  61.  * everything it knows how to (i.e. it's all-or-nothing, and one can't
  62.  * check only for a subset of possible problems).
  63.  */
  65. /*
  66.  * __db_verify --
  67.  * Walk the entire file page-by-page, either verifying with or without
  68.  * dumping in db_dump -d format, or DB_SALVAGE-ing whatever key/data
  69.  * pairs can be found and dumping them in standard (db_load-ready)
  70.  * dump format.
  71.  *
  72.  * (Salvaging isn't really a verification operation, but we put it
  73.  * here anyway because it requires essentially identical top-level
  74.  * code.)
  75.  *
  76.  * flags may be 0, DB_NOORDERCHK, DB_ORDERCHKONLY, or DB_SALVAGE
  77.  * (and optionally DB_AGGRESSIVE).
  78.  *
  79.  * __db_verify itself is simply a wrapper to __db_verify_internal,
  80.  * which lets us pass appropriate equivalents to FILE * in from the
  81.  * non-C APIs.
  82.  *
  83.  * PUBLIC: int __db_verify
  84.  * PUBLIC:     __P((DB *, const char *, const char *, FILE *, u_int32_t));
  85.  */
  86. int
  87. __db_verify(dbp, file, database, outfile, flags)
  88. DB *dbp;
  89. const char *file, *database;
  90. FILE *outfile;
  91. u_int32_t flags;
  92. {
  94. return (__db_verify_internal(dbp,
  95.     file, database, outfile, __db_verify_callback, flags));
  96. }
  98. /*
  99.  * __db_verify_callback --
  100.  * Callback function for using pr_* functions from C.
  101.  *
  102.  * PUBLIC: int  __db_verify_callback __P((void *, const void *));
  103.  */
  104. int
  105. __db_verify_callback(handle, str_arg)
  106. void *handle;
  107. const void *str_arg;
  108. {
  109. char *str;
  110. FILE *f;
  112. str = (char *)str_arg;
  113. f = (FILE *)handle;
  115. if (fprintf(f, "%s", str) != (int)strlen(str))
  116. return (EIO);
  118. return (0);
  119. }
  121. /*
  122.  * __db_verify_internal --
  123.  * Inner meat of __db_verify.
  124.  *
  125.  * PUBLIC: int __db_verify_internal __P((DB *, const char *,
  126.  * PUBLIC:     const char *, void *, int (*)(void *, const void *), u_int32_t));
  127.  */
  128. int
  129. __db_verify_internal(dbp_orig, name, subdb, handle, callback, flags)
  130. DB *dbp_orig;
  131. const char *name, *subdb;
  132. void *handle;
  133. int (*callback) __P((void *, const void *));
  134. u_int32_t flags;
  135. {
  136. DB *dbp;
  137. DB_ENV *dbenv;
  138. DB_FH fh, *fhp;
  139. PAGE *h;
  140. VRFY_DBINFO *vdp;
  141. db_pgno_t last;
  142. int has, ret, isbad;
  143. char *real_name;
  145. dbenv = dbp_orig->dbenv;
  146. vdp = NULL;
  147. real_name = NULL;
  148. ret = isbad = 0;
  150. memset(&fh, 0, sizeof(fh));
  151. fhp = &fh;
  153. PANIC_CHECK(dbenv);
  154. DB_ILLEGAL_AFTER_OPEN(dbp_orig, "verify");
  156. #define OKFLAGS (DB_AGGRESSIVE | DB_NOORDERCHK | DB_ORDERCHKONLY | DB_SALVAGE)
  157. if ((ret = __db_fchk(dbenv, "DB->verify", flags, OKFLAGS)) != 0)
  158. return (ret);
  160. /*
  161.  * DB_SALVAGE is mutually exclusive with the other flags except
  162.  * DB_AGGRESSIVE.
  163.  */
  164. if (LF_ISSET(DB_SALVAGE) &&
  165.     (flags & ~DB_AGGRESSIVE) != DB_SALVAGE)
  166. return (__db_ferr(dbenv, "__db_verify", 1));
  168. if (LF_ISSET(DB_ORDERCHKONLY) && flags != DB_ORDERCHKONLY)
  169. return (__db_ferr(dbenv, "__db_verify", 1));
  171. if (LF_ISSET(DB_ORDERCHKONLY) && subdb == NULL) {
  172. __db_err(dbenv, "DB_ORDERCHKONLY requires a database name");
  173. return (EINVAL);
  174. }
  176. /*
  177.  * Forbid working in an environment that uses transactions or
  178.  * locking;  we're going to be looking at the file freely,
  179.  * and while we're not going to modify it, we aren't obeying
  180.  * locking conventions either.
  181.  */
  182. if (TXN_ON(dbenv) || LOCKING_ON(dbenv) || LOGGING_ON(dbenv)) {
  183. dbp_orig->errx(dbp_orig,
  184.     "verify may not be used with transactions, logging, or locking");
  185. return (EINVAL);
  186. /* NOTREACHED */
  187. }
  189. /* Create a dbp to use internally, which we can close at our leisure. */
  190. if ((ret = db_create(&dbp, dbenv, 0)) != 0)
  191. goto err;
  193. F_SET(dbp, DB_AM_VERIFYING);
  195. /* Copy the supplied pagesize, which we use if the file one is bogus. */
  196. if (dbp_orig->pgsize >= DB_MIN_PGSIZE &&
  197.     dbp_orig->pgsize <= DB_MAX_PGSIZE)
  198. dbp->set_pagesize(dbp, dbp_orig->pgsize);
  200. /* Copy the feedback function, if present, and initialize it. */
  201. if (!LF_ISSET(DB_SALVAGE) && dbp_orig->db_feedback != NULL) {
  202. dbp->set_feedback(dbp, dbp_orig->db_feedback);
  203. dbp->db_feedback(dbp, DB_VERIFY, 0);
  204. }
  206. /*
  207.  * Copy the comparison and hashing functions.  Note that
  208.  * even if the database is not a hash or btree, the respective
  209.  * internal structures will have been initialized.
  210.  */
  211. if (dbp_orig->dup_compare != NULL &&
  212.     (ret = dbp->set_dup_compare(dbp, dbp_orig->dup_compare)) != 0)
  213. goto err;
  214. if (((BTREE *)dbp_orig->bt_internal)->bt_compare != NULL &&
  215.     (ret = dbp->set_bt_compare(dbp,
  216.     ((BTREE *)dbp_orig->bt_internal)->bt_compare)) != 0)
  217. goto err;
  218. if (((HASH *)dbp_orig->h_internal)->h_hash != NULL &&
  219.     (ret = dbp->set_h_hash(dbp,
  220.     ((HASH *)dbp_orig->h_internal)->h_hash)) != 0)
  221. goto err;
  223. /*
  224.  * We don't know how large the cache is, and if the database
  225.  * in question uses a small page size--which we don't know
  226.  * yet!--it may be uncomfortably small for the default page
  227.  * size [#2143].  However, the things we need temporary
  228.  * databases for in dbinfo are largely tiny, so using a
  229.  * 1024-byte pagesize is probably not going to be a big hit,
  230.  * and will make us fit better into small spaces.
  231.  */
  232. if ((ret = __db_vrfy_dbinfo_create(dbenv, 1024, &vdp)) != 0)
  233. goto err;
  235. /* Find the real name of the file. */
  236. if ((ret = __db_appname(dbenv,
  237.     DB_APP_DATA, NULL, name, 0, NULL, &real_name)) != 0)
  238. goto err;
  240. /*
  241.  * Our first order of business is to verify page 0, which is
  242.  * the metadata page for the master database of subdatabases
  243.  * or of the only database in the file.  We want to do this by hand
  244.  * rather than just calling __db_open in case it's corrupt--various
  245.  * things in __db_open might act funny.
  246.  *
  247.  * Once we know the metadata page is healthy, I believe that it's
  248.  * safe to open the database normally and then use the page swapping
  249.  * code, which makes life easier.
  250.  */
  251. if ((ret = __os_open(dbenv, real_name, DB_OSO_RDONLY, 0444, fhp)) != 0)
  252. goto err;
  254. /* Verify the metadata page 0; set pagesize and type. */
  255. if ((ret = __db_vrfy_pagezero(dbp, vdp, fhp, flags)) != 0) {
  256. if (ret == DB_VERIFY_BAD)
  257. isbad = 1;
  258. else
  259. goto err;
  260. }
  262. /*
  263.  * We can assume at this point that dbp->pagesize and dbp->type are
  264.  * set correctly, or at least as well as they can be, and that
  265.  * locking, logging, and txns are not in use.  Thus we can trust
  266.  * the memp code not to look at the page, and thus to be safe
  267.  * enough to use.
  268.  *
  269.  * The dbp is not open, but the file is open in the fhp, and we
  270.  * cannot assume that __db_open is safe.  Call __db_dbenv_setup,
  271.  * the [safe] part of __db_open that initializes the environment--
  272.  * and the mpool--manually.
  273.  */
  274. if ((ret = __db_dbenv_setup(dbp,
  275.     name, DB_ODDFILESIZE | DB_RDONLY)) != 0)
  276. return (ret);
  278. /* Mark the dbp as opened, so that we correctly handle its close. */
  279. F_SET(dbp, DB_OPEN_CALLED);
  281. /*
  282.  * Find out the page number of the last page in the database.
  283.  *
  284.  * XXX: This currently fails if the last page is of bad type,
  285.  * because it calls __db_pgin and that pukes.  This is bad.
  286.  */
  287. if ((ret = memp_fget(dbp->mpf, &last, DB_MPOOL_LAST, &h)) != 0)
  288. goto err;
  289. if ((ret = memp_fput(dbp->mpf, h, 0)) != 0)
  290. goto err;
  292. vdp->last_pgno = last;
  294. /*
  295.  * DB_ORDERCHKONLY is a special case;  our file consists of
  296.  * several subdatabases, which use different hash, bt_compare,
  297.  * and/or dup_compare functions.  Consequently, we couldn't verify
  298.  * sorting and hashing simply by calling DB->verify() on the file.
  299.  * DB_ORDERCHKONLY allows us to come back and check those things;  it
  300.  * requires a subdatabase, and assumes that everything but that
  301.  * database's sorting/hashing is correct.
  302.  */
  303. if (LF_ISSET(DB_ORDERCHKONLY)) {
  304. ret = __db_vrfy_orderchkonly(dbp, vdp, name, subdb, flags);
  305. goto done;
  306. }
  308. /*
  309.  * When salvaging, we use a db to keep track of whether we've seen a
  310.  * given overflow or dup page in the course of traversing normal data.
  311.  * If in the end we have not, we assume its key got lost and print it
  312.  * with key "UNKNOWN".
  313.  */
  314. if (LF_ISSET(DB_SALVAGE)) {
  315. if ((ret = __db_salvage_init(vdp)) != 0)
  316. return (ret);
  318. /*
  319.  * If we're not being aggressive, attempt to crack subdbs.
  320.  * "has" will indicate whether the attempt has succeeded
  321.  * (even in part), meaning that we have some semblance of
  322.  * subdbs;  on the walkpages pass, we print out
  323.  * whichever data pages we have not seen.
  324.  */
  325. has = 0;
  326. if (!LF_ISSET(DB_AGGRESSIVE) && (__db_salvage_subdbs(dbp,
  327.     vdp, handle, callback, flags, &has)) != 0)
  328. isbad = 1;
  330. /*
  331.  * If we have subdatabases, we need to signal that if
  332.  * any keys are found that don't belong to a subdatabase,
  333.  * they'll need to have an "__OTHER__" subdatabase header
  334.  * printed first.  Flag this.  Else, print a header for
  335.  * the normal, non-subdb database.
  336.  */
  337. if (has == 1)
  338. F_SET(vdp, SALVAGE_PRINTHEADER);
  339. else if ((ret = __db_prheader(dbp,
  340.     NULL, 0, 0, handle, callback, vdp, PGNO_BASE_MD)) != 0)
  341. goto err;
  342. }
  344. if ((ret =
  345.     __db_vrfy_walkpages(dbp, vdp, handle, callback, flags)) != 0) {
  346. if (ret == DB_VERIFY_BAD)
  347. isbad = 1;
  348. else if (ret != 0)
  349. goto err;
  350. }
  352. /* If we're verifying, verify inter-page structure. */
  353. if (!LF_ISSET(DB_SALVAGE) && isbad == 0)
  354. if ((ret =
  355.     __db_vrfy_structure(dbp, vdp, name, 0, flags)) != 0) {
  356. if (ret == DB_VERIFY_BAD)
  357. isbad = 1;
  358. else if (ret != 0)
  359. goto err;
  360. }
  362. /*
  363.  * If we're salvaging, output with key UNKNOWN any overflow or dup pages
  364.  * we haven't been able to put in context.  Then destroy the salvager's
  365.  * state-saving database.
  366.  */
  367. if (LF_ISSET(DB_SALVAGE)) {
  368. if ((ret = __db_salvage_unknowns(dbp,
  369.     vdp, handle, callback, flags)) != 0)
  370. isbad = 1;
  371. /* No return value, since there's little we can do. */
  372. __db_salvage_destroy(vdp);
  373. }
  375. if (0) {
  376. err: (void)__db_err(dbenv, "%s: %s", name, db_strerror(ret));
  377. }
  379. if (LF_ISSET(DB_SALVAGE) &&
  380.     (has == 0 || F_ISSET(vdp, SALVAGE_PRINTFOOTER)))
  381. (void)__db_prfooter(handle, callback);
  383. /* Send feedback that we're done. */
  384. done: if (!LF_ISSET(DB_SALVAGE) && dbp->db_feedback != NULL)
  385. dbp->db_feedback(dbp, DB_VERIFY, 100);
  387. if (F_ISSET(fhp, DB_FH_VALID))
  388. (void)__os_closehandle(fhp);
  389. if (dbp)
  390. (void)dbp->close(dbp, 0);
  391. if (vdp)
  392. (void)__db_vrfy_dbinfo_destroy(vdp);
  393. if (real_name)
  394. __os_freestr(real_name);
  396. if ((ret == 0 && isbad == 1) || ret == DB_VERIFY_FATAL)
  397. ret = DB_VERIFY_BAD;
  399. return (ret);
  400. }
  402. /*
  403.  * __db_vrfy_pagezero --
  404.  * Verify the master metadata page.  Use seek, read, and a local buffer
  405.  * rather than the DB paging code, for safety.
  406.  *
  407.  * Must correctly (or best-guess) set dbp->type and dbp->pagesize.
  408.  */
  409. static int
  410. __db_vrfy_pagezero(dbp, vdp, fhp, flags)
  411. DB *dbp;
  412. VRFY_DBINFO *vdp;
  413. DB_FH *fhp;
  414. u_int32_t flags;
  415. {
  416. DBMETA *meta;
  417. DB_ENV *dbenv;
  418. VRFY_PAGEINFO *pip;
  419. db_pgno_t freelist;
  420. int t_ret, ret, nr, swapped;
  421. u_int8_t mbuf[DBMETASIZE];
  423. swapped = ret = t_ret = 0;
  424. freelist = 0;
  425. dbenv = dbp->dbenv;
  426. meta = (DBMETA *)mbuf;
  427. dbp->type = DB_UNKNOWN;
  429. /*
  430.  * Seek to the metadata page.
  431.  * Note that if we're just starting a verification, dbp->pgsize
  432.  * may be zero;  this is okay, as we want page zero anyway and
  433.  * 0*0 == 0.
  434.  */
  435. if ((ret = __os_seek(dbenv, fhp, 0, 0, 0, 0, DB_OS_SEEK_SET)) != 0)
  436. goto err;
  438. if ((ret = __os_read(dbenv, fhp, mbuf, DBMETASIZE, (size_t *)&nr)) != 0)
  439. goto err;
  441. if (nr != DBMETASIZE) {
  442. EPRINT((dbp->dbenv,
  443.     "Incomplete metadata page %lu", (u_long)PGNO_BASE_MD));
  444. t_ret = DB_VERIFY_FATAL;
  445. goto err;
  446. }
  448. /*
  449.  * Check all of the fields that we can.
  450.  */
  452. /* 08-11: Current page number.  Must == pgno. */
  453. /* Note that endianness doesn't matter--it's zero. */
  454. if (meta->pgno != PGNO_BASE_MD) {
  455. EPRINT((dbp->dbenv, "Bad pgno: was %lu, should be %lu",
  456.     (u_long)meta->pgno, (u_long)PGNO_BASE_MD));
  457. ret = DB_VERIFY_BAD;
  458. }
  460. /* 12-15: Magic number.  Must be one of valid set. */
  461. if (__db_is_valid_magicno(meta->magic, &dbp->type))
  462. swapped = 0;
  463. else {
  464. M_32_SWAP(meta->magic);
  465. if (__db_is_valid_magicno(meta->magic,
  466.     &dbp->type))
  467. swapped = 1;
  468. else {
  469. EPRINT((dbp->dbenv,
  470.     "Bad magic number: %lu", (u_long)meta->magic));
  471. ret = DB_VERIFY_BAD;
  472. }
  473. }
  475. /*
  476.  * 16-19: Version.  Must be current;  for now, we
  477.  * don't support verification of old versions.
  478.  */
  479. if (swapped)
  480. M_32_SWAP(meta->version);
  481. if ((dbp->type == DB_BTREE && meta->version != DB_BTREEVERSION) ||
  482.     (dbp->type == DB_HASH && meta->version != DB_HASHVERSION) ||
  483.     (dbp->type == DB_QUEUE && meta->version != DB_QAMVERSION)) {
  484. ret = DB_VERIFY_BAD;
  485. EPRINT((dbp->dbenv, "%s%s", "Old or incorrect DB ",
  486.     "version; extraneous errors may result"));
  487. }
  489. /*
  490.  * 20-23: Pagesize.  Must be power of two,
  491.  * greater than 512, and less than 64K.
  492.  */
  493. if (swapped)
  494. M_32_SWAP(meta->pagesize);
  495. if (IS_VALID_PAGESIZE(meta->pagesize))
  496. dbp->pgsize = meta->pagesize;
  497. else {
  498. EPRINT((dbp->dbenv,
  499.     "Bad page size: %lu", (u_long)meta->pagesize));
  500. ret = DB_VERIFY_BAD;
  502. /*
  503.  * Now try to settle on a pagesize to use.
  504.  * If the user-supplied one is reasonable,
  505.  * use it;  else, guess.
  506.  */
  507. if (!IS_VALID_PAGESIZE(dbp->pgsize))
  508. dbp->pgsize = __db_guesspgsize(dbenv, fhp);
  509. }
  511. /*
  512.  * 25: Page type.  Must be correct for dbp->type,
  513.  * which is by now set as well as it can be.
  514.  */
  515. /* Needs no swapping--only one byte! */
  516. if ((dbp->type == DB_BTREE && meta->type != P_BTREEMETA) ||
  517.     (dbp->type == DB_HASH && meta->type != P_HASHMETA) ||
  518.     (dbp->type == DB_QUEUE && meta->type != P_QAMMETA)) {
  519. ret = DB_VERIFY_BAD;
  520. EPRINT((dbp->dbenv, "Bad page type: %lu", (u_long)meta->type));
  521. }
  523. /*
  524.  * 28-31: Free list page number.
  525.  * We'll verify its sensibility when we do inter-page
  526.  * verification later;  for now, just store it.
  527.  */
  528. if (swapped)
  529.     M_32_SWAP(meta->free);
  530. freelist = meta->free;
  532. /*
  533.  * Initialize vdp->pages to fit a single pageinfo structure for
  534.  * this one page.  We'll realloc later when we know how many
  535.  * pages there are.
  536.  */
  537. if ((ret = __db_vrfy_getpageinfo(vdp, PGNO_BASE_MD, &pip)) != 0)
  538. return (ret);
  539. pip->pgno = PGNO_BASE_MD;
  540. pip->type = meta->type;
  542. /*
  543.  * Signal that we still have to check the info specific to
  544.  * a given type of meta page.
  545.  */
  546. F_SET(pip, VRFY_INCOMPLETE);
  548. pip->free = freelist;
  550. if ((ret = __db_vrfy_putpageinfo(vdp, pip)) != 0)
  551. return (ret);
  553. /* Set up the dbp's fileid.  We don't use the regular open path. */
  554. memcpy(dbp->fileid, meta->uid, DB_FILE_ID_LEN);
  556. if (0) {
  557. err: __db_err(dbenv, "%s", db_strerror(ret));
  558. }
  560. if (swapped == 1)
  561. F_SET(dbp, DB_AM_SWAP);
  562. if (t_ret != 0)
  563. ret = t_ret;
  564. return (ret);
  565. }
  567. /*
  568.  * __db_vrfy_walkpages --
  569.  * Main loop of the verifier/salvager.  Walks through,
  570.  * page by page, and verifies all pages and/or prints all data pages.
  571.  */
  572. static int
  573. __db_vrfy_walkpages(dbp, vdp, handle, callback, flags)
  574. DB *dbp;
  575. VRFY_DBINFO *vdp;
  576. void *handle;
  577. int (*callback) __P((void *, const void *));
  578. u_int32_t flags;
  579. {
  580. DB_ENV *dbenv;
  581. PAGE *h;
  582. db_pgno_t i;
  583. int ret, t_ret, isbad;
  585. ret = isbad = t_ret = 0;
  586. dbenv = dbp->dbenv;
  588. if ((ret = __db_fchk(dbenv,
  589.     "__db_vrfy_walkpages", flags, OKFLAGS)) != 0)
  590. return (ret);
  592. for (i = 0; i <= vdp->last_pgno; i++) {
  593. /*
  594.  * If DB_SALVAGE is set, we inspect our database of
  595.  * completed pages, and skip any we've already printed in
  596.  * the subdb pass.
  597.  */
  598. if (LF_ISSET(DB_SALVAGE) && (__db_salvage_isdone(vdp, i) != 0))
  599. continue;
  601. /* If an individual page get fails, keep going. */
  602. if ((t_ret = memp_fget(dbp->mpf, &i, 0, &h)) != 0) {
  603. if (ret == 0)
  604. ret = t_ret;
  605. continue;
  606. }
  608. if (LF_ISSET(DB_SALVAGE)) {
  609. /*
  610.  * We pretty much don't want to quit unless a
  611.  * bomb hits.  May as well return that something
  612.  * was screwy, however.
  613.  */
  614. if ((t_ret = __db_salvage(dbp,
  615.     vdp, i, h, handle, callback, flags)) != 0) {
  616. if (ret == 0)
  617. ret = t_ret;
  618. isbad = 1;
  619. }
  620. } else {
  621. /*
  622.  * Verify info common to all page
  623.  * types.
  624.  */
  625. if (i != PGNO_BASE_MD)
  626. if ((t_ret = __db_vrfy_common(dbp,
  627.     vdp, h, i, flags)) == DB_VERIFY_BAD)
  628. isbad = 1;
  630. switch (TYPE(h)) {
  631. case P_INVALID:
  632. t_ret = __db_vrfy_invalid(dbp,
  633.     vdp, h, i, flags);
  634. break;
  635. case __P_DUPLICATE:
  636. isbad = 1;
  637. EPRINT((dbp->dbenv,
  638.     "Old-style duplicate page: %lu",
  639.     (u_long)i));
  640. break;
  641. case P_HASH:
  642. t_ret = __ham_vrfy(dbp,
  643.     vdp, h, i, flags);
  644. break;
  645. case P_IBTREE:
  646. case P_IRECNO:
  647. case P_LBTREE:
  648. case P_LDUP:
  649. t_ret = __bam_vrfy(dbp,
  650.     vdp, h, i, flags);
  651. break;
  652. case P_LRECNO:
  653. t_ret = __ram_vrfy_leaf(dbp,
  654.     vdp, h, i, flags);
  655. break;
  656. case P_OVERFLOW:
  657. t_ret = __db_vrfy_overflow(dbp,
  658.     vdp, h, i, flags);
  659. break;
  660. case P_HASHMETA:
  661. t_ret = __ham_vrfy_meta(dbp,
  662.     vdp, (HMETA *)h, i, flags);
  663. break;
  664. case P_BTREEMETA:
  665. t_ret = __bam_vrfy_meta(dbp,
  666.     vdp, (BTMETA *)h, i, flags);
  667. break;
  668. case P_QAMMETA:
  669. t_ret = __qam_vrfy_meta(dbp,
  670.     vdp, (QMETA *)h, i, flags);
  671. break;
  672. case P_QAMDATA:
  673. t_ret = __qam_vrfy_data(dbp,
  674.     vdp, (QPAGE *)h, i, flags);
  675. break;
  676. default:
  677. EPRINT((dbp->dbenv,
  678.     "Unknown page type: %lu", (u_long)TYPE(h)));
  679. isbad = 1;
  680. break;
  681. }
  683. /*
  684.  * Set up error return.
  685.  */
  686. if (t_ret == DB_VERIFY_BAD)
  687. isbad = 1;
  688. else if (t_ret == DB_VERIFY_FATAL)
  689. goto err;
  690. else
  691. ret = t_ret;
  693. /*
  694.  * Provide feedback to the application about our
  695.  * progress.  The range 0-50% comes from the fact
  696.  * that this is the first of two passes through the
  697.  * database (front-to-back, then top-to-bottom).
  698.  */
  699. if (dbp->db_feedback != NULL)
  700. dbp->db_feedback(dbp, DB_VERIFY,
  701.     (i + 1) * 50 / (vdp->last_pgno + 1));
  702. }
  704. if ((t_ret = memp_fput(dbp->mpf, h, 0)) != 0 && ret == 0)
  705. ret = t_ret;
  706. }
  708. if (0) {
  709. err: if ((t_ret = memp_fput(dbp->mpf, h, 0)) != 0)
  710. return (ret == 0 ? t_ret : ret);
  711. return (DB_VERIFY_BAD);
  712. }
  714. return ((isbad == 1 && ret == 0) ? DB_VERIFY_BAD : ret);
  715. }
  717. /*
  718.  * __db_vrfy_structure--
  719.  * After a beginning-to-end walk through the database has been
  720.  * completed, put together the information that has been collected
  721.  * to verify the overall database structure.
  722.  *
  723.  * Should only be called if we want to do a database verification,
  724.  * i.e. if DB_SALVAGE is not set.
  725.  */
  726. static int
  727. __db_vrfy_structure(dbp, vdp, dbname, meta_pgno, flags)
  728. DB *dbp;
  729. VRFY_DBINFO *vdp;
  730. const char *dbname;
  731. db_pgno_t meta_pgno;
  732. u_int32_t flags;
  733. {
  734. DB *pgset;
  735. DB_ENV *dbenv;
  736. VRFY_PAGEINFO *pip;
  737. db_pgno_t i;
  738. int ret, isbad, hassubs, p;
  740. isbad = 0;
  741. pip = NULL;
  742. dbenv = dbp->dbenv;
  743. pgset = vdp->pgset;
  745. if ((ret = __db_fchk(dbenv, "DB->verify", flags, OKFLAGS)) != 0)
  746. return (ret);
  747. if (LF_ISSET(DB_SALVAGE)) {
  748. __db_err(dbenv, "__db_vrfy_structure called with DB_SALVAGE");
  749. return (EINVAL);
  750. }
  752. /*
  753.  * Providing feedback here is tricky;  in most situations,
  754.  * we fetch each page one more time, but we do so in a top-down
  755.  * order that depends on the access method.  Worse, we do this
  756.  * recursively in btree, such that on any call where we're traversing
  757.  * a subtree we don't know where that subtree is in the whole database;
  758.  * worse still, any given database may be one of several subdbs.
  759.  *
  760.  * The solution is to decrement a counter vdp->pgs_remaining each time
  761.  * we verify (and call feedback on) a page.  We may over- or
  762.  * under-count, but the structure feedback function will ensure that we
  763.  * never give a percentage under 50 or over 100.  (The first pass
  764.  * covered the range 0-50%.)
  765.  */
  766. if (dbp->db_feedback != NULL)
  767. vdp->pgs_remaining = vdp->last_pgno + 1;
  769. /*
  770.  * Call the appropriate function to downwards-traverse the db type.
  771.  */
  772. switch(dbp->type) {
  773. case DB_BTREE:
  774. case DB_RECNO:
  775. if ((ret = __bam_vrfy_structure(dbp, vdp, 0, flags)) != 0) {
  776. if (ret == DB_VERIFY_BAD)
  777. isbad = 1;
  778. else
  779. goto err;
  780. }
  782. /*
  783.  * If we have subdatabases and we know that the database is,
  784.  * thus far, sound, it's safe to walk the tree of subdatabases.
  785.  * Do so, and verify the structure of the databases within.
  786.  */
  787. if ((ret = __db_vrfy_getpageinfo(vdp, 0, &pip)) != 0)
  788. goto err;
  789. hassubs = F_ISSET(pip, VRFY_HAS_SUBDBS);
  790. if ((ret = __db_vrfy_putpageinfo(vdp, pip)) != 0)
  791. goto err;
  793. if (isbad == 0 && hassubs)
  794. if ((ret =
  795.     __db_vrfy_subdbs(dbp, vdp, dbname, flags)) != 0) {
  796. if (ret == DB_VERIFY_BAD)
  797. isbad = 1;
  798. else
  799. goto err;
  800. }
  801. break;
  802. case DB_HASH:
  803. if ((ret = __ham_vrfy_structure(dbp, vdp, 0, flags)) != 0) {
  804. if (ret == DB_VERIFY_BAD)
  805. isbad = 1;
  806. else
  807. goto err;
  808. }
  809. break;
  810. case DB_QUEUE:
  811. if ((ret = __qam_vrfy_structure(dbp, vdp, flags)) != 0) {
  812. if (ret == DB_VERIFY_BAD)
  813. isbad = 1;
  814. }
  816. /*
  817.  * Queue pages may be unreferenced and totally zeroed, if
  818.  * they're empty;  queue doesn't have much structure, so
  819.  * this is unlikely to be wrong in any troublesome sense.
  820.  * Skip to "err".
  821.  */
  822. goto err;
  823. /* NOTREACHED */
  824. default:
  825. /* This should only happen if the verifier is somehow broken. */
  826. DB_ASSERT(0);
  827. ret = EINVAL;
  828. goto err;
  829. /* NOTREACHED */
  830. }
  832. /* Walk free list. */
  833. if ((ret =
  834.     __db_vrfy_freelist(dbp, vdp, meta_pgno, flags)) == DB_VERIFY_BAD)
  835. isbad = 1;
  837. /*
  838.  * If structure checks up until now have failed, it's likely that
  839.  * checking what pages have been missed will result in oodles of
  840.  * extraneous error messages being EPRINTed.  Skip to the end
  841.  * if this is the case;  we're going to be printing at least one
  842.  * error anyway, and probably all the more salient ones.
  843.  */
  844. if (ret != 0 || isbad == 1)
  845. goto err;
  847. /*
  848.  * Make sure no page has been missed and that no page is still marked
  849.  * "all zeroes" (only certain hash pages can be, and they're unmarked
  850.  * in __ham_vrfy_structure).
  851.  */
  852. for (i = 0; i < vdp->last_pgno + 1; i++) {
  853. if ((ret = __db_vrfy_getpageinfo(vdp, i, &pip)) != 0)
  854. goto err;
  855. if ((ret = __db_vrfy_pgset_get(pgset, i, &p)) != 0)
  856. goto err;
  857. if (p == 0) {
  858. EPRINT((dbp->dbenv,
  859.     "Unreferenced page %lu", (u_long)i));
  860. isbad = 1;
  861. }
  863. if (F_ISSET(pip, VRFY_IS_ALLZEROES)) {
  864. EPRINT((dbp->dbenv,
  865.     "Totally zeroed page %lu", (u_long)i));
  866. isbad = 1;
  867. }
  868. if ((ret = __db_vrfy_putpageinfo(vdp, pip)) != 0)
  869. goto err;
  870. pip = NULL;
  871. }
  873. err: if (pip != NULL)
  874. (void)__db_vrfy_putpageinfo(vdp, pip);
  876. return ((isbad == 1 && ret == 0) ? DB_VERIFY_BAD : ret);
  877. }
  879. /*
  880.  * __db_is_valid_pagetype
  881.  */
  882. static int
  883. __db_is_valid_pagetype(type)
  884. u_int32_t type;
  885. {
  886. switch (type) {
  887. case P_INVALID: /* Order matches ordinal value. */
  888. case P_HASH:
  889. case P_IBTREE:
  890. case P_IRECNO:
  891. case P_LBTREE:
  892. case P_LRECNO:
  893. case P_OVERFLOW:
  894. case P_HASHMETA:
  895. case P_BTREEMETA:
  896. case P_QAMMETA:
  897. case P_QAMDATA:
  898. case P_LDUP:
  899. return (1);
  900. }
  901. return (0);
  902. }
  904. /*
  905.  * __db_is_valid_magicno
  906.  */
  907. static int
  908. __db_is_valid_magicno(magic, typep)
  909. u_int32_t magic;
  910. DBTYPE *typep;
  911. {
  912. switch (magic) {
  913. case DB_BTREEMAGIC:
  914. *typep = DB_BTREE;
  915. return (1);
  916. case DB_HASHMAGIC:
  917. *typep = DB_HASH;
  918. return (1);
  919. case DB_QAMMAGIC:
  920. *typep = DB_QUEUE;
  921. return (1);
  922. }
  923. *typep = DB_UNKNOWN;
  924. return (0);
  925. }
  927. /*
  928.  * __db_vrfy_common --
  929.  * Verify info common to all page types.
  930.  */
  931. static int
  932. __db_vrfy_common(dbp, vdp, h, pgno, flags)
  933. DB *dbp;
  934. VRFY_DBINFO *vdp;
  935. PAGE *h;
  936. db_pgno_t pgno;
  937. u_int32_t flags;
  938. {
  939. VRFY_PAGEINFO *pip;
  940. int ret, t_ret;
  941. u_int8_t *p;
  943. if ((ret = __db_vrfy_getpageinfo(vdp, pgno, &pip)) != 0)
  944. return (ret);
  946. pip->pgno = pgno;
  947. F_CLR(pip, VRFY_IS_ALLZEROES);
  949. /*
  950.  * Hash expands the table by leaving some pages between the
  951.  * old last and the new last totally zeroed.  Its pgin function
  952.  * should fix things, but we might not be using that (e.g. if
  953.  * we're a subdatabase).
  954.  *
  955.  * Queue will create sparse files if sparse record numbers are used.
  956.  */
  957. if (pgno != 0 && PGNO(h) == 0) {
  958. for (p = (u_int8_t *)h; p < (u_int8_t *)h + dbp->pgsize; p++)
  959. if (*p != 0) {
  960. EPRINT((dbp->dbenv,
  961.     "Page %lu should be zeroed and is not",
  962.     (u_long)pgno));
  963. ret = DB_VERIFY_BAD;
  964. goto err;
  965. }
  966. /*
  967.  * It's totally zeroed;  mark it as a hash, and we'll
  968.  * check that that makes sense structurally later.
  969.  * (The queue verification doesn't care, since queues
  970.  * don't really have much in the way of structure.)
  971.  */
  972. pip->type = P_HASH;
  973. F_SET(pip, VRFY_IS_ALLZEROES);
  974. ret = 0;
  975. goto err; /* well, not really an err. */
  976. }
  978. if (PGNO(h) != pgno) {
  979. EPRINT((dbp->dbenv,
  980.     "Bad page number: %lu should be %lu",
  981.     (u_long)h->pgno, (u_long)pgno));
  982. ret = DB_VERIFY_BAD;
  983. }
  985. if (!__db_is_valid_pagetype(h->type)) {
  986. EPRINT((dbp->dbenv, "Bad page type: %lu", (u_long)h->type));
  987. ret = DB_VERIFY_BAD;
  988. }
  989. pip->type = h->type;
  991. err: if ((t_ret = __db_vrfy_putpageinfo(vdp, pip)) != 0 && ret == 0)
  992. ret = t_ret;
  994. return (ret);
  995. }
  997. /*
  998.  * __db_vrfy_invalid --
  999.  * Verify P_INVALID page.
  1000.  * (Yes, there's not much to do here.)
  1001.  */
  1002. static int
  1003. __db_vrfy_invalid(dbp, vdp, h, pgno, flags)
  1004. DB *dbp;
  1005. VRFY_DBINFO *vdp;
  1006. PAGE *h;
  1007. db_pgno_t pgno;
  1008. u_int32_t flags;
  1009. {
  1010. VRFY_PAGEINFO *pip;
  1011. int ret, t_ret;
  1013. if ((ret = __db_vrfy_getpageinfo(vdp, pgno, &pip)) != 0)
  1014. return (ret);
  1015. pip->next_pgno = pip->prev_pgno = 0;
  1017. if (!IS_VALID_PGNO(NEXT_PGNO(h))) {
  1018. EPRINT((dbp->dbenv,
  1019.     "Invalid next_pgno %lu on page %lu",
  1020.     (u_long)NEXT_PGNO(h), (u_long)pgno));
  1021. ret = DB_VERIFY_BAD;
  1022. } else
  1023. pip->next_pgno = NEXT_PGNO(h);
  1025. if ((t_ret = __db_vrfy_putpageinfo(vdp, pip)) != 0 && ret == 0)
  1026. ret = t_ret;
  1027. return (ret);
  1028. }
  1030. /*
  1031.  * __db_vrfy_datapage --
  1032.  * Verify elements common to data pages (P_HASH, P_LBTREE,
  1033.  * P_IBTREE, P_IRECNO, P_LRECNO, P_OVERFLOW, P_DUPLICATE)--i.e.,
  1034.  * those defined in the PAGE structure.
  1035.  *
  1036.  * Called from each of the per-page routines, after the
  1037.  * all-page-type-common elements of pip have been verified and filled
  1038.  * in.
  1039.  *
  1040.  * PUBLIC: int __db_vrfy_datapage
  1041.  * PUBLIC:     __P((DB *, VRFY_DBINFO *, PAGE *, db_pgno_t, u_int32_t));
  1042.  */
  1043. int
  1044. __db_vrfy_datapage(dbp, vdp, h, pgno, flags)
  1045. DB *dbp;
  1046. VRFY_DBINFO *vdp;
  1047. PAGE *h;
  1048. db_pgno_t pgno;
  1049. u_int32_t flags;
  1050. {
  1051. VRFY_PAGEINFO *pip;
  1052. int isbad, ret, t_ret;
  1054. if ((ret = __db_vrfy_getpageinfo(vdp, pgno, &pip)) != 0)
  1055. return (ret);
  1056. isbad = 0;
  1058. /*
  1059.  * prev_pgno and next_pgno:  store for inter-page checks,
  1060.  * verify that they point to actual pages and not to self.
  1061.  *
  1062.  * !!!
  1063.  * Internal btree pages do not maintain these fields (indeed,
  1064.  * they overload them).  Skip.
  1065.  */
  1066. if (TYPE(h) != P_IBTREE && TYPE(h) != P_IRECNO) {
  1067. if (!IS_VALID_PGNO(PREV_PGNO(h)) || PREV_PGNO(h) == pip->pgno) {
  1068. isbad = 1;
  1069. EPRINT((dbp->dbenv, "Page %lu: Invalid prev_pgno %lu",
  1070.     (u_long)pip->pgno, (u_long)PREV_PGNO(h)));
  1071. }
  1072. if (!IS_VALID_PGNO(NEXT_PGNO(h)) || NEXT_PGNO(h) == pip->pgno) {
  1073. isbad = 1;
  1074. EPRINT((dbp->dbenv, "Page %lu: Invalid next_pgno %lu",
  1075.     (u_long)pip->pgno, (u_long)NEXT_PGNO(h)));
  1076. }
  1077. pip->prev_pgno = PREV_PGNO(h);
  1078. pip->next_pgno = NEXT_PGNO(h);
  1079. }
  1081. /*
  1082.  * Verify the number of entries on the page.
  1083.  * There is no good way to determine if this is accurate;  the
  1084.  * best we can do is verify that it's not more than can, in theory,
  1085.  * fit on the page.  Then, we make sure there are at least
  1086.  * this many valid elements in inp[], and hope that this catches
  1087.  * most cases.
  1088.  */
  1089. if (TYPE(h) != P_OVERFLOW) {
  1090. if (BKEYDATA_PSIZE(0) * NUM_ENT(h) > dbp->pgsize) {
  1091. isbad = 1;
  1092. EPRINT((dbp->dbenv,
  1093.     "Page %lu: Too many entries: %lu",
  1094.     (u_long)pgno, (u_long)NUM_ENT(h)));
  1095. }
  1096. pip->entries = NUM_ENT(h);
  1097. }
  1099. /*
  1100.  * btree level.  Should be zero unless we're a btree;
  1101.  * if we are a btree, should be between LEAFLEVEL and MAXBTREELEVEL,
  1102.  * and we need to save it off.
  1103.  */
  1104. switch (TYPE(h)) {
  1105. case P_IBTREE:
  1106. case P_IRECNO:
  1107. if (LEVEL(h) < LEAFLEVEL + 1 || LEVEL(h) > MAXBTREELEVEL) {
  1108. isbad = 1;
  1109. EPRINT((dbp->dbenv, "Bad btree level %lu on page %lu",
  1110.     (u_long)LEVEL(h), (u_long)pgno));
  1111. }
  1112. pip->bt_level = LEVEL(h);
  1113. break;
  1114. case P_LBTREE:
  1115. case P_LDUP:
  1116. case P_LRECNO:
  1117. if (LEVEL(h) != LEAFLEVEL) {
  1118. isbad = 1;
  1119. EPRINT((dbp->dbenv,
  1120.     "Btree leaf page %lu has incorrect level %lu",
  1121.     (u_long)pgno, (u_long)LEVEL(h)));
  1122. }
  1123. break;
  1124. default:
  1125. if (LEVEL(h) != 0) {
  1126. isbad = 1;
  1127. EPRINT((dbp->dbenv,
  1128.     "Nonzero level %lu in non-btree database page %lu",
  1129.     (u_long)LEVEL(h), (u_long)pgno));
  1130. }
  1131. break;
  1132. }
  1134. /*
  1135.  * Even though inp[] occurs in all PAGEs, we look at it in the
  1136.  * access-method-specific code, since btree and hash treat
  1137.  * item lengths very differently, and one of the most important
  1138.  * things we want to verify is that the data--as specified
  1139.  * by offset and length--cover the right part of the page
  1140.  * without overlaps, gaps, or violations of the page boundary.
  1141.  */
  1142. if ((t_ret = __db_vrfy_putpageinfo(vdp, pip)) != 0 && ret == 0)
  1143. ret = t_ret;
  1145. return ((ret == 0 && isbad == 1) ? DB_VERIFY_BAD : ret);
  1146. }
  1148. /*
  1149.  * __db_vrfy_meta--
  1150.  * Verify the access-method common parts of a meta page, using
  1151.  * normal mpool routines.
  1152.  *
  1153.  * PUBLIC: int __db_vrfy_meta
  1154.  * PUBLIC:     __P((DB *, VRFY_DBINFO *, DBMETA *, db_pgno_t, u_int32_t));
  1155.  */
  1156. int
  1157. __db_vrfy_meta(dbp, vdp, meta, pgno, flags)
  1158. DB *dbp;
  1159. VRFY_DBINFO *vdp;
  1160. DBMETA *meta;
  1161. db_pgno_t pgno;
  1162. u_int32_t flags;
  1163. {
  1164. DBTYPE dbtype, magtype;
  1165. VRFY_PAGEINFO *pip;
  1166. int isbad, ret, t_ret;
  1168. isbad = 0;
  1169. if ((ret = __db_vrfy_getpageinfo(vdp, pgno, &pip)) != 0)
  1170. return (ret);
  1172. /* type plausible for a meta page */
  1173. switch (meta->type) {
  1174. case P_BTREEMETA:
  1175. dbtype = DB_BTREE;
  1176. break;
  1177. case P_HASHMETA:
  1178. dbtype = DB_HASH;
  1179. break;
  1180. case P_QAMMETA:
  1181. dbtype = DB_QUEUE;
  1182. break;
  1183. default:
  1184. /* The verifier should never let us get here. */
  1185. DB_ASSERT(0);
  1186. ret = EINVAL;
  1187. goto err;
  1188. }
  1190. /* magic number valid */
  1191. if (!__db_is_valid_magicno(meta->magic, &magtype)) {
  1192. isbad = 1;
  1193. EPRINT((dbp->dbenv,
  1194.     "Magic number invalid on page %lu", (u_long)pgno));
  1195. }
  1196. if (magtype != dbtype) {
  1197. isbad = 1;
  1198. EPRINT((dbp->dbenv,
  1199.     "Magic number does not match type of page %lu",
  1200.     (u_long)pgno));
  1201. }
  1203. /* version */
  1204. if ((dbtype == DB_BTREE && meta->version != DB_BTREEVERSION) ||
  1205.     (dbtype == DB_HASH && meta->version != DB_HASHVERSION) ||
  1206.     (dbtype == DB_QUEUE && meta->version != DB_QAMVERSION)) {
  1207. isbad = 1;
  1208. EPRINT((dbp->dbenv, "%s%s", "Old of incorrect DB ",
  1209.     "version; extraneous errors may result"));
  1210. }
  1212. /* pagesize */
  1213. if (meta->pagesize != dbp->pgsize) {
  1214. isbad = 1;
  1215. EPRINT((dbp->dbenv,
  1216.     "Invalid pagesize %lu on page %lu",
  1217.     (u_long)meta->pagesize, (u_long)pgno));
  1218. }
  1220. /* free list */
  1221. /*
  1222.  * If this is not the main, master-database meta page, it
  1223.  * should not have a free list.
  1224.  */
  1225. if (pgno != PGNO_BASE_MD && meta->free != PGNO_INVALID) {
  1226. isbad = 1;
  1227. EPRINT((dbp->dbenv,
  1228.     "Nonempty free list on subdatabase metadata page %lu",
  1229.     pgno));
  1230. }
  1232. /* Can correctly be PGNO_INVALID--that's just the end of the list. */
  1233. if (meta->free != PGNO_INVALID && IS_VALID_PGNO(meta->free))
  1234. pip->free = meta->free;
  1235. else if (!IS_VALID_PGNO(meta->free)) {
  1236. isbad = 1;
  1237. EPRINT((dbp->dbenv,
  1238.     "Nonsensical free list pgno %lu on page %lu",
  1239.     (u_long)meta->free, (u_long)pgno));
  1240. }
  1242. /*
  1243.  * We have now verified the common fields of the metadata page.
  1244.  * Clear the flag that told us they had been incompletely checked.
  1245.  */
  1246. F_CLR(pip, VRFY_INCOMPLETE);
  1248. err: if ((t_ret = __db_vrfy_putpageinfo(vdp, pip)) != 0 && ret == 0)
  1249. ret = t_ret;
  1251. return ((ret == 0 && isbad == 1) ? DB_VERIFY_BAD : ret);
  1252. }
  1254. /*
  1255.  * __db_vrfy_freelist --
  1256.  * Walk free list, checking off pages and verifying absence of
  1257.  * loops.
  1258.  */
  1259. static int
  1260. __db_vrfy_freelist(dbp, vdp, meta, flags)
  1261. DB *dbp;
  1262. VRFY_DBINFO *vdp;
  1263. db_pgno_t meta;
  1264. u_int32_t flags;
  1265. {
  1266. DB *pgset;
  1267. VRFY_PAGEINFO *pip;
  1268. db_pgno_t pgno;
  1269. int p, ret, t_ret;
  1271. pgset = vdp->pgset;
  1272. DB_ASSERT(pgset != NULL);
  1274. if ((ret = __db_vrfy_getpageinfo(vdp, meta, &pip)) != 0)
  1275. return (ret);
  1276. for (pgno = pip->free; pgno != PGNO_INVALID; pgno = pip->next_pgno) {
  1277. if ((ret = __db_vrfy_putpageinfo(vdp, pip)) != 0)
  1278. return (ret);
  1280. /* This shouldn't happen, but just in case. */
  1281. if (!IS_VALID_PGNO(pgno)) {
  1282. EPRINT((dbp->dbenv,
  1283.     "Invalid next_pgno on free list page %lu",
  1284.     (u_long)pgno));
  1285. return (DB_VERIFY_BAD);
  1286. }
  1288. /* Detect cycles. */
  1289. if ((ret = __db_vrfy_pgset_get(pgset, pgno, &p)) != 0)
  1290. return (ret);
  1291. if (p != 0) {
  1292. EPRINT((dbp->dbenv,
  1293.     "Page %lu encountered a second time on free list",
  1294.     (u_long)pgno));
  1295. return (DB_VERIFY_BAD);
  1296. }
  1297. if ((ret = __db_vrfy_pgset_inc(pgset, pgno)) != 0)
  1298. return (ret);
  1300. if ((ret = __db_vrfy_getpageinfo(vdp, pgno, &pip)) != 0)
  1301. return (ret);
  1303. if (pip->type != P_INVALID) {
  1304. EPRINT((dbp->dbenv,
  1305.     "Non-invalid page %lu on free list", (u_long)pgno));
  1306. ret = DB_VERIFY_BAD;   /* unsafe to continue */
  1307. break;
  1308. }
  1309. }
  1311. if ((t_ret = __db_vrfy_putpageinfo(vdp, pip)) != 0)
  1312. ret = t_ret;
  1313. return (ret);
  1314. }
  1316. /*
  1317.  * __db_vrfy_subdbs --
  1318.  * Walk the known-safe master database of subdbs with a cursor,
  1319.  * verifying the structure of each subdatabase we encounter.
  1320.  */
  1321. static int
  1322. __db_vrfy_subdbs(dbp, vdp, dbname, flags)
  1323. DB *dbp;
  1324. VRFY_DBINFO *vdp;
  1325. const char *dbname;
  1326. u_int32_t flags;
  1327. {
  1328. DB *mdbp;
  1329. DBC *dbc;
  1330. DBT key, data;
  1331. VRFY_PAGEINFO *pip;
  1332. db_pgno_t meta_pgno;
  1333. int ret, t_ret, isbad;
  1334. u_int8_t type;
  1336. isbad = 0;
  1337. dbc = NULL;
  1339. if ((ret = __db_master_open(dbp, dbname, DB_RDONLY, 0, &mdbp)) != 0)
  1340. return (ret);
  1342. if ((ret =
  1343.     __db_icursor(mdbp, NULL, DB_BTREE, PGNO_INVALID, 0, &dbc)) != 0)
  1344. goto err;
  1346. memset(&key, 0, sizeof(key));
  1347. memset(&data, 0, sizeof(data));
  1348. while ((ret = dbc->c_get(dbc, &key, &data, DB_NEXT)) == 0) {
  1349. if (data.size != sizeof(db_pgno_t)) {
  1350. EPRINT((dbp->dbenv, "Database entry of invalid size"));
  1351. isbad = 1;
  1352. goto err;
  1353. }
  1354. memcpy(&meta_pgno, data.data, data.size);
  1355. /*
  1356.  * Subdatabase meta pgnos are stored in network byte
  1357.  * order for cross-endian compatibility.  Swap if appropriate.
  1358.  */
  1359. DB_NTOHL(&meta_pgno);
  1360. if (meta_pgno == PGNO_INVALID || meta_pgno > vdp->last_pgno) {
  1361. EPRINT((dbp->dbenv,
  1362.     "Database entry references invalid page %lu",
  1363.     (u_long)meta_pgno));
  1364. isbad = 1;
  1365. goto err;
  1366. }
  1367. if ((ret = __db_vrfy_getpageinfo(vdp, meta_pgno, &pip)) != 0)
  1368. goto err;
  1369. type = pip->type;
  1370. if ((ret = __db_vrfy_putpageinfo(vdp, pip)) != 0)
  1371. goto err;
  1372. switch (type) {
  1373. case P_BTREEMETA:
  1374. if ((ret = __bam_vrfy_structure(
  1375.     dbp, vdp, meta_pgno, flags)) != 0) {
  1376. if (ret == DB_VERIFY_BAD)
  1377. isbad = 1;
  1378. else
  1379. goto err;
  1380. }
  1381. break;
  1382. case P_HASHMETA:
  1383. if ((ret = __ham_vrfy_structure(
  1384.     dbp, vdp, meta_pgno, flags)) != 0) {
  1385. if (ret == DB_VERIFY_BAD)
  1386. isbad = 1;
  1387. else
  1388. goto err;
  1389. }
  1390. break;
  1391. case P_QAMMETA:
  1392. default:
  1393. EPRINT((dbp->dbenv,
  1394.     "Database entry references page %lu of invalid type %lu",
  1395.     (u_long)meta_pgno, (u_long)type));
  1396. ret = DB_VERIFY_BAD;
  1397. goto err;
  1398. /* NOTREACHED */
  1399. }
  1400. }
  1402. if (ret == DB_NOTFOUND)
  1403. ret = 0;
  1405. err: if (dbc != NULL && (t_ret = __db_c_close(dbc)) != 0 && ret == 0)
  1406. ret = t_ret;
  1408. if ((t_ret = mdbp->close(mdbp, 0)) != 0 && ret == 0)
  1409. ret = t_ret;
  1411. return ((ret == 0 && isbad == 1) ? DB_VERIFY_BAD : ret);
  1412. }
  1414. /*
  1415.  * __db_vrfy_struct_feedback --
  1416.  * Provide feedback during top-down database structure traversal.
  1417.  * (See comment at the beginning of __db_vrfy_structure.)
  1418.  *
  1419.  * PUBLIC: int __db_vrfy_struct_feedback __P((DB *, VRFY_DBINFO *));
  1420.  */
  1421. int
  1422. __db_vrfy_struct_feedback(dbp, vdp)
  1423. DB *dbp;
  1424. VRFY_DBINFO *vdp;
  1425. {
  1426. int progress;
  1428. if (dbp->db_feedback == NULL)
  1429. return (0);
  1431. if (vdp->pgs_remaining > 0)
  1432. vdp->pgs_remaining--;
  1434. /* Don't allow a feedback call of 100 until we're really done. */
  1435. progress = 100 - (vdp->pgs_remaining * 50 / (vdp->last_pgno + 1));
  1436. dbp->db_feedback(dbp, DB_VERIFY, progress == 100 ? 99 : progress);
  1438. return (0);
  1439. }
  1441. /*
  1442.  * __db_vrfy_orderchkonly --
  1443.  * Do an sort-order/hashing check on a known-otherwise-good subdb.
  1444.  */
  1445. static int
  1446. __db_vrfy_orderchkonly(dbp, vdp, name, subdb, flags)
  1447. DB *dbp;
  1448. VRFY_DBINFO *vdp;
  1449. const char *name, *subdb;
  1450. u_int32_t flags;
  1451. {
  1452. BTMETA *btmeta;
  1453. DB *mdbp, *pgset;
  1454. DBC *pgsc;
  1455. DBT key, data;
  1456. HASH *h_internal;
  1457. HMETA *hmeta;
  1458. PAGE *h, *currpg;
  1459. db_pgno_t meta_pgno, p, pgno;
  1460. u_int32_t bucket;
  1461. int t_ret, ret;
  1463. currpg = h = NULL;
  1464. pgsc = NULL;
  1465. pgset = NULL;
  1467. LF_CLR(DB_NOORDERCHK);
  1469. /* Open the master database and get the meta_pgno for the subdb. */
  1470. if ((ret = db_create(&mdbp, NULL, 0)) != 0)
  1471. return (ret);
  1472. if ((ret = __db_master_open(dbp, name, DB_RDONLY, 0, &mdbp)) != 0)
  1473. goto err;
  1475. memset(&key, 0, sizeof(key));
  1476. key.data = (void *)subdb;
  1477. memset(&data, 0, sizeof(data));
  1478. if ((ret = dbp->get(dbp, NULL, &key, &data, 0)) != 0)
  1479. goto err;
  1481. if (data.size != sizeof(db_pgno_t)) {
  1482. EPRINT((dbp->dbenv, "Database entry of invalid size"));
  1483. ret = DB_VERIFY_BAD;
  1484. goto err;
  1485. }
  1487. memcpy(&meta_pgno, data.data, data.size);
  1489. if ((ret = memp_fget(dbp->mpf, &meta_pgno, 0, &h)) != 0)
  1490. goto err;
  1492. if ((ret = __db_vrfy_pgset(dbp->dbenv, dbp->pgsize, &pgset)) != 0)
  1493. goto err;
  1495. switch (TYPE(h)) {
  1496. case P_BTREEMETA:
  1497. btmeta = (BTMETA *)h;
  1498. if (F_ISSET(&btmeta->dbmeta, BTM_RECNO)) {
  1499. /* Recnos have no order to check. */
  1500. ret = 0;
  1501. goto err;
  1502. }
  1503. if ((ret =
  1504.     __db_meta2pgset(dbp, vdp, meta_pgno, flags, pgset)) != 0)
  1505. goto err;
  1506. if ((ret = pgset->cursor(pgset, NULL, &pgsc, 0)) != 0)
  1507. goto err;
  1508. while ((ret = __db_vrfy_pgset_next(pgsc, &p)) == 0) {
  1509. if ((ret = memp_fget(dbp->mpf, &p, 0, &currpg)) != 0)
  1510. goto err;
  1511. if ((ret = __bam_vrfy_itemorder(dbp,
  1512.     NULL, currpg, p, NUM_ENT(currpg), 1,
  1513.     F_ISSET(&btmeta->dbmeta, BTM_DUP), flags)) != 0)
  1514. goto err;
  1515. if ((ret = memp_fput(dbp->mpf, currpg, 0)) != 0)
  1516. goto err;
  1517. currpg = NULL;
  1518. }
  1519. if ((ret = pgsc->c_close(pgsc)) != 0)
  1520. goto err;
  1521. break;
  1522. case P_HASHMETA:
  1523. hmeta = (HMETA *)h;
  1524. h_internal = (HASH *)dbp->h_internal;
  1525. /*
  1526.  * Make sure h_charkey is right.
  1527.  */
  1528. if (h_internal == NULL || h_internal->h_hash == NULL) {
  1529. EPRINT((dbp->dbenv,
  1530.     "DB_ORDERCHKONLY requires that a hash function be set"));
  1531. ret = DB_VERIFY_BAD;
  1532. goto err;
  1533. }
  1534. if (hmeta->h_charkey !=
  1535.     h_internal->h_hash(dbp, CHARKEY, sizeof(CHARKEY))) {
  1536. EPRINT((dbp->dbenv,
  1537.     "Incorrect hash function for database"));
  1538. ret = DB_VERIFY_BAD;
  1539. goto err;
  1540. }
  1542. /*
  1543.  * Foreach bucket, verify hashing on each page in the
  1544.  * corresponding chain of pages.
  1545.  */
  1546. for (bucket = 0; bucket <= hmeta->max_bucket; bucket++) {
  1547. pgno = BS_TO_PAGE(bucket, hmeta->spares);
  1548. while (pgno != PGNO_INVALID) {
  1549. if ((ret = memp_fget(dbp->mpf,
  1550.     &pgno, 0, &currpg)) != 0)
  1551. goto err;
  1552. if ((ret = __ham_vrfy_hashing(dbp,
  1553.     NUM_ENT(currpg),hmeta, bucket, pgno,
  1554.     flags, h_internal->h_hash)) != 0)
  1555. goto err;
  1556. pgno = NEXT_PGNO(currpg);
  1557. if ((ret = memp_fput(dbp->mpf, currpg, 0)) != 0)
  1558. goto err;
  1559. currpg = NULL;
  1560. }
  1561. }
  1562. break;
  1563. default:
  1564. EPRINT((dbp->dbenv, "Database meta page %lu of bad type %lu",
  1565.     (u_long)meta_pgno, (u_long)TYPE(h)));
  1566. ret = DB_VERIFY_BAD;
  1567. break;
  1568. }
  1570. err: if (pgsc != NULL)
  1571. (void)pgsc->c_close(pgsc);
  1572. if (pgset != NULL)
  1573. (void)pgset->close(pgset, 0);
  1574. if (h != NULL && (t_ret = memp_fput(dbp->mpf, h, 0)) != 0)
  1575. ret = t_ret;
  1576. if (currpg != NULL && (t_ret = memp_fput(dbp->mpf, currpg, 0)) != 0)
  1577. ret = t_ret;
  1578. if ((t_ret = mdbp->close(mdbp, 0)) != 0)
  1579. ret = t_ret;
  1580. return (ret);
  1581. }
  1583. /*
  1584.  * __db_salvage --
  1585.  * Walk through a page, salvaging all likely or plausible (w/
  1586.  * DB_AGGRESSIVE) key/data pairs.
  1587.  *
  1588.  * PUBLIC: int __db_salvage __P((DB *, VRFY_DBINFO *, db_pgno_t, PAGE *,
  1589.  * PUBLIC:     void *, int (*)(void *, const void *), u_int32_t));
  1590.  */
  1591. int
  1592. __db_salvage(dbp, vdp, pgno, h, handle, callback, flags)
  1593. DB *dbp;
  1594. VRFY_DBINFO *vdp;
  1595. db_pgno_t pgno;
  1596. PAGE *h;
  1597. void *handle;
  1598. int (*callback) __P((void *, const void *));
  1599. u_int32_t flags;
  1600. {
  1601. DB_ASSERT(LF_ISSET(DB_SALVAGE));
  1603. /* If we got this page in the subdb pass, we can safely skip it. */
  1604. if (__db_salvage_isdone(vdp, pgno))
  1605. return (0);
  1607. switch (TYPE(h)) {
  1608. case P_HASH:
  1609. return (__ham_salvage(dbp,
  1610.     vdp, pgno, h, handle, callback, flags));
  1611. /* NOTREACHED */
  1612. case P_LBTREE:
  1613. return (__bam_salvage(dbp,
  1614.     vdp, pgno, P_LBTREE, h, handle, callback, NULL, flags));
  1615. /* NOTREACHED */
  1616. case P_LDUP:
  1617. return (__db_salvage_markneeded(vdp, pgno, SALVAGE_LDUP));
  1618. /* NOTREACHED */
  1619. case P_OVERFLOW:
  1620. return (__db_salvage_markneeded(vdp, pgno, SALVAGE_OVERFLOW));
  1621. /* NOTREACHED */
  1622. case P_LRECNO:
  1623. /*
  1624.  * Recnos are tricky -- they may represent dup pages, or
  1625.  * they may be subdatabase/regular database pages in their
  1626.  * own right.  If the former, they need to be printed with a
  1627.  * key, preferably when we hit the corresponding datum in
  1628.  * a btree/hash page.  If the latter, there is no key.
  1629.  *
  1630.  * If a database is sufficiently frotzed, we're not going
  1631.  * to be able to get this right, so we best-guess:  just
  1632.  * mark it needed now, and if we're really a normal recno
  1633.  * database page, the "unknowns" pass will pick us up.
  1634.  */
  1635. return (__db_salvage_markneeded(vdp, pgno, SALVAGE_LRECNO));
  1636. /* NOTREACHED */
  1637. case P_IBTREE:
  1638. case P_INVALID:
  1639. case P_IRECNO:
  1640. case __P_DUPLICATE:
  1641. default:
  1642. /* XXX: Should we be more aggressive here? */
  1643. break;
  1644. }
  1645. return (0);
  1646. }
  1648. /*
  1649.  * __db_salvage_unknowns --
  1650.  * Walk through the salvager database, printing with key "UNKNOWN"
  1651.  * any pages we haven't dealt with.
  1652.  */
  1653. static int
  1654. __db_salvage_unknowns(dbp, vdp, handle, callback, flags)
  1655. DB *dbp;
  1656. VRFY_DBINFO *vdp;
  1657. void *handle;
  1658. int (*callback) __P((void *, const void *));
  1659. u_int32_t flags;
  1660. {
  1661. DBT unkdbt, key, *dbt;
  1662. PAGE *h;
  1663. db_pgno_t pgno;
  1664. u_int32_t pgtype;
  1665. int ret, err_ret;
  1666. void *ovflbuf;
  1668. memset(&unkdbt, 0, sizeof(DBT));
  1669. unkdbt.size = strlen("UNKNOWN") + 1;
  1670. unkdbt.data = "UNKNOWN";
  1672. if ((ret = __os_malloc(dbp->dbenv, dbp->pgsize, 0, &ovflbuf)) != 0)
  1673. return (ret);
  1675. err_ret = 0;
  1676. while ((ret = __db_salvage_getnext(vdp, &pgno, &pgtype)) == 0) {
  1677. dbt = NULL;
  1679. if ((ret = memp_fget(dbp->mpf, &pgno, 0, &h)) != 0) {
  1680. err_ret = ret;
  1681. continue;
  1682. }
  1684. switch (pgtype) {
  1685. case SALVAGE_LDUP:
  1686. case SALVAGE_LRECNODUP:
  1687. dbt = &unkdbt;
  1688. /* FALLTHROUGH */
  1689. case SALVAGE_LBTREE:
  1690. case SALVAGE_LRECNO:
  1691. if ((ret = __bam_salvage(dbp, vdp, pgno, pgtype,
  1692.     h, handle, callback, dbt, flags)) != 0)
  1693. err_ret = ret;
  1694. break;
  1695. case SALVAGE_OVERFLOW:
  1696. /*
  1697.  * XXX:
  1698.  * This may generate multiple "UNKNOWN" keys in
  1699.  * a database with no dups.  What to do?
  1700.  */
  1701. if ((ret = __db_safe_goff(dbp,
  1702.     vdp, pgno, &key, &ovflbuf, flags)) != 0) {
  1703. err_ret = ret;
  1704. continue;
  1705. }
  1706. if ((ret = __db_prdbt(&key,
  1707.     0, " ", handle, callback, 0, NULL)) != 0) {
  1708. err_ret = ret;
  1709. continue;
  1710. }
  1711. if ((ret = __db_prdbt(&unkdbt,
  1712. 0, " ", handle, callback, 0, NULL)) != 0)
  1713. err_ret = ret;
  1714. break;
  1715. case SALVAGE_HASH:
  1716. if ((ret = __ham_salvage(
  1717.     dbp, vdp, pgno, h, handle, callback, flags)) != 0)
  1718. err_ret = ret;
  1719. break;
  1720. case SALVAGE_INVALID:
  1721. case SALVAGE_IGNORE:
  1722. default:
  1723. /*
  1724.  * Shouldn't happen, but if it does, just do what the
  1725.  * nice man says.
  1726.  */
  1727. DB_ASSERT(0);
  1728. break;
  1729. }
  1730. if ((ret = memp_fput(dbp->mpf, h, 0)) != 0)
  1731. err_ret = ret;
  1732. }
  1734. __os_free(ovflbuf, 0);
  1736. if (err_ret != 0 && ret == 0)
  1737. ret = err_ret;
  1739. return (ret == DB_NOTFOUND ? 0 : ret);
  1740. }
  1742. /*
  1743.  * Offset of the ith inp array entry, which we can compare to the offset
  1744.  * the entry stores.
  1745.  */
  1746. #define INP_OFFSET(h, i)
  1747.     ((db_indx_t)((u_int8_t *)(h)->inp + (i) - (u_int8_t *)(h)))
  1749. /*
  1750.  * __db_vrfy_inpitem --
  1751.  * Verify that a single entry in the inp array is sane, and update
  1752.  * the high water mark and current item offset.  (The former of these is
  1753.  * used for state information between calls, and is required;  it must
  1754.  * be initialized to the pagesize before the first call.)
  1755.  *
  1756.  * Returns DB_VERIFY_FATAL if inp has collided with the data,
  1757.  * since verification can't continue from there;  returns DB_VERIFY_BAD
  1758.  * if anything else is wrong.
  1759.  *
  1760.  * PUBLIC: int __db_vrfy_inpitem __P((DB *, PAGE *,
  1761.  * PUBLIC:     db_pgno_t, u_int32_t, int, u_int32_t, u_int32_t *, u_int32_t *));
  1762.  */
  1763. int
  1764. __db_vrfy_inpitem(dbp, h, pgno, i, is_btree, flags, himarkp, offsetp)
  1765. DB *dbp;
  1766. PAGE *h;
  1767. db_pgno_t pgno;
  1768. u_int32_t i;
  1769. int is_btree;
  1770. u_int32_t flags, *himarkp, *offsetp;
  1771. {
  1772. BKEYDATA *bk;
  1773. db_indx_t offset, len;
  1775. DB_ASSERT(himarkp != NULL);
  1777. /*
  1778.  * Check that the inp array, which grows from the beginning of the
  1779.  * page forward, has not collided with the data, which grow from the
  1780.  * end of the page backward.
  1781.  */
  1782. if (h->inp + i >= (db_indx_t *)((u_int8_t *)h + *himarkp)) {
  1783. /* We've collided with the data.  We need to bail. */
  1784. EPRINT((dbp->dbenv,
  1785.     "Page %lu entries listing %lu overlaps data",
  1786.     (u_long)pgno, (u_long)i));
  1787. return (DB_VERIFY_FATAL);
  1788. }
  1790. offset = h->inp[i];
  1792. /*
  1793.  * Check that the item offset is reasonable:  it points somewhere
  1794.  * after the inp array and before the end of the page.
  1795.  */
  1796. if (offset <= INP_OFFSET(h, i) || offset > dbp->pgsize) {
  1797. EPRINT((dbp->dbenv,
  1798.     "Bad offset %lu at page %lu index %lu",
  1799.     (u_long)offset, (u_long)pgno, (u_long)i));
  1800. return (DB_VERIFY_BAD);
  1801. }
  1803. /* Update the high-water mark (what HOFFSET should be) */
  1804. if (offset < *himarkp)
  1805. *himarkp = offset;
  1807. if (is_btree) {
  1808. /*
  1809.  * Check that the item length remains on-page.
  1810.  */
  1811. bk = GET_BKEYDATA(h, i);
  1813. /*
  1814.  * We need to verify the type of the item here;
  1815.  * we can't simply assume that it will be one of the
  1816.  * expected three.  If it's not a recognizable type,
  1817.  * it can't be considered to have a verifiable
  1818.  * length, so it's not possible to certify it as safe.
  1819.  */
  1820. switch (B_TYPE(bk->type)) {
  1821. case B_KEYDATA:
  1822. len = bk->len;
  1823. break;
  1824. case B_DUPLICATE:
  1825. case B_OVERFLOW:
  1826. len = BOVERFLOW_SIZE;
  1827. break;
  1828. default:
  1829. EPRINT((dbp->dbenv,
  1830.     "Item %lu on page %lu of unrecognizable type",
  1831.     i, pgno));
  1832. return (DB_VERIFY_BAD);
  1833. }
  1835. if ((size_t)(offset + len) > dbp->pgsize) {
  1836. EPRINT((dbp->dbenv,
  1837.     "Item %lu on page %lu extends past page boundary",
  1838.     (u_long)i, (u_long)pgno));
  1839. return (DB_VERIFY_BAD);
  1840. }
  1841. }
  1843. if (offsetp != NULL)
  1844. *offsetp = offset;
  1845. return (0);
  1846. }
  1848. /*
  1849.  * __db_vrfy_duptype--
  1850.  * Given a page number and a set of flags to __bam_vrfy_subtree,
  1851.  * verify that the dup tree type is correct--i.e., it's a recno
  1852.  * if DUPSORT is not set and a btree if it is.
  1853.  *
  1854.  * PUBLIC: int __db_vrfy_duptype
  1855.  * PUBLIC:     __P((DB *, VRFY_DBINFO *, db_pgno_t, u_int32_t));
  1856.  */
  1857. int
  1858. __db_vrfy_duptype(dbp, vdp, pgno, flags)
  1859. DB *dbp;
  1860. VRFY_DBINFO *vdp;
  1861. db_pgno_t pgno;
  1862. u_int32_t flags;
  1863. {
  1864. VRFY_PAGEINFO *pip;
  1865. int ret, isbad;
  1867. isbad = 0;
  1869. if ((ret = __db_vrfy_getpageinfo(vdp, pgno, &pip)) != 0)
  1870. return (ret);
  1872. switch (pip->type) {
  1873. case P_IBTREE:
  1874. case P_LDUP:
  1875. if (!LF_ISSET(ST_DUPSORT)) {
  1876. EPRINT((dbp->dbenv,
  1877.     "Sorted duplicate set at page %lu in unsorted-dup database",
  1878.     (u_long)pgno));
  1879. isbad = 1;
  1880. }
  1881. break;
  1882. case P_IRECNO:
  1883. case P_LRECNO:
  1884. if (LF_ISSET(ST_DUPSORT)) {
  1885. EPRINT((dbp->dbenv,
  1886.     "Unsorted duplicate set at page %lu in sorted-dup database",
  1887.     (u_long)pgno));
  1888. isbad = 1;
  1889. }
  1890. break;
  1891. default:
  1892. EPRINT((dbp->dbenv,
  1893.     "Duplicate page %lu of inappropriate type %lu",
  1894.     (u_long)pgno, (u_long)pip->type));
  1895. isbad = 1;
  1896. break;
  1897. }
  1899. if ((ret = __db_vrfy_putpageinfo(vdp, pip)) != 0)
  1900. return (ret);
  1901. return (isbad == 1 ? DB_VERIFY_BAD : 0);
  1902. }
  1904. /*
  1905.  * __db_salvage_duptree --
  1906.  * Attempt to salvage a given duplicate tree, given its alleged root.
  1907.  *
  1908.  * The key that corresponds to this dup set has been passed to us
  1909.  * in DBT *key.  Because data items follow keys, though, it has been
  1910.  * printed once already.
  1911.  *
  1912.  * The basic idea here is that pgno ought to be a P_LDUP, a P_LRECNO, a
  1913.  * P_IBTREE, or a P_IRECNO.  If it's an internal page, use the verifier
  1914.  * functions to make sure it's safe;  if it's not, we simply bail and the
  1915.  * data will have to be printed with no key later on.  if it is safe,
  1916.  * recurse on each of its children.
  1917.  *
  1918.  * Whether or not it's safe, if it's a leaf page, __bam_salvage it.
  1919.  *
  1920.  * At all times, use the DB hanging off vdp to mark and check what we've
  1921.  * done, so each page gets printed exactly once and we don't get caught
  1922.  * in any cycles.
  1923.  *
  1924.  * PUBLIC: int __db_salvage_duptree __P((DB *, VRFY_DBINFO *, db_pgno_t,
  1925.  * PUBLIC:     DBT *, void *, int (*)(void *, const void *), u_int32_t));
  1926.  */
  1927. int
  1928. __db_salvage_duptree(dbp, vdp, pgno, key, handle, callback, flags)
  1929. DB *dbp;
  1930. VRFY_DBINFO *vdp;
  1931. db_pgno_t pgno;
  1932. DBT *key;
  1933. void *handle;
  1934. int (*callback) __P((void *, const void *));
  1935. u_int32_t flags;
  1936. {
  1937. PAGE *h;
  1938. int ret, t_ret;
  1940. if (pgno == PGNO_INVALID || !IS_VALID_PGNO(pgno))
  1941. return (DB_VERIFY_BAD);
  1943. /* We have a plausible page.  Try it. */
  1944. if ((ret = memp_fget(dbp->mpf, &pgno, 0, &h)) != 0)
  1945. return (ret);
  1947. switch (TYPE(h)) {
  1948. case P_IBTREE:
  1949. case P_IRECNO:
  1950. if ((ret = __db_vrfy_common(dbp, vdp, h, pgno, flags)) != 0)
  1951. goto err;
  1952. if ((ret = __bam_vrfy(dbp,
  1953.     vdp, h, pgno, flags | DB_NOORDERCHK)) != 0 ||
  1954.     (ret = __db_salvage_markdone(vdp, pgno)) != 0)
  1955. goto err;
  1956. /*
  1957.  * We have a known-healthy internal page.  Walk it.
  1958.  */
  1959. if ((ret = __bam_salvage_walkdupint(dbp, vdp, h, key,
  1960.     handle, callback, flags)) != 0)
  1961. goto err;
  1962. break;
  1963. case P_LRECNO:
  1964. case P_LDUP:
  1965. if ((ret = __bam_salvage(dbp,
  1966.     vdp, pgno, TYPE(h), h, handle, callback, key, flags)) != 0)
  1967. goto err;
  1968. break;
  1969. default:
  1970. ret = DB_VERIFY_BAD;
  1971. goto err;
  1972. /* NOTREACHED */
  1973. }
  1975. err: if ((t_ret = memp_fput(dbp->mpf, h, 0)) != 0 && ret == 0)
  1976. ret = t_ret;
  1977. return (ret);
  1978. }
  1980. /*
  1981.  * __db_salvage_subdbs --
  1982.  * Check and see if this database has subdbs;  if so, try to salvage
  1983.  * them independently.
  1984.  */
  1985. static int
  1986. __db_salvage_subdbs(dbp, vdp, handle, callback, flags, hassubsp)
  1987. DB *dbp;
  1988. VRFY_DBINFO *vdp;
  1989. void *handle;
  1990. int (*callback) __P((void *, const void *));
  1991. u_int32_t flags;
  1992. int *hassubsp;
  1993. {
  1994. BTMETA *btmeta;
  1995. DB *pgset;
  1996. DBC *pgsc;
  1997. PAGE *h;
  1998. db_pgno_t p, meta_pgno;
  1999. int ret, err_ret;
  2001. err_ret = 0;
  2002. pgsc = NULL;
  2003. pgset = NULL;
  2005. meta_pgno = PGNO_BASE_MD;
  2006. if ((ret = memp_fget(dbp->mpf, &meta_pgno, 0, &h)) != 0)
  2007. return (ret);
  2009. if (TYPE(h) == P_BTREEMETA)
  2010. btmeta = (BTMETA *)h;
  2011. else {
  2012. /* Not a btree metadata, ergo no subdbs, so just return. */
  2013. ret = 0;
  2014. goto err;
  2015. }
  2017. /* If it's not a safe page, bail on the attempt. */
  2018. if ((ret = __db_vrfy_common(dbp, vdp, h, PGNO_BASE_MD, flags)) != 0 ||
  2019.    (ret = __bam_vrfy_meta(dbp, vdp, btmeta, PGNO_BASE_MD, flags)) != 0)
  2020. goto err;
  2022. if (!F_ISSET(&btmeta->dbmeta, BTM_SUBDB)) {
  2023. /* No subdbs, just return. */
  2024. ret = 0;
  2025. goto err;
  2026. }
  2028. /* We think we've got subdbs.  Mark it so. */
  2029. *hassubsp = 1;
  2031. if ((ret = memp_fput(dbp->mpf, h, 0)) != 0)
  2032. return (ret);
  2034. /*
  2035.  * We have subdbs.  Try to crack them.
  2036.  *
  2037.  * To do so, get a set of leaf pages in the master
  2038.  * database, and then walk each of the valid ones, salvaging
  2039.  * subdbs as we go.  If any prove invalid, just drop them;  we'll
  2040.  * pick them up on a later pass.
  2041.  */
  2042. if ((ret = __db_vrfy_pgset(dbp->dbenv, dbp->pgsize, &pgset)) != 0)
  2043. return (ret);
  2044. if ((ret =
  2045.     __db_meta2pgset(dbp, vdp, PGNO_BASE_MD, flags, pgset)) != 0)
  2046. goto err;
  2048. if ((ret = pgset->cursor(pgset, NULL, &pgsc, 0)) != 0)
  2049. goto err;
  2050. while ((ret = __db_vrfy_pgset_next(pgsc, &p)) == 0) {
  2051. if ((ret = memp_fget(dbp->mpf, &p, 0, &h)) != 0) {
  2052. err_ret = ret;
  2053. continue;
  2054. }
  2055. if ((ret = __db_vrfy_common(dbp, vdp, h, p, flags)) != 0 ||
  2056.     (ret = __bam_vrfy(dbp,
  2057.     vdp, h, p, flags | DB_NOORDERCHK)) != 0)
  2058. goto nextpg;
  2059. if (TYPE(h) != P_LBTREE)
  2060. goto nextpg;
  2061. else if ((ret = __db_salvage_subdbpg(
  2062.     dbp, vdp, h, handle, callback, flags)) != 0)
  2063. err_ret = ret;
  2064. nextpg: if ((ret = memp_fput(dbp->mpf, h, 0)) != 0)
  2065. err_ret = ret;
  2066. }
  2068. if (ret != DB_NOTFOUND)
  2069. goto err;
  2070. if ((ret = pgsc->c_close(pgsc)) != 0)
  2071. goto err;
  2073. ret = pgset->close(pgset, 0);
  2074. return ((ret == 0 && err_ret != 0) ? err_ret : ret);
  2076. /* NOTREACHED */
  2078. err: if (pgsc != NULL)
  2079. (void)pgsc->c_close(pgsc);
  2080. if (pgset != NULL)
  2081. (void)pgset->close(pgset, 0);
  2082. (void)memp_fput(dbp->mpf, h, 0);
  2083. return (ret);
  2084. }
  2086. /*
  2087.  * __db_salvage_subdbpg --
  2088.  * Given a known-good leaf page in the master database, salvage all
  2089.  * leaf pages corresponding to each subdb.
  2090.  *
  2091.  * PUBLIC: int __db_salvage_subdbpg
  2092.  * PUBLIC:     __P((DB *, VRFY_DBINFO *, PAGE *, void *,
  2093.  * PUBLIC:     int (*)(void *, const void *), u_int32_t));
  2094.  */
  2095. int
  2096. __db_salvage_subdbpg(dbp, vdp, master, handle, callback, flags)
  2097. DB *dbp;
  2098. VRFY_DBINFO *vdp;
  2099. PAGE *master;
  2100. void *handle;
  2101. int (*callback) __P((void *, const void *));
  2102. u_int32_t flags;
  2103. {
  2104. BKEYDATA *bkkey, *bkdata;
  2105. BOVERFLOW *bo;
  2106. DB *pgset;
  2107. DBC *pgsc;
  2108. DBT key;
  2109. PAGE *subpg;
  2110. db_indx_t i;
  2111. db_pgno_t meta_pgno, p;
  2112. int ret, err_ret, t_ret;
  2113. char *subdbname;
  2115. ret = err_ret = 0;
  2116. subdbname = NULL;
  2118. if ((ret = __db_vrfy_pgset(dbp->dbenv, dbp->pgsize, &pgset)) != 0)
  2119. return (ret);
  2121. /*
  2122.  * For each entry, get and salvage the set of pages
  2123.  * corresponding to that entry.
  2124.  */
  2125. for (i = 0; i < NUM_ENT(master); i += P_INDX) {
  2126. bkkey = GET_BKEYDATA(master, i);
  2127. bkdata = GET_BKEYDATA(master, i + O_INDX);
  2129. /* Get the subdatabase name. */
  2130. if (B_TYPE(bkkey->type) == B_OVERFLOW) {
  2131. /*
  2132.  * We can, in principle anyway, have a subdb
  2133.  * name so long it overflows.  Ick.
  2134.  */
  2135. bo = (BOVERFLOW *)bkkey;
  2136. if ((ret = __db_safe_goff(dbp, vdp, bo->pgno, &key,
  2137.     (void **)&subdbname, flags)) != 0) {
  2138. err_ret = DB_VERIFY_BAD;
  2139. continue;
  2140. }
  2142. /* Nul-terminate it. */
  2143. if ((ret = __os_realloc(dbp->dbenv,
  2144.     key.size + 1, NULL, &subdbname)) != 0)
  2145. goto err;
  2146. subdbname[key.size] = '';
  2147. } else if (B_TYPE(bkkey->type == B_KEYDATA)) {
  2148. if ((ret = __os_realloc(dbp->dbenv,
  2149.     bkkey->len + 1, NULL, &subdbname)) != 0)
  2150. goto err;
  2151. memcpy(subdbname, bkkey->data, bkkey->len);
  2152. subdbname[bkkey->len] = '';
  2153. }
  2155. /* Get the corresponding pgno. */
  2156. if (bkdata->len != sizeof(db_pgno_t)) {
  2157. err_ret = DB_VERIFY_BAD;
  2158. continue;
  2159. }
  2160. memcpy(&meta_pgno, bkdata->data, sizeof(db_pgno_t));
  2162. /* If we can't get the subdb meta page, just skip the subdb. */
  2163. if (!IS_VALID_PGNO(meta_pgno) ||
  2164.     (ret = memp_fget(dbp->mpf, &meta_pgno, 0, &subpg)) != 0) {
  2165. err_ret = ret;
  2166. continue;
  2167. }
  2169. /*
  2170.  * Verify the subdatabase meta page.  This has two functions.
  2171.  * First, if it's bad, we have no choice but to skip the subdb
  2172.  * and let the pages just get printed on a later pass.  Second,
  2173.  * the access-method-specific meta verification routines record
  2174.  * the various state info (such as the presence of dups)
  2175.  * that we need for __db_prheader().
  2176.  */
  2177. if ((ret =
  2178.     __db_vrfy_common(dbp, vdp, subpg, meta_pgno, flags)) != 0) {
  2179. err_ret = ret;
  2180. (void)memp_fput(dbp->mpf, subpg, 0);
  2181. continue;
  2182. }
  2183. switch (TYPE(subpg)) {
  2184. case P_BTREEMETA:
  2185. if ((ret = __bam_vrfy_meta(dbp,
  2186.     vdp, (BTMETA *)subpg, meta_pgno, flags)) != 0) {
  2187. err_ret = ret;
  2188. (void)memp_fput(dbp->mpf, subpg, 0);
  2189. continue;
  2190. }
  2191. break;
  2192. case P_HASHMETA:
  2193. if ((ret = __ham_vrfy_meta(dbp,
  2194.     vdp, (HMETA *)subpg, meta_pgno, flags)) != 0) {
  2195. err_ret = ret;
  2196. (void)memp_fput(dbp->mpf, subpg, 0);
  2197. continue;
  2198. }
  2199. break;
  2200. default:
  2201. /* This isn't an appropriate page;  skip this subdb. */
  2202. err_ret = DB_VERIFY_BAD;
  2203. continue;
  2204. /* NOTREACHED */
  2205. }
  2207. if ((ret = memp_fput(dbp->mpf, subpg, 0)) != 0) {
  2208. err_ret = ret;
  2209. continue;
  2210. }
  2212. /* Print a subdatabase header. */
  2213. if ((ret = __db_prheader(dbp,
  2214.     subdbname, 0, 0, handle, callback, vdp, meta_pgno)) != 0)
  2215. goto err;
  2217. if ((ret = __db_meta2pgset(dbp, vdp, meta_pgno,
  2218.     flags, pgset)) != 0) {
  2219. err_ret = ret;
  2220. continue;
  2221. }
  2223. if ((ret = pgset->cursor(pgset, NULL, &pgsc, 0)) != 0)
  2224. goto err;
  2225. while ((ret = __db_vrfy_pgset_next(pgsc, &p)) == 0) {
  2226. if ((ret = memp_fget(dbp->mpf, &p, 0, &subpg)) != 0) {
  2227. err_ret = ret;
  2228. continue;
  2229. }
  2230. if ((ret = __db_salvage(dbp, vdp, p, subpg,
  2231.     handle, callback, flags)) != 0)
  2232. err_ret = ret;
  2233. if ((ret = memp_fput(dbp->mpf, subpg, 0)) != 0)
  2234. err_ret = ret;
  2235. }
  2237. if (ret != DB_NOTFOUND)
  2238. goto err;
  2240. if ((ret = pgsc->c_close(pgsc)) != 0)
  2241. goto err;
  2242. if ((ret = __db_prfooter(handle, callback)) != 0)
  2243. goto err;
  2244. }
  2245. err: if (subdbname)
  2246. __os_free(subdbname, 0);
  2248. if ((t_ret = pgset->close(pgset, 0)) != 0)
  2249. ret = t_ret;
  2251. if ((t_ret = __db_salvage_markdone(vdp, PGNO(master))) != 0)
  2252. return (t_ret);
  2254. return ((err_ret != 0) ? err_ret : ret);
  2255. }
  2257. /*
  2258.  * __db_meta2pgset --
  2259.  * Given a known-safe meta page number, return the set of pages
  2260.  * corresponding to the database it represents.  Return DB_VERIFY_BAD if
  2261.  * it's not a suitable meta page or is invalid.
  2262.  */
  2263. static int
  2264. __db_meta2pgset(dbp, vdp, pgno, flags, pgset)
  2265. DB *dbp;
  2266. VRFY_DBINFO *vdp;
  2267. db_pgno_t pgno;
  2268. u_int32_t flags;
  2269. DB *pgset;
  2270. {
  2271. PAGE *h;
  2272. int ret, t_ret;
  2274. if ((ret = memp_fget(dbp->mpf, &pgno, 0, &h)) != 0)
  2275. return (ret);
  2277. switch (TYPE(h)) {
  2278. case P_BTREEMETA:
  2279. ret = __bam_meta2pgset(dbp, vdp, (BTMETA *)h, flags, pgset);
  2280. break;
  2281. case P_HASHMETA:
  2282. ret = __ham_meta2pgset(dbp, vdp, (HMETA *)h, flags, pgset);
  2283. break;
  2284. default:
  2285. ret = DB_VERIFY_BAD;
  2286. break;
  2287. }
  2289. if ((t_ret = memp_fput(dbp->mpf, h, 0)) != 0)
  2290. return (t_ret);
  2291. return (ret);
  2292. }
  2294. /*
  2295.  * __db_guesspgsize --
  2296.  * Try to guess what the pagesize is if the one on the meta page
  2297.  * and the one in the db are invalid.
  2298.  */
  2299. static int
  2300. __db_guesspgsize(dbenv, fhp)
  2301. DB_ENV *dbenv;
  2302. DB_FH *fhp;
  2303. {
  2304. db_pgno_t i;
  2305. size_t nr;
  2306. u_int32_t guess;
  2307. u_int8_t type;
  2308. int ret;
  2310. for (guess = DB_MAX_PGSIZE; guess >= DB_MIN_PGSIZE; guess >>= 1) {
  2311. /*
  2312.  * We try to read three pages ahead after the first one
  2313.  * and make sure we have plausible types for all of them.
  2314.  * If the seeks fail, continue with a smaller size;
  2315.  * we're probably just looking past the end of the database.
  2316.  * If they succeed and the types are reasonable, also continue
  2317.  * with a size smaller;  we may be looking at pages N,
  2318.  * 2N, and 3N for some N > 1.
  2319.  *
  2320.  * As soon as we hit an invalid type, we stop and return
  2321.  * our previous guess; that last one was probably the page size.
  2322.  */
  2323. for (i = 1; i <= 3; i++) {
  2324. if ((ret = __os_seek(dbenv, fhp, guess,
  2325.     i, SSZ(DBMETA, type), 0, DB_OS_SEEK_SET)) != 0)
  2326. break;
  2327. if ((ret = __os_read(dbenv,
  2328.     fhp, &type, 1, &nr)) != 0 || nr == 0)
  2329. break;
  2330. if (type == P_INVALID || type >= P_PAGETYPE_MAX)
  2331. return (guess << 1);
  2332. }
  2333. }
  2335. /*
  2336.  * If we're just totally confused--the corruption takes up most of the
  2337.  * beginning pages of the database--go with the default size.
  2338.  */
  2339. return (DB_DEF_IOSIZE);
  2340. }