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

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

MySQL数据库

开发平台：

Visual C++

rec_hash：源码内容
  1. #include "db_config.h"
  3. #ifndef NO_SYSTEM_INCLUDES
  4. #include <sys/types.h>
  6. #include <string.h>
  7. #endif
  9. #include "db_int.h"
  10. #include "db_page.h"
  11. #include "ham.h"
  12. #include "log.h"
  14. /*
  15.  * __ham_insdel_recover --
  16.  * Recovery function for insdel.
  17.  *
  18.  * PUBLIC: int __ham_insdel_recover
  19.  * PUBLIC:   __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  20.  */
  21. int
  22. __ham_insdel_recover(dbenv, dbtp, lsnp, op, info)
  23. DB_ENV *dbenv;
  24. DBT *dbtp;
  25. DB_LSN *lsnp;
  26. db_recops op;
  27. void *info;
  28. {
  29. __ham_insdel_args *argp;
  30. DB *file_dbp;
  31. DBC *dbc;
  32. DB_MPOOLFILE *mpf;
  33. PAGE *pagep;
  34. int cmp_n, cmp_p, modified, ret;
  36. REC_PRINT(__ham_insdel_print);
  37. REC_INTRO(__ham_insdel_read);
  39. if ((ret = memp_fget(mpf, &argp->pgno, 0, &pagep)) != 0)
  40. if (DB_REDO(op)) {
  41. if ((ret = memp_fget(mpf,
  42.     &argp->pgno, DB_MPOOL_CREATE, &pagep)) != 0)
  43. goto out;
  44. } else {
  45. *lsnp = argp->prev_lsn;
  46. ret = 0;
  47. goto out;
  48. }
  50. modified = 0;
  51. cmp_n = log_compare(lsnp, &LSN(pagep));
  53. /*
  54.  * Use this when there is something like "pagelsn" in the argp
  55.  * structure.  Sometimes, you might need to compare meta-data
  56.  * lsn's instead.
  57.  *
  58.  * cmp_p = log_compare(&LSN(pagep), argp->pagelsn);
  59.  */
  60. if (cmp_p == 0 && DB_REDO(op)) {
  61. /* Need to redo update described. */
  62. modified = 1;
  63. } else if (cmp_n == 0 && !DB_REDO(op)) {
  64. /* Need to undo update described. */
  65. modified = 1;
  66. }
  67. if (ret = memp_fput(mpf, pagep, modified ? DB_MPOOL_DIRTY : 0))
  68. goto out;
  70. *lsnp = argp->prev_lsn;
  71. ret = 0;
  73. out: REC_CLOSE;
  74. }
  76. /*
  77.  * __ham_newpage_recover --
  78.  * Recovery function for newpage.
  79.  *
  80.  * PUBLIC: int __ham_newpage_recover
  81.  * PUBLIC:   __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  82.  */
  83. int
  84. __ham_newpage_recover(dbenv, dbtp, lsnp, op, info)
  85. DB_ENV *dbenv;
  86. DBT *dbtp;
  87. DB_LSN *lsnp;
  88. db_recops op;
  89. void *info;
  90. {
  91. __ham_newpage_args *argp;
  92. DB *file_dbp;
  93. DBC *dbc;
  94. DB_MPOOLFILE *mpf;
  95. PAGE *pagep;
  96. int cmp_n, cmp_p, modified, ret;
  98. REC_PRINT(__ham_newpage_print);
  99. REC_INTRO(__ham_newpage_read);
  101. if ((ret = memp_fget(mpf, &argp->pgno, 0, &pagep)) != 0)
  102. if (DB_REDO(op)) {
  103. if ((ret = memp_fget(mpf,
  104.     &argp->pgno, DB_MPOOL_CREATE, &pagep)) != 0)
  105. goto out;
  106. } else {
  107. *lsnp = argp->prev_lsn;
  108. ret = 0;
  109. goto out;
  110. }
  112. modified = 0;
  113. cmp_n = log_compare(lsnp, &LSN(pagep));
  115. /*
  116.  * Use this when there is something like "pagelsn" in the argp
  117.  * structure.  Sometimes, you might need to compare meta-data
  118.  * lsn's instead.
  119.  *
  120.  * cmp_p = log_compare(&LSN(pagep), argp->pagelsn);
  121.  */
  122. if (cmp_p == 0 && DB_REDO(op)) {
  123. /* Need to redo update described. */
  124. modified = 1;
  125. } else if (cmp_n == 0 && !DB_REDO(op)) {
  126. /* Need to undo update described. */
  127. modified = 1;
  128. }
  129. if (ret = memp_fput(mpf, pagep, modified ? DB_MPOOL_DIRTY : 0))
  130. goto out;
  132. *lsnp = argp->prev_lsn;
  133. ret = 0;
  135. out: REC_CLOSE;
  136. }
  138. /*
  139.  * __ham_splitmeta_recover --
  140.  * Recovery function for splitmeta.
  141.  *
  142.  * PUBLIC: int __ham_splitmeta_recover
  143.  * PUBLIC:   __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  144.  */
  145. int
  146. __ham_splitmeta_recover(dbenv, dbtp, lsnp, op, info)
  147. DB_ENV *dbenv;
  148. DBT *dbtp;
  149. DB_LSN *lsnp;
  150. db_recops op;
  151. void *info;
  152. {
  153. __ham_splitmeta_args *argp;
  154. DB *file_dbp;
  155. DBC *dbc;
  156. DB_MPOOLFILE *mpf;
  157. PAGE *pagep;
  158. int cmp_n, cmp_p, modified, ret;
  160. REC_PRINT(__ham_splitmeta_print);
  161. REC_INTRO(__ham_splitmeta_read);
  163. if ((ret = memp_fget(mpf, &argp->pgno, 0, &pagep)) != 0)
  164. if (DB_REDO(op)) {
  165. if ((ret = memp_fget(mpf,
  166.     &argp->pgno, DB_MPOOL_CREATE, &pagep)) != 0)
  167. goto out;
  168. } else {
  169. *lsnp = argp->prev_lsn;
  170. ret = 0;
  171. goto out;
  172. }
  174. modified = 0;
  175. cmp_n = log_compare(lsnp, &LSN(pagep));
  177. /*
  178.  * Use this when there is something like "pagelsn" in the argp
  179.  * structure.  Sometimes, you might need to compare meta-data
  180.  * lsn's instead.
  181.  *
  182.  * cmp_p = log_compare(&LSN(pagep), argp->pagelsn);
  183.  */
  184. if (cmp_p == 0 && DB_REDO(op)) {
  185. /* Need to redo update described. */
  186. modified = 1;
  187. } else if (cmp_n == 0 && !DB_REDO(op)) {
  188. /* Need to undo update described. */
  189. modified = 1;
  190. }
  191. if (ret = memp_fput(mpf, pagep, modified ? DB_MPOOL_DIRTY : 0))
  192. goto out;
  194. *lsnp = argp->prev_lsn;
  195. ret = 0;
  197. out: REC_CLOSE;
  198. }
  200. /*
  201.  * __ham_splitdata_recover --
  202.  * Recovery function for splitdata.
  203.  *
  204.  * PUBLIC: int __ham_splitdata_recover
  205.  * PUBLIC:   __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  206.  */
  207. int
  208. __ham_splitdata_recover(dbenv, dbtp, lsnp, op, info)
  209. DB_ENV *dbenv;
  210. DBT *dbtp;
  211. DB_LSN *lsnp;
  212. db_recops op;
  213. void *info;
  214. {
  215. __ham_splitdata_args *argp;
  216. DB *file_dbp;
  217. DBC *dbc;
  218. DB_MPOOLFILE *mpf;
  219. PAGE *pagep;
  220. int cmp_n, cmp_p, modified, ret;
  222. REC_PRINT(__ham_splitdata_print);
  223. REC_INTRO(__ham_splitdata_read);
  225. if ((ret = memp_fget(mpf, &argp->pgno, 0, &pagep)) != 0)
  226. if (DB_REDO(op)) {
  227. if ((ret = memp_fget(mpf,
  228.     &argp->pgno, DB_MPOOL_CREATE, &pagep)) != 0)
  229. goto out;
  230. } else {
  231. *lsnp = argp->prev_lsn;
  232. ret = 0;
  233. goto out;
  234. }
  236. modified = 0;
  237. cmp_n = log_compare(lsnp, &LSN(pagep));
  239. /*
  240.  * Use this when there is something like "pagelsn" in the argp
  241.  * structure.  Sometimes, you might need to compare meta-data
  242.  * lsn's instead.
  243.  *
  244.  * cmp_p = log_compare(&LSN(pagep), argp->pagelsn);
  245.  */
  246. if (cmp_p == 0 && DB_REDO(op)) {
  247. /* Need to redo update described. */
  248. modified = 1;
  249. } else if (cmp_n == 0 && !DB_REDO(op)) {
  250. /* Need to undo update described. */
  251. modified = 1;
  252. }
  253. if (ret = memp_fput(mpf, pagep, modified ? DB_MPOOL_DIRTY : 0))
  254. goto out;
  256. *lsnp = argp->prev_lsn;
  257. ret = 0;
  259. out: REC_CLOSE;
  260. }
  262. /*
  263.  * __ham_replace_recover --
  264.  * Recovery function for replace.
  265.  *
  266.  * PUBLIC: int __ham_replace_recover
  267.  * PUBLIC:   __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  268.  */
  269. int
  270. __ham_replace_recover(dbenv, dbtp, lsnp, op, info)
  271. DB_ENV *dbenv;
  272. DBT *dbtp;
  273. DB_LSN *lsnp;
  274. db_recops op;
  275. void *info;
  276. {
  277. __ham_replace_args *argp;
  278. DB *file_dbp;
  279. DBC *dbc;
  280. DB_MPOOLFILE *mpf;
  281. PAGE *pagep;
  282. int cmp_n, cmp_p, modified, ret;
  284. REC_PRINT(__ham_replace_print);
  285. REC_INTRO(__ham_replace_read);
  287. if ((ret = memp_fget(mpf, &argp->pgno, 0, &pagep)) != 0)
  288. if (DB_REDO(op)) {
  289. if ((ret = memp_fget(mpf,
  290.     &argp->pgno, DB_MPOOL_CREATE, &pagep)) != 0)
  291. goto out;
  292. } else {
  293. *lsnp = argp->prev_lsn;
  294. ret = 0;
  295. goto out;
  296. }
  298. modified = 0;
  299. cmp_n = log_compare(lsnp, &LSN(pagep));
  301. /*
  302.  * Use this when there is something like "pagelsn" in the argp
  303.  * structure.  Sometimes, you might need to compare meta-data
  304.  * lsn's instead.
  305.  *
  306.  * cmp_p = log_compare(&LSN(pagep), argp->pagelsn);
  307.  */
  308. if (cmp_p == 0 && DB_REDO(op)) {
  309. /* Need to redo update described. */
  310. modified = 1;
  311. } else if (cmp_n == 0 && !DB_REDO(op)) {
  312. /* Need to undo update described. */
  313. modified = 1;
  314. }
  315. if (ret = memp_fput(mpf, pagep, modified ? DB_MPOOL_DIRTY : 0))
  316. goto out;
  318. *lsnp = argp->prev_lsn;
  319. ret = 0;
  321. out: REC_CLOSE;
  322. }
  324. /*
  325.  * __ham_newpgno_recover --
  326.  * Recovery function for newpgno.
  327.  *
  328.  * PUBLIC: int __ham_newpgno_recover
  329.  * PUBLIC:   __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  330.  */
  331. int
  332. __ham_newpgno_recover(dbenv, dbtp, lsnp, op, info)
  333. DB_ENV *dbenv;
  334. DBT *dbtp;
  335. DB_LSN *lsnp;
  336. db_recops op;
  337. void *info;
  338. {
  339. __ham_newpgno_args *argp;
  340. DB *file_dbp;
  341. DBC *dbc;
  342. DB_MPOOLFILE *mpf;
  343. PAGE *pagep;
  344. int cmp_n, cmp_p, modified, ret;
  346. REC_PRINT(__ham_newpgno_print);
  347. REC_INTRO(__ham_newpgno_read);
  349. if ((ret = memp_fget(mpf, &argp->pgno, 0, &pagep)) != 0)
  350. if (DB_REDO(op)) {
  351. if ((ret = memp_fget(mpf,
  352.     &argp->pgno, DB_MPOOL_CREATE, &pagep)) != 0)
  353. goto out;
  354. } else {
  355. *lsnp = argp->prev_lsn;
  356. ret = 0;
  357. goto out;
  358. }
  360. modified = 0;
  361. cmp_n = log_compare(lsnp, &LSN(pagep));
  363. /*
  364.  * Use this when there is something like "pagelsn" in the argp
  365.  * structure.  Sometimes, you might need to compare meta-data
  366.  * lsn's instead.
  367.  *
  368.  * cmp_p = log_compare(&LSN(pagep), argp->pagelsn);
  369.  */
  370. if (cmp_p == 0 && DB_REDO(op)) {
  371. /* Need to redo update described. */
  372. modified = 1;
  373. } else if (cmp_n == 0 && !DB_REDO(op)) {
  374. /* Need to undo update described. */
  375. modified = 1;
  376. }
  377. if (ret = memp_fput(mpf, pagep, modified ? DB_MPOOL_DIRTY : 0))
  378. goto out;
  380. *lsnp = argp->prev_lsn;
  381. ret = 0;
  383. out: REC_CLOSE;
  384. }
  386. /*
  387.  * __ham_ovfl_recover --
  388.  * Recovery function for ovfl.
  389.  *
  390.  * PUBLIC: int __ham_ovfl_recover
  391.  * PUBLIC:   __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  392.  */
  393. int
  394. __ham_ovfl_recover(dbenv, dbtp, lsnp, op, info)
  395. DB_ENV *dbenv;
  396. DBT *dbtp;
  397. DB_LSN *lsnp;
  398. db_recops op;
  399. void *info;
  400. {
  401. __ham_ovfl_args *argp;
  402. DB *file_dbp;
  403. DBC *dbc;
  404. DB_MPOOLFILE *mpf;
  405. PAGE *pagep;
  406. int cmp_n, cmp_p, modified, ret;
  408. REC_PRINT(__ham_ovfl_print);
  409. REC_INTRO(__ham_ovfl_read);
  411. if ((ret = memp_fget(mpf, &argp->pgno, 0, &pagep)) != 0)
  412. if (DB_REDO(op)) {
  413. if ((ret = memp_fget(mpf,
  414.     &argp->pgno, DB_MPOOL_CREATE, &pagep)) != 0)
  415. goto out;
  416. } else {
  417. *lsnp = argp->prev_lsn;
  418. ret = 0;
  419. goto out;
  420. }
  422. modified = 0;
  423. cmp_n = log_compare(lsnp, &LSN(pagep));
  425. /*
  426.  * Use this when there is something like "pagelsn" in the argp
  427.  * structure.  Sometimes, you might need to compare meta-data
  428.  * lsn's instead.
  429.  *
  430.  * cmp_p = log_compare(&LSN(pagep), argp->pagelsn);
  431.  */
  432. if (cmp_p == 0 && DB_REDO(op)) {
  433. /* Need to redo update described. */
  434. modified = 1;
  435. } else if (cmp_n == 0 && !DB_REDO(op)) {
  436. /* Need to undo update described. */
  437. modified = 1;
  438. }
  439. if (ret = memp_fput(mpf, pagep, modified ? DB_MPOOL_DIRTY : 0))
  440. goto out;
  442. *lsnp = argp->prev_lsn;
  443. ret = 0;
  445. out: REC_CLOSE;
  446. }
  448. /*
  449.  * __ham_copypage_recover --
  450.  * Recovery function for copypage.
  451.  *
  452.  * PUBLIC: int __ham_copypage_recover
  453.  * PUBLIC:   __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  454.  */
  455. int
  456. __ham_copypage_recover(dbenv, dbtp, lsnp, op, info)
  457. DB_ENV *dbenv;
  458. DBT *dbtp;
  459. DB_LSN *lsnp;
  460. db_recops op;
  461. void *info;
  462. {
  463. __ham_copypage_args *argp;
  464. DB *file_dbp;
  465. DBC *dbc;
  466. DB_MPOOLFILE *mpf;
  467. PAGE *pagep;
  468. int cmp_n, cmp_p, modified, ret;
  470. REC_PRINT(__ham_copypage_print);
  471. REC_INTRO(__ham_copypage_read);
  473. if ((ret = memp_fget(mpf, &argp->pgno, 0, &pagep)) != 0)
  474. if (DB_REDO(op)) {
  475. if ((ret = memp_fget(mpf,
  476.     &argp->pgno, DB_MPOOL_CREATE, &pagep)) != 0)
  477. goto out;
  478. } else {
  479. *lsnp = argp->prev_lsn;
  480. ret = 0;
  481. goto out;
  482. }
  484. modified = 0;
  485. cmp_n = log_compare(lsnp, &LSN(pagep));
  487. /*
  488.  * Use this when there is something like "pagelsn" in the argp
  489.  * structure.  Sometimes, you might need to compare meta-data
  490.  * lsn's instead.
  491.  *
  492.  * cmp_p = log_compare(&LSN(pagep), argp->pagelsn);
  493.  */
  494. if (cmp_p == 0 && DB_REDO(op)) {
  495. /* Need to redo update described. */
  496. modified = 1;
  497. } else if (cmp_n == 0 && !DB_REDO(op)) {
  498. /* Need to undo update described. */
  499. modified = 1;
  500. }
  501. if (ret = memp_fput(mpf, pagep, modified ? DB_MPOOL_DIRTY : 0))
  502. goto out;
  504. *lsnp = argp->prev_lsn;
  505. ret = 0;
  507. out: REC_CLOSE;
  508. }
  510. /*
  511.  * __ham_metagroup_recover --
  512.  * Recovery function for metagroup.
  513.  *
  514.  * PUBLIC: int __ham_metagroup_recover
  515.  * PUBLIC:   __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  516.  */
  517. int
  518. __ham_metagroup_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. __ham_metagroup_args *argp;
  526. DB *file_dbp;
  527. DBC *dbc;
  528. DB_MPOOLFILE *mpf;
  529. PAGE *pagep;
  530. int cmp_n, cmp_p, modified, ret;
  532. REC_PRINT(__ham_metagroup_print);
  533. REC_INTRO(__ham_metagroup_read);
  535. if ((ret = memp_fget(mpf, &argp->pgno, 0, &pagep)) != 0)
  536. if (DB_REDO(op)) {
  537. if ((ret = memp_fget(mpf,
  538.     &argp->pgno, DB_MPOOL_CREATE, &pagep)) != 0)
  539. goto out;
  540. } else {
  541. *lsnp = argp->prev_lsn;
  542. ret = 0;
  543. goto out;
  544. }
  546. modified = 0;
  547. cmp_n = log_compare(lsnp, &LSN(pagep));
  549. /*
  550.  * Use this when there is something like "pagelsn" in the argp
  551.  * structure.  Sometimes, you might need to compare meta-data
  552.  * lsn's instead.
  553.  *
  554.  * cmp_p = log_compare(&LSN(pagep), argp->pagelsn);
  555.  */
  556. if (cmp_p == 0 && DB_REDO(op)) {
  557. /* Need to redo update described. */
  558. modified = 1;
  559. } else if (cmp_n == 0 && !DB_REDO(op)) {
  560. /* Need to undo update described. */
  561. modified = 1;
  562. }
  563. if (ret = memp_fput(mpf, pagep, modified ? DB_MPOOL_DIRTY : 0))
  564. goto out;
  566. *lsnp = argp->prev_lsn;
  567. ret = 0;
  569. out: REC_CLOSE;
  570. }
  572. /*
  573.  * __ham_groupalloc1_recover --
  574.  * Recovery function for groupalloc1.
  575.  *
  576.  * PUBLIC: int __ham_groupalloc1_recover
  577.  * PUBLIC:   __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  578.  */
  579. int
  580. __ham_groupalloc1_recover(dbenv, dbtp, lsnp, op, info)
  581. DB_ENV *dbenv;
  582. DBT *dbtp;
  583. DB_LSN *lsnp;
  584. db_recops op;
  585. void *info;
  586. {
  587. __ham_groupalloc1_args *argp;
  588. DB *file_dbp;
  589. DBC *dbc;
  590. DB_MPOOLFILE *mpf;
  591. PAGE *pagep;
  592. int cmp_n, cmp_p, modified, ret;
  594. REC_PRINT(__ham_groupalloc1_print);
  595. REC_INTRO(__ham_groupalloc1_read);
  597. if ((ret = memp_fget(mpf, &argp->pgno, 0, &pagep)) != 0)
  598. if (DB_REDO(op)) {
  599. if ((ret = memp_fget(mpf,
  600.     &argp->pgno, DB_MPOOL_CREATE, &pagep)) != 0)
  601. goto out;
  602. } else {
  603. *lsnp = argp->prev_lsn;
  604. ret = 0;
  605. goto out;
  606. }
  608. modified = 0;
  609. cmp_n = log_compare(lsnp, &LSN(pagep));
  611. /*
  612.  * Use this when there is something like "pagelsn" in the argp
  613.  * structure.  Sometimes, you might need to compare meta-data
  614.  * lsn's instead.
  615.  *
  616.  * cmp_p = log_compare(&LSN(pagep), argp->pagelsn);
  617.  */
  618. if (cmp_p == 0 && DB_REDO(op)) {
  619. /* Need to redo update described. */
  620. modified = 1;
  621. } else if (cmp_n == 0 && !DB_REDO(op)) {
  622. /* Need to undo update described. */
  623. modified = 1;
  624. }
  625. if (ret = memp_fput(mpf, pagep, modified ? DB_MPOOL_DIRTY : 0))
  626. goto out;
  628. *lsnp = argp->prev_lsn;
  629. ret = 0;
  631. out: REC_CLOSE;
  632. }
  634. /*
  635.  * __ham_groupalloc2_recover --
  636.  * Recovery function for groupalloc2.
  637.  *
  638.  * PUBLIC: int __ham_groupalloc2_recover
  639.  * PUBLIC:   __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  640.  */
  641. int
  642. __ham_groupalloc2_recover(dbenv, dbtp, lsnp, op, info)
  643. DB_ENV *dbenv;
  644. DBT *dbtp;
  645. DB_LSN *lsnp;
  646. db_recops op;
  647. void *info;
  648. {
  649. __ham_groupalloc2_args *argp;
  650. DB *file_dbp;
  651. DBC *dbc;
  652. DB_MPOOLFILE *mpf;
  653. PAGE *pagep;
  654. int cmp_n, cmp_p, modified, ret;
  656. REC_PRINT(__ham_groupalloc2_print);
  657. REC_INTRO(__ham_groupalloc2_read);
  659. if ((ret = memp_fget(mpf, &argp->pgno, 0, &pagep)) != 0)
  660. if (DB_REDO(op)) {
  661. if ((ret = memp_fget(mpf,
  662.     &argp->pgno, DB_MPOOL_CREATE, &pagep)) != 0)
  663. goto out;
  664. } else {
  665. *lsnp = argp->prev_lsn;
  666. ret = 0;
  667. goto out;
  668. }
  670. modified = 0;
  671. cmp_n = log_compare(lsnp, &LSN(pagep));
  673. /*
  674.  * Use this when there is something like "pagelsn" in the argp
  675.  * structure.  Sometimes, you might need to compare meta-data
  676.  * lsn's instead.
  677.  *
  678.  * cmp_p = log_compare(&LSN(pagep), argp->pagelsn);
  679.  */
  680. if (cmp_p == 0 && DB_REDO(op)) {
  681. /* Need to redo update described. */
  682. modified = 1;
  683. } else if (cmp_n == 0 && !DB_REDO(op)) {
  684. /* Need to undo update described. */
  685. modified = 1;
  686. }
  687. if (ret = memp_fput(mpf, pagep, modified ? DB_MPOOL_DIRTY : 0))
  688. goto out;
  690. *lsnp = argp->prev_lsn;
  691. ret = 0;
  693. out: REC_CLOSE;
  694. }
  696. /*
  697.  * __ham_groupalloc_recover --
  698.  * Recovery function for groupalloc.
  699.  *
  700.  * PUBLIC: int __ham_groupalloc_recover
  701.  * PUBLIC:   __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  702.  */
  703. int
  704. __ham_groupalloc_recover(dbenv, dbtp, lsnp, op, info)
  705. DB_ENV *dbenv;
  706. DBT *dbtp;
  707. DB_LSN *lsnp;
  708. db_recops op;
  709. void *info;
  710. {
  711. __ham_groupalloc_args *argp;
  712. DB *file_dbp;
  713. DBC *dbc;
  714. DB_MPOOLFILE *mpf;
  715. PAGE *pagep;
  716. int cmp_n, cmp_p, modified, ret;
  718. REC_PRINT(__ham_groupalloc_print);
  719. REC_INTRO(__ham_groupalloc_read);
  721. if ((ret = memp_fget(mpf, &argp->pgno, 0, &pagep)) != 0)
  722. if (DB_REDO(op)) {
  723. if ((ret = memp_fget(mpf,
  724.     &argp->pgno, DB_MPOOL_CREATE, &pagep)) != 0)
  725. goto out;
  726. } else {
  727. *lsnp = argp->prev_lsn;
  728. ret = 0;
  729. goto out;
  730. }
  732. modified = 0;
  733. cmp_n = log_compare(lsnp, &LSN(pagep));
  735. /*
  736.  * Use this when there is something like "pagelsn" in the argp
  737.  * structure.  Sometimes, you might need to compare meta-data
  738.  * lsn's instead.
  739.  *
  740.  * cmp_p = log_compare(&LSN(pagep), argp->pagelsn);
  741.  */
  742. if (cmp_p == 0 && DB_REDO(op)) {
  743. /* Need to redo update described. */
  744. modified = 1;
  745. } else if (cmp_n == 0 && !DB_REDO(op)) {
  746. /* Need to undo update described. */
  747. modified = 1;
  748. }
  749. if (ret = memp_fput(mpf, pagep, modified ? DB_MPOOL_DIRTY : 0))
  750. goto out;
  752. *lsnp = argp->prev_lsn;
  753. ret = 0;
  755. out: REC_CLOSE;
  756. }
  758. /*
  759.  * __ham_curadj_recover --
  760.  * Recovery function for curadj.
  761.  *
  762.  * PUBLIC: int __ham_curadj_recover
  763.  * PUBLIC:   __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  764.  */
  765. int
  766. __ham_curadj_recover(dbenv, dbtp, lsnp, op, info)
  767. DB_ENV *dbenv;
  768. DBT *dbtp;
  769. DB_LSN *lsnp;
  770. db_recops op;
  771. void *info;
  772. {
  773. __ham_curadj_args *argp;
  774. DB *file_dbp;
  775. DBC *dbc;
  776. DB_MPOOLFILE *mpf;
  777. PAGE *pagep;
  778. int cmp_n, cmp_p, modified, ret;
  780. REC_PRINT(__ham_curadj_print);
  781. REC_INTRO(__ham_curadj_read);
  783. if ((ret = memp_fget(mpf, &argp->pgno, 0, &pagep)) != 0)
  784. if (DB_REDO(op)) {
  785. if ((ret = memp_fget(mpf,
  786.     &argp->pgno, DB_MPOOL_CREATE, &pagep)) != 0)
  787. goto out;
  788. } else {
  789. *lsnp = argp->prev_lsn;
  790. ret = 0;
  791. goto out;
  792. }
  794. modified = 0;
  795. cmp_n = log_compare(lsnp, &LSN(pagep));
  797. /*
  798.  * Use this when there is something like "pagelsn" in the argp
  799.  * structure.  Sometimes, you might need to compare meta-data
  800.  * lsn's instead.
  801.  *
  802.  * cmp_p = log_compare(&LSN(pagep), argp->pagelsn);
  803.  */
  804. if (cmp_p == 0 && DB_REDO(op)) {
  805. /* Need to redo update described. */
  806. modified = 1;
  807. } else if (cmp_n == 0 && !DB_REDO(op)) {
  808. /* Need to undo update described. */
  809. modified = 1;
  810. }
  811. if (ret = memp_fput(mpf, pagep, modified ? DB_MPOOL_DIRTY : 0))
  812. goto out;
  814. *lsnp = argp->prev_lsn;
  815. ret = 0;
  817. out: REC_CLOSE;
  818. }
  820. /*
  821.  * __ham_chgpg_recover --
  822.  * Recovery function for chgpg.
  823.  *
  824.  * PUBLIC: int __ham_chgpg_recover
  825.  * PUBLIC:   __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  826.  */
  827. int
  828. __ham_chgpg_recover(dbenv, dbtp, lsnp, op, info)
  829. DB_ENV *dbenv;
  830. DBT *dbtp;
  831. DB_LSN *lsnp;
  832. db_recops op;
  833. void *info;
  834. {
  835. __ham_chgpg_args *argp;
  836. DB *file_dbp;
  837. DBC *dbc;
  838. DB_MPOOLFILE *mpf;
  839. PAGE *pagep;
  840. int cmp_n, cmp_p, modified, ret;
  842. REC_PRINT(__ham_chgpg_print);
  843. REC_INTRO(__ham_chgpg_read);
  845. if ((ret = memp_fget(mpf, &argp->pgno, 0, &pagep)) != 0)
  846. if (DB_REDO(op)) {
  847. if ((ret = memp_fget(mpf,
  848.     &argp->pgno, DB_MPOOL_CREATE, &pagep)) != 0)
  849. goto out;
  850. } else {
  851. *lsnp = argp->prev_lsn;
  852. ret = 0;
  853. goto out;
  854. }
  856. modified = 0;
  857. cmp_n = log_compare(lsnp, &LSN(pagep));
  859. /*
  860.  * Use this when there is something like "pagelsn" in the argp
  861.  * structure.  Sometimes, you might need to compare meta-data
  862.  * lsn's instead.
  863.  *
  864.  * cmp_p = log_compare(&LSN(pagep), argp->pagelsn);
  865.  */
  866. if (cmp_p == 0 && DB_REDO(op)) {
  867. /* Need to redo update described. */
  868. modified = 1;
  869. } else if (cmp_n == 0 && !DB_REDO(op)) {
  870. /* Need to undo update described. */
  871. modified = 1;
  872. }
  873. if (ret = memp_fput(mpf, pagep, modified ? DB_MPOOL_DIRTY : 0))
  874. goto out;
  876. *lsnp = argp->prev_lsn;
  877. ret = 0;
  879. out: REC_CLOSE;
  880. }