db2/db/db_dup.c

   1 /*-
   2  * See the file LICENSE for redistribution information.
   3  *
   4  * Copyright (c) 1996, 1997
   5  *      Sleepycat Software.  All rights reserved.
   6  */
   7
   8 #include "config.h"
   9
  10 #ifndef lint
  11 static const char sccsid[] = "@(#)db_dup.c      10.10 (Sleepycat) 10/25/97";
  12 #endif /* not lint */
  13
  14 #ifndef NO_SYSTEM_INCLUDES
  15 #include <sys/types.h>
  16 #include <sys/stat.h>
  17
  18 #include <errno.h>
  19 #include <fcntl.h>
  20 #include <stddef.h>
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <unistd.h>
  25 #endif
  26
  27 #include "db_int.h"
  28 #include "db_page.h"
  29 #include "db_swap.h"
  30 #include "btree.h"
  31 #include "db_am.h"
  32 #include "common_ext.h"
  33
  34 static int __db_addpage __P((DB *,
  35     PAGE **, db_indx_t *, int (*)(DB *, u_int32_t, PAGE **)));
  36 static int __db_dsplit __P((DB *,
  37     PAGE **, db_indx_t *, u_int32_t, int (*)(DB *, u_int32_t, PAGE **)));
  38
  39 /*
  40  * __db_dput --
  41  *      Put a duplicate item onto a duplicate page at the given index.
  42  *
  43  * PUBLIC: int __db_dput __P((DB *,
  44  * PUBLIC:    DBT *, PAGE **, db_indx_t *, int (*)(DB *, u_int32_t, PAGE **)));
  45  */
  46 int
  47 __db_dput(dbp, dbt, pp, indxp, newfunc)
  48         DB *dbp;
  49         DBT *dbt;
  50         PAGE **pp;
  51         db_indx_t *indxp;
  52         int (*newfunc) __P((DB *, u_int32_t, PAGE **));
  53 {
  54         BOVERFLOW bo;
  55         DBT *data_dbtp, hdr_dbt, *hdr_dbtp;
  56         PAGE *pagep;
  57         db_indx_t size, isize;
  58         db_pgno_t pgno;
  59         int ret;
  60
  61         /*
  62          * We need some access method independent threshold for when we put
  63          * a duplicate item onto an overflow page.
  64          */
  65         if (dbt->size > 0.25 * dbp->pgsize) {
  66                 if ((ret = __db_poff(dbp, dbt, &pgno, newfunc)) != 0)
  67                         return (ret);
  68                 B_TSET(bo.type, B_OVERFLOW, 0);
  69                 bo.tlen = dbt->size;
  70                 bo.pgno = pgno;
  71                 hdr_dbt.data = &bo;
  72                 hdr_dbt.size = isize = BOVERFLOW_SIZE;
  73                 hdr_dbtp = &hdr_dbt;
  74                 size = BOVERFLOW_PSIZE;
  75                 data_dbtp = NULL;
  76         } else {
  77                 size = BKEYDATA_PSIZE(dbt->size);
  78                 isize = BKEYDATA_SIZE(dbt->size);
  79                 hdr_dbtp = NULL;
  80                 data_dbtp = dbt;
  81         }
  82
  83         pagep = *pp;
  84         if (size > P_FREESPACE(pagep)) {
  85                 if (*indxp == NUM_ENT(*pp) && NEXT_PGNO(*pp) == PGNO_INVALID)
  86                         ret = __db_addpage(dbp, pp, indxp, newfunc);
  87                 else
  88                         ret = __db_dsplit(dbp, pp, indxp, isize, newfunc);
  89                 if (ret != 0)
  90                         /* XXX: Pages not returned to free list. */
  91                         return (ret);
  92                 pagep = *pp;
  93         }
  94
  95         /*
  96          * Now, pagep references the page on which to insert and indx is the
  97          * the location to insert.
  98          */
  99         if ((ret = __db_pitem(dbp,
 100             pagep, (u_int32_t)*indxp, isize, hdr_dbtp, data_dbtp)) != 0)
 101                 return (ret);
 102
 103         (void)memp_fset(dbp->mpf, pagep, DB_MPOOL_DIRTY);
 104         return (0);
 105 }
 106
 107 /*
 108  * __db_drem --
 109  *      Remove a duplicate at the given index on the given page.
 110  *
 111  * PUBLIC: int __db_drem __P((DB *,
 112  * PUBLIC:    PAGE **, u_int32_t, int (*)(DB *, PAGE *)));
 113  */
 114 int
 115 __db_drem(dbp, pp, indx, freefunc)
 116         DB *dbp;
 117         PAGE **pp;
 118         u_int32_t indx;
 119         int (*freefunc) __P((DB *, PAGE *));
 120 {
 121         PAGE *pagep;
 122         int ret;
 123
 124         pagep = *pp;
 125
 126         /* Check if we are freeing a big item. */
 127         if (B_TYPE(GET_BKEYDATA(pagep, indx)->type) == B_OVERFLOW) {
 128                 if ((ret = __db_doff(dbp,
 129                     GET_BOVERFLOW(pagep, indx)->pgno, freefunc)) != 0)
 130                         return (ret);
 131                 ret = __db_ditem(dbp, pagep, indx, BOVERFLOW_SIZE);
 132         } else
 133                 ret = __db_ditem(dbp, pagep, indx,
 134                     BKEYDATA_SIZE(GET_BKEYDATA(pagep, indx)->len));
 135         if (ret != 0)
 136                 return (ret);
 137
 138         if (NUM_ENT(pagep) == 0) {
 139                 /*
 140                  * If the page is emptied, then the page is freed and the pp
 141                  * parameter is set to reference the next, locked page in the
 142                  * duplicate chain, if one exists.  If there was no such page,
 143                  * then it is set to NULL.
 144                  *
 145                  * !!!
 146                  * __db_relink will set the dirty bit for us.
 147                  */
 148                 if ((ret = __db_relink(dbp, pagep, pp, 0)) != 0)
 149                         return (ret);
 150                 if ((ret = freefunc(dbp, pagep)) != 0)
 151                         return (ret);
 152         } else
 153                 (void)memp_fset(dbp->mpf, pagep, DB_MPOOL_DIRTY);
 154
 155         return (0);
 156 }
 157
 158 /*
 159  * __db_dend --
 160  *      Find the last page in a set of offpage duplicates.
 161  *
 162  * PUBLIC: int __db_dend __P((DB *, db_pgno_t, PAGE **));
 163  */
 164 int
 165 __db_dend(dbp, pgno, pagep)
 166         DB *dbp;
 167         db_pgno_t pgno;
 168         PAGE **pagep;
 169 {
 170         PAGE *h;
 171         int ret;
 172
 173         /*
 174          * This implements DB_KEYLAST.  The last page is returned in pp; pgno
 175          * should be the page number of the first page of the duplicate chain.
 176          */
 177         for (;;) {
 178                 if ((ret = memp_fget(dbp->mpf, &pgno, 0, &h)) != 0) {
 179                         (void)__db_pgerr(dbp, pgno);
 180                         return (ret);
 181                 }
 182                 if ((pgno = NEXT_PGNO(h)) == PGNO_INVALID)
 183                         break;
 184                 (void)memp_fput(dbp->mpf, h, 0);
 185         }
 186
 187         *pagep = h;
 188         return (0);
 189 }
 190
 191 /*
 192  * __db_dsplit --
 193  *      Split a page of duplicates, calculating the split point based
 194  *      on an element of size "size" being added at "*indxp".
 195  *      On entry hp contains a pointer to the page-pointer of the original
 196  *      page.  On exit, it returns a pointer to the page containing "*indxp"
 197  *      and "indxp" has been modified to reflect the index on the new page
 198  *      where the element should be added.  The function returns with
 199  *      the page on which the insert should happen, not yet put.
 200  */
 201 static int
 202 __db_dsplit(dbp, hp, indxp, size, newfunc)
 203         DB *dbp;
 204         PAGE **hp;
 205         db_indx_t *indxp;
 206         u_int32_t size;
 207         int (*newfunc) __P((DB *, u_int32_t, PAGE **));
 208 {
 209         PAGE *h, *np, *tp;
 210         BKEYDATA *bk;
 211         DBT page_dbt;
 212         db_indx_t indx, nindex, oindex, sum;
 213         db_indx_t halfbytes, i, lastsum;
 214         int did_indx, ret, s;
 215
 216         h = *hp;
 217         indx = *indxp;
 218
 219         /* Create a temporary page to do compaction onto. */
 220         if ((tp = (PAGE *)__db_malloc(dbp->pgsize)) == NULL)
 221                 return (ENOMEM);
 222 #ifdef DEBUG
 223         memset(tp, 0xff, dbp->pgsize);
 224 #endif
 225         /* Create new page for the split. */
 226         if ((ret = newfunc(dbp, P_DUPLICATE, &np)) != 0) {
 227                 FREE(tp, dbp->pgsize);
 228                 return (ret);
 229         }
 230
 231         P_INIT(np, dbp->pgsize, PGNO(np), PGNO(h), NEXT_PGNO(h), 0,
 232             P_DUPLICATE);
 233         P_INIT(tp, dbp->pgsize, PGNO(h), PREV_PGNO(h), PGNO(np), 0,
 234             P_DUPLICATE);
 235
 236         /* Figure out the split point */
 237         halfbytes = (dbp->pgsize - HOFFSET(h)) / 2;
 238         did_indx = 0;
 239         for (sum = 0, lastsum = 0, i = 0; i < NUM_ENT(h); i++) {
 240                 if (i == indx) {
 241                         sum += size;
 242                         if (lastsum < halfbytes && sum >= halfbytes) {
 243                                 /* We've crossed the halfway point. */
 244                                 if ((db_indx_t)(halfbytes - lastsum) <
 245                                     (db_indx_t)(sum - halfbytes)) {
 246                                         *hp = np;
 247                                         *indxp = 0;
 248                                         i--;
 249                                 } else
 250                                         *indxp = i;
 251                                 break;
 252                         }
 253                         *indxp = i;
 254                         lastsum = sum;
 255                         did_indx = 1;
 256                 }
 257                 if (B_TYPE(GET_BKEYDATA(h, i)->type) == B_KEYDATA)
 258                         sum += BKEYDATA_SIZE(GET_BKEYDATA(h, i)->len);
 259                 else
 260                         sum += BOVERFLOW_SIZE;
 261
 262                 if (lastsum < halfbytes && sum >= halfbytes) {
 263                         /* We've crossed the halfway point. */
 264                         if ((db_indx_t)(halfbytes - lastsum) <
 265                             (db_indx_t)(sum - halfbytes))
 266                                 i--;
 267                         break;
 268                 }
 269         }
 270
 271         /*
 272          * Check if we have set the return values of the index pointer and
 273          * page pointer.
 274          */
 275         if (!did_indx) {
 276                 *hp = np;
 277                 *indxp = indx - i - 1;
 278         }
 279
 280         if (DB_LOGGING(dbp)) {
 281                 page_dbt.size = dbp->pgsize;
 282                 page_dbt.data = h;
 283                 if ((ret = __db_split_log(dbp->dbenv->lg_info,
 284                     dbp->txn, &LSN(h), 0, DB_SPLITOLD, dbp->log_fileid,
 285                     PGNO(h), &page_dbt, &LSN(h))) != 0) {
 286                         FREE(tp, dbp->pgsize);
 287                         return (ret);
 288                 }
 289                 LSN(tp) = LSN(h);
 290         }
 291
 292         /*
 293          * If it's a btree, adjust the cursors.
 294          *
 295          * i is the index of the last element to stay on the page.
 296          */
 297         if (dbp->type == DB_BTREE || dbp->type == DB_RECNO)
 298                 __bam_ca_split(dbp, PGNO(h), PGNO(h), PGNO(np), i + 1, 0);
 299
 300         for (nindex = 0, oindex = i + 1; oindex < NUM_ENT(h); oindex++) {
 301                 bk = GET_BKEYDATA(h, oindex);
 302                 if (B_TYPE(bk->type) == B_KEYDATA)
 303                         s = BKEYDATA_SIZE(bk->len);
 304                 else
 305                         s = BOVERFLOW_SIZE;
 306
 307                 np->inp[nindex++] = HOFFSET(np) -= s;
 308                 memcpy((u_int8_t *)np + HOFFSET(np), bk, s);
 309                 NUM_ENT(np)++;
 310         }
 311
 312         /*
 313          * Now do data compaction by copying the remaining stuff onto the
 314          * temporary page and then copying it back to the real page.
 315          */
 316         for (nindex = 0, oindex = 0; oindex <= i; oindex++) {
 317                 bk = GET_BKEYDATA(h, oindex);
 318                 if (B_TYPE(bk->type) == B_KEYDATA)
 319                         s = BKEYDATA_SIZE(bk->len);
 320                 else
 321                         s = BOVERFLOW_SIZE;
 322
 323                 tp->inp[nindex++] = HOFFSET(tp) -= s;
 324                 memcpy((u_int8_t *)tp + HOFFSET(tp), bk, s);
 325                 NUM_ENT(tp)++;
 326         }
 327
 328         /*
 329          * This page (the temporary) should be only half full, so we do two
 330          * memcpy's, one for the top of the page and one for the bottom of
 331          * the page.  This way we avoid copying the middle which should be
 332          * about half a page.
 333          */
 334         memcpy(h, tp, LOFFSET(tp));
 335         memcpy((u_int8_t *)h + HOFFSET(tp),
 336             (u_int8_t *)tp + HOFFSET(tp), dbp->pgsize - HOFFSET(tp));
 337         FREE(tp, dbp->pgsize);
 338
 339         if (DB_LOGGING(dbp)) {
 340                 page_dbt.size = dbp->pgsize;
 341                 page_dbt.data = h;
 342                 if ((ret = __db_split_log(dbp->dbenv->lg_info,
 343                     dbp->txn, &LSN(h), 0, DB_SPLITNEW, dbp->log_fileid,
 344                     PGNO(h), &page_dbt, &LSN(h))) != 0)
 345                         return (ret);
 346
 347                 page_dbt.size = dbp->pgsize;
 348                 page_dbt.data = np;
 349                 if ((ret = __db_split_log(dbp->dbenv->lg_info,
 350                     dbp->txn, &LSN(np), 0, DB_SPLITNEW, dbp->log_fileid,
 351                     PGNO(np),  &page_dbt, &LSN(np))) != 0)
 352                         return (ret);
 353         }
 354
 355         /*
 356          * Figure out if the location we're interested in is on the new
 357          * page, and if so, reset the callers' pointer.  Push the other
 358          * page back to the store.
 359          */
 360         if (*hp == h)
 361                 ret = memp_fput(dbp->mpf, np, DB_MPOOL_DIRTY);
 362         else
 363                 ret = memp_fput(dbp->mpf, h, DB_MPOOL_DIRTY);
 364
 365         return (ret);
 366 }
 367
 368 /*
 369  * __db_ditem --
 370  *      Remove an item from a page.
 371  *
 372  * PUBLIC:  int __db_ditem __P((DB *, PAGE *, int, u_int32_t));
 373  */
 374 int
 375 __db_ditem(dbp, pagep, indx, nbytes)
 376         DB *dbp;
 377         PAGE *pagep;
 378         int indx;
 379         u_int32_t nbytes;
 380 {
 381         DBT ldbt;
 382         db_indx_t cnt, offset;
 383         int ret;
 384         u_int8_t *from;
 385
 386         if (DB_LOGGING(dbp)) {
 387                 ldbt.data = P_ENTRY(pagep, indx);
 388                 ldbt.size = nbytes;
 389                 if ((ret = __db_addrem_log(dbp->dbenv->lg_info, dbp->txn,
 390                     &LSN(pagep), 0, DB_REM_DUP, dbp->log_fileid, PGNO(pagep),
 391                     (u_int32_t)indx, nbytes, &ldbt, NULL, &LSN(pagep))) != 0)
 392                         return (ret);
 393         }
 394
 395         /*
 396          * If there's only a single item on the page, we don't have to
 397          * work hard.
 398          */
 399         if (NUM_ENT(pagep) == 1) {
 400                 NUM_ENT(pagep) = 0;
 401                 HOFFSET(pagep) = dbp->pgsize;
 402                 return (0);
 403         }
 404
 405         /*
 406          * Pack the remaining key/data items at the end of the page.  Use
 407          * memmove(3), the regions may overlap.
 408          */
 409         from = (u_int8_t *)pagep + HOFFSET(pagep);
 410         memmove(from + nbytes, from, pagep->inp[indx] - HOFFSET(pagep));
 411         HOFFSET(pagep) += nbytes;
 412
 413         /* Adjust the indices' offsets. */
 414         offset = pagep->inp[indx];
 415         for (cnt = 0; cnt < NUM_ENT(pagep); ++cnt)
 416                 if (pagep->inp[cnt] < offset)
 417                         pagep->inp[cnt] += nbytes;
 418
 419         /* Shift the indices down. */
 420         --NUM_ENT(pagep);
 421         if (indx != NUM_ENT(pagep))
 422                 memmove(&pagep->inp[indx], &pagep->inp[indx + 1],
 423                     sizeof(db_indx_t) * (NUM_ENT(pagep) - indx));
 424
 425         /* If it's a btree, adjust the cursors. */
 426         if (dbp->type == DB_BTREE || dbp->type == DB_RECNO)
 427                 __bam_ca_di(dbp, PGNO(pagep), indx, -1);
 428
 429         return (0);
 430 }
 431
 432 /*
 433  * __db_pitem --
 434  *      Put an item on a page.
 435  *
 436  * PUBLIC: int __db_pitem
 437  * PUBLIC:     __P((DB *, PAGE *, u_int32_t, u_int32_t, DBT *, DBT *));
 438  */
 439 int
 440 __db_pitem(dbp, pagep, indx, nbytes, hdr, data)
 441         DB *dbp;
 442         PAGE *pagep;
 443         u_int32_t indx;
 444         u_int32_t nbytes;
 445         DBT *hdr, *data;
 446 {
 447         BKEYDATA bk;
 448         DBT thdr;
 449         int ret;
 450         u_int8_t *p;
 451
 452         /*
 453          * Put a single item onto a page.  The logic figuring out where to
 454          * insert and whether it fits is handled in the caller.  All we do
 455          * here is manage the page shuffling.  We cheat a little bit in that
 456          * we don't want to copy the dbt on a normal put twice.  If hdr is
 457          * NULL, we create a BKEYDATA structure on the page, otherwise, just
 458          * copy the caller's information onto the page.
 459          *
 460          * This routine is also used to put entries onto the page where the
 461          * entry is pre-built, e.g., during recovery.  In this case, the hdr
 462          * will point to the entry, and the data argument will be NULL.
 463          *
 464          * !!!
 465          * There's a tremendous potential for off-by-one errors here, since
 466          * the passed in header sizes must be adjusted for the structure's
 467          * placeholder for the trailing variable-length data field.
 468          */
 469         if (DB_LOGGING(dbp))
 470                 if ((ret = __db_addrem_log(dbp->dbenv->lg_info, dbp->txn,
 471                     &LSN(pagep), 0, DB_ADD_DUP, dbp->log_fileid, PGNO(pagep),
 472                     (u_int32_t)indx, nbytes, hdr, data, &LSN(pagep))) != 0)
 473                         return (ret);
 474
 475         if (hdr == NULL) {
 476                 B_TSET(bk.type, B_KEYDATA, 0);
 477                 bk.len = data == NULL ? 0 : data->size;
 478
 479                 thdr.data = &bk;
 480                 thdr.size = SSZA(BKEYDATA, data);
 481                 hdr = &thdr;
 482         }
 483
 484         /* Adjust the index table, then put the item on the page. */
 485         if (indx != NUM_ENT(pagep))
 486                 memmove(&pagep->inp[indx + 1], &pagep->inp[indx],
 487                     sizeof(db_indx_t) * (NUM_ENT(pagep) - indx));
 488         HOFFSET(pagep) -= nbytes;
 489         pagep->inp[indx] = HOFFSET(pagep);
 490         ++NUM_ENT(pagep);
 491
 492         p = P_ENTRY(pagep, indx);
 493         memcpy(p, hdr->data, hdr->size);
 494         if (data != NULL)
 495                 memcpy(p + hdr->size, data->data, data->size);
 496
 497         /* If it's a btree, adjust the cursors. */
 498         if (dbp->type == DB_BTREE || dbp->type == DB_RECNO)
 499                 __bam_ca_di(dbp, PGNO(pagep), indx, 1);
 500
 501         return (0);
 502 }
 503
 504 /*
 505  * __db_relink --
 506  *      Relink around a deleted page.
 507  *
 508  * PUBLIC: int __db_relink __P((DB *, PAGE *, PAGE **, int));
 509  */
 510 int
 511 __db_relink(dbp, pagep, new_next, needlock)
 512         DB *dbp;
 513         PAGE *pagep, **new_next;
 514         int needlock;
 515 {
 516         PAGE *np, *pp;
 517         DB_LOCK npl, ppl;
 518         DB_LSN *nlsnp, *plsnp;
 519         int ret;
 520
 521         ret = 0;
 522         np = pp = NULL;
 523         npl = ppl = LOCK_INVALID;
 524         nlsnp = plsnp = NULL;
 525
 526         /* Retrieve and lock the two pages. */
 527         if (pagep->next_pgno != PGNO_INVALID) {
 528                 if (needlock && (ret = __bam_lget(dbp,
 529                     0, pagep->next_pgno, DB_LOCK_WRITE, &npl)) != 0)
 530                         goto err;
 531                 if ((ret = memp_fget(dbp->mpf,
 532                     &pagep->next_pgno, 0, &np)) != 0) {
 533                         (void)__db_pgerr(dbp, pagep->next_pgno);
 534                         goto err;
 535                 }
 536                 nlsnp = &np->lsn;
 537         }
 538         if (pagep->prev_pgno != PGNO_INVALID) {
 539                 if (needlock && (ret = __bam_lget(dbp,
 540                     0, pagep->prev_pgno, DB_LOCK_WRITE, &ppl)) != 0)
 541                         goto err;
 542                 if ((ret = memp_fget(dbp->mpf,
 543                     &pagep->prev_pgno, 0, &pp)) != 0) {
 544                         (void)__db_pgerr(dbp, pagep->next_pgno);
 545                         goto err;
 546                 }
 547                 plsnp = &pp->lsn;
 548         }
 549
 550         /* Log the change. */
 551         if (DB_LOGGING(dbp)) {
 552                 if ((ret = __db_relink_log(dbp->dbenv->lg_info, dbp->txn,
 553                     &pagep->lsn, 0, dbp->log_fileid, pagep->pgno, &pagep->lsn,
 554                     pagep->prev_pgno, plsnp, pagep->next_pgno, nlsnp)) != 0)
 555                         goto err;
 556                 if (np != NULL)
 557                         np->lsn = pagep->lsn;
 558                 if (pp != NULL)
 559                         pp->lsn = pagep->lsn;
 560         }
 561
 562         /*
 563          * Modify and release the two pages.
 564          *
 565          * !!!
 566          * The parameter new_next gets set to the page following the page we
 567          * are removing.  If there is no following page, then new_next gets
 568          * set to NULL.
 569          */
 570         if (np != NULL) {
 571                 np->prev_pgno = pagep->prev_pgno;
 572                 if (new_next == NULL)
 573                         ret = memp_fput(dbp->mpf, np, DB_MPOOL_DIRTY);
 574                 else {
 575                         *new_next = np;
 576                         ret = memp_fset(dbp->mpf, np, DB_MPOOL_DIRTY);
 577                 }
 578                 if (ret != 0)
 579                         goto err;
 580                 if (needlock)
 581                         (void)__bam_lput(dbp, npl);
 582         } else if (new_next != NULL)
 583                 *new_next = NULL;
 584
 585         if (pp != NULL) {
 586                 pp->next_pgno = pagep->next_pgno;
 587                 if ((ret = memp_fput(dbp->mpf, pp, DB_MPOOL_DIRTY)) != 0)
 588                         goto err;
 589                 if (needlock)
 590                         (void)__bam_lput(dbp, ppl);
 591         }
 592         return (0);
 593
 594 err:    if (np != NULL)
 595                 (void)memp_fput(dbp->mpf, np, 0);
 596         if (needlock && npl != LOCK_INVALID)
 597                 (void)__bam_lput(dbp, npl);
 598         if (pp != NULL)
 599                 (void)memp_fput(dbp->mpf, pp, 0);
 600         if (needlock && ppl != LOCK_INVALID)
 601                 (void)__bam_lput(dbp, ppl);
 602         return (ret);
 603 }
 604
 605 /*
 606  * __db_ddup --
 607  *      Delete an offpage chain of duplicates.
 608  *
 609  * PUBLIC: int __db_ddup __P((DB *, db_pgno_t, int (*)(DB *, PAGE *)));
 610  */
 611 int
 612 __db_ddup(dbp, pgno, freefunc)
 613         DB *dbp;
 614         db_pgno_t pgno;
 615         int (*freefunc) __P((DB *, PAGE *));
 616 {
 617         PAGE *pagep;
 618         DBT tmp_dbt;
 619         int ret;
 620
 621         do {
 622                 if ((ret = memp_fget(dbp->mpf, &pgno, 0, &pagep)) != 0) {
 623                         (void)__db_pgerr(dbp, pgno);
 624                         return (ret);
 625                 }
 626
 627                 if (DB_LOGGING(dbp)) {
 628                         tmp_dbt.data = pagep;
 629                         tmp_dbt.size = dbp->pgsize;
 630                         if ((ret = __db_split_log(dbp->dbenv->lg_info, dbp->txn,
 631                             &LSN(pagep), 0, DB_SPLITOLD, dbp->log_fileid,
 632                             PGNO(pagep), &tmp_dbt, &LSN(pagep))) != 0)
 633                                 return (ret);
 634                 }
 635                 pgno = pagep->next_pgno;
 636                 if ((ret = freefunc(dbp, pagep)) != 0)
 637                         return (ret);
 638         } while (pgno != PGNO_INVALID);
 639
 640         return (0);
 641 }
 642
 643 /*
 644  * __db_addpage --
 645  *      Create a new page and link it onto the next_pgno field of the
 646  *      current page.
 647  */
 648 static int
 649 __db_addpage(dbp, hp, indxp, newfunc)
 650         DB *dbp;
 651         PAGE **hp;
 652         db_indx_t *indxp;
 653         int (*newfunc) __P((DB *, u_int32_t, PAGE **));
 654 {
 655         PAGE *newpage;
 656         int ret;
 657
 658         if ((ret = newfunc(dbp, P_DUPLICATE, &newpage)) != 0)
 659                 return (ret);
 660
 661         if (DB_LOGGING(dbp)) {
 662                 if ((ret = __db_addpage_log(dbp->dbenv->lg_info,
 663                     dbp->txn, &LSN(*hp), 0, dbp->log_fileid,
 664                     PGNO(*hp), &LSN(*hp), PGNO(newpage), &LSN(newpage))) != 0) {
 665                         return (ret);
 666                 }
 667                 LSN(newpage) = LSN(*hp);
 668         }
 669
 670         PREV_PGNO(newpage) = PGNO(*hp);
 671         NEXT_PGNO(*hp) = PGNO(newpage);
 672
 673         if ((ret = memp_fput(dbp->mpf, *hp, DB_MPOOL_DIRTY)) != 0)
 674                 return (ret);
 675         *hp = newpage;
 676         *indxp = 0;
 677         return (0);
 678 }