1 /*-
2 * See the file LICENSE for redistribution information.
3 *
4 * Copyright (c) 1996, 1997, 1998
5 * Sleepycat Software. All rights reserved.
6 */
7
8 #include "config.h"
9
10 #ifndef lint
11 static const char sccsid[] = "@(#)bt_rec.c 10.28 (Sleepycat) 9/27/98";
12 #endif /* not lint */
13
14 #ifndef NO_SYSTEM_INCLUDES
15 #include <sys/types.h>
16
17 #include <errno.h>
18 #include <string.h>
19 #endif
20
21 #include "db_int.h"
22 #include "db_page.h"
23 #include "shqueue.h"
24 #include "hash.h"
25 #include "btree.h"
26 #include "log.h"
27 #include "common_ext.h"
28
29 /*
30 * __bam_pg_alloc_recover --
31 * Recovery function for pg_alloc.
32 *
33 * PUBLIC: int __bam_pg_alloc_recover
34 * PUBLIC: __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
35 */
36 int
__bam_pg_alloc_recover(logp,dbtp,lsnp,redo,info)37 __bam_pg_alloc_recover(logp, dbtp, lsnp, redo, info)
38 DB_LOG *logp;
39 DBT *dbtp;
40 DB_LSN *lsnp;
41 int redo;
42 void *info;
43 {
44 __bam_pg_alloc_args *argp;
45 BTMETA *meta;
46 DB_MPOOLFILE *mpf;
47 PAGE *pagep;
48 DB *file_dbp;
49 DBC *dbc;
50 db_pgno_t pgno;
51 int cmp_n, cmp_p, modified, ret;
52
53 REC_PRINT(__bam_pg_alloc_print);
54 REC_INTRO(__bam_pg_alloc_read);
55
56 /*
57 * Fix up the allocated page. If we're redoing the operation, we have
58 * to get the page (creating it if it doesn't exist), and update its
59 * LSN. If we're undoing the operation, we have to reset the page's
60 * LSN and put it on the free list.
61 *
62 * Fix up the metadata page. If we're redoing the operation, we have
63 * to get the metadata page and update its LSN and its free pointer.
64 * If we're undoing the operation and the page was ever created, we put
65 * it on the freelist.
66 */
67 pgno = PGNO_METADATA;
68 if ((ret = memp_fget(mpf, &pgno, 0, &meta)) != 0) {
69 /* The metadata page must always exist. */
70 (void)__db_pgerr(file_dbp, pgno);
71 goto out;
72 }
73 if ((ret = memp_fget(mpf, &argp->pgno, DB_MPOOL_CREATE, &pagep)) != 0) {
74 /*
75 * We specify creation and check for it later, because this
76 * operation was supposed to create the page, and even in
77 * the undo case it's going to get linked onto the freelist
78 * which we're also fixing up.
79 */
80 (void)__db_pgerr(file_dbp, argp->pgno);
81 (void)memp_fput(mpf, meta, 0);
82 goto out;
83 }
84
85 /* Fix up the allocated page. */
86 modified = 0;
87 cmp_n = log_compare(lsnp, &LSN(pagep));
88 cmp_p = log_compare(&LSN(pagep), &argp->page_lsn);
89 if (cmp_p == 0 && redo) {
90 /* Need to redo update described. */
91 P_INIT(pagep, file_dbp->pgsize,
92 argp->pgno, PGNO_INVALID, PGNO_INVALID, 0, argp->ptype);
93
94 pagep->lsn = *lsnp;
95 modified = 1;
96 } else if (cmp_n == 0 && !redo) {
97 /* Need to undo update described. */
98 P_INIT(pagep, file_dbp->pgsize,
99 argp->pgno, PGNO_INVALID, meta->free, 0, P_INVALID);
100
101 pagep->lsn = argp->page_lsn;
102 modified = 1;
103 }
104 if ((ret = memp_fput(mpf, pagep, modified ? DB_MPOOL_DIRTY : 0)) != 0) {
105 (void)memp_fput(mpf, meta, 0);
106 goto out;
107 }
108
109 /* Fix up the metadata page. */
110 modified = 0;
111 cmp_n = log_compare(lsnp, &LSN(meta));
112 cmp_p = log_compare(&LSN(meta), &argp->meta_lsn);
113 if (cmp_p == 0 && redo) {
114 /* Need to redo update described. */
115 meta->lsn = *lsnp;
116 meta->free = argp->next;
117 modified = 1;
118 } else if (cmp_n == 0 && !redo) {
119 /* Need to undo update described. */
120 meta->lsn = argp->meta_lsn;
121 meta->free = argp->pgno;
122 modified = 1;
123 }
124 if ((ret = memp_fput(mpf, meta, modified ? DB_MPOOL_DIRTY : 0)) != 0)
125 goto out;
126
127 done: *lsnp = argp->prev_lsn;
128 ret = 0;
129
130 out: REC_CLOSE;
131 }
132
133 /*
134 * __bam_pg_free_recover --
135 * Recovery function for pg_free.
136 *
137 * PUBLIC: int __bam_pg_free_recover
138 * PUBLIC: __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
139 */
140 int
__bam_pg_free_recover(logp,dbtp,lsnp,redo,info)141 __bam_pg_free_recover(logp, dbtp, lsnp, redo, info)
142 DB_LOG *logp;
143 DBT *dbtp;
144 DB_LSN *lsnp;
145 int redo;
146 void *info;
147 {
148 __bam_pg_free_args *argp;
149 BTMETA *meta;
150 DB *file_dbp;
151 DBC *dbc;
152 DB_MPOOLFILE *mpf;
153 PAGE *pagep;
154 db_pgno_t pgno;
155 int cmp_n, cmp_p, modified, ret;
156
157 REC_PRINT(__bam_pg_free_print);
158 REC_INTRO(__bam_pg_free_read);
159
160 /*
161 * Fix up the freed page. If we're redoing the operation we get the
162 * page and explicitly discard its contents, then update its LSN. If
163 * we're undoing the operation, we get the page and restore its header.
164 */
165 if ((ret = memp_fget(mpf, &argp->pgno, 0, &pagep)) != 0) {
166 /*
167 * We don't automatically create the page. The only way the
168 * page might not exist is if the alloc never happened, and
169 * the only way the alloc might never have happened is if we
170 * are undoing, in which case there's no reason to create the
171 * page.
172 */
173 if (!redo)
174 goto done;
175 (void)__db_pgerr(file_dbp, argp->pgno);
176 goto out;
177 }
178 modified = 0;
179 cmp_n = log_compare(lsnp, &LSN(pagep));
180 cmp_p = log_compare(&LSN(pagep), &LSN(argp->header.data));
181 if (cmp_p == 0 && redo) {
182 /* Need to redo update described. */
183 P_INIT(pagep, file_dbp->pgsize,
184 pagep->pgno, PGNO_INVALID, argp->next, 0, P_INVALID);
185 pagep->lsn = *lsnp;
186
187 modified = 1;
188 } else if (cmp_n == 0 && !redo) {
189 /* Need to undo update described. */
190 memcpy(pagep, argp->header.data, argp->header.size);
191
192 modified = 1;
193 }
194 if ((ret = memp_fput(mpf, pagep, modified ? DB_MPOOL_DIRTY : 0)) != 0)
195 goto out;
196
197 /*
198 * Fix up the metadata page. If we're redoing or undoing the operation
199 * we get the page and update its LSN and free pointer.
200 */
201 pgno = PGNO_METADATA;
202 if ((ret = memp_fget(mpf, &pgno, 0, &meta)) != 0) {
203 /* The metadata page must always exist. */
204 (void)__db_pgerr(file_dbp, pgno);
205 goto out;
206 }
207
208 modified = 0;
209 cmp_n = log_compare(lsnp, &LSN(meta));
210 cmp_p = log_compare(&LSN(meta), &argp->meta_lsn);
211 if (cmp_p == 0 && redo) {
212 /* Need to redo update described. */
213 meta->free = argp->pgno;
214
215 meta->lsn = *lsnp;
216 modified = 1;
217 } else if (cmp_n == 0 && !redo) {
218 /* Need to undo update described. */
219 meta->free = argp->next;
220
221 meta->lsn = argp->meta_lsn;
222 modified = 1;
223 }
224 if ((ret = memp_fput(mpf, meta, modified ? DB_MPOOL_DIRTY : 0)) != 0)
225 goto out;
226
227 done: *lsnp = argp->prev_lsn;
228 ret = 0;
229
230 out: REC_CLOSE;
231 }
232
233 /*
234 * __bam_split_recover --
235 * Recovery function for split.
236 *
237 * PUBLIC: int __bam_split_recover
238 * PUBLIC: __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
239 */
240 int
__bam_split_recover(logp,dbtp,lsnp,redo,info)241 __bam_split_recover(logp, dbtp, lsnp, redo, info)
242 DB_LOG *logp;
243 DBT *dbtp;
244 DB_LSN *lsnp;
245 int redo;
246 void *info;
247 {
248 __bam_split_args *argp;
249 DB *file_dbp;
250 DBC *dbc;
251 DB_MPOOLFILE *mpf;
252 PAGE *_lp, *lp, *np, *pp, *_rp, *rp, *sp;
253 db_pgno_t pgno;
254 int l_update, p_update, r_update, ret, rootsplit, t_ret;
255
256 REC_PRINT(__bam_split_print);
257
258 mpf = NULL;
259 _lp = lp = np = pp = _rp = rp = NULL;
260
261 REC_INTRO(__bam_split_read);
262
263 /*
264 * There are two kinds of splits that we have to recover from. The
265 * first is a root-page split, where the root page is split from a
266 * leaf page into an internal page and two new leaf pages are created.
267 * The second is where a page is split into two pages, and a new key
268 * is inserted into the parent page.
269 */
270 sp = argp->pg.data;
271 pgno = PGNO(sp);
272 rootsplit = pgno == PGNO_ROOT;
273 if (memp_fget(mpf, &argp->left, 0, &lp) != 0)
274 lp = NULL;
275 if (memp_fget(mpf, &argp->right, 0, &rp) != 0)
276 rp = NULL;
277
278 if (redo) {
279 l_update = r_update = p_update = 0;
280 /*
281 * Decide if we need to resplit the page.
282 *
283 * If this is a root split, then the root has to exist, it's
284 * the page we're splitting and it gets modified. If this is
285 * not a root split, then the left page has to exist, for the
286 * same reason.
287 */
288 if (rootsplit) {
289 if ((ret = memp_fget(mpf, &pgno, 0, &pp)) != 0) {
290 (void)__db_pgerr(file_dbp, pgno);
291 pp = NULL;
292 goto out;
293 }
294 p_update =
295 log_compare(&LSN(pp), &LSN(argp->pg.data)) == 0;
296 } else
297 if (lp == NULL) {
298 (void)__db_pgerr(file_dbp, argp->left);
299 goto out;
300 }
301 if (lp == NULL || log_compare(&LSN(lp), &argp->llsn) == 0)
302 l_update = 1;
303 if (rp == NULL || log_compare(&LSN(rp), &argp->rlsn) == 0)
304 r_update = 1;
305 if (!p_update && !l_update && !r_update)
306 goto done;
307
308 /* Allocate and initialize new left/right child pages. */
309 if ((ret = __os_malloc(file_dbp->pgsize, NULL, &_lp)) != 0 ||
310 (ret = __os_malloc(file_dbp->pgsize, NULL, &_rp)) != 0)
311 goto out;
312 if (rootsplit) {
313 P_INIT(_lp, file_dbp->pgsize, argp->left,
314 PGNO_INVALID,
315 ISINTERNAL(sp) ? PGNO_INVALID : argp->right,
316 LEVEL(sp), TYPE(sp));
317 P_INIT(_rp, file_dbp->pgsize, argp->right,
318 ISINTERNAL(sp) ? PGNO_INVALID : argp->left,
319 PGNO_INVALID, LEVEL(sp), TYPE(sp));
320 } else {
321 P_INIT(_lp, file_dbp->pgsize, PGNO(sp),
322 ISINTERNAL(sp) ? PGNO_INVALID : PREV_PGNO(sp),
323 ISINTERNAL(sp) ? PGNO_INVALID : argp->right,
324 LEVEL(sp), TYPE(sp));
325 P_INIT(_rp, file_dbp->pgsize, argp->right,
326 ISINTERNAL(sp) ? PGNO_INVALID : sp->pgno,
327 ISINTERNAL(sp) ? PGNO_INVALID : NEXT_PGNO(sp),
328 LEVEL(sp), TYPE(sp));
329 }
330
331 /* Split the page. */
332 if ((ret = __bam_copy(file_dbp, sp, _lp, 0, argp->indx)) != 0 ||
333 (ret = __bam_copy(file_dbp, sp, _rp, argp->indx,
334 NUM_ENT(sp))) != 0)
335 goto out;
336
337 /* If the left child is wrong, update it. */
338 if (lp == NULL && (ret =
339 memp_fget(mpf, &argp->left, DB_MPOOL_CREATE, &lp)) != 0) {
340 (void)__db_pgerr(file_dbp, argp->left);
341 lp = NULL;
342 goto out;
343 }
344 if (l_update) {
345 memcpy(lp, _lp, file_dbp->pgsize);
346 lp->lsn = *lsnp;
347 if ((ret = memp_fput(mpf, lp, DB_MPOOL_DIRTY)) != 0)
348 goto out;
349 lp = NULL;
350 }
351
352 /* If the right child is wrong, update it. */
353 if (rp == NULL && (ret = memp_fget(mpf,
354 &argp->right, DB_MPOOL_CREATE, &rp)) != 0) {
355 (void)__db_pgerr(file_dbp, argp->right);
356 rp = NULL;
357 goto out;
358 }
359 if (r_update) {
360 memcpy(rp, _rp, file_dbp->pgsize);
361 rp->lsn = *lsnp;
362 if ((ret = memp_fput(mpf, rp, DB_MPOOL_DIRTY)) != 0)
363 goto out;
364 rp = NULL;
365 }
366
367 /*
368 * If the parent page is wrong, update it. This is of interest
369 * only if it was a root split, since root splits create parent
370 * pages. All other splits modify a parent page, but those are
371 * separately logged and recovered.
372 */
373 if (rootsplit && p_update) {
374 if (file_dbp->type == DB_BTREE)
375 P_INIT(pp, file_dbp->pgsize,
376 PGNO_ROOT, PGNO_INVALID, PGNO_INVALID,
377 _lp->level + 1, P_IBTREE);
378 else
379 P_INIT(pp, file_dbp->pgsize,
380 PGNO_ROOT, PGNO_INVALID, PGNO_INVALID,
381 _lp->level + 1, P_IRECNO);
382 RE_NREC_SET(pp,
383 file_dbp->type == DB_RECNO ||
384 F_ISSET(file_dbp, DB_BT_RECNUM) ?
385 __bam_total(_lp) + __bam_total(_rp) : 0);
386 pp->lsn = *lsnp;
387 if ((ret = memp_fput(mpf, pp, DB_MPOOL_DIRTY)) != 0)
388 goto out;
389 pp = NULL;
390 }
391
392 /*
393 * Finally, redo the next-page link if necessary. This is of
394 * interest only if it wasn't a root split -- inserting a new
395 * page in the tree requires that any following page have its
396 * previous-page pointer updated to our new page. The next
397 * page must exist because we're redoing the operation.
398 */
399 if (!rootsplit && !IS_ZERO_LSN(argp->nlsn)) {
400 if ((ret = memp_fget(mpf, &argp->npgno, 0, &np)) != 0) {
401 (void)__db_pgerr(file_dbp, argp->npgno);
402 np = NULL;
403 goto out;
404 }
405 if (log_compare(&LSN(np), &argp->nlsn) == 0) {
406 PREV_PGNO(np) = argp->right;
407 np->lsn = *lsnp;
408 if ((ret =
409 memp_fput(mpf, np, DB_MPOOL_DIRTY)) != 0)
410 goto out;
411 np = NULL;
412 }
413 }
414 } else {
415 /*
416 * If the split page is wrong, replace its contents with the
417 * logged page contents. If the page doesn't exist, it means
418 * that the create of the page never happened, nor did any of
419 * the adds onto the page that caused the split, and there's
420 * really no undo-ing to be done.
421 */
422 if ((ret = memp_fget(mpf, &pgno, 0, &pp)) != 0) {
423 pp = NULL;
424 goto lrundo;
425 }
426 if (log_compare(lsnp, &LSN(pp)) == 0) {
427 memcpy(pp, argp->pg.data, argp->pg.size);
428 if ((ret = memp_fput(mpf, pp, DB_MPOOL_DIRTY)) != 0)
429 goto out;
430 pp = NULL;
431 }
432
433 /*
434 * If it's a root split and the left child ever existed, update
435 * its LSN. (If it's not a root split, we've updated the left
436 * page already -- it's the same as the split page.) If the
437 * right child ever existed, root split or not, update its LSN.
438 * The undo of the page allocation(s) will restore them to the
439 * free list.
440 */
441 lrundo: if ((rootsplit && lp != NULL) || rp != NULL) {
442 if (rootsplit && lp != NULL &&
443 log_compare(lsnp, &LSN(lp)) == 0) {
444 lp->lsn = argp->llsn;
445 if ((ret =
446 memp_fput(mpf, lp, DB_MPOOL_DIRTY)) != 0)
447 goto out;
448 lp = NULL;
449 }
450 if (rp != NULL &&
451 log_compare(lsnp, &LSN(rp)) == 0) {
452 rp->lsn = argp->rlsn;
453 if ((ret =
454 memp_fput(mpf, rp, DB_MPOOL_DIRTY)) != 0)
455 goto out;
456 rp = NULL;
457 }
458 }
459
460 /*
461 * Finally, undo the next-page link if necessary. This is of
462 * interest only if it wasn't a root split -- inserting a new
463 * page in the tree requires that any following page have its
464 * previous-page pointer updated to our new page. Since it's
465 * possible that the next-page never existed, we ignore it as
466 * if there's nothing to undo.
467 */
468 if (!rootsplit && !IS_ZERO_LSN(argp->nlsn)) {
469 if ((ret = memp_fget(mpf, &argp->npgno, 0, &np)) != 0) {
470 np = NULL;
471 goto done;
472 }
473 if (log_compare(lsnp, &LSN(np)) == 0) {
474 PREV_PGNO(np) = argp->left;
475 np->lsn = argp->nlsn;
476 if (memp_fput(mpf, np, DB_MPOOL_DIRTY))
477 goto out;
478 np = NULL;
479 }
480 }
481 }
482
483 done: *lsnp = argp->prev_lsn;
484 ret = 0;
485
486 out: /* Free any pages that weren't dirtied. */
487 if (pp != NULL && (t_ret = memp_fput(mpf, pp, 0)) != 0 && ret == 0)
488 ret = t_ret;
489 if (lp != NULL && (t_ret = memp_fput(mpf, lp, 0)) != 0 && ret == 0)
490 ret = t_ret;
491 if (np != NULL && (t_ret = memp_fput(mpf, np, 0)) != 0 && ret == 0)
492 ret = t_ret;
493 if (rp != NULL && (t_ret = memp_fput(mpf, rp, 0)) != 0 && ret == 0)
494 ret = t_ret;
495
496 /* Free any allocated space. */
497 if (_lp != NULL)
498 __os_free(_lp, file_dbp->pgsize);
499 if (_rp != NULL)
500 __os_free(_rp, file_dbp->pgsize);
501
502 REC_CLOSE;
503 }
504
505 /*
506 * __bam_rsplit_recover --
507 * Recovery function for a reverse split.
508 *
509 * PUBLIC: int __bam_rsplit_recover
510 * PUBLIC: __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
511 */
512 int
__bam_rsplit_recover(logp,dbtp,lsnp,redo,info)513 __bam_rsplit_recover(logp, dbtp, lsnp, redo, info)
514 DB_LOG *logp;
515 DBT *dbtp;
516 DB_LSN *lsnp;
517 int redo;
518 void *info;
519 {
520 __bam_rsplit_args *argp;
521 DB *file_dbp;
522 DBC *dbc;
523 DB_MPOOLFILE *mpf;
524 PAGE *pagep;
525 db_pgno_t pgno;
526 int cmp_n, cmp_p, modified, ret;
527
528 REC_PRINT(__bam_rsplit_print);
529 REC_INTRO(__bam_rsplit_read);
530
531 /* Fix the root page. */
532 pgno = PGNO_ROOT;
533 if ((ret = memp_fget(mpf, &pgno, 0, &pagep)) != 0) {
534 /* The root page must always exist. */
535 __db_pgerr(file_dbp, pgno);
536 goto out;
537 }
538 modified = 0;
539 cmp_n = log_compare(lsnp, &LSN(pagep));
540 cmp_p = log_compare(&LSN(pagep), &argp->rootlsn);
541 if (cmp_p == 0 && redo) {
542 /* Need to redo update described. */
543 memcpy(pagep, argp->pgdbt.data, argp->pgdbt.size);
544 pagep->pgno = PGNO_ROOT;
545 pagep->lsn = *lsnp;
546 modified = 1;
547 } else if (cmp_n == 0 && !redo) {
548 /* Need to undo update described. */
549 P_INIT(pagep, file_dbp->pgsize, PGNO_ROOT,
550 argp->nrec, PGNO_INVALID, pagep->level + 1,
551 file_dbp->type == DB_BTREE ? P_IBTREE : P_IRECNO);
552 if ((ret = __db_pitem(dbc, pagep, 0,
553 argp->rootent.size, &argp->rootent, NULL)) != 0)
554 goto out;
555 pagep->lsn = argp->rootlsn;
556 modified = 1;
557 }
558 if ((ret = memp_fput(mpf, pagep, modified ? DB_MPOOL_DIRTY : 0)) != 0)
559 goto out;
560
561 /*
562 * Fix the page copied over the root page. It's possible that the
563 * page never made it to disk, so if we're undo-ing and the page
564 * doesn't exist, it's okay and there's nothing further to do.
565 */
566 if ((ret = memp_fget(mpf, &argp->pgno, 0, &pagep)) != 0) {
567 if (!redo)
568 goto done;
569 (void)__db_pgerr(file_dbp, argp->pgno);
570 goto out;
571 }
572 modified = 0;
573 cmp_n = log_compare(lsnp, &LSN(pagep));
574 cmp_p = log_compare(&LSN(pagep), &LSN(argp->pgdbt.data));
575 if (cmp_p == 0 && redo) {
576 /* Need to redo update described. */
577 pagep->lsn = *lsnp;
578 modified = 1;
579 } else if (cmp_n == 0 && !redo) {
580 /* Need to undo update described. */
581 memcpy(pagep, argp->pgdbt.data, argp->pgdbt.size);
582 modified = 1;
583 }
584 if ((ret = memp_fput(mpf, pagep, modified ? DB_MPOOL_DIRTY : 0)) != 0)
585 goto out;
586
587 done: *lsnp = argp->prev_lsn;
588 ret = 0;
589
590 out: REC_CLOSE;
591 }
592
593 /*
594 * __bam_adj_recover --
595 * Recovery function for adj.
596 *
597 * PUBLIC: int __bam_adj_recover
598 * PUBLIC: __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
599 */
600 int
__bam_adj_recover(logp,dbtp,lsnp,redo,info)601 __bam_adj_recover(logp, dbtp, lsnp, redo, info)
602 DB_LOG *logp;
603 DBT *dbtp;
604 DB_LSN *lsnp;
605 int redo;
606 void *info;
607 {
608 __bam_adj_args *argp;
609 DB *file_dbp;
610 DBC *dbc;
611 DB_MPOOLFILE *mpf;
612 PAGE *pagep;
613 int cmp_n, cmp_p, modified, ret;
614
615 REC_PRINT(__bam_adj_print);
616 REC_INTRO(__bam_adj_read);
617
618 /* Get the page; if it never existed and we're undoing, we're done. */
619 if ((ret = memp_fget(mpf, &argp->pgno, 0, &pagep)) != 0) {
620 if (!redo)
621 goto done;
622 (void)__db_pgerr(file_dbp, argp->pgno);
623 goto out;
624 }
625
626 modified = 0;
627 cmp_n = log_compare(lsnp, &LSN(pagep));
628 cmp_p = log_compare(&LSN(pagep), &argp->lsn);
629 if (cmp_p == 0 && redo) {
630 /* Need to redo update described. */
631 if ((ret = __bam_adjindx(dbc,
632 pagep, argp->indx, argp->indx_copy, argp->is_insert)) != 0)
633 goto err;
634
635 LSN(pagep) = *lsnp;
636 modified = 1;
637 } else if (cmp_n == 0 && !redo) {
638 /* Need to undo update described. */
639 if ((ret = __bam_adjindx(dbc,
640 pagep, argp->indx, argp->indx_copy, !argp->is_insert)) != 0)
641 goto err;
642
643 LSN(pagep) = argp->lsn;
644 modified = 1;
645 }
646 if ((ret = memp_fput(mpf, pagep, modified ? DB_MPOOL_DIRTY : 0)) != 0)
647 goto out;
648
649 done: *lsnp = argp->prev_lsn;
650 ret = 0;
651
652 if (0) {
653 err: (void)memp_fput(mpf, pagep, 0);
654 }
655 out: REC_CLOSE;
656 }
657
658 /*
659 * __bam_cadjust_recover --
660 * Recovery function for the adjust of a count change in an internal
661 * page.
662 *
663 * PUBLIC: int __bam_cadjust_recover
664 * PUBLIC: __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
665 */
666 int
__bam_cadjust_recover(logp,dbtp,lsnp,redo,info)667 __bam_cadjust_recover(logp, dbtp, lsnp, redo, info)
668 DB_LOG *logp;
669 DBT *dbtp;
670 DB_LSN *lsnp;
671 int redo;
672 void *info;
673 {
674 __bam_cadjust_args *argp;
675 DB *file_dbp;
676 DBC *dbc;
677 DB_MPOOLFILE *mpf;
678 PAGE *pagep;
679 int cmp_n, cmp_p, modified, ret;
680
681 REC_PRINT(__bam_cadjust_print);
682 REC_INTRO(__bam_cadjust_read);
683
684 /* Get the page; if it never existed and we're undoing, we're done. */
685 if ((ret = memp_fget(mpf, &argp->pgno, 0, &pagep)) != 0) {
686 if (!redo)
687 goto done;
688 (void)__db_pgerr(file_dbp, argp->pgno);
689 goto out;
690 }
691
692 modified = 0;
693 cmp_n = log_compare(lsnp, &LSN(pagep));
694 cmp_p = log_compare(&LSN(pagep), &argp->lsn);
695 if (cmp_p == 0 && redo) {
696 /* Need to redo update described. */
697 if (file_dbp->type == DB_BTREE &&
698 F_ISSET(file_dbp, DB_BT_RECNUM)) {
699 GET_BINTERNAL(pagep, argp->indx)->nrecs += argp->adjust;
700 if (argp->total && PGNO(pagep) == PGNO_ROOT)
701 RE_NREC_ADJ(pagep, argp->adjust);
702 }
703 if (file_dbp->type == DB_RECNO) {
704 GET_RINTERNAL(pagep, argp->indx)->nrecs += argp->adjust;
705 if (argp->total && PGNO(pagep) == PGNO_ROOT)
706 RE_NREC_ADJ(pagep, argp->adjust);
707 }
708
709 LSN(pagep) = *lsnp;
710 modified = 1;
711 } else if (cmp_n == 0 && !redo) {
712 /* Need to undo update described. */
713 if (file_dbp->type == DB_BTREE &&
714 F_ISSET(file_dbp, DB_BT_RECNUM)) {
715 GET_BINTERNAL(pagep, argp->indx)->nrecs -= argp->adjust;
716 if (argp->total && PGNO(pagep) == PGNO_ROOT)
717 RE_NREC_ADJ(pagep, argp->adjust);
718 }
719 if (file_dbp->type == DB_RECNO) {
720 GET_RINTERNAL(pagep, argp->indx)->nrecs -= argp->adjust;
721 if (argp->total && PGNO(pagep) == PGNO_ROOT)
722 RE_NREC_ADJ(pagep, -(argp->adjust));
723 }
724 LSN(pagep) = argp->lsn;
725 modified = 1;
726 }
727 if ((ret = memp_fput(mpf, pagep, modified ? DB_MPOOL_DIRTY : 0)) != 0)
728 goto out;
729
730 done: *lsnp = argp->prev_lsn;
731 ret = 0;
732
733 out: REC_CLOSE;
734 }
735
736 /*
737 * __bam_cdel_recover --
738 * Recovery function for the intent-to-delete of a cursor record.
739 *
740 * PUBLIC: int __bam_cdel_recover
741 * PUBLIC: __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
742 */
743 int
__bam_cdel_recover(logp,dbtp,lsnp,redo,info)744 __bam_cdel_recover(logp, dbtp, lsnp, redo, info)
745 DB_LOG *logp;
746 DBT *dbtp;
747 DB_LSN *lsnp;
748 int redo;
749 void *info;
750 {
751 __bam_cdel_args *argp;
752 DB *file_dbp;
753 DBC *dbc;
754 DB_MPOOLFILE *mpf;
755 PAGE *pagep;
756 int cmp_n, cmp_p, modified, ret;
757
758 REC_PRINT(__bam_cdel_print);
759 REC_INTRO(__bam_cdel_read);
760
761 /* Get the page; if it never existed and we're undoing, we're done. */
762 if ((ret = memp_fget(mpf, &argp->pgno, 0, &pagep)) != 0) {
763 if (!redo)
764 goto done;
765 (void)__db_pgerr(file_dbp, argp->pgno);
766 goto out;
767 }
768
769 modified = 0;
770 cmp_n = log_compare(lsnp, &LSN(pagep));
771 cmp_p = log_compare(&LSN(pagep), &argp->lsn);
772 if (cmp_p == 0 && redo) {
773 /* Need to redo update described. */
774 if (pagep->type == P_DUPLICATE)
775 B_DSET(GET_BKEYDATA(pagep, argp->indx)->type);
776 else
777 B_DSET(GET_BKEYDATA(pagep, argp->indx + O_INDX)->type);
778
779 LSN(pagep) = *lsnp;
780 modified = 1;
781 } else if (cmp_n == 0 && !redo) {
782 /* Need to undo update described. */
783 if (pagep->type == P_DUPLICATE)
784 B_DCLR(GET_BKEYDATA(pagep, argp->indx)->type);
785 else
786 B_DCLR(GET_BKEYDATA(pagep, argp->indx + O_INDX)->type);
787
788 LSN(pagep) = argp->lsn;
789 modified = 1;
790 }
791 if ((ret = memp_fput(mpf, pagep, modified ? DB_MPOOL_DIRTY : 0)) != 0)
792 goto out;
793
794 done: *lsnp = argp->prev_lsn;
795 ret = 0;
796
797 out: REC_CLOSE;
798 }
799
800 /*
801 * __bam_repl_recover --
802 * Recovery function for page item replacement.
803 *
804 * PUBLIC: int __bam_repl_recover
805 * PUBLIC: __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
806 */
807 int
__bam_repl_recover(logp,dbtp,lsnp,redo,info)808 __bam_repl_recover(logp, dbtp, lsnp, redo, info)
809 DB_LOG *logp;
810 DBT *dbtp;
811 DB_LSN *lsnp;
812 int redo;
813 void *info;
814 {
815 __bam_repl_args *argp;
816 BKEYDATA *bk;
817 DB *file_dbp;
818 DBC *dbc;
819 DBT dbt;
820 DB_MPOOLFILE *mpf;
821 PAGE *pagep;
822 int cmp_n, cmp_p, modified, ret;
823 u_int8_t *p;
824
825 REC_PRINT(__bam_repl_print);
826 REC_INTRO(__bam_repl_read);
827
828 /* Get the page; if it never existed and we're undoing, we're done. */
829 if ((ret = memp_fget(mpf, &argp->pgno, 0, &pagep)) != 0) {
830 if (!redo)
831 goto done;
832 (void)__db_pgerr(file_dbp, argp->pgno);
833 goto out;
834 }
835 bk = GET_BKEYDATA(pagep, argp->indx);
836
837 modified = 0;
838 cmp_n = log_compare(lsnp, &LSN(pagep));
839 cmp_p = log_compare(&LSN(pagep), &argp->lsn);
840 if (cmp_p == 0 && redo) {
841 /*
842 * Need to redo update described.
843 *
844 * Re-build the replacement item.
845 */
846 memset(&dbt, 0, sizeof(dbt));
847 dbt.size = argp->prefix + argp->suffix + argp->repl.size;
848 if ((ret = __os_malloc(dbt.size, NULL, &dbt.data)) != 0)
849 goto err;
850 p = dbt.data;
851 memcpy(p, bk->data, argp->prefix);
852 p += argp->prefix;
853 memcpy(p, argp->repl.data, argp->repl.size);
854 p += argp->repl.size;
855 memcpy(p, bk->data + (bk->len - argp->suffix), argp->suffix);
856
857 ret = __bam_ritem(dbc, pagep, argp->indx, &dbt);
858 __os_free(dbt.data, dbt.size);
859 if (ret != 0)
860 goto err;
861
862 LSN(pagep) = *lsnp;
863 modified = 1;
864 } else if (cmp_n == 0 && !redo) {
865 /*
866 * Need to undo update described.
867 *
868 * Re-build the original item.
869 */
870 memset(&dbt, 0, sizeof(dbt));
871 dbt.size = argp->prefix + argp->suffix + argp->orig.size;
872 if ((ret = __os_malloc(dbt.size, NULL, &dbt.data)) != 0)
873 goto err;
874 p = dbt.data;
875 memcpy(p, bk->data, argp->prefix);
876 p += argp->prefix;
877 memcpy(p, argp->orig.data, argp->orig.size);
878 p += argp->orig.size;
879 memcpy(p, bk->data + (bk->len - argp->suffix), argp->suffix);
880
881 ret = __bam_ritem(dbc, pagep, argp->indx, &dbt);
882 __os_free(dbt.data, dbt.size);
883 if (ret != 0)
884 goto err;
885
886 /* Reset the deleted flag, if necessary. */
887 if (argp->isdeleted)
888 B_DSET(GET_BKEYDATA(pagep, argp->indx)->type);
889
890 LSN(pagep) = argp->lsn;
891 modified = 1;
892 }
893 if ((ret = memp_fput(mpf, pagep, modified ? DB_MPOOL_DIRTY : 0)) != 0)
894 goto out;
895
896 done: *lsnp = argp->prev_lsn;
897 ret = 0;
898
899 if (0) {
900 err: (void)memp_fput(mpf, pagep, 0);
901 }
902 out: REC_CLOSE;
903 }
904