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

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

MySQL数据库

开发平台：

Visual C++

db_rec.c：源码内容
  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 1996-2002
  5.  * Sleepycat Software.  All rights reserved.
  6.  */
  8. #include "db_config.h"
  10. #ifndef lint
  11. static const char revid[] = "$Id: db_rec.c,v 11.35 2002/08/08 03:57:49 bostic Exp $";
  12. #endif /* not lint */
  14. #ifndef NO_SYSTEM_INCLUDES
  15. #include <sys/types.h>
  17. #include <string.h>
  18. #endif
  20. #include "db_int.h"
  21. #include "dbinc/db_page.h"
  22. #include "dbinc/log.h"
  23. #include "dbinc/hash.h"
  25. /*
  26.  * PUBLIC: int __db_addrem_recover
  27.  * PUBLIC:    __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  28.  *
  29.  * This log message is generated whenever we add or remove a duplicate
  30.  * to/from a duplicate page.  On recover, we just do the opposite.
  31.  */
  32. int
  33. __db_addrem_recover(dbenv, dbtp, lsnp, op, info)
  34. DB_ENV *dbenv;
  35. DBT *dbtp;
  36. DB_LSN *lsnp;
  37. db_recops op;
  38. void *info;
  39. {
  40. __db_addrem_args *argp;
  41. DB *file_dbp;
  42. DBC *dbc;
  43. DB_MPOOLFILE *mpf;
  44. PAGE *pagep;
  45. u_int32_t change;
  46. int cmp_n, cmp_p, ret;
  48. pagep = NULL;
  49. COMPQUIET(info, NULL);
  50. REC_PRINT(__db_addrem_print);
  51. REC_INTRO(__db_addrem_read, 1);
  53. if ((ret = mpf->get(mpf, &argp->pgno, 0, &pagep)) != 0) {
  54. if (DB_UNDO(op)) {
  55. /*
  56.  * We are undoing and the page doesn't exist.  That
  57.  * is equivalent to having a pagelsn of 0, so we
  58.  * would not have to undo anything.  In this case,
  59.  * don't bother creating a page.
  60.  */
  61. goto done;
  62. } else
  63. if ((ret = mpf->get(mpf,
  64.     &argp->pgno, DB_MPOOL_CREATE, &pagep)) != 0)
  65. goto out;
  66. }
  68. cmp_n = log_compare(lsnp, &LSN(pagep));
  69. cmp_p = log_compare(&LSN(pagep), &argp->pagelsn);
  70. CHECK_LSN(op, cmp_p, &LSN(pagep), &argp->pagelsn);
  71. change = 0;
  72. if ((cmp_p == 0 && DB_REDO(op) && argp->opcode == DB_ADD_DUP) ||
  73.     (cmp_n == 0 && DB_UNDO(op) && argp->opcode == DB_REM_DUP)) {
  75. /* Need to redo an add, or undo a delete. */
  76. if ((ret = __db_pitem(dbc, pagep, argp->indx, argp->nbytes,
  77.     argp->hdr.size == 0 ? NULL : &argp->hdr,
  78.     argp->dbt.size == 0 ? NULL : &argp->dbt)) != 0)
  79. goto out;
  81. change = DB_MPOOL_DIRTY;
  83. } else if ((cmp_n == 0 && DB_UNDO(op) && argp->opcode == DB_ADD_DUP) ||
  84.     (cmp_p == 0 && DB_REDO(op) && argp->opcode == DB_REM_DUP)) {
  85. /* Need to undo an add, or redo a delete. */
  86. if ((ret = __db_ditem(dbc,
  87.     pagep, argp->indx, argp->nbytes)) != 0)
  88. goto out;
  89. change = DB_MPOOL_DIRTY;
  90. }
  92. if (change) {
  93. if (DB_REDO(op))
  94. LSN(pagep) = *lsnp;
  95. else
  96. LSN(pagep) = argp->pagelsn;
  97. }
  99. if ((ret = mpf->put(mpf, pagep, change)) != 0)
  100. goto out;
  101. pagep = NULL;
  103. done: *lsnp = argp->prev_lsn;
  104. ret = 0;
  106. out: if (pagep != NULL)
  107. (void)mpf->put(mpf, pagep, 0);
  108. REC_CLOSE;
  109. }
  111. /*
  112.  * PUBLIC: int __db_big_recover
  113.  * PUBLIC:     __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  114.  */
  115. int
  116. __db_big_recover(dbenv, dbtp, lsnp, op, info)
  117. DB_ENV *dbenv;
  118. DBT *dbtp;
  119. DB_LSN *lsnp;
  120. db_recops op;
  121. void *info;
  122. {
  123. __db_big_args *argp;
  124. DB *file_dbp;
  125. DBC *dbc;
  126. DB_MPOOLFILE *mpf;
  127. PAGE *pagep;
  128. u_int32_t change;
  129. int cmp_n, cmp_p, ret;
  131. pagep = NULL;
  132. COMPQUIET(info, NULL);
  133. REC_PRINT(__db_big_print);
  134. REC_INTRO(__db_big_read, 1);
  136. if ((ret = mpf->get(mpf, &argp->pgno, 0, &pagep)) != 0) {
  137. if (DB_UNDO(op)) {
  138. /*
  139.  * We are undoing and the page doesn't exist.  That
  140.  * is equivalent to having a pagelsn of 0, so we
  141.  * would not have to undo anything.  In this case,
  142.  * don't bother creating a page.
  143.  */
  144. ret = 0;
  145. goto ppage;
  146. } else
  147. if ((ret = mpf->get(mpf,
  148.     &argp->pgno, DB_MPOOL_CREATE, &pagep)) != 0)
  149. goto out;
  150. }
  152. /*
  153.  * There are three pages we need to check.  The one on which we are
  154.  * adding data, the previous one whose next_pointer may have
  155.  * been updated, and the next one whose prev_pointer may have
  156.  * been updated.
  157.  */
  158. cmp_n = log_compare(lsnp, &LSN(pagep));
  159. cmp_p = log_compare(&LSN(pagep), &argp->pagelsn);
  160. CHECK_LSN(op, cmp_p, &LSN(pagep), &argp->pagelsn);
  161. change = 0;
  162. if ((cmp_p == 0 && DB_REDO(op) && argp->opcode == DB_ADD_BIG) ||
  163.     (cmp_n == 0 && DB_UNDO(op) && argp->opcode == DB_REM_BIG)) {
  164. /* We are either redo-ing an add, or undoing a delete. */
  165. P_INIT(pagep, file_dbp->pgsize, argp->pgno, argp->prev_pgno,
  166. argp->next_pgno, 0, P_OVERFLOW);
  167. OV_LEN(pagep) = argp->dbt.size;
  168. OV_REF(pagep) = 1;
  169. memcpy((u_int8_t *)pagep + P_OVERHEAD(file_dbp), argp->dbt.data,
  170.     argp->dbt.size);
  171. PREV_PGNO(pagep) = argp->prev_pgno;
  172. change = DB_MPOOL_DIRTY;
  173. } else if ((cmp_n == 0 && DB_UNDO(op) && argp->opcode == DB_ADD_BIG) ||
  174.     (cmp_p == 0 && DB_REDO(op) && argp->opcode == DB_REM_BIG)) {
  175. /*
  176.  * We are either undo-ing an add or redo-ing a delete.
  177.  * The page is about to be reclaimed in either case, so
  178.  * there really isn't anything to do here.
  179.  */
  180. change = DB_MPOOL_DIRTY;
  181. }
  182. if (change)
  183. LSN(pagep) = DB_REDO(op) ? *lsnp : argp->pagelsn;
  185. if ((ret = mpf->put(mpf, pagep, change)) != 0)
  186. goto out;
  187. pagep = NULL;
  189. /*
  190.  * We only delete a whole chain of overflow.
  191.  * Each page is handled individually
  192.  */
  193. if (argp->opcode == DB_REM_BIG)
  194. goto done;
  196. /* Now check the previous page. */
  197. ppage: if (argp->prev_pgno != PGNO_INVALID) {
  198. change = 0;
  199. if ((ret = mpf->get(mpf, &argp->prev_pgno, 0, &pagep)) != 0) {
  200. if (DB_UNDO(op)) {
  201. /*
  202.  * We are undoing and the page doesn't exist.
  203.  * That is equivalent to having a pagelsn of 0,
  204.  * so we would not have to undo anything.  In
  205.  * this case, don't bother creating a page.
  206.  */
  207. *lsnp = argp->prev_lsn;
  208. ret = 0;
  209. goto npage;
  210. } else
  211. if ((ret = mpf->get(mpf, &argp->prev_pgno,
  212.     DB_MPOOL_CREATE, &pagep)) != 0)
  213. goto out;
  214. }
  216. cmp_n = log_compare(lsnp, &LSN(pagep));
  217. cmp_p = log_compare(&LSN(pagep), &argp->prevlsn);
  218. CHECK_LSN(op, cmp_p, &LSN(pagep), &argp->prevlsn);
  220. if (cmp_p == 0 && DB_REDO(op) && argp->opcode == DB_ADD_BIG) {
  221. /* Redo add, undo delete. */
  222. NEXT_PGNO(pagep) = argp->pgno;
  223. change = DB_MPOOL_DIRTY;
  224. } else if (cmp_n == 0 &&
  225.     DB_UNDO(op) && argp->opcode == DB_ADD_BIG) {
  226. /* Redo delete, undo add. */
  227. NEXT_PGNO(pagep) = argp->next_pgno;
  228. change = DB_MPOOL_DIRTY;
  229. }
  230. if (change)
  231. LSN(pagep) = DB_REDO(op) ? *lsnp : argp->prevlsn;
  232. if ((ret = mpf->put(mpf, pagep, change)) != 0)
  233. goto out;
  234. }
  235. pagep = NULL;
  237. /* Now check the next page.  Can only be set on a delete. */
  238. npage: if (argp->next_pgno != PGNO_INVALID) {
  239. change = 0;
  240. if ((ret = mpf->get(mpf, &argp->next_pgno, 0, &pagep)) != 0) {
  241. if (DB_UNDO(op)) {
  242. /*
  243.  * We are undoing and the page doesn't exist.
  244.  * That is equivalent to having a pagelsn of 0,
  245.  * so we would not have to undo anything.  In
  246.  * this case, don't bother creating a page.
  247.  */
  248. goto done;
  249. } else
  250. if ((ret = mpf->get(mpf, &argp->next_pgno,
  251.     DB_MPOOL_CREATE, &pagep)) != 0)
  252. goto out;
  253. }
  255. cmp_n = log_compare(lsnp, &LSN(pagep));
  256. cmp_p = log_compare(&LSN(pagep), &argp->nextlsn);
  257. CHECK_LSN(op, cmp_p, &LSN(pagep), &argp->nextlsn);
  258. if (cmp_p == 0 && DB_REDO(op)) {
  259. PREV_PGNO(pagep) = PGNO_INVALID;
  260. change = DB_MPOOL_DIRTY;
  261. } else if (cmp_n == 0 && DB_UNDO(op)) {
  262. PREV_PGNO(pagep) = argp->pgno;
  263. change = DB_MPOOL_DIRTY;
  264. }
  265. if (change)
  266. LSN(pagep) = DB_REDO(op) ? *lsnp : argp->nextlsn;
  267. if ((ret = mpf->put(mpf, pagep, change)) != 0)
  268. goto out;
  269. }
  270. pagep = NULL;
  272. done: *lsnp = argp->prev_lsn;
  273. ret = 0;
  275. out: if (pagep != NULL)
  276. (void)mpf->put(mpf, pagep, 0);
  277. REC_CLOSE;
  278. }
  280. /*
  281.  * __db_ovref_recover --
  282.  * Recovery function for __db_ovref().
  283.  *
  284.  * PUBLIC: int __db_ovref_recover
  285.  * PUBLIC:     __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  286.  */
  287. int
  288. __db_ovref_recover(dbenv, dbtp, lsnp, op, info)
  289. DB_ENV *dbenv;
  290. DBT *dbtp;
  291. DB_LSN *lsnp;
  292. db_recops op;
  293. void *info;
  294. {
  295. __db_ovref_args *argp;
  296. DB *file_dbp;
  297. DBC *dbc;
  298. DB_MPOOLFILE *mpf;
  299. PAGE *pagep;
  300. int cmp, modified, ret;
  302. pagep = NULL;
  303. COMPQUIET(info, NULL);
  304. REC_PRINT(__db_ovref_print);
  305. REC_INTRO(__db_ovref_read, 1);
  307. if ((ret = mpf->get(mpf, &argp->pgno, 0, &pagep)) != 0) {
  308. if (DB_UNDO(op))
  309. goto done;
  310. __db_pgerr(file_dbp, argp->pgno, ret);
  311. goto out;
  312. }
  314. modified = 0;
  315. cmp = log_compare(&LSN(pagep), &argp->lsn);
  316. CHECK_LSN(op, cmp, &LSN(pagep), &argp->lsn);
  317. if (cmp == 0 && DB_REDO(op)) {
  318. /* Need to redo update described. */
  319. OV_REF(pagep) += argp->adjust;
  321. pagep->lsn = *lsnp;
  322. modified = 1;
  323. } else if (log_compare(lsnp, &LSN(pagep)) == 0 && DB_UNDO(op)) {
  324. /* Need to undo update described. */
  325. OV_REF(pagep) -= argp->adjust;
  327. pagep->lsn = argp->lsn;
  328. modified = 1;
  329. }
  330. if ((ret = mpf->put(mpf, pagep, modified ? DB_MPOOL_DIRTY : 0)) != 0)
  331. goto out;
  332. pagep = NULL;
  334. done: *lsnp = argp->prev_lsn;
  335. ret = 0;
  337. out: if (pagep != NULL)
  338. (void)mpf->put(mpf, pagep, 0);
  339. REC_CLOSE;
  340. }
  342. /*
  343.  * __db_relink_recover --
  344.  * Recovery function for relink.
  345.  *
  346.  * PUBLIC: int __db_relink_recover
  347.  * PUBLIC:   __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  348.  */
  349. int
  350. __db_relink_recover(dbenv, dbtp, lsnp, op, info)
  351. DB_ENV *dbenv;
  352. DBT *dbtp;
  353. DB_LSN *lsnp;
  354. db_recops op;
  355. void *info;
  356. {
  357. __db_relink_args *argp;
  358. DB *file_dbp;
  359. DBC *dbc;
  360. DB_MPOOLFILE *mpf;
  361. PAGE *pagep;
  362. int cmp_n, cmp_p, modified, ret;
  364. pagep = NULL;
  365. COMPQUIET(info, NULL);
  366. REC_PRINT(__db_relink_print);
  367. REC_INTRO(__db_relink_read, 1);
  369. /*
  370.  * There are up to three pages we need to check -- the page, and the
  371.  * previous and next pages, if they existed.  For a page add operation,
  372.  * the current page is the result of a split and is being recovered
  373.  * elsewhere, so all we need do is recover the next page.
  374.  */
  375. if ((ret = mpf->get(mpf, &argp->pgno, 0, &pagep)) != 0) {
  376. if (DB_REDO(op)) {
  377. __db_pgerr(file_dbp, argp->pgno, ret);
  378. goto out;
  379. }
  380. goto next2;
  381. }
  382. modified = 0;
  383. if (argp->opcode == DB_ADD_PAGE)
  384. goto next1;
  386. cmp_p = log_compare(&LSN(pagep), &argp->lsn);
  387. CHECK_LSN(op, cmp_p, &LSN(pagep), &argp->lsn);
  388. if (cmp_p == 0 && DB_REDO(op)) {
  389. /* Redo the relink. */
  390. pagep->lsn = *lsnp;
  391. modified = 1;
  392. } else if (log_compare(lsnp, &LSN(pagep)) == 0 && DB_UNDO(op)) {
  393. /* Undo the relink. */
  394. pagep->next_pgno = argp->next;
  395. pagep->prev_pgno = argp->prev;
  397. pagep->lsn = argp->lsn;
  398. modified = 1;
  399. }
  400. next1: if ((ret = mpf->put(mpf, pagep, modified ? DB_MPOOL_DIRTY : 0)) != 0)
  401. goto out;
  402. pagep = NULL;
  404. next2: if ((ret = mpf->get(mpf, &argp->next, 0, &pagep)) != 0) {
  405. if (DB_REDO(op)) {
  406. __db_pgerr(file_dbp, argp->next, ret);
  407. goto out;
  408. }
  409. goto prev;
  410. }
  411. modified = 0;
  412. cmp_n = log_compare(lsnp, &LSN(pagep));
  413. cmp_p = log_compare(&LSN(pagep), &argp->lsn_next);
  414. CHECK_LSN(op, cmp_p, &LSN(pagep), &argp->lsn_next);
  415. if ((argp->opcode == DB_REM_PAGE && cmp_p == 0 && DB_REDO(op)) ||
  416.     (argp->opcode == DB_ADD_PAGE && cmp_n == 0 && DB_UNDO(op))) {
  417. /* Redo the remove or undo the add. */
  418. pagep->prev_pgno = argp->prev;
  420. modified = 1;
  421. } else if ((argp->opcode == DB_REM_PAGE && cmp_n == 0 && DB_UNDO(op)) ||
  422.     (argp->opcode == DB_ADD_PAGE && cmp_p == 0 && DB_REDO(op))) {
  423. /* Undo the remove or redo the add. */
  424. pagep->prev_pgno = argp->pgno;
  426. modified = 1;
  427. }
  428. if (modified == 1) {
  429. if (DB_UNDO(op))
  430. pagep->lsn = argp->lsn_next;
  431. else
  432. pagep->lsn = *lsnp;
  433. }
  434. if ((ret = mpf->put(mpf, pagep, modified ? DB_MPOOL_DIRTY : 0)) != 0)
  435. goto out;
  436. pagep = NULL;
  437. if (argp->opcode == DB_ADD_PAGE)
  438. goto done;
  440. prev: if ((ret = mpf->get(mpf, &argp->prev, 0, &pagep)) != 0) {
  441. if (DB_REDO(op)) {
  442. __db_pgerr(file_dbp, argp->prev, ret);
  443. goto out;
  444. }
  445. goto done;
  446. }
  447. modified = 0;
  448. cmp_p = log_compare(&LSN(pagep), &argp->lsn_prev);
  449. CHECK_LSN(op, cmp_p, &LSN(pagep), &argp->lsn_prev);
  450. if (cmp_p == 0 && DB_REDO(op)) {
  451. /* Redo the relink. */
  452. pagep->next_pgno = argp->next;
  454. modified = 1;
  455. } else if (log_compare(lsnp, &LSN(pagep)) == 0 && DB_UNDO(op)) {
  456. /* Undo the relink. */
  457. pagep->next_pgno = argp->pgno;
  459. modified = 1;
  460. }
  461. if (modified == 1) {
  462. if (DB_UNDO(op))
  463. pagep->lsn = argp->lsn_prev;
  464. else
  465. pagep->lsn = *lsnp;
  466. }
  467. if ((ret = mpf->put(mpf, pagep, modified ? DB_MPOOL_DIRTY : 0)) != 0)
  468. goto out;
  469. pagep = NULL;
  471. done: *lsnp = argp->prev_lsn;
  472. ret = 0;
  474. out: if (pagep != NULL)
  475. (void)mpf->put(mpf, pagep, 0);
  476. REC_CLOSE;
  477. }
  479. /*
  480.  * __db_debug_recover --
  481.  * Recovery function for debug.
  482.  *
  483.  * PUBLIC: int __db_debug_recover __P((DB_ENV *,
  484.  * PUBLIC:     DBT *, DB_LSN *, db_recops, void *));
  485.  */
  486. int
  487. __db_debug_recover(dbenv, dbtp, lsnp, op, info)
  488. DB_ENV *dbenv;
  489. DBT *dbtp;
  490. DB_LSN *lsnp;
  491. db_recops op;
  492. void *info;
  493. {
  494. __db_debug_args *argp;
  495. int ret;
  497. COMPQUIET(dbenv, NULL);
  498. COMPQUIET(op, DB_TXN_ABORT);
  499. COMPQUIET(info, NULL);
  501. REC_PRINT(__db_debug_print);
  502. REC_NOOP_INTRO(__db_debug_read);
  504. *lsnp = argp->prev_lsn;
  505. ret = 0;
  507. REC_NOOP_CLOSE;
  508. }
  510. /*
  511.  * __db_noop_recover --
  512.  * Recovery function for noop.
  513.  *
  514.  * PUBLIC: int __db_noop_recover __P((DB_ENV *,
  515.  * PUBLIC:      DBT *, DB_LSN *, db_recops, void *));
  516.  */
  517. int
  518. __db_noop_recover(dbenv, dbtp, lsnp, op, info)
  519. DB_ENV *dbenv;
  520. DBT *dbtp;
  521. DB_LSN *lsnp;
  522. db_recops op;
  523. void *info;
  524. {
  525. __db_noop_args *argp;
  526. DB *file_dbp;
  527. DBC *dbc;
  528. DB_MPOOLFILE *mpf;
  529. PAGE *pagep;
  530. u_int32_t change;
  531. int cmp_n, cmp_p, ret;
  533. pagep = NULL;
  534. COMPQUIET(info, NULL);
  535. REC_PRINT(__db_noop_print);
  536. REC_INTRO(__db_noop_read, 0);
  538. if ((ret = mpf->get(mpf, &argp->pgno, 0, &pagep)) != 0)
  539. goto out;
  541. cmp_n = log_compare(lsnp, &LSN(pagep));
  542. cmp_p = log_compare(&LSN(pagep), &argp->prevlsn);
  543. CHECK_LSN(op, cmp_p, &LSN(pagep), &argp->prevlsn);
  544. change = 0;
  545. if (cmp_p == 0 && DB_REDO(op)) {
  546. LSN(pagep) = *lsnp;
  547. change = DB_MPOOL_DIRTY;
  548. } else if (cmp_n == 0 && DB_UNDO(op)) {
  549. LSN(pagep) = argp->prevlsn;
  550. change = DB_MPOOL_DIRTY;
  551. }
  552. ret = mpf->put(mpf, pagep, change);
  553. pagep = NULL;
  555. done: *lsnp = argp->prev_lsn;
  556. out: if (pagep != NULL)
  557. (void)mpf->put(mpf, pagep, 0);
  558. REC_CLOSE;
  559. }
  561. /*
  562.  * __db_pg_alloc_recover --
  563.  * Recovery function for pg_alloc.
  564.  *
  565.  * PUBLIC: int __db_pg_alloc_recover
  566.  * PUBLIC:   __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  567.  */
  568. int
  569. __db_pg_alloc_recover(dbenv, dbtp, lsnp, op, info)
  570. DB_ENV *dbenv;
  571. DBT *dbtp;
  572. DB_LSN *lsnp;
  573. db_recops op;
  574. void *info;
  575. {
  576. __db_pg_alloc_args *argp;
  577. DB *file_dbp;
  578. DBC *dbc;
  579. DBMETA *meta;
  580. DB_MPOOLFILE *mpf;
  581. PAGE *pagep;
  582. db_pgno_t pgno;
  583. int cmp_n, cmp_p, created, level, modified, ret;
  585. meta = NULL;
  586. pagep = NULL;
  587. REC_PRINT(__db_pg_alloc_print);
  588. REC_INTRO(__db_pg_alloc_read, 0);
  590. /*
  591.  * Fix up the allocated page.  If we're redoing the operation, we have
  592.  * to get the page (creating it if it doesn't exist), and update its
  593.  * LSN.  If we're undoing the operation, we have to reset the page's
  594.  * LSN and put it on the free list.
  595.  *
  596.  * Fix up the metadata page.  If we're redoing the operation, we have
  597.  * to get the metadata page and update its LSN and its free pointer.
  598.  * If we're undoing the operation and the page was ever created, we put
  599.  * it on the freelist.
  600.  */
  601. pgno = PGNO_BASE_MD;
  602. if ((ret = mpf->get(mpf, &pgno, 0, &meta)) != 0) {
  603. /* The metadata page must always exist on redo. */
  604. if (DB_REDO(op)) {
  605. __db_pgerr(file_dbp, pgno, ret);
  606. goto out;
  607. } else
  608. goto done;
  609. }
  610. created = modified = 0;
  611. if ((ret = mpf->get(mpf, &argp->pgno, 0, &pagep)) != 0) {
  612. /*
  613.  * We have to be able to identify if a page was newly
  614.  * created so we can recover it properly.  We cannot simply
  615.  * look for an empty header, because hash uses a pgin
  616.  * function that will set the header.  Instead, we explicitly
  617.  * try for the page without CREATE and if that fails, then
  618.  * create it.
  619.  */
  620. if ((ret =
  621.     mpf->get(mpf, &argp->pgno, DB_MPOOL_CREATE, &pagep)) != 0) {
  622. __db_pgerr(file_dbp, argp->pgno, ret);
  623. goto out;
  624. }
  625. created = modified = 1;
  626. }
  628. /* Fix up the allocated page. */
  629. cmp_n = log_compare(lsnp, &LSN(pagep));
  630. cmp_p = log_compare(&LSN(pagep), &argp->page_lsn);
  632. /*
  633.  * If an inital allocation is aborted and then reallocated
  634.  * during an archival restore the log record will have
  635.  * an LSN for the page but the page will be empty.
  636.  */
  637. if (IS_ZERO_LSN(LSN(pagep)))
  638. cmp_p = 0;
  639. CHECK_LSN(op, cmp_p, &LSN(pagep), &argp->page_lsn);
  640. /*
  641.  * If we we rolled back this allocation previously during an
  642.  * archive restore, the page may have the LSN of the meta page
  643.  * at the point of the roll back.  This will be no more
  644.  * than the LSN of the metadata page at the time of this allocation.
  645.  * Another special case we have to handle is if we ended up with a
  646.  * page of all 0's which can happen if we abort between allocating a
  647.  * page in mpool and initializing it.  In that case, even if we're
  648.  * undoing, we need to re-initialize the page.
  649.  */
  650. if (DB_REDO(op) &&
  651.     (cmp_p == 0 ||
  652.     (IS_ZERO_LSN(argp->page_lsn) &&
  653.     log_compare(&LSN(pagep), &argp->meta_lsn) <= 0))) {
  654. /* Need to redo update described. */
  655. switch (argp->ptype) {
  656. case P_LBTREE:
  657. case P_LRECNO:
  658. case P_LDUP:
  659. level = LEAFLEVEL;
  660. break;
  661. default:
  662. level = 0;
  663. break;
  664. }
  665. P_INIT(pagep, file_dbp->pgsize,
  666.     argp->pgno, PGNO_INVALID, PGNO_INVALID, level, argp->ptype);
  668. pagep->lsn = *lsnp;
  669. modified = 1;
  670. } else if (DB_UNDO(op) && (cmp_n == 0 || created)) {
  671. /*
  672.  * This is where we handle the case of a 0'd page (pagep->pgno
  673.  * is equal to PGNO_INVALID).
  674.  * Undo the allocation, reinitialize the page and
  675.  * link its next pointer to the free list.
  676.  */
  677. P_INIT(pagep, file_dbp->pgsize,
  678.     argp->pgno, PGNO_INVALID, argp->next, 0, P_INVALID);
  680. pagep->lsn = argp->page_lsn;
  681. modified = 1;
  682. }
  684. /*
  685.  * If the page was newly created, put it on the limbo list.
  686.  */
  687. if (IS_ZERO_LSN(LSN(pagep)) &&
  688.     IS_ZERO_LSN(argp->page_lsn) && DB_UNDO(op)) {
  689. /* Put the page in limbo.*/
  690. if ((ret = __db_add_limbo(dbenv,
  691.     info, argp->fileid, argp->pgno, 1)) != 0)
  692. goto out;
  693. }
  695. if ((ret = mpf->put(mpf, pagep, modified ? DB_MPOOL_DIRTY : 0)) != 0)
  696. goto out;
  697. pagep = NULL;
  699. /* Fix up the metadata page. */
  700. modified = 0;
  701. cmp_n = log_compare(lsnp, &LSN(meta));
  702. cmp_p = log_compare(&LSN(meta), &argp->meta_lsn);
  703. CHECK_LSN(op, cmp_p, &LSN(meta), &argp->meta_lsn);
  704. if (cmp_p == 0 && DB_REDO(op)) {
  705. /* Need to redo update described. */
  706. LSN(meta) = *lsnp;
  707. meta->free = argp->next;
  708. modified = 1;
  709. } else if (cmp_n == 0 && DB_UNDO(op)) {
  710. /* Need to undo update described. */
  711. LSN(meta) = argp->meta_lsn;
  713. /*
  714.  * If the page has a zero LSN then its newly created
  715.  * and will go into limbo rather than directly on the
  716.  * free list.
  717.  */
  718. if (!IS_ZERO_LSN(argp->page_lsn))
  719. meta->free = argp->pgno;
  720. modified = 1;
  721. }
  722. if ((ret = mpf->put(mpf, meta, modified ? DB_MPOOL_DIRTY : 0)) != 0)
  723. goto out;
  724. meta = NULL;
  725. /*
  726.  * This could be the metapage from a subdb which is read from disk
  727.  * to recover its creation.
  728.  */
  729. if (F_ISSET(file_dbp, DB_AM_SUBDB))
  730. switch (argp->type) {
  731. case P_BTREEMETA:
  732. case P_HASHMETA:
  733. case P_QAMMETA:
  734. file_dbp->sync(file_dbp, 0);
  735. break;
  736. }
  738. done: *lsnp = argp->prev_lsn;
  739. ret = 0;
  741. out: if (pagep != NULL)
  742. (void)mpf->put(mpf, pagep, 0);
  743. if (meta != NULL)
  744. (void)mpf->put(mpf, meta, 0);
  745. if (ret == ENOENT && op == DB_TXN_BACKWARD_ALLOC)
  746. ret = 0;
  747. REC_CLOSE;
  748. }
  750. /*
  751.  * __db_pg_free_recover --
  752.  * Recovery function for pg_free.
  753.  *
  754.  * PUBLIC: int __db_pg_free_recover
  755.  * PUBLIC:   __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  756.  */
  757. int
  758. __db_pg_free_recover(dbenv, dbtp, lsnp, op, info)
  759. DB_ENV *dbenv;
  760. DBT *dbtp;
  761. DB_LSN *lsnp;
  762. db_recops op;
  763. void *info;
  764. {
  765. __db_pg_free_args *argp;
  766. DB *file_dbp;
  767. DBC *dbc;
  768. DBMETA *meta;
  769. DB_LSN copy_lsn;
  770. DB_MPOOLFILE *mpf;
  771. PAGE *pagep;
  772. db_pgno_t pgno;
  773. int cmp_n, cmp_p, modified, ret;
  775. COMPQUIET(info, NULL);
  776. meta = NULL;
  777. pagep = NULL;
  778. REC_PRINT(__db_pg_free_print);
  779. REC_INTRO(__db_pg_free_read, 1);
  781. /*
  782.  * Fix up the freed page.  If we're redoing the operation we get the
  783.  * page and explicitly discard its contents, then update its LSN.  If
  784.  * we're undoing the operation, we get the page and restore its header.
  785.  * Create the page if necessary, we may be freeing an aborted
  786.  * create.
  787.  */
  788. if ((ret = mpf->get(mpf, &argp->pgno, DB_MPOOL_CREATE, &pagep)) != 0)
  789. goto out;
  790. modified = 0;
  791. (void)__ua_memcpy(&copy_lsn, &LSN(argp->header.data), sizeof(DB_LSN));
  792. cmp_n = log_compare(lsnp, &LSN(pagep));
  793. cmp_p = log_compare(&LSN(pagep), &copy_lsn);
  794. CHECK_LSN(op, cmp_p, &LSN(pagep), &copy_lsn);
  795. if (DB_REDO(op) &&
  796.     (cmp_p == 0 ||
  797.     (IS_ZERO_LSN(copy_lsn) &&
  798.     log_compare(&LSN(pagep), &argp->meta_lsn) <= 0))) {
  799. /* Need to redo update described. */
  800. P_INIT(pagep, file_dbp->pgsize,
  801.     argp->pgno, PGNO_INVALID, argp->next, 0, P_INVALID);
  802. pagep->lsn = *lsnp;
  804. modified = 1;
  805. } else if (cmp_n == 0 && DB_UNDO(op)) {
  806. /* Need to undo update described. */
  807. memcpy(pagep, argp->header.data, argp->header.size);
  809. modified = 1;
  810. }
  811. if ((ret = mpf->put(mpf, pagep, modified ? DB_MPOOL_DIRTY : 0)) != 0)
  812. goto out;
  813. pagep = NULL;
  815. /*
  816.  * Fix up the metadata page.  If we're redoing or undoing the operation
  817.  * we get the page and update its LSN and free pointer.
  818.  */
  819. pgno = PGNO_BASE_MD;
  820. if ((ret = mpf->get(mpf, &pgno, 0, &meta)) != 0) {
  821. /* The metadata page must always exist. */
  822. __db_pgerr(file_dbp, pgno, ret);
  823. goto out;
  824. }
  826. modified = 0;
  827. cmp_n = log_compare(lsnp, &LSN(meta));
  828. cmp_p = log_compare(&LSN(meta), &argp->meta_lsn);
  829. CHECK_LSN(op, cmp_p, &LSN(meta), &argp->meta_lsn);
  830. if (cmp_p == 0 && DB_REDO(op)) {
  831. /* Need to redo the deallocation. */
  832. meta->free = argp->pgno;
  833. LSN(meta) = *lsnp;
  834. modified = 1;
  835. } else if (cmp_n == 0 && DB_UNDO(op)) {
  836. /* Need to undo the deallocation. */
  837. meta->free = argp->next;
  838. LSN(meta) = argp->meta_lsn;
  839. modified = 1;
  840. }
  841. if ((ret = mpf->put(mpf, meta, modified ? DB_MPOOL_DIRTY : 0)) != 0)
  842. goto out;
  843. meta = NULL;
  845. done: *lsnp = argp->prev_lsn;
  846. ret = 0;
  848. out: if (pagep != NULL)
  849. (void)mpf->put(mpf, pagep, 0);
  850. if (meta != NULL)
  851. (void)mpf->put(mpf, meta, 0);
  852. REC_CLOSE;
  853. }
  855. /*
  856.  * __db_cksum_recover --
  857.  * Recovery function for checksum failure log record.
  858.  *
  859.  * PUBLIC: int __db_cksum_recover __P((DB_ENV *,
  860.  * PUBLIC:      DBT *, DB_LSN *, db_recops, void *));
  861.  */
  862. int
  863. __db_cksum_recover(dbenv, dbtp, lsnp, op, info)
  864. DB_ENV *dbenv;
  865. DBT *dbtp;
  866. DB_LSN *lsnp;
  867. db_recops op;
  868. void *info;
  869. {
  870. __db_cksum_args *argp;
  872. int ret;
  874. COMPQUIET(info, NULL);
  875. COMPQUIET(lsnp, NULL);
  876. COMPQUIET(op, DB_TXN_ABORT);
  878. REC_PRINT(__db_cksum_print);
  880. if ((ret = __db_cksum_read(dbenv, dbtp->data, &argp)) != 0)
  881. return (ret);
  883. /*
  884.  * We had a checksum failure -- the only option is to run catastrophic
  885.  * recovery.
  886.  */
  887. if (F_ISSET(dbenv, DB_ENV_FATAL))
  888. ret = 0;
  889. else {
  890. __db_err(dbenv,
  891.     "Checksum failure requires catastrophic recovery");
  892. ret = __db_panic(dbenv, DB_RUNRECOVERY);
  893. }
  895. __os_free(dbenv, argp);
  896. return (ret);
  897. }