db_vrfyutil.c
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:19k
源码类别:

MySQL数据库

开发平台:

Visual 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_vrfyutil.c,v 11.29 2002/08/08 03:57:50 bostic Exp $
  8.  */
  9. #include "db_config.h"
  10. #ifndef lint
  11. static const char revid[] = "$Id: db_vrfyutil.c,v 11.29 2002/08/08 03:57:50 bostic Exp $";
  12. #endif /* not lint */
  13. #ifndef NO_SYSTEM_INCLUDES
  14. #include <sys/types.h>
  15. #include <string.h>
  16. #endif
  17. #include "db_int.h"
  18. #include "dbinc/db_page.h"
  19. #include "dbinc/db_verify.h"
  20. #include "dbinc/db_am.h"
  21. static int __db_vrfy_pageinfo_create __P((DB_ENV *, VRFY_PAGEINFO **));
  22. static int __db_vrfy_pgset_iinc __P((DB *, db_pgno_t, int));
  23. /*
  24.  * __db_vrfy_dbinfo_create --
  25.  * Allocate and initialize a VRFY_DBINFO structure.
  26.  *
  27.  * PUBLIC: int __db_vrfy_dbinfo_create
  28.  * PUBLIC:     __P((DB_ENV *, u_int32_t, VRFY_DBINFO **));
  29.  */
  30. int
  31. __db_vrfy_dbinfo_create(dbenv, pgsize, vdpp)
  32. DB_ENV *dbenv;
  33. u_int32_t pgsize;
  34. VRFY_DBINFO **vdpp;
  35. {
  36. DB *cdbp, *pgdbp, *pgset;
  37. VRFY_DBINFO *vdp;
  38. int ret;
  39. vdp = NULL;
  40. cdbp = pgdbp = pgset = NULL;
  41. if ((ret = __os_calloc(NULL,
  42.     1, sizeof(VRFY_DBINFO), (void **)&vdp)) != 0)
  43. goto err;
  44. if ((ret = db_create(&cdbp, dbenv, 0)) != 0)
  45. goto err;
  46. if ((ret = cdbp->set_flags(cdbp, DB_DUP)) != 0)
  47. goto err;
  48. if ((ret = cdbp->set_pagesize(cdbp, pgsize)) != 0)
  49. goto err;
  50. if ((ret =
  51.     cdbp->open(cdbp, NULL, NULL, NULL, DB_BTREE, DB_CREATE, 0600)) != 0)
  52. goto err;
  53. if ((ret = db_create(&pgdbp, dbenv, 0)) != 0)
  54. goto err;
  55. if ((ret = pgdbp->set_pagesize(pgdbp, pgsize)) != 0)
  56. goto err;
  57. if ((ret = pgdbp->open(pgdbp,
  58.     NULL, NULL, NULL, DB_BTREE, DB_CREATE, 0600)) != 0)
  59. goto err;
  60. if ((ret = __db_vrfy_pgset(dbenv, pgsize, &pgset)) != 0)
  61. goto err;
  62. LIST_INIT(&vdp->subdbs);
  63. LIST_INIT(&vdp->activepips);
  64. vdp->cdbp = cdbp;
  65. vdp->pgdbp = pgdbp;
  66. vdp->pgset = pgset;
  67. *vdpp = vdp;
  68. return (0);
  69. err: if (cdbp != NULL)
  70. (void)cdbp->close(cdbp, 0);
  71. if (pgdbp != NULL)
  72. (void)pgdbp->close(pgdbp, 0);
  73. if (vdp != NULL)
  74. __os_free(dbenv, vdp);
  75. return (ret);
  76. }
  77. /*
  78.  * __db_vrfy_dbinfo_destroy --
  79.  * Destructor for VRFY_DBINFO.  Destroys VRFY_PAGEINFOs and deallocates
  80.  * structure.
  81.  *
  82.  * PUBLIC: int __db_vrfy_dbinfo_destroy __P((DB_ENV *, VRFY_DBINFO *));
  83.  */
  84. int
  85. __db_vrfy_dbinfo_destroy(dbenv, vdp)
  86. DB_ENV *dbenv;
  87. VRFY_DBINFO *vdp;
  88. {
  89. VRFY_CHILDINFO *c, *d;
  90. int t_ret, ret;
  91. ret = 0;
  92. for (c = LIST_FIRST(&vdp->subdbs); c != NULL; c = d) {
  93. d = LIST_NEXT(c, links);
  94. __os_free(NULL, c);
  95. }
  96. if ((t_ret = vdp->pgdbp->close(vdp->pgdbp, 0)) != 0)
  97. ret = t_ret;
  98. if ((t_ret = vdp->cdbp->close(vdp->cdbp, 0)) != 0 && ret == 0)
  99. ret = t_ret;
  100. if ((t_ret = vdp->pgset->close(vdp->pgset, 0)) != 0 && ret == 0)
  101. ret = t_ret;
  102. DB_ASSERT(LIST_FIRST(&vdp->activepips) == NULL);
  103. __os_free(dbenv, vdp);
  104. return (ret);
  105. }
  106. /*
  107.  * __db_vrfy_getpageinfo --
  108.  * Get a PAGEINFO structure for a given page, creating it if necessary.
  109.  *
  110.  * PUBLIC: int __db_vrfy_getpageinfo
  111.  * PUBLIC:     __P((VRFY_DBINFO *, db_pgno_t, VRFY_PAGEINFO **));
  112.  */
  113. int
  114. __db_vrfy_getpageinfo(vdp, pgno, pipp)
  115. VRFY_DBINFO *vdp;
  116. db_pgno_t pgno;
  117. VRFY_PAGEINFO **pipp;
  118. {
  119. DBT key, data;
  120. DB *pgdbp;
  121. VRFY_PAGEINFO *pip;
  122. int ret;
  123. /*
  124.  * We want a page info struct.  There are three places to get it from,
  125.  * in decreasing order of preference:
  126.  *
  127.  * 1. vdp->activepips.  If it's already "checked out", we're
  128.  * already using it, we return the same exact structure with a
  129.  * bumped refcount.  This is necessary because this code is
  130.  * replacing array accesses, and it's common for f() to make some
  131.  * changes to a pip, and then call g() and h() which each make
  132.  * changes to the same pip.  vdps are never shared between threads
  133.  * (they're never returned to the application), so this is safe.
  134.  * 2. The pgdbp.  It's not in memory, but it's in the database, so
  135.  * get it, give it a refcount of 1, and stick it on activepips.
  136.  * 3. malloc.  It doesn't exist yet;  create it, then stick it on
  137.  * activepips.  We'll put it in the database when we putpageinfo
  138.  * later.
  139.  */
  140. /* Case 1. */
  141. for (pip = LIST_FIRST(&vdp->activepips); pip != NULL;
  142.     pip = LIST_NEXT(pip, links))
  143. if (pip->pgno == pgno)
  144. /* Found it. */
  145. goto found;
  146. /* Case 2. */
  147. pgdbp = vdp->pgdbp;
  148. memset(&key, 0, sizeof(DBT));
  149. memset(&data, 0, sizeof(DBT));
  150. F_SET(&data, DB_DBT_MALLOC);
  151. key.data = &pgno;
  152. key.size = sizeof(db_pgno_t);
  153. if ((ret = pgdbp->get(pgdbp, NULL, &key, &data, 0)) == 0) {
  154. /* Found it. */
  155. DB_ASSERT(data.size = sizeof(VRFY_PAGEINFO));
  156. pip = data.data;
  157. DB_ASSERT(pip->pi_refcount == 0);
  158. LIST_INSERT_HEAD(&vdp->activepips, pip, links);
  159. goto found;
  160. } else if (ret != DB_NOTFOUND) /* Something nasty happened. */
  161. return (ret);
  162. /* Case 3 */
  163. if ((ret = __db_vrfy_pageinfo_create(pgdbp->dbenv, &pip)) != 0)
  164. return (ret);
  165. LIST_INSERT_HEAD(&vdp->activepips, pip, links);
  166. found: pip->pi_refcount++;
  167. *pipp = pip;
  168. DB_ASSERT(pip->pi_refcount > 0);
  169. return (0);
  170. }
  171. /*
  172.  * __db_vrfy_putpageinfo --
  173.  * Put back a VRFY_PAGEINFO that we're done with.
  174.  *
  175.  * PUBLIC: int __db_vrfy_putpageinfo __P((DB_ENV *,
  176.  * PUBLIC:     VRFY_DBINFO *, VRFY_PAGEINFO *));
  177.  */
  178. int
  179. __db_vrfy_putpageinfo(dbenv, vdp, pip)
  180. DB_ENV *dbenv;
  181. VRFY_DBINFO *vdp;
  182. VRFY_PAGEINFO *pip;
  183. {
  184. DBT key, data;
  185. DB *pgdbp;
  186. VRFY_PAGEINFO *p;
  187. int ret;
  188. #ifdef DIAGNOSTIC
  189. int found;
  190. found = 0;
  191. #endif
  192. if (--pip->pi_refcount > 0)
  193. return (0);
  194. pgdbp = vdp->pgdbp;
  195. memset(&key, 0, sizeof(DBT));
  196. memset(&data, 0, sizeof(DBT));
  197. key.data = &pip->pgno;
  198. key.size = sizeof(db_pgno_t);
  199. data.data = pip;
  200. data.size = sizeof(VRFY_PAGEINFO);
  201. if ((ret = pgdbp->put(pgdbp, NULL, &key, &data, 0)) != 0)
  202. return (ret);
  203. for (p = LIST_FIRST(&vdp->activepips); p != NULL;
  204.     p = LIST_NEXT(p, links))
  205. if (p == pip) {
  206. #ifdef DIAGNOSTIC
  207. found++;
  208. #endif
  209. DB_ASSERT(p->pi_refcount == 0);
  210. LIST_REMOVE(p, links);
  211. break;
  212. }
  213. #ifdef DIAGNOSTIC
  214. DB_ASSERT(found == 1);
  215. #endif
  216. DB_ASSERT(pip->pi_refcount == 0);
  217. __os_ufree(dbenv, pip);
  218. return (0);
  219. }
  220. /*
  221.  * __db_vrfy_pgset --
  222.  * Create a temporary database for the storing of sets of page numbers.
  223.  * (A mapping from page number to int, used by the *_meta2pgset functions,
  224.  * as well as for keeping track of which pages the verifier has seen.)
  225.  *
  226.  * PUBLIC: int __db_vrfy_pgset __P((DB_ENV *, u_int32_t, DB **));
  227.  */
  228. int
  229. __db_vrfy_pgset(dbenv, pgsize, dbpp)
  230. DB_ENV *dbenv;
  231. u_int32_t pgsize;
  232. DB **dbpp;
  233. {
  234. DB *dbp;
  235. int ret;
  236. if ((ret = db_create(&dbp, dbenv, 0)) != 0)
  237. return (ret);
  238. if ((ret = dbp->set_pagesize(dbp, pgsize)) != 0)
  239. goto err;
  240. if ((ret = dbp->open(dbp,
  241.     NULL, NULL, NULL, DB_BTREE, DB_CREATE, 0600)) == 0)
  242. *dbpp = dbp;
  243. else
  244. err: (void)dbp->close(dbp, 0);
  245. return (ret);
  246. }
  247. /*
  248.  * __db_vrfy_pgset_get --
  249.  * Get the value associated in a page set with a given pgno.  Return
  250.  * a 0 value (and succeed) if we've never heard of this page.
  251.  *
  252.  * PUBLIC: int __db_vrfy_pgset_get __P((DB *, db_pgno_t, int *));
  253.  */
  254. int
  255. __db_vrfy_pgset_get(dbp, pgno, valp)
  256. DB *dbp;
  257. db_pgno_t pgno;
  258. int *valp;
  259. {
  260. DBT key, data;
  261. int ret, val;
  262. memset(&key, 0, sizeof(DBT));
  263. memset(&data, 0, sizeof(DBT));
  264. key.data = &pgno;
  265. key.size = sizeof(db_pgno_t);
  266. data.data = &val;
  267. data.ulen = sizeof(int);
  268. F_SET(&data, DB_DBT_USERMEM);
  269. if ((ret = dbp->get(dbp, NULL, &key, &data, 0)) == 0) {
  270. DB_ASSERT(data.size = sizeof(int));
  271. memcpy(&val, data.data, sizeof(int));
  272. } else if (ret == DB_NOTFOUND)
  273. val = 0;
  274. else
  275. return (ret);
  276. *valp = val;
  277. return (0);
  278. }
  279. /*
  280.  * __db_vrfy_pgset_inc --
  281.  * Increment the value associated with a pgno by 1.
  282.  *
  283.  * PUBLIC: int __db_vrfy_pgset_inc __P((DB *, db_pgno_t));
  284.  */
  285. int
  286. __db_vrfy_pgset_inc(dbp, pgno)
  287. DB *dbp;
  288. db_pgno_t pgno;
  289. {
  290. return (__db_vrfy_pgset_iinc(dbp, pgno, 1));
  291. }
  292. /*
  293.  * __db_vrfy_pgset_dec --
  294.  * Increment the value associated with a pgno by 1.
  295.  *
  296.  * PUBLIC: int __db_vrfy_pgset_dec __P((DB *, db_pgno_t));
  297.  */
  298. int
  299. __db_vrfy_pgset_dec(dbp, pgno)
  300. DB *dbp;
  301. db_pgno_t pgno;
  302. {
  303. return (__db_vrfy_pgset_iinc(dbp, pgno, -1));
  304. }
  305. /*
  306.  * __db_vrfy_pgset_iinc --
  307.  * Increment the value associated with a pgno by i.
  308.  *
  309.  */
  310. static int
  311. __db_vrfy_pgset_iinc(dbp, pgno, i)
  312. DB *dbp;
  313. db_pgno_t pgno;
  314. int i;
  315. {
  316. DBT key, data;
  317. int ret;
  318. int val;
  319. memset(&key, 0, sizeof(DBT));
  320. memset(&data, 0, sizeof(DBT));
  321. val = 0;
  322. key.data = &pgno;
  323. key.size = sizeof(db_pgno_t);
  324. data.data = &val;
  325. data.ulen = sizeof(int);
  326. F_SET(&data, DB_DBT_USERMEM);
  327. if ((ret = dbp->get(dbp, NULL, &key, &data, 0)) == 0) {
  328. DB_ASSERT(data.size == sizeof(int));
  329. memcpy(&val, data.data, sizeof(int));
  330. } else if (ret != DB_NOTFOUND)
  331. return (ret);
  332. data.size = sizeof(int);
  333. val += i;
  334. return (dbp->put(dbp, NULL, &key, &data, 0));
  335. }
  336. /*
  337.  * __db_vrfy_pgset_next --
  338.  * Given a cursor open in a pgset database, get the next page in the
  339.  * set.
  340.  *
  341.  * PUBLIC: int __db_vrfy_pgset_next __P((DBC *, db_pgno_t *));
  342.  */
  343. int
  344. __db_vrfy_pgset_next(dbc, pgnop)
  345. DBC *dbc;
  346. db_pgno_t *pgnop;
  347. {
  348. DBT key, data;
  349. db_pgno_t pgno;
  350. int ret;
  351. memset(&key, 0, sizeof(DBT));
  352. memset(&data, 0, sizeof(DBT));
  353. /* We don't care about the data, just the keys. */
  354. F_SET(&data, DB_DBT_USERMEM | DB_DBT_PARTIAL);
  355. F_SET(&key, DB_DBT_USERMEM);
  356. key.data = &pgno;
  357. key.ulen = sizeof(db_pgno_t);
  358. if ((ret = dbc->c_get(dbc, &key, &data, DB_NEXT)) != 0)
  359. return (ret);
  360. DB_ASSERT(key.size == sizeof(db_pgno_t));
  361. *pgnop = pgno;
  362. return (0);
  363. }
  364. /*
  365.  * __db_vrfy_childcursor --
  366.  * Create a cursor to walk the child list with.  Returns with a nonzero
  367.  * final argument if the specified page has no children.
  368.  *
  369.  * PUBLIC: int __db_vrfy_childcursor __P((VRFY_DBINFO *, DBC **));
  370.  */
  371. int
  372. __db_vrfy_childcursor(vdp, dbcp)
  373. VRFY_DBINFO *vdp;
  374. DBC **dbcp;
  375. {
  376. DB *cdbp;
  377. DBC *dbc;
  378. int ret;
  379. cdbp = vdp->cdbp;
  380. if ((ret = cdbp->cursor(cdbp, NULL, &dbc, 0)) == 0)
  381. *dbcp = dbc;
  382. return (ret);
  383. }
  384. /*
  385.  * __db_vrfy_childput --
  386.  * Add a child structure to the set for a given page.
  387.  *
  388.  * PUBLIC: int __db_vrfy_childput
  389.  * PUBLIC:     __P((VRFY_DBINFO *, db_pgno_t, VRFY_CHILDINFO *));
  390.  */
  391. int
  392. __db_vrfy_childput(vdp, pgno, cip)
  393. VRFY_DBINFO *vdp;
  394. db_pgno_t pgno;
  395. VRFY_CHILDINFO *cip;
  396. {
  397. DB *cdbp;
  398. DBC *cc;
  399. DBT key, data;
  400. VRFY_CHILDINFO *oldcip;
  401. int ret;
  402. cdbp = vdp->cdbp;
  403. memset(&key, 0, sizeof(DBT));
  404. memset(&data, 0, sizeof(DBT));
  405. key.data = &pgno;
  406. key.size = sizeof(db_pgno_t);
  407. /*
  408.  * We want to avoid adding multiple entries for a single child page;
  409.  * we only need to verify each child once, even if a child (such
  410.  * as an overflow key) is multiply referenced.
  411.  *
  412.  * However, we also need to make sure that when walking the list
  413.  * of children, we encounter them in the order they're referenced
  414.  * on a page.  (This permits us, for example, to verify the
  415.  * prev_pgno/next_pgno chain of Btree leaf pages.)
  416.  *
  417.  * Check the child database to make sure that this page isn't
  418.  * already a child of the specified page number.  If it's not,
  419.  * put it at the end of the duplicate set.
  420.  */
  421. if ((ret = __db_vrfy_childcursor(vdp, &cc)) != 0)
  422. return (ret);
  423. for (ret = __db_vrfy_ccset(cc, pgno, &oldcip); ret == 0;
  424.     ret = __db_vrfy_ccnext(cc, &oldcip))
  425. if (oldcip->pgno == cip->pgno) {
  426. /*
  427.  * Found a matching child.  Return without
  428.  * putting it again.
  429.  */
  430. if ((ret = __db_vrfy_ccclose(cc)) != 0)
  431. return (ret);
  432. return (0);
  433. }
  434. if (ret != DB_NOTFOUND) {
  435. (void)__db_vrfy_ccclose(cc);
  436. return (ret);
  437. }
  438. if ((ret = __db_vrfy_ccclose(cc)) != 0)
  439. return (ret);
  440. data.data = cip;
  441. data.size = sizeof(VRFY_CHILDINFO);
  442. return (cdbp->put(cdbp, NULL, &key, &data, 0));
  443. }
  444. /*
  445.  * __db_vrfy_ccset --
  446.  * Sets a cursor created with __db_vrfy_childcursor to the first
  447.  * child of the given pgno, and returns it in the third arg.
  448.  *
  449.  * PUBLIC: int __db_vrfy_ccset __P((DBC *, db_pgno_t, VRFY_CHILDINFO **));
  450.  */
  451. int
  452. __db_vrfy_ccset(dbc, pgno, cipp)
  453. DBC *dbc;
  454. db_pgno_t pgno;
  455. VRFY_CHILDINFO **cipp;
  456. {
  457. DBT key, data;
  458. int ret;
  459. memset(&key, 0, sizeof(DBT));
  460. memset(&data, 0, sizeof(DBT));
  461. key.data = &pgno;
  462. key.size = sizeof(db_pgno_t);
  463. if ((ret = dbc->c_get(dbc, &key, &data, DB_SET)) != 0)
  464. return (ret);
  465. DB_ASSERT(data.size == sizeof(VRFY_CHILDINFO));
  466. *cipp = (VRFY_CHILDINFO *)data.data;
  467. return (0);
  468. }
  469. /*
  470.  * __db_vrfy_ccnext --
  471.  * Gets the next child of the given cursor created with
  472.  * __db_vrfy_childcursor, and returns it in the memory provided in the
  473.  * second arg.
  474.  *
  475.  * PUBLIC: int __db_vrfy_ccnext __P((DBC *, VRFY_CHILDINFO **));
  476.  */
  477. int
  478. __db_vrfy_ccnext(dbc, cipp)
  479. DBC *dbc;
  480. VRFY_CHILDINFO **cipp;
  481. {
  482. DBT key, data;
  483. int ret;
  484. memset(&key, 0, sizeof(DBT));
  485. memset(&data, 0, sizeof(DBT));
  486. if ((ret = dbc->c_get(dbc, &key, &data, DB_NEXT_DUP)) != 0)
  487. return (ret);
  488. DB_ASSERT(data.size == sizeof(VRFY_CHILDINFO));
  489. *cipp = (VRFY_CHILDINFO *)data.data;
  490. return (0);
  491. }
  492. /*
  493.  * __db_vrfy_ccclose --
  494.  * Closes the cursor created with __db_vrfy_childcursor.
  495.  *
  496.  * This doesn't actually do anything interesting now, but it's
  497.  * not inconceivable that we might change the internal database usage
  498.  * and keep the interfaces the same, and a function call here or there
  499.  * seldom hurts anyone.
  500.  *
  501.  * PUBLIC: int __db_vrfy_ccclose __P((DBC *));
  502.  */
  503. int
  504. __db_vrfy_ccclose(dbc)
  505. DBC *dbc;
  506. {
  507. return (dbc->c_close(dbc));
  508. }
  509. /*
  510.  * __db_vrfy_pageinfo_create --
  511.  * Constructor for VRFY_PAGEINFO;  allocates and initializes.
  512.  */
  513. static int
  514. __db_vrfy_pageinfo_create(dbenv, pgipp)
  515. DB_ENV *dbenv;
  516. VRFY_PAGEINFO **pgipp;
  517. {
  518. VRFY_PAGEINFO *pgip;
  519. int ret;
  520. /*
  521.  * pageinfo structs are sometimes allocated here and sometimes
  522.  * allocated by fetching them from a database with DB_DBT_MALLOC.
  523.  * There's no easy way for the destructor to tell which was
  524.  * used, and so we always allocate with __os_umalloc so we can free
  525.  * with __os_ufree.
  526.  */
  527. if ((ret = __os_umalloc(dbenv,
  528.     sizeof(VRFY_PAGEINFO), (void **)&pgip)) != 0)
  529. return (ret);
  530. memset(pgip, 0, sizeof(VRFY_PAGEINFO));
  531. DB_ASSERT(pgip->pi_refcount == 0);
  532. *pgipp = pgip;
  533. return (0);
  534. }
  535. /*
  536.  * __db_salvage_init --
  537.  * Set up salvager database.
  538.  *
  539.  * PUBLIC: int  __db_salvage_init __P((VRFY_DBINFO *));
  540.  */
  541. int
  542. __db_salvage_init(vdp)
  543. VRFY_DBINFO *vdp;
  544. {
  545. DB *dbp;
  546. int ret;
  547. if ((ret = db_create(&dbp, NULL, 0)) != 0)
  548. return (ret);
  549. if ((ret = dbp->set_pagesize(dbp, 1024)) != 0)
  550. goto err;
  551. if ((ret = dbp->open(dbp,
  552.     NULL, NULL, NULL, DB_BTREE, DB_CREATE, 0)) != 0)
  553. goto err;
  554. vdp->salvage_pages = dbp;
  555. return (0);
  556. err: (void)dbp->close(dbp, 0);
  557. return (ret);
  558. }
  559. /*
  560.  * __db_salvage_destroy --
  561.  * Close salvager database.
  562.  * PUBLIC: void  __db_salvage_destroy __P((VRFY_DBINFO *));
  563.  */
  564. void
  565. __db_salvage_destroy(vdp)
  566. VRFY_DBINFO *vdp;
  567. {
  568. (void)vdp->salvage_pages->close(vdp->salvage_pages, 0);
  569. }
  570. /*
  571.  * __db_salvage_getnext --
  572.  * Get the next (first) unprinted page in the database of pages we need to
  573.  * print still.  Delete entries for any already-printed pages we encounter
  574.  * in this search, as well as the page we're returning.
  575.  *
  576.  * PUBLIC: int __db_salvage_getnext
  577.  * PUBLIC:     __P((VRFY_DBINFO *, db_pgno_t *, u_int32_t *));
  578.  */
  579. int
  580. __db_salvage_getnext(vdp, pgnop, pgtypep)
  581. VRFY_DBINFO *vdp;
  582. db_pgno_t *pgnop;
  583. u_int32_t *pgtypep;
  584. {
  585. DB *dbp;
  586. DBC *dbc;
  587. DBT key, data;
  588. int ret;
  589. u_int32_t pgtype;
  590. dbp = vdp->salvage_pages;
  591. memset(&key, 0, sizeof(DBT));
  592. memset(&data, 0, sizeof(DBT));
  593. if ((ret = dbp->cursor(dbp, NULL, &dbc, 0)) != 0)
  594. return (ret);
  595. while ((ret = dbc->c_get(dbc, &key, &data, DB_NEXT)) == 0) {
  596. DB_ASSERT(data.size == sizeof(u_int32_t));
  597. memcpy(&pgtype, data.data, sizeof(pgtype));
  598. if ((ret = dbc->c_del(dbc, 0)) != 0)
  599. goto err;
  600. if (pgtype != SALVAGE_IGNORE)
  601. goto found;
  602. }
  603. /* No more entries--ret probably equals DB_NOTFOUND. */
  604. if (0) {
  605. found: DB_ASSERT(key.size == sizeof(db_pgno_t));
  606. DB_ASSERT(data.size == sizeof(u_int32_t));
  607. *pgnop = *(db_pgno_t *)key.data;
  608. *pgtypep = *(u_int32_t *)data.data;
  609. }
  610. err: (void)dbc->c_close(dbc);
  611. return (ret);
  612. }
  613. /*
  614.  * __db_salvage_isdone --
  615.  * Return whether or not the given pgno is already marked
  616.  * SALVAGE_IGNORE (meaning that we don't need to print it again).
  617.  *
  618.  * Returns DB_KEYEXIST if it is marked, 0 if not, or another error on
  619.  * error.
  620.  *
  621.  * PUBLIC: int __db_salvage_isdone __P((VRFY_DBINFO *, db_pgno_t));
  622.  */
  623. int
  624. __db_salvage_isdone(vdp, pgno)
  625. VRFY_DBINFO *vdp;
  626. db_pgno_t pgno;
  627. {
  628. DBT key, data;
  629. DB *dbp;
  630. int ret;
  631. u_int32_t currtype;
  632. dbp = vdp->salvage_pages;
  633. memset(&key, 0, sizeof(DBT));
  634. memset(&data, 0, sizeof(DBT));
  635. currtype = SALVAGE_INVALID;
  636. data.data = &currtype;
  637. data.ulen = sizeof(u_int32_t);
  638. data.flags = DB_DBT_USERMEM;
  639. key.data = &pgno;
  640. key.size = sizeof(db_pgno_t);
  641. /*
  642.  * Put an entry for this page, with pgno as key and type as data,
  643.  * unless it's already there and is marked done.
  644.  * If it's there and is marked anything else, that's fine--we
  645.  * want to mark it done.
  646.  */
  647. ret = dbp->get(dbp, NULL, &key, &data, 0);
  648. if (ret == 0) {
  649. /*
  650.  * The key's already here.  Check and see if it's already
  651.  * marked done.  If it is, return DB_KEYEXIST.  If it's not,
  652.  * return 0.
  653.  */
  654. if (currtype == SALVAGE_IGNORE)
  655. return (DB_KEYEXIST);
  656. else
  657. return (0);
  658. } else if (ret != DB_NOTFOUND)
  659. return (ret);
  660. /* The pgno is not yet marked anything; return 0. */
  661. return (0);
  662. }
  663. /*
  664.  * __db_salvage_markdone --
  665.  * Mark as done a given page.
  666.  *
  667.  * PUBLIC: int __db_salvage_markdone __P((VRFY_DBINFO *, db_pgno_t));
  668.  */
  669. int
  670. __db_salvage_markdone(vdp, pgno)
  671. VRFY_DBINFO *vdp;
  672. db_pgno_t pgno;
  673. {
  674. DBT key, data;
  675. DB *dbp;
  676. int pgtype, ret;
  677. u_int32_t currtype;
  678. pgtype = SALVAGE_IGNORE;
  679. dbp = vdp->salvage_pages;
  680. memset(&key, 0, sizeof(DBT));
  681. memset(&data, 0, sizeof(DBT));
  682. currtype = SALVAGE_INVALID;
  683. data.data = &currtype;
  684. data.ulen = sizeof(u_int32_t);
  685. data.flags = DB_DBT_USERMEM;
  686. key.data = &pgno;
  687. key.size = sizeof(db_pgno_t);
  688. /*
  689.  * Put an entry for this page, with pgno as key and type as data,
  690.  * unless it's already there and is marked done.
  691.  * If it's there and is marked anything else, that's fine--we
  692.  * want to mark it done, but db_salvage_isdone only lets
  693.  * us know if it's marked IGNORE.
  694.  *
  695.  * We don't want to return DB_KEYEXIST, though;  this will
  696.  * likely get passed up all the way and make no sense to the
  697.  * application.  Instead, use DB_VERIFY_BAD to indicate that
  698.  * we've seen this page already--it probably indicates a
  699.  * multiply-linked page.
  700.  */
  701. if ((ret = __db_salvage_isdone(vdp, pgno)) != 0)
  702. return (ret == DB_KEYEXIST ? DB_VERIFY_BAD : ret);
  703. data.size = sizeof(u_int32_t);
  704. data.data = &pgtype;
  705. return (dbp->put(dbp, NULL, &key, &data, 0));
  706. }
  707. /*
  708.  * __db_salvage_markneeded --
  709.  * If it has not yet been printed, make note of the fact that a page
  710.  * must be dealt with later.
  711.  *
  712.  * PUBLIC: int __db_salvage_markneeded
  713.  * PUBLIC:     __P((VRFY_DBINFO *, db_pgno_t, u_int32_t));
  714.  */
  715. int
  716. __db_salvage_markneeded(vdp, pgno, pgtype)
  717. VRFY_DBINFO *vdp;
  718. db_pgno_t pgno;
  719. u_int32_t pgtype;
  720. {
  721. DB *dbp;
  722. DBT key, data;
  723. int ret;
  724. dbp = vdp->salvage_pages;
  725. memset(&key, 0, sizeof(DBT));
  726. memset(&data, 0, sizeof(DBT));
  727. key.data = &pgno;
  728. key.size = sizeof(db_pgno_t);
  729. data.data = &pgtype;
  730. data.size = sizeof(u_int32_t);
  731. /*
  732.  * Put an entry for this page, with pgno as key and type as data,
  733.  * unless it's already there, in which case it's presumably
  734.  * already been marked done.
  735.  */
  736. ret = dbp->put(dbp, NULL, &key, &data, DB_NOOVERWRITE);
  737. return (ret == DB_KEYEXIST ? 0 : ret);
  738. }