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

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

MySQL数据库

开发平台：

Visual C++

bt_rec.c：源码内容
  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 1996, 1997, 1998, 1999, 2000
  5.  * Sleepycat Software.  All rights reserved.
  6.  */
  8. #include "db_config.h"
  10. #ifndef lint
  11. static const char revid[] = "$Id: bt_rec.c,v 11.35 2001/01/10 16:24:47 ubell 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 "db_page.h"
  22. #include "hash.h"
  23. #include "btree.h"
  24. #include "log.h"
  26. #define IS_BTREE_PAGE(pagep)
  27. (TYPE(pagep) == P_IBTREE ||
  28.  TYPE(pagep) == P_LBTREE || TYPE(pagep) == P_LDUP)
  30. /*
  31.  * __bam_pg_alloc_recover --
  32.  * Recovery function for pg_alloc.
  33.  *
  34.  * PUBLIC: int __bam_pg_alloc_recover
  35.  * PUBLIC:   __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  36.  */
  37. int
  38. __bam_pg_alloc_recover(dbenv, dbtp, lsnp, op, info)
  39. DB_ENV *dbenv;
  40. DBT *dbtp;
  41. DB_LSN *lsnp;
  42. db_recops op;
  43. void *info;
  44. {
  45. __bam_pg_alloc_args *argp;
  46. DB *file_dbp;
  47. DBC *dbc;
  48. DBMETA *meta;
  49. DB_MPOOLFILE *mpf;
  50. PAGE *pagep;
  51. db_pgno_t pgno;
  52. int cmp_n, cmp_p, level, modified, ret;
  54. REC_PRINT(__bam_pg_alloc_print);
  55. REC_INTRO(__bam_pg_alloc_read, 0);
  57. /*
  58.  * Fix up the allocated page.  If we're redoing the operation, we have
  59.  * to get the page (creating it if it doesn't exist), and update its
  60.  * LSN.  If we're undoing the operation, we have to reset the page's
  61.  * LSN and put it on the free list.
  62.  *
  63.  * Fix up the metadata page.  If we're redoing the operation, we have
  64.  * to get the metadata page and update its LSN and its free pointer.
  65.  * If we're undoing the operation and the page was ever created, we put
  66.  * it on the freelist.
  67.  */
  68. pgno = PGNO_BASE_MD;
  69. meta = NULL;
  70. if ((ret = memp_fget(mpf, &pgno, 0, &meta)) != 0) {
  71. /* The metadata page must always exist on redo. */
  72. if (DB_REDO(op)) {
  73. (void)__db_pgerr(file_dbp, pgno);
  74. goto out;
  75. } else
  76. goto done;
  77. }
  78. if ((ret = memp_fget(mpf, &argp->pgno, DB_MPOOL_CREATE, &pagep)) != 0) {
  79. /*
  80.  * We specify creation and check for it later, because this
  81.  * operation was supposed to create the page, and even in
  82.  * the undo case it's going to get linked onto the freelist
  83.  * which we're also fixing up.
  84.  */
  85. (void)__db_pgerr(file_dbp, argp->pgno);
  86. goto err;
  87. }
  89. /* Fix up the allocated page. */
  90. modified = 0;
  91. cmp_n = log_compare(lsnp, &LSN(pagep));
  92. cmp_p = log_compare(&LSN(pagep), &argp->page_lsn);
  94. /*
  95.  * If an inital allocation is aborted and then reallocated
  96.  * during an archival restore the log record will have
  97.  * an LSN for the page but the page will be empty.
  98.  */
  99. if (IS_ZERO_LSN(LSN(pagep)))
  100. cmp_p = 0;
  101. CHECK_LSN(op, cmp_p, &LSN(pagep), &argp->page_lsn);
  102. /*
  103.  * If we we rolled back this allocation previously during an
  104.  * archive restore, the page may have the LSN of the meta page
  105.  * at the point of the roll back.  This will be no more
  106.  * than the LSN of the metadata page at the time of this allocation.
  107.  */
  108. if (DB_REDO(op) &&
  109.     (cmp_p == 0 ||
  110.     (IS_ZERO_LSN(argp->page_lsn) &&
  111.     log_compare(&LSN(pagep), &argp->meta_lsn) <= 0))) {
  112. /* Need to redo update described. */
  113. switch (argp->ptype) {
  114. case P_LBTREE:
  115. case P_LRECNO:
  116. case P_LDUP:
  117. level = LEAFLEVEL;
  118. break;
  119. default:
  120. level = 0;
  121. break;
  122. }
  123. P_INIT(pagep, file_dbp->pgsize,
  124.     argp->pgno, PGNO_INVALID, PGNO_INVALID, level, argp->ptype);
  126. pagep->lsn = *lsnp;
  127. modified = 1;
  128. } else if (cmp_n == 0 && DB_UNDO(op)) {
  129. /*
  130.  * Undo the allocation, reinitialize the page and
  131.  * link its next pointer to the free list.
  132.  */
  133. P_INIT(pagep, file_dbp->pgsize,
  134.     argp->pgno, PGNO_INVALID, argp->next, 0, P_INVALID);
  136. pagep->lsn = argp->page_lsn;
  137. modified = 1;
  138. }
  140. if ((ret = memp_fput(mpf, pagep, modified ? DB_MPOOL_DIRTY : 0)) != 0) {
  141. goto err;
  142. }
  144. /*
  145.  * If the page was newly created, put it on the limbo list.
  146.  */
  147. if (IS_ZERO_LSN(LSN(pagep)) &&
  148.      IS_ZERO_LSN(argp->page_lsn) && DB_UNDO(op)) {
  149. /* Put the page in limbo.*/
  150. if ((ret = __db_add_limbo(dbenv,
  151.     info, argp->fileid, argp->pgno, 1)) != 0)
  152. goto err;
  153. }
  155. /* Fix up the metadata page. */
  156. modified = 0;
  157. cmp_n = log_compare(lsnp, &LSN(meta));
  158. cmp_p = log_compare(&LSN(meta), &argp->meta_lsn);
  159. CHECK_LSN(op, cmp_p, &LSN(meta), &argp->meta_lsn);
  160. if (cmp_p == 0 && DB_REDO(op)) {
  161. /* Need to redo update described. */
  162. LSN(meta) = *lsnp;
  163. meta->free = argp->next;
  164. modified = 1;
  165. } else if (cmp_n == 0 && DB_UNDO(op)) {
  166. /* Need to undo update described. */
  167. LSN(meta) = argp->meta_lsn;
  169. /*
  170.  * If the page has a zero LSN then its newly created
  171.  * and will go into limbo rather than directly on the
  172.  * free list.
  173.  */
  174. if (!IS_ZERO_LSN(argp->page_lsn))
  175. meta->free = argp->pgno;
  176. modified = 1;
  177. }
  178. if ((ret = memp_fput(mpf, meta, modified ? DB_MPOOL_DIRTY : 0)) != 0)
  179. goto out;
  180. /*
  181.  * This could be the metapage from a subdb which is read from disk
  182.  * to recover its creation.
  183.  */
  184. if (F_ISSET(file_dbp, DB_AM_SUBDB))
  185. switch (argp->type) {
  186. case P_BTREEMETA:
  187. case P_HASHMETA:
  188. case P_QAMMETA:
  189. file_dbp->sync(file_dbp, 0);
  190. break;
  191. }
  193. done: *lsnp = argp->prev_lsn;
  194. ret = 0;
  196. if (0) {
  197. err:
  198. if (meta != NULL)
  199. (void)memp_fput(mpf, meta, 0);
  200. }
  201. out: REC_CLOSE;
  202. }
  204. /*
  205.  * __bam_pg_free_recover --
  206.  * Recovery function for pg_free.
  207.  *
  208.  * PUBLIC: int __bam_pg_free_recover
  209.  * PUBLIC:   __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  210.  */
  211. int
  212. __bam_pg_free_recover(dbenv, dbtp, lsnp, op, info)
  213. DB_ENV *dbenv;
  214. DBT *dbtp;
  215. DB_LSN *lsnp;
  216. db_recops op;
  217. void *info;
  218. {
  219. __bam_pg_free_args *argp;
  220. DB *file_dbp;
  221. DBC *dbc;
  222. DBMETA *meta;
  223. DB_LSN copy_lsn;
  224. DB_MPOOLFILE *mpf;
  225. PAGE *pagep;
  226. db_pgno_t pgno;
  227. int cmp_n, cmp_p, modified, ret;
  229. COMPQUIET(info, NULL);
  230. REC_PRINT(__bam_pg_free_print);
  231. REC_INTRO(__bam_pg_free_read, 1);
  233. /*
  234.  * Fix up the freed page.  If we're redoing the operation we get the
  235.  * page and explicitly discard its contents, then update its LSN.  If
  236.  * we're undoing the operation, we get the page and restore its header.
  237.  * Create the page if necessary, we may be freeing an aborted
  238.  * create.
  239.  */
  240. if ((ret = memp_fget(mpf, &argp->pgno, DB_MPOOL_CREATE, &pagep)) != 0)
  241. goto out;
  242. modified = 0;
  243. __ua_memcpy(&copy_lsn, &LSN(argp->header.data), sizeof(DB_LSN));
  244. cmp_n = log_compare(lsnp, &LSN(pagep));
  245. cmp_p = log_compare(&LSN(pagep), &copy_lsn);
  246. CHECK_LSN(op, cmp_p, &LSN(pagep), &copy_lsn);
  247. if (DB_REDO(op) &&
  248.     (cmp_p == 0 ||
  249.     (IS_ZERO_LSN(copy_lsn) &&
  250.     log_compare(&LSN(pagep), &argp->meta_lsn) <= 0))) {
  251. /* Need to redo update described. */
  252. P_INIT(pagep, file_dbp->pgsize,
  253.     argp->pgno, PGNO_INVALID, argp->next, 0, P_INVALID);
  254. pagep->lsn = *lsnp;
  256. modified = 1;
  257. } else if (cmp_n == 0 && DB_UNDO(op)) {
  258. /* Need to undo update described. */
  259. memcpy(pagep, argp->header.data, argp->header.size);
  261. modified = 1;
  262. }
  263. if ((ret = memp_fput(mpf, pagep, modified ? DB_MPOOL_DIRTY : 0)) != 0)
  264. goto out;
  266. /*
  267.  * Fix up the metadata page.  If we're redoing or undoing the operation
  268.  * we get the page and update its LSN and free pointer.
  269.  */
  270. pgno = PGNO_BASE_MD;
  271. if ((ret = memp_fget(mpf, &pgno, 0, &meta)) != 0) {
  272. /* The metadata page must always exist. */
  273. (void)__db_pgerr(file_dbp, pgno);
  274. goto out;
  275. }
  277. modified = 0;
  278. cmp_n = log_compare(lsnp, &LSN(meta));
  279. cmp_p = log_compare(&LSN(meta), &argp->meta_lsn);
  280. CHECK_LSN(op, cmp_p, &LSN(meta), &argp->meta_lsn);
  281. if (cmp_p == 0 && DB_REDO(op)) {
  282. /* Need to redo the deallocation. */
  283. meta->free = argp->pgno;
  284. LSN(meta) = *lsnp;
  285. modified = 1;
  286. } else if (cmp_n == 0 && DB_UNDO(op)) {
  287. /* Need to undo the deallocation. */
  288. meta->free = argp->next;
  289. LSN(meta) = argp->meta_lsn;
  290. modified = 1;
  291. }
  292. if ((ret = memp_fput(mpf, meta, modified ? DB_MPOOL_DIRTY : 0)) != 0)
  293. goto out;
  295. done: *lsnp = argp->prev_lsn;
  296. ret = 0;
  298. out: REC_CLOSE;
  299. }
  301. /*
  302.  * __bam_split_recover --
  303.  * Recovery function for split.
  304.  *
  305.  * PUBLIC: int __bam_split_recover
  306.  * PUBLIC:   __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  307.  */
  308. int
  309. __bam_split_recover(dbenv, dbtp, lsnp, op, info)
  310. DB_ENV *dbenv;
  311. DBT *dbtp;
  312. DB_LSN *lsnp;
  313. db_recops op;
  314. void *info;
  315. {
  316. __bam_split_args *argp;
  317. DB *file_dbp;
  318. DBC *dbc;
  319. DB_MPOOLFILE *mpf;
  320. PAGE *_lp, *lp, *np, *pp, *_rp, *rp, *sp;
  321. db_pgno_t pgno, root_pgno;
  322. u_int32_t ptype;
  323. int cmp, l_update, p_update, r_update, rc, ret, rootsplit, t_ret;
  325. COMPQUIET(info, NULL);
  326. REC_PRINT(__bam_split_print);
  328. mpf = NULL;
  329. _lp = lp = np = pp = _rp = rp = NULL;
  330. sp = NULL;
  332. REC_INTRO(__bam_split_read, 1);
  334. /*
  335.  * There are two kinds of splits that we have to recover from.  The
  336.  * first is a root-page split, where the root page is split from a
  337.  * leaf page into an internal page and two new leaf pages are created.
  338.  * The second is where a page is split into two pages, and a new key
  339.  * is inserted into the parent page.
  340.  *
  341.  * DBTs are not aligned in log records, so we need to copy the page
  342.  * so that we can access fields within it throughout this routine.
  343.  * Although we could hardcode the unaligned copies in this routine,
  344.  * we will be calling into regular btree functions with this page,
  345.  * so it's got to be aligned.  Copying it into allocated memory is
  346.  * the only way to guarantee this.
  347.  */
  348. if ((ret = __os_malloc(dbenv, argp->pg.size, NULL, &sp)) != 0)
  349. goto out;
  350. memcpy(sp, argp->pg.data, argp->pg.size);
  352. pgno = PGNO(sp);
  353. root_pgno = argp->root_pgno;
  354. rootsplit = pgno == root_pgno;
  355. if (memp_fget(mpf, &argp->left, 0, &lp) != 0)
  356. lp = NULL;
  357. if (memp_fget(mpf, &argp->right, 0, &rp) != 0)
  358. rp = NULL;
  360. if (DB_REDO(op)) {
  361. l_update = r_update = p_update = 0;
  362. /*
  363.  * Decide if we need to resplit the page.
  364.  *
  365.  * If this is a root split, then the root has to exist, it's
  366.  * the page we're splitting and it gets modified.  If this is
  367.  * not a root split, then the left page has to exist, for the
  368.  * same reason.
  369.  */
  370. if (rootsplit) {
  371. if ((ret = memp_fget(mpf, &pgno, 0, &pp)) != 0) {
  372. (void)__db_pgerr(file_dbp, pgno);
  373. pp = NULL;
  374. goto out;
  375. }
  376. cmp = log_compare(&LSN(pp), &LSN(argp->pg.data));
  377. CHECK_LSN(op, cmp, &LSN(pp), &LSN(argp->pg.data));
  378. p_update = cmp  == 0;
  379. } else if (lp == NULL) {
  380. (void)__db_pgerr(file_dbp, argp->left);
  381. goto out;
  382. }
  384. if (lp != NULL) {
  385. cmp = log_compare(&LSN(lp), &argp->llsn);
  386. CHECK_LSN(op, cmp, &LSN(lp), &argp->llsn);
  387. if (cmp == 0)
  388. l_update = 1;
  389. } else
  390. l_update = 1;
  392. if (rp != NULL) {
  393. cmp = log_compare(&LSN(rp), &argp->rlsn);
  394. CHECK_LSN(op, cmp, &LSN(rp), &argp->rlsn);
  395. if (cmp == 0)
  396. r_update = 1;
  397. } else
  398. r_update = 1;
  399. if (!p_update && !l_update && !r_update)
  400. goto check_next;
  402. /* Allocate and initialize new left/right child pages. */
  403. if ((ret =
  404.     __os_malloc(dbenv, file_dbp->pgsize, NULL, &_lp)) != 0
  405.     || (ret =
  406.     __os_malloc(dbenv, file_dbp->pgsize, NULL, &_rp)) != 0)
  407. goto out;
  408. if (rootsplit) {
  409. P_INIT(_lp, file_dbp->pgsize, argp->left,
  410.     PGNO_INVALID,
  411.     ISINTERNAL(sp) ? PGNO_INVALID : argp->right,
  412.     LEVEL(sp), TYPE(sp));
  413. P_INIT(_rp, file_dbp->pgsize, argp->right,
  414.     ISINTERNAL(sp) ?  PGNO_INVALID : argp->left,
  415.     PGNO_INVALID, LEVEL(sp), TYPE(sp));
  416. } else {
  417. P_INIT(_lp, file_dbp->pgsize, PGNO(sp),
  418.     ISINTERNAL(sp) ? PGNO_INVALID : PREV_PGNO(sp),
  419.     ISINTERNAL(sp) ? PGNO_INVALID : argp->right,
  420.     LEVEL(sp), TYPE(sp));
  421. P_INIT(_rp, file_dbp->pgsize, argp->right,
  422.     ISINTERNAL(sp) ? PGNO_INVALID : sp->pgno,
  423.     ISINTERNAL(sp) ? PGNO_INVALID : NEXT_PGNO(sp),
  424.     LEVEL(sp), TYPE(sp));
  425. }
  427. /* Split the page. */
  428. if ((ret = __bam_copy(file_dbp, sp, _lp, 0, argp->indx)) != 0 ||
  429.     (ret = __bam_copy(file_dbp, sp, _rp, argp->indx,
  430.     NUM_ENT(sp))) != 0)
  431. goto out;
  433. /* If the left child is wrong, update it. */
  434. if (lp == NULL && (ret =
  435.     memp_fget(mpf, &argp->left, DB_MPOOL_CREATE, &lp)) != 0) {
  436. (void)__db_pgerr(file_dbp, argp->left);
  437. lp = NULL;
  438. goto out;
  439. }
  440. if (l_update) {
  441. memcpy(lp, _lp, file_dbp->pgsize);
  442. lp->lsn = *lsnp;
  443. if ((ret = memp_fput(mpf, lp, DB_MPOOL_DIRTY)) != 0)
  444. goto out;
  445. lp = NULL;
  446. }
  448. /* If the right child is wrong, update it. */
  449. if (rp == NULL && (ret = memp_fget(mpf,
  450.     &argp->right, DB_MPOOL_CREATE, &rp)) != 0) {
  451. (void)__db_pgerr(file_dbp, argp->right);
  452. rp = NULL;
  453. goto out;
  454. }
  455. if (r_update) {
  456. memcpy(rp, _rp, file_dbp->pgsize);
  457. rp->lsn = *lsnp;
  458. if ((ret = memp_fput(mpf, rp, DB_MPOOL_DIRTY)) != 0)
  459. goto out;
  460. rp = NULL;
  461. }
  463. /*
  464.  * If the parent page is wrong, update it.  This is of interest
  465.  * only if it was a root split, since root splits create parent
  466.  * pages.  All other splits modify a parent page, but those are
  467.  * separately logged and recovered.
  468.  */
  469. if (rootsplit && p_update) {
  470. if (IS_BTREE_PAGE(sp)) {
  471. ptype = P_IBTREE;
  472. rc = argp->opflags & SPL_NRECS ? 1 : 0;
  473. } else {
  474. ptype = P_IRECNO;
  475. rc = 1;
  476. }
  478. P_INIT(pp, file_dbp->pgsize, root_pgno,
  479.     PGNO_INVALID, PGNO_INVALID, _lp->level + 1, ptype);
  480. RE_NREC_SET(pp,
  481.     rc ? __bam_total(_lp) + __bam_total(_rp) : 0);
  483. pp->lsn = *lsnp;
  484. if ((ret = memp_fput(mpf, pp, DB_MPOOL_DIRTY)) != 0)
  485. goto out;
  486. pp = NULL;
  487. }
  489. check_next: /*
  490.  * Finally, redo the next-page link if necessary.  This is of
  491.  * interest only if it wasn't a root split -- inserting a new
  492.  * page in the tree requires that any following page have its
  493.  * previous-page pointer updated to our new page.  The next
  494.  * page must exist because we're redoing the operation.
  495.  */
  496. if (!rootsplit && !IS_ZERO_LSN(argp->nlsn)) {
  497. if ((ret = memp_fget(mpf, &argp->npgno, 0, &np)) != 0) {
  498. (void)__db_pgerr(file_dbp, argp->npgno);
  499. np = NULL;
  500. goto out;
  501. }
  502. cmp = log_compare(&LSN(np), &argp->nlsn);
  503. CHECK_LSN(op, cmp, &LSN(np), &argp->nlsn);
  504. if (cmp == 0) {
  505. PREV_PGNO(np) = argp->right;
  506. np->lsn = *lsnp;
  507. if ((ret =
  508.     memp_fput(mpf, np, DB_MPOOL_DIRTY)) != 0)
  509. goto out;
  510. np = NULL;
  511. }
  512. }
  513. } else {
  514. /*
  515.  * If the split page is wrong, replace its contents with the
  516.  * logged page contents.  If the page doesn't exist, it means
  517.  * that the create of the page never happened, nor did any of
  518.  * the adds onto the page that caused the split, and there's
  519.  * really no undo-ing to be done.
  520.  */
  521. if ((ret = memp_fget(mpf, &pgno, 0, &pp)) != 0) {
  522. pp = NULL;
  523. goto lrundo;
  524. }
  525. if (log_compare(lsnp, &LSN(pp)) == 0) {
  526. memcpy(pp, argp->pg.data, argp->pg.size);
  527. if ((ret = memp_fput(mpf, pp, DB_MPOOL_DIRTY)) != 0)
  528. goto out;
  529. pp = NULL;
  530. }
  532. /*
  533.  * If it's a root split and the left child ever existed, update
  534.  * its LSN.  (If it's not a root split, we've updated the left
  535.  * page already -- it's the same as the split page.) If the
  536.  * right child ever existed, root split or not, update its LSN.
  537.  * The undo of the page allocation(s) will restore them to the
  538.  * free list.
  539.  */
  540. lrundo: if ((rootsplit && lp != NULL) || rp != NULL) {
  541. if (rootsplit && lp != NULL &&
  542.     log_compare(lsnp, &LSN(lp)) == 0) {
  543. lp->lsn = argp->llsn;
  544. if ((ret =
  545.     memp_fput(mpf, lp, DB_MPOOL_DIRTY)) != 0)
  546. goto out;
  547. lp = NULL;
  548. }
  549. if (rp != NULL &&
  550.     log_compare(lsnp, &LSN(rp)) == 0) {
  551. rp->lsn = argp->rlsn;
  552. if ((ret =
  553.     memp_fput(mpf, rp, DB_MPOOL_DIRTY)) != 0)
  554. goto out;
  555. rp = NULL;
  556. }
  557. }
  559. /*
  560.  * Finally, undo the next-page link if necessary.  This is of
  561.  * interest only if it wasn't a root split -- inserting a new
  562.  * page in the tree requires that any following page have its
  563.  * previous-page pointer updated to our new page.  Since it's
  564.  * possible that the next-page never existed, we ignore it as
  565.  * if there's nothing to undo.
  566.  */
  567. if (!rootsplit && !IS_ZERO_LSN(argp->nlsn)) {
  568. if ((ret = memp_fget(mpf, &argp->npgno, 0, &np)) != 0) {
  569. np = NULL;
  570. goto done;
  571. }
  572. if (log_compare(lsnp, &LSN(np)) == 0) {
  573. PREV_PGNO(np) = argp->left;
  574. np->lsn = argp->nlsn;
  575. if (memp_fput(mpf, np, DB_MPOOL_DIRTY))
  576. goto out;
  577. np = NULL;
  578. }
  579. }
  580. }
  582. done: *lsnp = argp->prev_lsn;
  583. ret = 0;
  585. out: /* Free any pages that weren't dirtied. */
  586. if (pp != NULL && (t_ret = memp_fput(mpf, pp, 0)) != 0 && ret == 0)
  587. ret = t_ret;
  588. if (lp != NULL && (t_ret = memp_fput(mpf, lp, 0)) != 0 && ret == 0)
  589. ret = t_ret;
  590. if (np != NULL && (t_ret = memp_fput(mpf, np, 0)) != 0 && ret == 0)
  591. ret = t_ret;
  592. if (rp != NULL && (t_ret = memp_fput(mpf, rp, 0)) != 0 && ret == 0)
  593. ret = t_ret;
  595. /* Free any allocated space. */
  596. if (_lp != NULL)
  597. __os_free(_lp, file_dbp->pgsize);
  598. if (_rp != NULL)
  599. __os_free(_rp, file_dbp->pgsize);
  600. if (sp != NULL)
  601. __os_free(sp, argp->pg.size);
  603. REC_CLOSE;
  604. }
  606. /*
  607.  * __bam_rsplit_recover --
  608.  * Recovery function for a reverse split.
  609.  *
  610.  * PUBLIC: int __bam_rsplit_recover
  611.  * PUBLIC:   __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  612.  */
  613. int
  614. __bam_rsplit_recover(dbenv, dbtp, lsnp, op, info)
  615. DB_ENV *dbenv;
  616. DBT *dbtp;
  617. DB_LSN *lsnp;
  618. db_recops op;
  619. void *info;
  620. {
  621. __bam_rsplit_args *argp;
  622. DB *file_dbp;
  623. DBC *dbc;
  624. DB_LSN copy_lsn;
  625. DB_MPOOLFILE *mpf;
  626. PAGE *pagep;
  627. db_pgno_t pgno, root_pgno;
  628. int cmp_n, cmp_p, modified, ret;
  630. COMPQUIET(info, NULL);
  631. REC_PRINT(__bam_rsplit_print);
  632. REC_INTRO(__bam_rsplit_read, 1);
  634. /* Fix the root page. */
  635. pgno = root_pgno = argp->root_pgno;
  636. if ((ret = memp_fget(mpf, &pgno, 0, &pagep)) != 0) {
  637. /* The root page must always exist if we are going forward. */
  638. if (DB_REDO(op)) {
  639. __db_pgerr(file_dbp, pgno);
  640. goto out;
  641. }
  642. /* This must be the root of an OPD tree. */
  643. DB_ASSERT(root_pgno !=
  644.     ((BTREE *)file_dbp->bt_internal)->bt_root);
  645. ret = 0;
  646. goto done;
  647. }
  648. modified = 0;
  649. cmp_n = log_compare(lsnp, &LSN(pagep));
  650. cmp_p = log_compare(&LSN(pagep), &argp->rootlsn);
  651. CHECK_LSN(op, cmp_p, &LSN(pagep), &argp->rootlsn);
  652. if (cmp_p == 0 && DB_REDO(op)) {
  653. /* Need to redo update described. */
  654. memcpy(pagep, argp->pgdbt.data, argp->pgdbt.size);
  655. pagep->pgno = root_pgno;
  656. pagep->lsn = *lsnp;
  657. modified = 1;
  658. } else if (cmp_n == 0 && DB_UNDO(op)) {
  659. /* Need to undo update described. */
  660. P_INIT(pagep, file_dbp->pgsize, root_pgno,
  661.     argp->nrec, PGNO_INVALID, pagep->level + 1,
  662.     IS_BTREE_PAGE(pagep) ? P_IBTREE : P_IRECNO);
  663. if ((ret = __db_pitem(dbc, pagep, 0,
  664.     argp->rootent.size, &argp->rootent, NULL)) != 0)
  665. goto out;
  666. pagep->lsn = argp->rootlsn;
  667. modified = 1;
  668. }
  669. if ((ret = memp_fput(mpf, pagep, modified ? DB_MPOOL_DIRTY : 0)) != 0)
  670. goto out;
  672. /*
  673.  * Fix the page copied over the root page.  It's possible that the
  674.  * page never made it to disk, so if we're undo-ing and the page
  675.  * doesn't exist, it's okay and there's nothing further to do.
  676.  */
  677. if ((ret = memp_fget(mpf, &argp->pgno, 0, &pagep)) != 0) {
  678. if (DB_UNDO(op))
  679. goto done;
  680. (void)__db_pgerr(file_dbp, argp->pgno);
  681. goto out;
  682. }
  683. modified = 0;
  684. __ua_memcpy(&copy_lsn, &LSN(argp->pgdbt.data), sizeof(DB_LSN));
  685. cmp_n = log_compare(lsnp, &LSN(pagep));
  686. cmp_p = log_compare(&LSN(pagep), &copy_lsn);
  687. CHECK_LSN(op, cmp_p, &LSN(pagep), &copy_lsn);
  688. if (cmp_p == 0 && DB_REDO(op)) {
  689. /* Need to redo update described. */
  690. pagep->lsn = *lsnp;
  691. modified = 1;
  692. } else if (cmp_n == 0 && DB_UNDO(op)) {
  693. /* Need to undo update described. */
  694. memcpy(pagep, argp->pgdbt.data, argp->pgdbt.size);
  695. modified = 1;
  696. }
  697. if ((ret = memp_fput(mpf, pagep, modified ? DB_MPOOL_DIRTY : 0)) != 0)
  698. goto out;
  700. done: *lsnp = argp->prev_lsn;
  701. ret = 0;
  703. out: REC_CLOSE;
  704. }
  706. /*
  707.  * __bam_adj_recover --
  708.  * Recovery function for adj.
  709.  *
  710.  * PUBLIC: int __bam_adj_recover
  711.  * PUBLIC:   __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  712.  */
  713. int
  714. __bam_adj_recover(dbenv, dbtp, lsnp, op, info)
  715. DB_ENV *dbenv;
  716. DBT *dbtp;
  717. DB_LSN *lsnp;
  718. db_recops op;
  719. void *info;
  720. {
  721. __bam_adj_args *argp;
  722. DB *file_dbp;
  723. DBC *dbc;
  724. DB_MPOOLFILE *mpf;
  725. PAGE *pagep;
  726. int cmp_n, cmp_p, modified, ret;
  728. COMPQUIET(info, NULL);
  729. REC_PRINT(__bam_adj_print);
  730. REC_INTRO(__bam_adj_read, 1);
  732. /* Get the page; if it never existed and we're undoing, we're done. */
  733. if ((ret = memp_fget(mpf, &argp->pgno, 0, &pagep)) != 0) {
  734. if (DB_UNDO(op))
  735. goto done;
  736. (void)__db_pgerr(file_dbp, argp->pgno);
  737. goto out;
  738. }
  740. modified = 0;
  741. cmp_n = log_compare(lsnp, &LSN(pagep));
  742. cmp_p = log_compare(&LSN(pagep), &argp->lsn);
  743. CHECK_LSN(op, cmp_p, &LSN(pagep), &argp->lsn);
  744. if (cmp_p == 0 && DB_REDO(op)) {
  745. /* Need to redo update described. */
  746. if ((ret = __bam_adjindx(dbc,
  747.     pagep, argp->indx, argp->indx_copy, argp->is_insert)) != 0)
  748. goto err;
  750. LSN(pagep) = *lsnp;
  751. modified = 1;
  752. } else if (cmp_n == 0 && DB_UNDO(op)) {
  753. /* Need to undo update described. */
  754. if ((ret = __bam_adjindx(dbc,
  755.     pagep, argp->indx, argp->indx_copy, !argp->is_insert)) != 0)
  756. goto err;
  758. LSN(pagep) = argp->lsn;
  759. modified = 1;
  760. }
  761. if ((ret = memp_fput(mpf, pagep, modified ? DB_MPOOL_DIRTY : 0)) != 0)
  762. goto out;
  764. done: *lsnp = argp->prev_lsn;
  765. ret = 0;
  767. if (0) {
  768. err: (void)memp_fput(mpf, pagep, 0);
  769. }
  770. out: REC_CLOSE;
  771. }
  773. /*
  774.  * __bam_cadjust_recover --
  775.  * Recovery function for the adjust of a count change in an internal
  776.  * page.
  777.  *
  778.  * PUBLIC: int __bam_cadjust_recover
  779.  * PUBLIC:   __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  780.  */
  781. int
  782. __bam_cadjust_recover(dbenv, dbtp, lsnp, op, info)
  783. DB_ENV *dbenv;
  784. DBT *dbtp;
  785. DB_LSN *lsnp;
  786. db_recops op;
  787. void *info;
  788. {
  789. __bam_cadjust_args *argp;
  790. DB *file_dbp;
  791. DBC *dbc;
  792. DB_MPOOLFILE *mpf;
  793. PAGE *pagep;
  794. int cmp_n, cmp_p, modified, ret;
  796. COMPQUIET(info, NULL);
  797. REC_PRINT(__bam_cadjust_print);
  798. REC_INTRO(__bam_cadjust_read, 1);
  800. /* Get the page; if it never existed and we're undoing, we're done. */
  801. if ((ret = memp_fget(mpf, &argp->pgno, 0, &pagep)) != 0) {
  802. if (DB_UNDO(op))
  803. goto done;
  804. (void)__db_pgerr(file_dbp, argp->pgno);
  805. goto out;
  806. }
  808. modified = 0;
  809. cmp_n = log_compare(lsnp, &LSN(pagep));
  810. cmp_p = log_compare(&LSN(pagep), &argp->lsn);
  811. CHECK_LSN(op, cmp_p, &LSN(pagep), &argp->lsn);
  812. if (cmp_p == 0 && DB_REDO(op)) {
  813. /* Need to redo update described. */
  814. if (IS_BTREE_PAGE(pagep)) {
  815. GET_BINTERNAL(pagep, argp->indx)->nrecs += argp->adjust;
  816. if (argp->opflags & CAD_UPDATEROOT)
  817. RE_NREC_ADJ(pagep, argp->adjust);
  818. } else {
  819. GET_RINTERNAL(pagep, argp->indx)->nrecs += argp->adjust;
  820. if (argp->opflags & CAD_UPDATEROOT)
  821. RE_NREC_ADJ(pagep, argp->adjust);
  822. }
  824. LSN(pagep) = *lsnp;
  825. modified = 1;
  826. } else if (cmp_n == 0 && DB_UNDO(op)) {
  827. /* Need to undo update described. */
  828. if (IS_BTREE_PAGE(pagep)) {
  829. GET_BINTERNAL(pagep, argp->indx)->nrecs -= argp->adjust;
  830. if (argp->opflags & CAD_UPDATEROOT)
  831. RE_NREC_ADJ(pagep, -(argp->adjust));
  832. } else {
  833. GET_RINTERNAL(pagep, argp->indx)->nrecs -= argp->adjust;
  834. if (argp->opflags & CAD_UPDATEROOT)
  835. RE_NREC_ADJ(pagep, -(argp->adjust));
  836. }
  837. LSN(pagep) = argp->lsn;
  838. modified = 1;
  839. }
  840. if ((ret = memp_fput(mpf, pagep, modified ? DB_MPOOL_DIRTY : 0)) != 0)
  841. goto out;
  843. done: *lsnp = argp->prev_lsn;
  844. ret = 0;
  846. out: REC_CLOSE;
  847. }
  849. /*
  850.  * __bam_cdel_recover --
  851.  * Recovery function for the intent-to-delete of a cursor record.
  852.  *
  853.  * PUBLIC: int __bam_cdel_recover
  854.  * PUBLIC:   __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  855.  */
  856. int
  857. __bam_cdel_recover(dbenv, dbtp, lsnp, op, info)
  858. DB_ENV *dbenv;
  859. DBT *dbtp;
  860. DB_LSN *lsnp;
  861. db_recops op;
  862. void *info;
  863. {
  864. __bam_cdel_args *argp;
  865. DB *file_dbp;
  866. DBC *dbc;
  867. DB_MPOOLFILE *mpf;
  868. PAGE *pagep;
  869. u_int32_t indx;
  870. int cmp_n, cmp_p, modified, ret;
  872. COMPQUIET(info, NULL);
  873. REC_PRINT(__bam_cdel_print);
  874. REC_INTRO(__bam_cdel_read, 1);
  876. /* Get the page; if it never existed and we're undoing, we're done. */
  877. if ((ret = memp_fget(mpf, &argp->pgno, 0, &pagep)) != 0) {
  878. if (DB_UNDO(op))
  879. goto done;
  880. (void)__db_pgerr(file_dbp, argp->pgno);
  881. goto out;
  882. }
  884. modified = 0;
  885. cmp_n = log_compare(lsnp, &LSN(pagep));
  886. cmp_p = log_compare(&LSN(pagep), &argp->lsn);
  887. CHECK_LSN(op, cmp_p, &LSN(pagep), &argp->lsn);
  888. if (cmp_p == 0 && DB_REDO(op)) {
  889. /* Need to redo update described. */
  890. indx = argp->indx + (TYPE(pagep) == P_LBTREE ? O_INDX : 0);
  891. B_DSET(GET_BKEYDATA(pagep, indx)->type);
  893. LSN(pagep) = *lsnp;
  894. modified = 1;
  895. } else if (cmp_n == 0 && DB_UNDO(op)) {
  896. /* Need to undo update described. */
  897. indx = argp->indx + (TYPE(pagep) == P_LBTREE ? O_INDX : 0);
  898. B_DCLR(GET_BKEYDATA(pagep, indx)->type);
  900. (void)__bam_ca_delete(file_dbp, argp->pgno, argp->indx, 0);
  902. LSN(pagep) = argp->lsn;
  903. modified = 1;
  904. }
  905. if ((ret = memp_fput(mpf, pagep, modified ? DB_MPOOL_DIRTY : 0)) != 0)
  906. goto out;
  908. done: *lsnp = argp->prev_lsn;
  909. ret = 0;
  911. out: REC_CLOSE;
  912. }
  914. /*
  915.  * __bam_repl_recover --
  916.  * Recovery function for page item replacement.
  917.  *
  918.  * PUBLIC: int __bam_repl_recover
  919.  * PUBLIC:   __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  920.  */
  921. int
  922. __bam_repl_recover(dbenv, dbtp, lsnp, op, info)
  923. DB_ENV *dbenv;
  924. DBT *dbtp;
  925. DB_LSN *lsnp;
  926. db_recops op;
  927. void *info;
  928. {
  929. __bam_repl_args *argp;
  930. BKEYDATA *bk;
  931. DB *file_dbp;
  932. DBC *dbc;
  933. DBT dbt;
  934. DB_MPOOLFILE *mpf;
  935. PAGE *pagep;
  936. int cmp_n, cmp_p, modified, ret;
  937. u_int8_t *p;
  939. COMPQUIET(info, NULL);
  940. REC_PRINT(__bam_repl_print);
  941. REC_INTRO(__bam_repl_read, 1);
  943. /* Get the page; if it never existed and we're undoing, we're done. */
  944. if ((ret = memp_fget(mpf, &argp->pgno, 0, &pagep)) != 0) {
  945. if (DB_UNDO(op))
  946. goto done;
  947. (void)__db_pgerr(file_dbp, argp->pgno);
  948. goto out;
  949. }
  950. bk = GET_BKEYDATA(pagep, argp->indx);
  952. modified = 0;
  953. cmp_n = log_compare(lsnp, &LSN(pagep));
  954. cmp_p = log_compare(&LSN(pagep), &argp->lsn);
  955. CHECK_LSN(op, cmp_p, &LSN(pagep), &argp->lsn);
  956. if (cmp_p == 0 && DB_REDO(op)) {
  957. /*
  958.  * Need to redo update described.
  959.  *
  960.  * Re-build the replacement item.
  961.  */
  962. memset(&dbt, 0, sizeof(dbt));
  963. dbt.size = argp->prefix + argp->suffix + argp->repl.size;
  964. if ((ret = __os_malloc(dbenv, dbt.size, NULL, &dbt.data)) != 0)
  965. goto err;
  966. p = dbt.data;
  967. memcpy(p, bk->data, argp->prefix);
  968. p += argp->prefix;
  969. memcpy(p, argp->repl.data, argp->repl.size);
  970. p += argp->repl.size;
  971. memcpy(p, bk->data + (bk->len - argp->suffix), argp->suffix);
  973. ret = __bam_ritem(dbc, pagep, argp->indx, &dbt);
  974. __os_free(dbt.data, dbt.size);
  975. if (ret != 0)
  976. goto err;
  978. LSN(pagep) = *lsnp;
  979. modified = 1;
  980. } else if (cmp_n == 0 && DB_UNDO(op)) {
  981. /*
  982.  * Need to undo update described.
  983.  *
  984.  * Re-build the original item.
  985.  */
  986. memset(&dbt, 0, sizeof(dbt));
  987. dbt.size = argp->prefix + argp->suffix + argp->orig.size;
  988. if ((ret = __os_malloc(dbenv, dbt.size, NULL, &dbt.data)) != 0)
  989. goto err;
  990. p = dbt.data;
  991. memcpy(p, bk->data, argp->prefix);
  992. p += argp->prefix;
  993. memcpy(p, argp->orig.data, argp->orig.size);
  994. p += argp->orig.size;
  995. memcpy(p, bk->data + (bk->len - argp->suffix), argp->suffix);
  997. ret = __bam_ritem(dbc, pagep, argp->indx, &dbt);
  998. __os_free(dbt.data, dbt.size);
  999. if (ret != 0)
  1000. goto err;
  1002. /* Reset the deleted flag, if necessary. */
  1003. if (argp->isdeleted)
  1004. B_DSET(GET_BKEYDATA(pagep, argp->indx)->type);
  1006. LSN(pagep) = argp->lsn;
  1007. modified = 1;
  1008. }
  1009. if ((ret = memp_fput(mpf, pagep, modified ? DB_MPOOL_DIRTY : 0)) != 0)
  1010. goto out;
  1012. done: *lsnp = argp->prev_lsn;
  1013. ret = 0;
  1015. if (0) {
  1016. err: (void)memp_fput(mpf, pagep, 0);
  1017. }
  1018. out: REC_CLOSE;
  1019. }
  1021. /*
  1022.  * __bam_root_recover --
  1023.  * Recovery function for setting the root page on the meta-data page.
  1024.  *
  1025.  * PUBLIC: int __bam_root_recover
  1026.  * PUBLIC:   __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  1027.  */
  1028. int
  1029. __bam_root_recover(dbenv, dbtp, lsnp, op, info)
  1030. DB_ENV *dbenv;
  1031. DBT *dbtp;
  1032. DB_LSN *lsnp;
  1033. db_recops op;
  1034. void *info;
  1035. {
  1036. __bam_root_args *argp;
  1037. BTMETA *meta;
  1038. DB *file_dbp;
  1039. DBC *dbc;
  1040. DB_MPOOLFILE *mpf;
  1041. int cmp_n, cmp_p, modified, ret;
  1043. COMPQUIET(info, NULL);
  1044. REC_PRINT(__bam_root_print);
  1045. REC_INTRO(__bam_root_read, 0);
  1047. if ((ret = memp_fget(mpf, &argp->meta_pgno, 0, &meta)) != 0) {
  1048. /* The metadata page must always exist on redo. */
  1049. if (DB_REDO(op)) {
  1050. (void)__db_pgerr(file_dbp, argp->meta_pgno);
  1051. goto out;
  1052. } else
  1053. goto done;
  1054. }
  1056. modified = 0;
  1057. cmp_n = log_compare(lsnp, &LSN(meta));
  1058. cmp_p = log_compare(&LSN(meta), &argp->meta_lsn);
  1059. CHECK_LSN(op, cmp_p, &LSN(meta), &argp->meta_lsn);
  1060. if (cmp_p == 0 && DB_REDO(op)) {
  1061. /* Need to redo update described. */
  1062. meta->root = argp->root_pgno;
  1063. meta->dbmeta.lsn = *lsnp;
  1064. ((BTREE *)file_dbp->bt_internal)->bt_root = meta->root;
  1065. modified = 1;
  1066. } else if (cmp_n == 0 && DB_UNDO(op)) {
  1067. /* Nothing to undo except lsn. */
  1068. meta->dbmeta.lsn = argp->meta_lsn;
  1069. modified = 1;
  1070. }
  1071. if ((ret = memp_fput(mpf, meta, modified ? DB_MPOOL_DIRTY : 0)) != 0)
  1072. goto out;
  1074. done: *lsnp = argp->prev_lsn;
  1075. ret = 0;
  1077. out: REC_CLOSE;
  1078. }
  1080. /*
  1081.  * __bam_curadj_recover --
  1082.  * Transaction abort function to undo cursor adjustments.
  1083.  * This should only be triggered by subtransaction aborts.
  1084.  *
  1085.  * PUBLIC: int __bam_curadj_recover
  1086.  * PUBLIC:   __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  1087.  */
  1088. int
  1089. __bam_curadj_recover(dbenv, dbtp, lsnp, op, info)
  1090. DB_ENV *dbenv;
  1091. DBT *dbtp;
  1092. DB_LSN *lsnp;
  1093. db_recops op;
  1094. void *info;
  1095. {
  1096. __bam_curadj_args *argp;
  1097. DB *file_dbp;
  1098. DBC *dbc;
  1099. DB_MPOOLFILE *mpf;
  1100. int ret;
  1102. COMPQUIET(info, NULL);
  1104. REC_PRINT(__bam_curadj_print);
  1105. REC_INTRO(__bam_curadj_read, 0);
  1107. ret = 0;
  1108. if (op != DB_TXN_ABORT)
  1109. goto done;
  1111. switch(argp->mode) {
  1112. case DB_CA_DI:
  1113. if ((ret = __bam_ca_di(dbc, argp->from_pgno,
  1114.     argp->from_indx, -(int)argp->first_indx)) != 0)
  1115. goto out;
  1116. break;
  1117. case DB_CA_DUP:
  1118. if ((ret = __bam_ca_undodup(file_dbp, argp->first_indx,
  1119.      argp->from_pgno, argp->from_indx, argp->to_indx)) != 0)
  1120. goto out;
  1121. break;
  1123. case DB_CA_RSPLIT:
  1124. if ((ret =
  1125.     __bam_ca_rsplit(dbc, argp->to_pgno, argp->from_pgno)) != 0)
  1126. goto out;
  1127. break;
  1129. case DB_CA_SPLIT:
  1130. __bam_ca_undosplit(file_dbp, argp->from_pgno,
  1131.     argp->to_pgno, argp->left_pgno, argp->from_indx);
  1132. break;
  1133. }
  1135. done: *lsnp = argp->prev_lsn;
  1136. out: REC_CLOSE;
  1137. }
  1139. /*
  1140.  * __bam_rcuradj_recover --
  1141.  * Transaction abort function to undo cursor adjustments in rrecno.
  1142.  * This should only be triggered by subtransaction aborts.
  1143.  *
  1144.  * PUBLIC: int __bam_rcuradj_recover
  1145.  * PUBLIC:   __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  1146.  */
  1147. int
  1148. __bam_rcuradj_recover(dbenv, dbtp, lsnp, op, info)
  1149. DB_ENV *dbenv;
  1150. DBT *dbtp;
  1151. DB_LSN *lsnp;
  1152. db_recops op;
  1153. void *info;
  1154. {
  1155. __bam_rcuradj_args *argp;
  1156. BTREE_CURSOR *cp;
  1157. DB *file_dbp;
  1158. DBC *dbc, *rdbc;
  1159. DB_MPOOLFILE *mpf;
  1160. int ret, t_ret;
  1162. COMPQUIET(info, NULL);
  1163. rdbc = NULL;
  1165. REC_PRINT(__bam_rcuradj_print);
  1166. REC_INTRO(__bam_rcuradj_read, 0);
  1168. ret = t_ret = 0;
  1170. if (op != DB_TXN_ABORT)
  1171. goto done;
  1173. /*
  1174.  * We don't know whether we're in an offpage dup set, and
  1175.  * thus don't know whether the dbc REC_INTRO has handed us is
  1176.  * of a reasonable type.  It's certainly unset, so if this is
  1177.  * an offpage dup set, we don't have an OPD cursor.  The
  1178.  * simplest solution is just to allocate a whole new cursor
  1179.  * for our use;  we're only really using it to hold pass some
  1180.  * state into __ram_ca, and this way we don't need to make
  1181.  * this function know anything about how offpage dups work.
  1182.  */
  1183. if ((ret =
  1184.     __db_icursor(file_dbp, NULL, DB_RECNO, argp->root, 0, &rdbc)) != 0)
  1185. goto out;
  1187. cp = (BTREE_CURSOR *)rdbc->internal;
  1188. F_SET(cp, C_RENUMBER);
  1189. cp->recno = argp->recno;
  1191. switch(argp->mode) {
  1192. case CA_DELETE:
  1193. /*
  1194.  * The way to undo a delete is with an insert.  Since
  1195.  * we're undoing it, the delete flag must be set.
  1196.  */
  1197. F_SET(cp, C_DELETED);
  1198. F_SET(cp, C_RENUMBER); /* Just in case. */
  1199. cp->order = argp->order;
  1200. __ram_ca(rdbc, CA_ICURRENT);
  1201. break;
  1202. case CA_IAFTER:
  1203. case CA_IBEFORE:
  1204. case CA_ICURRENT:
  1205. /*
  1206.  * The way to undo an insert is with a delete.  The delete
  1207.  * flag is unset to start with.
  1208.  */
  1209. F_CLR(cp, C_DELETED);
  1210. cp->order = INVALID_ORDER;
  1211. __ram_ca(rdbc, CA_DELETE);
  1212. break;
  1213. }
  1215. done: *lsnp = argp->prev_lsn;
  1216. out: if (rdbc != NULL && (t_ret = rdbc->c_close(rdbc)) != 0 && ret == 0)
  1217. ret = t_ret;
  1218. REC_CLOSE;
  1219. }