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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
db_vrfy.c
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：62k
源码类别：

MySQL数据库

开发平台：

Visual C++

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