Update from db-2.3.12.
[kopensolaris-gnu/glibc.git] / db2 / btree / bt_split.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  * Copyright (c) 1990, 1993, 1994, 1995, 1996
9  *      Keith Bostic.  All rights reserved.
10  */
11 /*
12  * Copyright (c) 1990, 1993, 1994, 1995
13  *      The Regents of the University of California.  All rights reserved.
14  *
15  * Redistribution and use in source and binary forms, with or without
16  * modification, are permitted provided that the following conditions
17  * are met:
18  * 1. Redistributions of source code must retain the above copyright
19  *    notice, this list of conditions and the following disclaimer.
20  * 2. Redistributions in binary form must reproduce the above copyright
21  *    notice, this list of conditions and the following disclaimer in the
22  *    documentation and/or other materials provided with the distribution.
23  * 3. All advertising materials mentioning features or use of this software
24  *    must display the following acknowledgement:
25  *      This product includes software developed by the University of
26  *      California, Berkeley and its contributors.
27  * 4. Neither the name of the University nor the names of its contributors
28  *    may be used to endorse or promote products derived from this software
29  *    without specific prior written permission.
30  *
31  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
32  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
33  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
34  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
35  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
39  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
40  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
41  * SUCH DAMAGE.
42  */
43
44 #include "config.h"
45
46 #ifndef lint
47 static const char sccsid[] = "@(#)bt_split.c    10.17 (Sleepycat) 11/2/97";
48 #endif /* not lint */
49
50 #ifndef NO_SYSTEM_INCLUDES
51 #include <sys/types.h>
52
53 #include <errno.h>
54 #include <limits.h>
55 #include <stdio.h>
56 #include <stdlib.h>
57 #include <string.h>
58 #endif
59
60 #include "db_int.h"
61 #include "db_page.h"
62 #include "btree.h"
63
64 static int __bam_page __P((DB *, EPG *, EPG *));
65 static int __bam_pinsert __P((DB *, EPG *, PAGE *, PAGE *));
66 static int __bam_psplit __P((DB *, EPG *, PAGE *, PAGE *, int));
67 static int __bam_root __P((DB *, EPG *));
68
69 /*
70  * __bam_split --
71  *      Split a page.
72  *
73  * PUBLIC: int __bam_split __P((DB *, void *));
74  */
75 int
76 __bam_split(dbp, arg)
77         DB *dbp;
78         void *arg;
79 {
80         BTREE *t;
81         enum { UP, DOWN } dir;
82         int exact, level, ret;
83
84         t = dbp->internal;
85
86         /*
87          * The locking protocol we use to avoid deadlock to acquire locks by
88          * walking down the tree, but we do it as lazily as possible, locking
89          * the root only as a last resort.  We expect all stack pages to have
90          * been discarded before we're called; we discard all short-term locks.
91          *
92          * When __bam_split is first called, we know that a leaf page was too
93          * full for an insert.  We don't know what leaf page it was, but we
94          * have the key/recno that caused the problem.  We call XX_search to
95          * reacquire the leaf page, but this time get both the leaf page and
96          * its parent, locked.  We then split the leaf page and see if the new
97          * internal key will fit into the parent page.  If it will, we're done.
98          *
99          * If it won't, we discard our current locks and repeat the process,
100          * only this time acquiring the parent page and its parent, locked.
101          * This process repeats until we succeed in the split, splitting the
102          * root page as the final resort.  The entire process then repeats,
103          * as necessary, until we split a leaf page.
104          *
105          * XXX
106          * A traditional method of speeding this up is to maintain a stack of
107          * the pages traversed in the original search.  You can detect if the
108          * stack is correct by storing the page's LSN when it was searched and
109          * comparing that LSN with the current one when it's locked during the
110          * split.  This would be an easy change for this code, but I have no
111          * numbers that indicate it's worthwhile.
112          */
113         for (dir = UP, level = LEAFLEVEL;; dir == UP ? ++level : --level) {
114                 /*
115                  * Acquire a page and its parent, locked.
116                  */
117                 if ((ret = (dbp->type == DB_BTREE ?
118                     __bam_search(dbp, arg, S_WRPAIR, level, NULL, &exact) :
119                     __bam_rsearch(dbp,
120                         (db_recno_t *)arg, S_WRPAIR, level, &exact))) != 0)
121                         return (ret);
122
123                 /* Split the page. */
124                 ret = t->bt_csp[0].page->pgno == PGNO_ROOT ?
125                     __bam_root(dbp, &t->bt_csp[0]) :
126                     __bam_page(dbp, &t->bt_csp[-1], &t->bt_csp[0]);
127
128                 switch (ret) {
129                 case 0:
130                         /* Once we've split the leaf page, we're done. */
131                         if (level == LEAFLEVEL)
132                                 return (0);
133
134                         /* Switch directions. */
135                         if (dir == UP)
136                                 dir = DOWN;
137                         break;
138                 case DB_NEEDSPLIT:
139                         /*
140                          * It's possible to fail to split repeatedly, as other
141                          * threads may be modifying the tree, or the page usage
142                          * is sufficiently bad that we don't get enough space
143                          * the first time.
144                          */
145                         if (dir == DOWN)
146                                 dir = UP;
147                         break;
148                 default:
149                         return (ret);
150                 }
151         }
152         /* NOTREACHED */
153 }
154
155 /*
156  * __bam_root --
157  *      Split the root page of a btree.
158  */
159 static int
160 __bam_root(dbp, cp)
161         DB *dbp;
162         EPG *cp;
163 {
164         BTREE *t;
165         PAGE *lp, *rp;
166         int ret;
167
168         t = dbp->internal;
169
170         /* Yeah, right. */
171         if (cp->page->level >= MAXBTREELEVEL)
172                 return (ENOSPC);
173
174         /* Create new left and right pages for the split. */
175         lp = rp = NULL;
176         if ((ret = __bam_new(dbp, TYPE(cp->page), &lp)) != 0 ||
177             (ret = __bam_new(dbp, TYPE(cp->page), &rp)) != 0)
178                 goto err;
179         P_INIT(lp, dbp->pgsize, lp->pgno,
180             PGNO_INVALID, ISINTERNAL(cp->page) ? PGNO_INVALID : rp->pgno,
181             cp->page->level, TYPE(cp->page));
182         P_INIT(rp, dbp->pgsize, rp->pgno,
183             ISINTERNAL(cp->page) ?  PGNO_INVALID : lp->pgno, PGNO_INVALID,
184             cp->page->level, TYPE(cp->page));
185
186         /* Split the page. */
187         if ((ret = __bam_psplit(dbp, cp, lp, rp, 1)) != 0)
188                 goto err;
189
190         /* Log the change. */
191         if (DB_LOGGING(dbp)) {
192                 DBT __a;
193                 DB_LSN __lsn;
194                 memset(&__a, 0, sizeof(__a));
195                 __a.data = cp->page;
196                 __a.size = dbp->pgsize;
197                 ZERO_LSN(__lsn);
198                 if ((ret = __bam_split_log(dbp->dbenv->lg_info, dbp->txn,
199                     &LSN(cp->page), 0, dbp->log_fileid, PGNO(lp), &LSN(lp),
200                     PGNO(rp), &LSN(rp), (u_int32_t)NUM_ENT(lp), 0, &__lsn,
201                     &__a)) != 0)
202                         goto err;
203                 LSN(lp) = LSN(rp) = LSN(cp->page);
204         }
205
206         /* Clean up the new root page. */
207         if ((ret = (dbp->type == DB_RECNO ?
208             __ram_root(dbp, cp->page, lp, rp) :
209             __bam_broot(dbp, cp->page, lp, rp))) != 0)
210                 goto err;
211
212         /* Success -- write the real pages back to the store. */
213         (void)memp_fput(dbp->mpf, cp->page, DB_MPOOL_DIRTY);
214         (void)__BT_TLPUT(dbp, cp->lock);
215         (void)memp_fput(dbp->mpf, lp, DB_MPOOL_DIRTY);
216         (void)memp_fput(dbp->mpf, rp, DB_MPOOL_DIRTY);
217
218         ++t->lstat.bt_split;
219         ++t->lstat.bt_rootsplit;
220         return (0);
221
222 err:    if (lp != NULL)
223                 (void)__bam_free(dbp, lp);
224         if (rp != NULL)
225                 (void)__bam_free(dbp, rp);
226         (void)memp_fput(dbp->mpf, cp->page, 0);
227         (void)__BT_TLPUT(dbp, cp->lock);
228         return (ret);
229 }
230
231 /*
232  * __bam_page --
233  *      Split the non-root page of a btree.
234  */
235 static int
236 __bam_page(dbp, pp, cp)
237         DB *dbp;
238         EPG *pp, *cp;
239 {
240         BTREE *t;
241         DB_LOCK tplock;
242         PAGE *lp, *rp, *tp;
243         int ret;
244
245         t = dbp->internal;
246         lp = rp = tp = NULL;
247         ret = -1;
248
249         /* Create new right page for the split. */
250         if ((ret = __bam_new(dbp, TYPE(cp->page), &rp)) != 0)
251                 return (ret);
252         P_INIT(rp, dbp->pgsize, rp->pgno,
253             ISINTERNAL(cp->page) ? PGNO_INVALID : cp->page->pgno,
254             ISINTERNAL(cp->page) ? PGNO_INVALID : cp->page->next_pgno,
255             cp->page->level, TYPE(cp->page));
256
257         /* Create new left page for the split. */
258         if ((lp = (PAGE *)__db_malloc(dbp->pgsize)) == NULL) {
259                 ret = ENOMEM;
260                 goto err;
261         }
262 #ifdef DEBUG
263         memset(lp, 0xff, dbp->pgsize);
264 #endif
265         P_INIT(lp, dbp->pgsize, cp->page->pgno,
266             ISINTERNAL(cp->page) ?  PGNO_INVALID : cp->page->prev_pgno,
267             ISINTERNAL(cp->page) ?  PGNO_INVALID : rp->pgno,
268             cp->page->level, TYPE(cp->page));
269         ZERO_LSN(lp->lsn);
270
271         /*
272          * Split right.
273          *
274          * Only the indices are sorted on the page, i.e., the key/data pairs
275          * aren't, so it's simpler to copy the data from the split page onto
276          * two new pages instead of copying half the data to the right page
277          * and compacting the left page in place.  Since the left page can't
278          * change, we swap the original and the allocated left page after the
279          * split.
280          */
281         if ((ret = __bam_psplit(dbp, cp, lp, rp, 0)) != 0)
282                 goto err;
283
284         /*
285          * Fix up the previous pointer of any leaf page following the split
286          * page.
287          *
288          * !!!
289          * There are interesting deadlock situations here as we write-lock a
290          * page that's not in our direct ancestry.  Consider a cursor walking
291          * through the leaf pages, that has the previous page read-locked and
292          * is waiting on a lock for the page we just split.  It will deadlock
293          * here.  If this is a problem, we can fail in the split; it's not a
294          * problem as the split will succeed after the cursor passes through
295          * the page we're splitting.
296          */
297         if (TYPE(cp->page) == P_LBTREE && rp->next_pgno != PGNO_INVALID) {
298                 if ((ret = __bam_lget(dbp,
299                     0, rp->next_pgno, DB_LOCK_WRITE, &tplock)) != 0)
300                         goto err;
301                 if ((ret = __bam_pget(dbp, &tp, &rp->next_pgno, 0)) != 0)
302                         goto err;
303         }
304
305         /* Insert the new pages into the parent page. */
306         if ((ret = __bam_pinsert(dbp, pp, lp, rp)) != 0)
307                 goto err;
308
309         /* Log the change. */
310         if (DB_LOGGING(dbp)) {
311                 DBT __a;
312                 DB_LSN __lsn;
313                 memset(&__a, 0, sizeof(__a));
314                 __a.data = cp->page;
315                 __a.size = dbp->pgsize;
316                 if (tp == NULL)
317                         ZERO_LSN(__lsn);
318                 if ((ret = __bam_split_log(dbp->dbenv->lg_info, dbp->txn,
319                     &cp->page->lsn, 0, dbp->log_fileid, PGNO(cp->page),
320                     &LSN(cp->page), PGNO(rp), &LSN(rp), (u_int32_t)NUM_ENT(lp),
321                     tp == NULL ? 0 : PGNO(tp),
322                     tp == NULL ? &__lsn : &LSN(tp), &__a)) != 0)
323                         goto err;
324
325                 LSN(lp) = LSN(rp) = LSN(cp->page);
326                 if (tp != NULL)
327                         LSN(tp) = LSN(cp->page);
328         }
329
330         /* Copy the allocated page into place. */
331         memcpy(cp->page, lp, LOFFSET(lp));
332         memcpy((u_int8_t *)cp->page + HOFFSET(lp),
333             (u_int8_t *)lp + HOFFSET(lp), dbp->pgsize - HOFFSET(lp));
334         FREE(lp, dbp->pgsize);
335         lp = NULL;
336
337         /* Finish the next-page link. */
338         if (tp != NULL)
339                 tp->prev_pgno = rp->pgno;
340
341         /* Success -- write the real pages back to the store. */
342         (void)memp_fput(dbp->mpf, pp->page, DB_MPOOL_DIRTY);
343         (void)__BT_TLPUT(dbp, pp->lock);
344         (void)memp_fput(dbp->mpf, cp->page, DB_MPOOL_DIRTY);
345         (void)__BT_TLPUT(dbp, cp->lock);
346         (void)memp_fput(dbp->mpf, rp, DB_MPOOL_DIRTY);
347         if (tp != NULL) {
348                 (void)memp_fput(dbp->mpf, tp, DB_MPOOL_DIRTY);
349                 (void)__BT_TLPUT(dbp, tplock);
350         }
351         return (0);
352
353 err:    if (lp != NULL)
354                 FREE(lp, dbp->pgsize);
355         if (rp != NULL)
356                 (void)__bam_free(dbp, rp);
357         if (tp != NULL) {
358                 (void)memp_fput(dbp->mpf, tp, 0);
359                 (void)__BT_TLPUT(dbp, tplock);
360         }
361         (void)memp_fput(dbp->mpf, pp->page, 0);
362         (void)__BT_TLPUT(dbp, pp->lock);
363         (void)memp_fput(dbp->mpf, cp->page, 0);
364         (void)__BT_TLPUT(dbp, cp->lock);
365         return (ret);
366 }
367
368 /*
369  * __bam_broot --
370  *      Fix up the btree root page after it has been split.
371  *
372  * PUBLIC: int __bam_broot __P((DB *, PAGE *, PAGE *, PAGE *));
373  */
374 int
375 __bam_broot(dbp, rootp, lp, rp)
376         DB *dbp;
377         PAGE *rootp, *lp, *rp;
378 {
379         BINTERNAL bi, *child_bi;
380         BKEYDATA *child_bk;
381         DBT hdr, data;
382         int ret;
383
384         /*
385          * If the root page was a leaf page, change it into an internal page.
386          * We copy the key we split on (but not the key's data, in the case of
387          * a leaf page) to the new root page.
388          */
389         P_INIT(rootp, dbp->pgsize,
390             PGNO_ROOT, PGNO_INVALID, PGNO_INVALID, lp->level + 1, P_IBTREE);
391
392         memset(&data, 0, sizeof(data));
393         memset(&hdr, 0, sizeof(hdr));
394
395         /*
396          * The btree comparison code guarantees that the left-most key on any
397          * level of the tree is never used, so it doesn't need to be filled in.
398          */
399         bi.len = 0;
400         B_TSET(bi.type, B_KEYDATA, 0);
401         bi.pgno = lp->pgno;
402         if (F_ISSET(dbp, DB_BT_RECNUM)) {
403                 bi.nrecs = __bam_total(lp);
404                 RE_NREC_SET(rootp, bi.nrecs);
405         } else
406                 bi.nrecs = 0;
407         hdr.data = &bi;
408         hdr.size = SSZA(BINTERNAL, data);
409         if ((ret =
410             __db_pitem(dbp, rootp, 0, BINTERNAL_SIZE(0), &hdr, NULL)) != 0)
411                 return (ret);
412
413         switch (TYPE(rp)) {
414         case P_IBTREE:
415                 /* Copy the first key of the child page onto the root page. */
416                 child_bi = GET_BINTERNAL(rp, 0);
417
418                 bi.len = child_bi->len;
419                 B_TSET(bi.type, child_bi->type, 0);
420                 bi.pgno = rp->pgno;
421                 if (F_ISSET(dbp, DB_BT_RECNUM)) {
422                         bi.nrecs = __bam_total(rp);
423                         RE_NREC_ADJ(rootp, bi.nrecs);
424                 }
425                 hdr.data = &bi;
426                 hdr.size = SSZA(BINTERNAL, data);
427                 data.data = child_bi->data;
428                 data.size = child_bi->len;
429                 if ((ret = __db_pitem(dbp, rootp, 1,
430                     BINTERNAL_SIZE(child_bi->len), &hdr, &data)) != 0)
431                         return (ret);
432
433                 /* Increment the overflow ref count. */
434                 if (B_TYPE(child_bi->type) == B_OVERFLOW)
435                         if ((ret = __db_ovref(dbp,
436                             ((BOVERFLOW *)(child_bi->data))->pgno, 1)) != 0)
437                                 return (ret);
438                 break;
439         case P_LBTREE:
440                 /* Copy the first key of the child page onto the root page. */
441                 child_bk = GET_BKEYDATA(rp, 0);
442                 switch (B_TYPE(child_bk->type)) {
443                 case B_KEYDATA:
444                         bi.len = child_bk->len;
445                         B_TSET(bi.type, child_bk->type, 0);
446                         bi.pgno = rp->pgno;
447                         if (F_ISSET(dbp, DB_BT_RECNUM)) {
448                                 bi.nrecs = __bam_total(rp);
449                                 RE_NREC_ADJ(rootp, bi.nrecs);
450                         }
451                         hdr.data = &bi;
452                         hdr.size = SSZA(BINTERNAL, data);
453                         data.data = child_bk->data;
454                         data.size = child_bk->len;
455                         if ((ret = __db_pitem(dbp, rootp, 1,
456                             BINTERNAL_SIZE(child_bk->len), &hdr, &data)) != 0)
457                                 return (ret);
458                         break;
459                 case B_DUPLICATE:
460                 case B_OVERFLOW:
461                         bi.len = BOVERFLOW_SIZE;
462                         B_TSET(bi.type, child_bk->type, 0);
463                         bi.pgno = rp->pgno;
464                         if (F_ISSET(dbp, DB_BT_RECNUM)) {
465                                 bi.nrecs = __bam_total(rp);
466                                 RE_NREC_ADJ(rootp, bi.nrecs);
467                         }
468                         hdr.data = &bi;
469                         hdr.size = SSZA(BINTERNAL, data);
470                         data.data = child_bk;
471                         data.size = BOVERFLOW_SIZE;
472                         if ((ret = __db_pitem(dbp, rootp, 1,
473                             BINTERNAL_SIZE(BOVERFLOW_SIZE), &hdr, &data)) != 0)
474                                 return (ret);
475
476                         /* Increment the overflow ref count. */
477                         if (B_TYPE(child_bk->type) == B_OVERFLOW)
478                                 if ((ret = __db_ovref(dbp,
479                                     ((BOVERFLOW *)child_bk)->pgno, 1)) != 0)
480                                         return (ret);
481                         break;
482                 default:
483                         return (__db_pgfmt(dbp, rp->pgno));
484                 }
485                 break;
486         default:
487                 return (__db_pgfmt(dbp, rp->pgno));
488         }
489         return (0);
490 }
491
492 /*
493  * __ram_root --
494  *      Fix up the recno root page after it has been split.
495  *
496  * PUBLIC: int __ram_root __P((DB *, PAGE *, PAGE *, PAGE *));
497  */
498 int
499 __ram_root(dbp, rootp, lp, rp)
500         DB *dbp;
501         PAGE *rootp, *lp, *rp;
502 {
503         DBT hdr;
504         RINTERNAL ri;
505         int ret;
506
507         /* Initialize the page. */
508         P_INIT(rootp, dbp->pgsize,
509             PGNO_ROOT, PGNO_INVALID, PGNO_INVALID, lp->level + 1, P_IRECNO);
510
511         /* Initialize the header. */
512         memset(&hdr, 0, sizeof(hdr));
513         hdr.data = &ri;
514         hdr.size = RINTERNAL_SIZE;
515
516         /* Insert the left and right keys, set the header information. */
517         ri.pgno = lp->pgno;
518         ri.nrecs = __bam_total(lp);
519         if ((ret = __db_pitem(dbp, rootp, 0, RINTERNAL_SIZE, &hdr, NULL)) != 0)
520                 return (ret);
521         RE_NREC_SET(rootp, ri.nrecs);
522         ri.pgno = rp->pgno;
523         ri.nrecs = __bam_total(rp);
524         if ((ret = __db_pitem(dbp, rootp, 1, RINTERNAL_SIZE, &hdr, NULL)) != 0)
525                 return (ret);
526         RE_NREC_ADJ(rootp, ri.nrecs);
527         return (0);
528 }
529
530 /*
531  * __bam_pinsert --
532  *      Insert a new key into a parent page, completing the split.
533  */
534 static int
535 __bam_pinsert(dbp, parent, lchild, rchild)
536         DB *dbp;
537         EPG *parent;
538         PAGE *lchild, *rchild;
539 {
540         BINTERNAL bi, *child_bi;
541         BKEYDATA *child_bk, *tmp_bk;
542         BTREE *t;
543         DBT a, b, hdr, data;
544         PAGE *ppage;
545         RINTERNAL ri;
546         db_indx_t off;
547         db_recno_t nrecs;
548         u_int32_t n, nbytes, nksize;
549         int ret;
550
551         t = dbp->internal;
552         ppage = parent->page;
553
554         /* If handling record numbers, count records split to the right page. */
555         nrecs = dbp->type == DB_RECNO || F_ISSET(dbp, DB_BT_RECNUM) ?
556             __bam_total(rchild) : 0;
557
558         /*
559          * Now we insert the new page's first key into the parent page, which
560          * completes the split.  The parent points to a PAGE and a page index
561          * offset, where the new key goes ONE AFTER the index, because we split
562          * to the right.
563          *
564          * XXX
565          * Some btree algorithms replace the key for the old page as well as
566          * the new page.  We don't, as there's no reason to believe that the
567          * first key on the old page is any better than the key we have, and,
568          * in the case of a key being placed at index 0 causing the split, the
569          * key is unavailable.
570          */
571         off = parent->indx + O_INDX;
572
573         /*
574          * Calculate the space needed on the parent page.
575          *
576          * Prefix trees: space hack used when inserting into BINTERNAL pages.
577          * Retain only what's needed to distinguish between the new entry and
578          * the LAST entry on the page to its left.  If the keys compare equal,
579          * retain the entire key.  We ignore overflow keys, and the entire key
580          * must be retained for the next-to-leftmost key on the leftmost page
581          * of each level, or the search will fail.  Applicable ONLY to internal
582          * pages that have leaf pages as children.  Further reduction of the
583          * key between pairs of internal pages loses too much information.
584          */
585         switch (TYPE(rchild)) {
586         case P_IBTREE:
587                 child_bi = GET_BINTERNAL(rchild, 0);
588                 nbytes = BINTERNAL_PSIZE(child_bi->len);
589
590                 if (P_FREESPACE(ppage) < nbytes)
591                         return (DB_NEEDSPLIT);
592
593                 /* Add a new record for the right page. */
594                 bi.len = child_bi->len;
595                 B_TSET(bi.type, child_bi->type, 0);
596                 bi.pgno = rchild->pgno;
597                 bi.nrecs = nrecs;
598                 memset(&hdr, 0, sizeof(hdr));
599                 hdr.data = &bi;
600                 hdr.size = SSZA(BINTERNAL, data);
601                 memset(&data, 0, sizeof(data));
602                 data.data = child_bi->data;
603                 data.size = child_bi->len;
604                 if ((ret = __db_pitem(dbp, ppage, off,
605                     BINTERNAL_SIZE(child_bi->len), &hdr, &data)) != 0)
606                         return (ret);
607
608                 /* Increment the overflow ref count. */
609                 if (B_TYPE(child_bi->type) == B_OVERFLOW)
610                         if ((ret = __db_ovref(dbp,
611                             ((BOVERFLOW *)(child_bi->data))->pgno, 1)) != 0)
612                                 return (ret);
613                 break;
614         case P_LBTREE:
615                 child_bk = GET_BKEYDATA(rchild, 0);
616                 switch (B_TYPE(child_bk->type)) {
617                 case B_KEYDATA:
618                         nbytes = BINTERNAL_PSIZE(child_bk->len);
619                         nksize = child_bk->len;
620                         if (t->bt_prefix == NULL)
621                                 goto noprefix;
622                         if (ppage->prev_pgno == PGNO_INVALID && off <= 1)
623                                 goto noprefix;
624                         tmp_bk = GET_BKEYDATA(lchild, NUM_ENT(lchild) - P_INDX);
625                         if (B_TYPE(tmp_bk->type) != B_KEYDATA)
626                                 goto noprefix;
627                         memset(&a, 0, sizeof(a));
628                         a.size = tmp_bk->len;
629                         a.data = tmp_bk->data;
630                         memset(&b, 0, sizeof(b));
631                         b.size = child_bk->len;
632                         b.data = child_bk->data;
633                         nksize = t->bt_prefix(&a, &b);
634                         if ((n = BINTERNAL_PSIZE(nksize)) < nbytes) {
635                                 t->lstat.bt_pfxsaved += nbytes - n;
636                                 nbytes = n;
637                         } else
638 noprefix:                       nksize = child_bk->len;
639
640                         if (P_FREESPACE(ppage) < nbytes)
641                                 return (DB_NEEDSPLIT);
642
643                         bi.len = nksize;
644                         B_TSET(bi.type, child_bk->type, 0);
645                         bi.pgno = rchild->pgno;
646                         bi.nrecs = nrecs;
647                         memset(&hdr, 0, sizeof(hdr));
648                         hdr.data = &bi;
649                         hdr.size = SSZA(BINTERNAL, data);
650                         memset(&data, 0, sizeof(data));
651                         data.data = child_bk->data;
652                         data.size = nksize;
653                         if ((ret = __db_pitem(dbp, ppage, off,
654                             BINTERNAL_SIZE(nksize), &hdr, &data)) != 0)
655                                 return (ret);
656                         break;
657                 case B_DUPLICATE:
658                 case B_OVERFLOW:
659                         nbytes = BINTERNAL_PSIZE(BOVERFLOW_SIZE);
660
661                         if (P_FREESPACE(ppage) < nbytes)
662                                 return (DB_NEEDSPLIT);
663
664                         bi.len = BOVERFLOW_SIZE;
665                         B_TSET(bi.type, child_bk->type, 0);
666                         bi.pgno = rchild->pgno;
667                         bi.nrecs = nrecs;
668                         memset(&hdr, 0, sizeof(hdr));
669                         hdr.data = &bi;
670                         hdr.size = SSZA(BINTERNAL, data);
671                         memset(&data, 0, sizeof(data));
672                         data.data = child_bk;
673                         data.size = BOVERFLOW_SIZE;
674                         if ((ret = __db_pitem(dbp, ppage, off,
675                             BINTERNAL_SIZE(BOVERFLOW_SIZE), &hdr, &data)) != 0)
676                                 return (ret);
677
678                         /* Increment the overflow ref count. */
679                         if (B_TYPE(child_bk->type) == B_OVERFLOW)
680                                 if ((ret = __db_ovref(dbp,
681                                     ((BOVERFLOW *)child_bk)->pgno, 1)) != 0)
682                                         return (ret);
683                         break;
684                 default:
685                         return (__db_pgfmt(dbp, rchild->pgno));
686                 }
687                 break;
688         case P_IRECNO:
689         case P_LRECNO:
690                 nbytes = RINTERNAL_PSIZE;
691
692                 if (P_FREESPACE(ppage) < nbytes)
693                         return (DB_NEEDSPLIT);
694
695                 /* Add a new record for the right page. */
696                 memset(&hdr, 0, sizeof(hdr));
697                 hdr.data = &ri;
698                 hdr.size = RINTERNAL_SIZE;
699                 ri.pgno = rchild->pgno;
700                 ri.nrecs = nrecs;
701                 if ((ret = __db_pitem(dbp,
702                     ppage, off, RINTERNAL_SIZE, &hdr, NULL)) != 0)
703                         return (ret);
704                 break;
705         default:
706                 return (__db_pgfmt(dbp, rchild->pgno));
707         }
708
709         /* Adjust the parent page's left page record count. */
710         if (dbp->type == DB_RECNO || F_ISSET(dbp, DB_BT_RECNUM)) {
711                 /* Log the change. */
712                 if (DB_LOGGING(dbp) &&
713                     (ret = __bam_cadjust_log(dbp->dbenv->lg_info,
714                     dbp->txn, &LSN(ppage), 0, dbp->log_fileid,
715                     PGNO(ppage), &LSN(ppage), (u_int32_t)parent->indx,
716                     -(int32_t)nrecs, (int32_t)0)) != 0)
717                         return (ret);
718
719                 /* Update the left page count. */
720                 if (dbp->type == DB_RECNO)
721                         GET_RINTERNAL(ppage, parent->indx)->nrecs -= nrecs;
722                 else
723                         GET_BINTERNAL(ppage, parent->indx)->nrecs -= nrecs;
724         }
725
726         return (0);
727 }
728
729 /*
730  * __bam_psplit --
731  *      Do the real work of splitting the page.
732  */
733 static int
734 __bam_psplit(dbp, cp, lp, rp, cleft)
735         DB *dbp;
736         EPG *cp;
737         PAGE *lp, *rp;
738         int cleft;
739 {
740         BTREE *t;
741         PAGE *pp;
742         db_indx_t half, nbytes, off, splitp, top;
743         int adjust, cnt, isbigkey, ret;
744
745         t = dbp->internal;
746         pp = cp->page;
747         adjust = TYPE(pp) == P_LBTREE ? P_INDX : O_INDX;
748
749         /*
750          * If we're splitting the first (last) page on a level because we're
751          * inserting (appending) a key to it, it's likely that the data is
752          * sorted.  Moving a single item to the new page is less work and can
753          * push the fill factor higher than normal.  If we're wrong it's not
754          * a big deal, we'll just do the split the right way next time.
755          */
756         off = 0;
757         if (NEXT_PGNO(pp) == PGNO_INVALID &&
758             ((ISINTERNAL(pp) && cp->indx == NUM_ENT(cp->page) - 1) ||
759             (!ISINTERNAL(pp) && cp->indx == NUM_ENT(cp->page))))
760                 off = NUM_ENT(cp->page) - adjust;
761         else if (PREV_PGNO(pp) == PGNO_INVALID && cp->indx == 0)
762                 off = adjust;
763
764         ++t->lstat.bt_split;
765         if (off != 0) {
766                 ++t->lstat.bt_fastsplit;
767                 goto sort;
768         }
769
770         /*
771          * Split the data to the left and right pages.  Try not to split on
772          * an overflow key.  (Overflow keys on internal pages will slow down
773          * searches.)  Refuse to split in the middle of a set of duplicates.
774          *
775          * First, find the optimum place to split.
776          *
777          * It's possible to try and split past the last record on the page if
778          * there's a very large record at the end of the page.  Make sure this
779          * doesn't happen by bounding the check at the next-to-last entry on
780          * the page.
781          *
782          * Note, we try and split half the data present on the page.  This is
783          * because another process may have already split the page and left
784          * it half empty.  We don't try and skip the split -- we don't know
785          * how much space we're going to need on the page, and we may need up
786          * to half the page for a big item, so there's no easy test to decide
787          * if we need to split or not.  Besides, if two threads are inserting
788          * data into the same place in the database, we're probably going to
789          * need more space soon anyway.
790          */
791         top = NUM_ENT(pp) - adjust;
792         half = (dbp->pgsize - HOFFSET(pp)) / 2;
793         for (nbytes = 0, off = 0; off < top && nbytes < half; ++off)
794                 switch (TYPE(pp)) {
795                 case P_IBTREE:
796                         if (B_TYPE(GET_BINTERNAL(pp, off)->type) == B_KEYDATA)
797                                 nbytes +=
798                                    BINTERNAL_SIZE(GET_BINTERNAL(pp, off)->len);
799                         else
800                                 nbytes += BINTERNAL_SIZE(BOVERFLOW_SIZE);
801                         break;
802                 case P_LBTREE:
803                         if (B_TYPE(GET_BKEYDATA(pp, off)->type) == B_KEYDATA)
804                                 nbytes +=
805                                     BKEYDATA_SIZE(GET_BKEYDATA(pp, off)->len);
806                         else
807                                 nbytes += BOVERFLOW_SIZE;
808
809                         ++off;
810                         if (B_TYPE(GET_BKEYDATA(pp, off)->type) == B_KEYDATA)
811                                 nbytes +=
812                                     BKEYDATA_SIZE(GET_BKEYDATA(pp, off)->len);
813                         else
814                                 nbytes += BOVERFLOW_SIZE;
815                         break;
816                 case P_IRECNO:
817                         nbytes += RINTERNAL_SIZE;
818                         break;
819                 case P_LRECNO:
820                         nbytes += BKEYDATA_SIZE(GET_BKEYDATA(pp, off)->len);
821                         break;
822                 default:
823                         return (__db_pgfmt(dbp, pp->pgno));
824                 }
825 sort:   splitp = off;
826
827         /*
828          * Splitp is either at or just past the optimum split point.  If
829          * it's a big key, try and find something close by that's not.
830          */
831         if (TYPE(pp) == P_IBTREE)
832                 isbigkey = B_TYPE(GET_BINTERNAL(pp, off)->type) != B_KEYDATA;
833         else if (TYPE(pp) == P_LBTREE)
834                 isbigkey = B_TYPE(GET_BKEYDATA(pp, off)->type) != B_KEYDATA;
835         else
836                 isbigkey = 0;
837         if (isbigkey)
838                 for (cnt = 1; cnt <= 3; ++cnt) {
839                         off = splitp + cnt * adjust;
840                         if (off < (db_indx_t)NUM_ENT(pp) &&
841                             ((TYPE(pp) == P_IBTREE &&
842                             B_TYPE(GET_BINTERNAL(pp,off)->type) == B_KEYDATA) ||
843                             B_TYPE(GET_BKEYDATA(pp, off)->type) == B_KEYDATA)) {
844                                 splitp = off;
845                                 break;
846                         }
847                         if (splitp <= (db_indx_t)(cnt * adjust))
848                                 continue;
849                         off = splitp - cnt * adjust;
850                         if (TYPE(pp) == P_IBTREE ?
851                             B_TYPE(GET_BINTERNAL(pp, off)->type) == B_KEYDATA :
852                             B_TYPE(GET_BKEYDATA(pp, off)->type) == B_KEYDATA) {
853                                 splitp = off;
854                                 break;
855                         }
856                 }
857
858         /*
859          * We can't split in the middle a set of duplicates.  We know that
860          * no duplicate set can take up more than about 25% of the page,
861          * because that's the point where we push it off onto a duplicate
862          * page set.  So, this loop can't be unbounded.
863          */
864         if (F_ISSET(dbp, DB_AM_DUP) && TYPE(pp) == P_LBTREE &&
865             pp->inp[splitp] == pp->inp[splitp - adjust])
866                 for (cnt = 1;; ++cnt) {
867                         off = splitp + cnt * adjust;
868                         if (off < NUM_ENT(pp) &&
869                             pp->inp[splitp] != pp->inp[off]) {
870                                 splitp = off;
871                                 break;
872                         }
873                         if (splitp <= (db_indx_t)(cnt * adjust))
874                                 continue;
875                         off = splitp - cnt * adjust;
876                         if (pp->inp[splitp] != pp->inp[off]) {
877                                 splitp = off + adjust;
878                                 break;
879                         }
880                 }
881
882
883         /* We're going to split at splitp. */
884         if ((ret = __bam_copy(dbp, pp, lp, 0, splitp)) != 0)
885                 return (ret);
886         if ((ret = __bam_copy(dbp, pp, rp, splitp, NUM_ENT(pp))) != 0)
887                 return (ret);
888
889         /* Adjust the cursors. */
890         __bam_ca_split(dbp, pp->pgno, lp->pgno, rp->pgno, splitp, cleft);
891         return (0);
892 }
893
894 /*
895  * __bam_copy --
896  *      Copy a set of records from one page to another.
897  *
898  * PUBLIC: int __bam_copy __P((DB *, PAGE *, PAGE *, u_int32_t, u_int32_t));
899  */
900 int
901 __bam_copy(dbp, pp, cp, nxt, stop)
902         DB *dbp;
903         PAGE *pp, *cp;
904         u_int32_t nxt, stop;
905 {
906         db_indx_t dup, nbytes, off;
907
908         /*
909          * Copy the rest of the data to the right page.  Nxt is the next
910          * offset placed on the target page.
911          */
912         for (dup = off = 0; nxt < stop; ++nxt, ++NUM_ENT(cp), ++off) {
913                 switch (TYPE(pp)) {
914                 case P_IBTREE:
915                         if (B_TYPE(GET_BINTERNAL(pp, nxt)->type) == B_KEYDATA)
916                                 nbytes =
917                                     BINTERNAL_SIZE(GET_BINTERNAL(pp, nxt)->len);
918                         else
919                                 nbytes = BINTERNAL_SIZE(BOVERFLOW_SIZE);
920                         break;
921                 case P_LBTREE:
922                         /*
923                          * If we're on a key and it's a duplicate, just copy
924                          * the offset.
925                          */
926                         if (off != 0 && (nxt % P_INDX) == 0 &&
927                             pp->inp[nxt] == pp->inp[nxt - P_INDX]) {
928                                 cp->inp[off] = cp->inp[off - P_INDX];
929                                 continue;
930                         }
931                         /* FALLTHROUGH */
932                 case P_LRECNO:
933                         if (B_TYPE(GET_BKEYDATA(pp, nxt)->type) == B_KEYDATA)
934                                 nbytes =
935                                     BKEYDATA_SIZE(GET_BKEYDATA(pp, nxt)->len);
936                         else
937                                 nbytes = BOVERFLOW_SIZE;
938                         break;
939                 case P_IRECNO:
940                         nbytes = RINTERNAL_SIZE;
941                         break;
942                 default:
943                         return (__db_pgfmt(dbp, pp->pgno));
944                 }
945                 cp->inp[off] = HOFFSET(cp) -= nbytes;
946                 memcpy(P_ENTRY(cp, off), P_ENTRY(pp, nxt), nbytes);
947         }
948         return (0);
949 }