db2/include/db_page.h

   1 /*-
   2  * See the file LICENSE for redistribution information.
   3  *
   4  * Copyright (c) 1996, 1997
   5  *      Sleepycat Software.  All rights reserved.
   6  *
   7  *      @(#)db_page.h   10.13 (Sleepycat) 9/24/97
   8  */
   9
  10 #ifndef _DB_PAGE_H_
  11 #define _DB_PAGE_H_
  12
  13 /*
  14  * DB page formats.
  15  *
  16  * This implementation requires that values within the following structures
  17  * NOT be padded -- note, ANSI C permits random padding within structures.
  18  * If your compiler pads randomly you can just forget ever making DB run on
  19  * your system.  In addition, no data type can require larger alignment than
  20  * its own size, e.g., a 4-byte data element may not require 8-byte alignment.
  21  *
  22  * Note that key/data lengths are often stored in db_indx_t's -- this is
  23  * not accidental, nor does it limit the key/data size.  If the key/data
  24  * item fits on a page, it's guaranteed to be small enough to fit into a
  25  * db_indx_t, and storing it in one saves space.
  26  */
  27
  28 #define PGNO_METADATA   0       /* Metadata page number. */
  29 #define PGNO_INVALID    0       /* Metadata page number, therefore illegal. */
  30 #define PGNO_ROOT       1       /* Root is page #1. */
  31
  32 /************************************************************************
  33  BTREE METADATA PAGE LAYOUT
  34  ************************************************************************/
  35
  36 /*
  37  * Btree metadata page layout:
  38  *
  39  *      +-----------------------------------+
  40  *      |    lsn    |   pgno    |   magic   |
  41  *      +-----------------------------------+
  42  *      |   version |  pagesize |   free    |
  43  *      +-----------------------------------+
  44  *      |    flags  |  unused ...           |
  45  *      +-----------------------------------+
  46  */
  47 typedef struct _btmeta {
  48         DB_LSN    lsn;          /* 00-07: LSN. */
  49         db_pgno_t pgno;         /* 08-11: Current page number. */
  50         u_int32_t magic;        /* 12-15: Magic number. */
  51         u_int32_t version;      /* 16-19: Version. */
  52         u_int32_t pagesize;     /* 20-23: Pagesize. */
  53         u_int32_t maxkey;       /* 24-27: Btree: Maxkey. */
  54         u_int32_t minkey;       /* 28-31: Btree: Minkey. */
  55         u_int32_t free;         /* 32-35: Free list page number. */
  56 #define BTM_DUP         0x001   /*        Duplicates. */
  57 #define BTM_RECNO       0x002   /*        Recno tree. */
  58 #define BTM_RECNUM      0x004   /*        Btree: maintain record count. */
  59 #define BTM_FIXEDLEN    0x008   /*        Recno: fixed length records. */
  60 #define BTM_RENUMBER    0x010   /*        Recno: renumber on insert/delete. */
  61 #define BTM_MASK        0x01f
  62         u_int32_t flags;        /* 36-39: Flags. */
  63         u_int32_t re_len;       /* 40-43: Recno: fixed-length record length. */
  64         u_int32_t re_pad;       /* 44-47: Recno: fixed-length record pad. */
  65                                 /* 48-67: Unique file ID. */
  66         u_int8_t  uid[DB_FILE_ID_LEN];
  67
  68         u_int32_t spare[13];    /* 68-123: Save some room for growth. */
  69
  70         DB_BTREE_LSTAT stat;    /* 124-163: Statistics. */
  71 } BTMETA;
  72
  73 /************************************************************************
  74  HASH METADATA PAGE LAYOUT
  75  ************************************************************************/
  76
  77 /*
  78  * Hash metadata page layout:
  79  *
  80  *      +-----------------------------------+
  81  *      |    lsn    |   magic   |  version  |
  82  *      +-----------------------------------+
  83  *      |  pagesize | ovfl_point| last_freed|
  84  *      +-----------------------------------+
  85  *      | max_bucket| high_mask | low_mask  |
  86  *      +-----------------------------------+
  87  *      | ffactor   |   nelem   | charkey   |
  88  *      +-----------------------------------+
  89  *      | spares[32]|   flags   | unused    |
  90  *      +-----------------------------------+
  91  */
  92 /* Hash Table Information */
  93 typedef struct hashhdr {        /* Disk resident portion */
  94         DB_LSN  lsn;            /* 00-07: LSN of the header page */
  95         db_pgno_t pgno;         /* 08-11: Page number (btree compatibility). */
  96         u_int32_t magic;        /* 12-15: Magic NO for hash tables */
  97         u_int32_t version;      /* 16-19: Version ID */
  98         u_int32_t pagesize;     /* 20-23: Bucket/Page Size */
  99         u_int32_t ovfl_point;   /* 24-27: Overflow page allocation location */
 100         u_int32_t last_freed;   /* 28-31: Last freed overflow page pgno */
 101         u_int32_t max_bucket;   /* 32-35: ID of Maximum bucket in use */
 102         u_int32_t high_mask;    /* 36-39: Modulo mask into table */
 103         u_int32_t low_mask;     /* 40-43: Modulo mask into table lower half */
 104         u_int32_t ffactor;      /* 44-47: Fill factor */
 105         u_int32_t nelem;        /* 48-51: Number of keys in hash table */
 106         u_int32_t h_charkey;    /* 52-55: Value of hash(CHARKEY) */
 107 #define DB_HASH_DUP     0x01
 108         u_int32_t flags;        /* 56-59: Allow duplicates. */
 109 #define NCACHED 32              /* number of spare points */
 110                                 /* 60-187: Spare pages for overflow */
 111         u_int32_t spares[NCACHED];
 112                                 /* 188-207: Unique file ID. */
 113         u_int8_t  uid[DB_FILE_ID_LEN];
 114
 115         /*
 116          * Minimum page size is 256.
 117          */
 118 } HASHHDR;
 119
 120 /************************************************************************
 121  MAIN PAGE LAYOUT
 122  ************************************************************************/
 123
 124 /*
 125  *      +-----------------------------------+
 126  *      |    lsn    |   pgno    | prev pgno |
 127  *      +-----------------------------------+
 128  *      | next pgno |  entries  | hf offset |
 129  *      +-----------------------------------+
 130  *      |   level   |   type    |   index   |
 131  *      +-----------------------------------+
 132  *      |   index   | free -->              |
 133  *      +-----------+-----------------------+
 134  *      |        F R E E A R E A            |
 135  *      +-----------------------------------+
 136  *      |              <-- free |   item    |
 137  *      +-----------------------------------+
 138  *      |   item    |   item    |   item    |
 139  *      +-----------------------------------+
 140  *
 141  * sizeof(PAGE) == 26 bytes, and the following indices are guaranteed to be
 142  * two-byte aligned.
 143  *
 144  * For hash and btree leaf pages, index items are paired, e.g., inp[0] is the
 145  * key for inp[1]'s data.  All other types of pages only contain single items.
 146  */
 147 typedef struct _db_page {
 148         DB_LSN    lsn;          /* 00-07: Log sequence number. */
 149         db_pgno_t pgno;         /* 08-11: Current page number. */
 150         db_pgno_t prev_pgno;    /* 12-15: Previous page number. */
 151         db_pgno_t next_pgno;    /* 16-19: Next page number. */
 152         db_indx_t entries;      /* 20-21: Number of item pairs on the page. */
 153         db_indx_t hf_offset;    /* 22-23: High free byte page offset. */
 154
 155         /*
 156          * The btree levels are numbered from the leaf to the root, starting
 157          * with 1, so the leaf is level 1, its parent is level 2, and so on.
 158          * We maintain this level on all btree pages, but the only place that
 159          * we actually need it is on the root page.  It would not be difficult
 160          * to hide the byte on the root page once it becomes an internal page,
 161          * so we could get this byte back if we needed it for something else.
 162          */
 163 #define LEAFLEVEL         1
 164 #define MAXBTREELEVEL   255
 165         u_int8_t  level;        /*    24: Btree tree level. */
 166
 167 #define P_INVALID       0       /*        Invalid page type. */
 168 #define P_DUPLICATE     1       /*        Duplicate. */
 169 #define P_HASH          2       /*        Hash. */
 170 #define P_IBTREE        3       /*        Btree internal. */
 171 #define P_IRECNO        4       /*        Recno internal. */
 172 #define P_LBTREE        5       /*        Btree leaf. */
 173 #define P_LRECNO        6       /*        Recno leaf. */
 174 #define P_OVERFLOW      7       /*        Overflow. */
 175         u_int8_t  type;         /*    25: Page type. */
 176         db_indx_t inp[1];       /* Variable length index of items. */
 177 } PAGE;
 178
 179 /* Element macros. */
 180 #define LSN(p)          (((PAGE *)p)->lsn)
 181 #define PGNO(p)         (((PAGE *)p)->pgno)
 182 #define PREV_PGNO(p)    (((PAGE *)p)->prev_pgno)
 183 #define NEXT_PGNO(p)    (((PAGE *)p)->next_pgno)
 184 #define NUM_ENT(p)      (((PAGE *)p)->entries)
 185 #define HOFFSET(p)      (((PAGE *)p)->hf_offset)
 186 #define LEVEL(p)        (((PAGE *)p)->level)
 187 #define TYPE(p)         (((PAGE *)p)->type)
 188
 189 /*
 190  * !!!
 191  * The next_pgno and prev_pgno fields are not maintained for btree and recno
 192  * internal pages.  It's a minor performance improvement, and more, it's
 193  * hard to do when deleting internal pages, and it decreases the chance of
 194  * deadlock during deletes and splits.
 195  *
 196  * !!!
 197  * The btree/recno access method needs db_recno_t bytes of space on the root
 198  * page to specify how many records are stored in the tree.  (The alternative
 199  * is to store the number of records in the meta-data page, which will create
 200  * a second hot spot in trees being actively modified, or recalculate it from
 201  * the BINTERNAL fields on each access.)  Overload the prev_pgno field.
 202  */
 203 #define RE_NREC(p)                                                      \
 204         (TYPE(p) == P_LBTREE ? NUM_ENT(p) / 2 :                         \
 205             TYPE(p) == P_LRECNO ? NUM_ENT(p) : PREV_PGNO(p))
 206 #define RE_NREC_ADJ(p, adj)                                             \
 207         PREV_PGNO(p) += adj;
 208 #define RE_NREC_SET(p, num)                                             \
 209         PREV_PGNO(p) = num;
 210
 211 /*
 212  * Initialize a page.
 213  *
 214  * !!!
 215  * Don't modify the page's LSN, code depends on it being unchanged after a
 216  * P_INIT call.
 217  */
 218 #define P_INIT(pg, pg_size, n, pg_prev, pg_next, btl, pg_type) do {     \
 219         PGNO(pg) = n;                                                   \
 220         PREV_PGNO(pg) = pg_prev;                                        \
 221         NEXT_PGNO(pg) = pg_next;                                        \
 222         NUM_ENT(pg) = 0;                                                \
 223         HOFFSET(pg) = pg_size;                                          \
 224         LEVEL(pg) = btl;                                                \
 225         TYPE(pg) = pg_type;                                             \
 226 } while (0)
 227
 228 /* Page header length (offset to first index). */
 229 #define P_OVERHEAD              (SSZA(PAGE, inp))
 230
 231 /* First free byte. */
 232 #define LOFFSET(pg)             (P_OVERHEAD + NUM_ENT(pg) * sizeof(db_indx_t))
 233
 234 /* Free space on the page. */
 235 #define P_FREESPACE(pg)         (HOFFSET(pg) - LOFFSET(pg))
 236
 237 /* Get a pointer to the bytes at a specific index. */
 238 #define P_ENTRY(pg, indx)       ((u_int8_t *)pg + ((PAGE *)pg)->inp[indx])
 239
 240 /************************************************************************
 241  OVERFLOW PAGE LAYOUT
 242  ************************************************************************/
 243
 244 /*
 245  * Overflow items are referenced by HOFFPAGE and BOVERFLOW structures, which
 246  * store a page number (the first page of the overflow item) and a length
 247  * (the total length of the overflow item).  The overflow item consists of
 248  * some number of overflow pages, linked by the next_pgno field of the page.
 249  * A next_pgno field of PGNO_INVALID flags the end of the overflow item.
 250  *
 251  * Overflow page overloads:
 252  *      The amount of overflow data stored on each page is stored in the
 253  *      hf_offset field.
 254  *
 255  *      The implementation reference counts overflow items as it's possible
 256  *      for them to be promoted onto btree internal pages.  The reference
 257  *      count is stored in the entries field.
 258  */
 259 #define OV_LEN(p)       (((PAGE *)p)->hf_offset)
 260 #define OV_REF(p)       (((PAGE *)p)->entries)
 261
 262 /* Maximum number of bytes that you can put on an overflow page. */
 263 #define P_MAXSPACE(psize)       ((psize) - P_OVERHEAD)
 264
 265 /************************************************************************
 266  HASH PAGE LAYOUT
 267  ************************************************************************/
 268
 269 /* Each index references a group of bytes on the page. */
 270 #define H_KEYDATA       1       /* Key/data item. */
 271 #define H_DUPLICATE     2       /* Duplicate key/data item. */
 272 #define H_OFFPAGE       3       /* Overflow key/data item. */
 273 #define H_OFFDUP        4       /* Overflow page of duplicates. */
 274
 275 /*
 276  * !!!
 277  * Items on hash pages are (potentially) unaligned, so we can never cast the
 278  * (page + offset) pointer to an HKEYDATA, HOFFPAGE or HOFFDUP structure, as
 279  * we do with B+tree on-page structures.  Because we frequently want the type
 280  * field, it requires no alignment, and it's in the same location in all three
 281  * structures, there's a pair of macros.
 282  */
 283 #define HPAGE_PTYPE(p)          (*(u_int8_t *)p)
 284 #define HPAGE_TYPE(pg, indx)    (*P_ENTRY(pg, indx))
 285
 286 /*
 287  * The first and second types are H_KEYDATA and H_DUPLICATE, represented
 288  * by the HKEYDATA structure:
 289  *
 290  *      +-----------------------------------+
 291  *      |    type   | key/data ...          |
 292  *      +-----------------------------------+
 293  *
 294  * For duplicates, the data field encodes duplicate elements in the data
 295  * field:
 296  *
 297  *      +---------------------------------------------------------------+
 298  *      |    type   | len1 | element1 | len1 | len2 | element2 | len2   |
 299  *      +---------------------------------------------------------------+
 300  *
 301  * Thus, by keeping track of the offset in the element, we can do both
 302  * backward and forward traversal.
 303  */
 304 typedef struct _hkeydata {
 305         u_int8_t  type;         /*    00: Page type. */
 306         u_int8_t  data[1];      /* Variable length key/data item. */
 307 } HKEYDATA;
 308 #define HKEYDATA_DATA(p)        (((u_int8_t *)p) + SSZA(HKEYDATA, data))
 309
 310 /*
 311  * The length of any HKEYDATA item. Note that indx is an element index,
 312  * not a PAIR index.
 313  */
 314 #define LEN_HITEM(pg, pgsize, indx)                                     \
 315         (((indx) == 0 ? pgsize : pg->inp[indx - 1]) - pg->inp[indx])
 316
 317 #define LEN_HKEYDATA(pg, psize, indx)                                   \
 318         (((indx) == 0 ? psize : pg->inp[indx - 1]) -                    \
 319         pg->inp[indx] - HKEYDATA_SIZE(0))
 320
 321 /*
 322  * Page space required to add a new HKEYDATA item to the page, with and
 323  * without the index value.
 324  */
 325 #define HKEYDATA_SIZE(len)                                              \
 326         ((len) + SSZA(HKEYDATA, data))
 327 #define HKEYDATA_PSIZE(len)                                             \
 328         (HKEYDATA_SIZE(len) + sizeof(db_indx_t))
 329
 330 /* Put a HKEYDATA item at the location referenced by a page entry. */
 331 #define PUT_HKEYDATA(pe, kd, len, type) {                               \
 332         ((HKEYDATA *)pe)->type = type;                                  \
 333         memcpy((u_int8_t *)pe + sizeof(u_int8_t), kd, len);             \
 334 }
 335
 336 /*
 337  * Macros the describe the page layout in terms of key-data pairs.
 338  * The use of "pindex" indicates that the argument is the index
 339  * expressed in pairs instead of individual elements.
 340  */
 341 #define H_NUMPAIRS(pg)                  (NUM_ENT(pg) / 2)
 342 #define H_KEYINDEX(pindx)               (2 * (pindx))
 343 #define H_DATAINDEX(pindx)              ((2 * (pindx)) + 1)
 344 #define H_PAIRKEY(pg, pindx)            P_ENTRY(pg, H_KEYINDEX(pindx))
 345 #define H_PAIRDATA(pg, pindx)           P_ENTRY(pg, H_DATAINDEX(pindx))
 346 #define H_PAIRSIZE(pg, psize, pindx)                                    \
 347         (LEN_HITEM(pg, psize, H_KEYINDEX(pindx)) +                      \
 348         LEN_HITEM(pg, psize, H_DATAINDEX(pindx)))
 349 #define LEN_HDATA(p, psize, pindx) LEN_HKEYDATA(p, psize, H_DATAINDEX(pindx))
 350 #define LEN_HKEY(p, psize, pindx) LEN_HKEYDATA(p, psize, H_KEYINDEX(pindx))
 351
 352 /*
 353  * The third type is the H_OFFPAGE, represented by the HOFFPAGE structure:
 354  *
 355  *      +-----------------------------------+
 356  *      |   type    |  pgno_t   | total len |
 357  *      +-----------------------------------+
 358  */
 359 typedef struct _hoffpage {
 360         u_int8_t  type;         /*    00: Page type and delete flag. */
 361         u_int8_t  unused[3];    /* 01-03: Padding, unused. */
 362         db_pgno_t pgno;         /* 04-07: Offpage page number. */
 363         u_int32_t tlen;         /* 08-11: Total length of item. */
 364 } HOFFPAGE;
 365
 366 #define HOFFPAGE_PGNO(p)        (((u_int8_t *)p) + SSZ(HOFFPAGE, pgno))
 367 #define HOFFPAGE_TLEN(p)        (((u_int8_t *)p) + SSZ(HOFFPAGE, tlen))
 368
 369 /*
 370  * Page space required to add a new HOFFPAGE item to the page, with and
 371  * without the index value.
 372  */
 373 #define HOFFPAGE_SIZE           (sizeof(HOFFPAGE))
 374 #define HOFFPAGE_PSIZE          (HOFFPAGE_SIZE + sizeof(db_indx_t))
 375
 376 /*
 377  * The fourth type is H_OFFDUP represented by the HOFFDUP structure:
 378  *
 379  *      +-----------------------+
 380  *      |   type    |  pgno_t   |
 381  *      +-----------------------+
 382  */
 383 typedef struct _hoffdup {
 384         u_int8_t  type;         /*    00: Page type and delete flag. */
 385         u_int8_t  unused[3];    /* 01-03: Padding, unused. */
 386         db_pgno_t pgno;         /* 04-07: Offpage page number. */
 387 } HOFFDUP;
 388 #define HOFFDUP_PGNO(p)         (((u_int8_t *)p) + SSZ(HOFFDUP, pgno))
 389
 390 /*
 391  * Page space required to add a new HOFFDUP item to the page, with and
 392  * without the index value.
 393  */
 394 #define HOFFDUP_SIZE            (sizeof(HOFFDUP))
 395 #define HOFFDUP_PSIZE           (HOFFDUP_SIZE + sizeof(db_indx_t))
 396
 397 /************************************************************************
 398  BTREE PAGE LAYOUT
 399  ************************************************************************/
 400
 401 /* Each index references a group of bytes on the page. */
 402 #define B_KEYDATA       1       /* Key/data item. */
 403 #define B_DUPLICATE     2       /* Duplicate key/data item. */
 404 #define B_OVERFLOW      3       /* Overflow key/data item. */
 405
 406 /*
 407  * We have to store a deleted entry flag in the page.   The reason is complex,
 408  * but the simple version is that we can't delete on-page items referenced by
 409  * a cursor -- the return order of subsequent insertions might be wrong.  The
 410  * delete flag is an overload of the top bit of the type byte.
 411  */
 412 #define B_DELETE        (0x80)
 413 #define B_DCLR(t)       (t) &= ~B_DELETE
 414 #define B_DSET(t)       (t) |= B_DELETE
 415 #define B_DISSET(t)     ((t) & B_DELETE)
 416
 417 #define B_TYPE(t)       ((t) & ~B_DELETE)
 418 #define B_TSET(t, type, deleted) {                                      \
 419         (t) = (type);                                                   \
 420         if (deleted)                                                    \
 421                 B_DSET(t);                                              \
 422 }
 423
 424 /*
 425  * The first type is B_KEYDATA, represented by the BKEYDATA structure:
 426  *
 427  *      +-----------------------------------+
 428  *      |   length  |    type   | key/data  |
 429  *      +-----------------------------------+
 430  */
 431 typedef struct _bkeydata {
 432         db_indx_t len;          /* 00-01: Key/data item length. */
 433         u_int8_t  type;         /*    02: Page type AND DELETE FLAG. */
 434         u_int8_t  data[1];      /* Variable length key/data item. */
 435 } BKEYDATA;
 436
 437 /* Get a BKEYDATA item for a specific index. */
 438 #define GET_BKEYDATA(pg, indx)                                          \
 439         ((BKEYDATA *)P_ENTRY(pg, indx))
 440
 441 /*
 442  * Page space required to add a new BKEYDATA item to the page, with and
 443  * without the index value.
 444  */
 445 #define BKEYDATA_SIZE(len)                                              \
 446         ALIGN((len) + SSZA(BKEYDATA, data), 4)
 447 #define BKEYDATA_PSIZE(len)                                             \
 448         (BKEYDATA_SIZE(len) + sizeof(db_indx_t))
 449
 450 /*
 451  * The second and third types are B_DUPLICATE and B_OVERFLOW, represented
 452  * by the BOVERFLOW structure:
 453  *
 454  *      +-----------------------------------+
 455  *      | total len |    type   |   unused  |
 456  *      +-----------------------------------+
 457  *      | nxt: page |  nxt: off | nxt: len  |
 458  *      +-----------------------------------+
 459  */
 460 typedef struct _boverflow {
 461         db_indx_t unused1;      /* 00-01: Padding, unused. */
 462         u_int8_t  type;         /*    02: Page type AND DELETE FLAG. */
 463         u_int8_t  unused2;      /*    03: Padding, unused. */
 464         db_pgno_t pgno;         /* 04-07: Next page number. */
 465         u_int32_t tlen;         /* 08-11: Total length of item. */
 466 } BOVERFLOW;
 467
 468 /* Get a BOVERFLOW item for a specific index. */
 469 #define GET_BOVERFLOW(pg, indx)                                         \
 470         ((BOVERFLOW *)P_ENTRY(pg, indx))
 471
 472 /*
 473  * Page space required to add a new BOVERFLOW item to the page, with and
 474  * without the index value.
 475  */
 476 #define BOVERFLOW_SIZE                                                  \
 477         ALIGN(sizeof(BOVERFLOW), 4)
 478 #define BOVERFLOW_PSIZE                                                 \
 479         (BOVERFLOW_SIZE + sizeof(db_indx_t))
 480
 481 /*
 482  * Btree leaf and hash page layouts group indices in sets of two, one
 483  * for the key and one for the data.  Everything else does it in sets
 484  * of one to save space.  I use the following macros so that it's real
 485  * obvious what's going on...
 486  */
 487 #define O_INDX  1
 488 #define P_INDX  2
 489
 490 /************************************************************************
 491  BTREE INTERNAL PAGE LAYOUT
 492  ************************************************************************/
 493
 494 /*
 495  * Btree internal entry.
 496  *
 497  *      +-----------------------------------+
 498  *      | leaf pgno |   type    | data ...  |
 499  *      +-----------------------------------+
 500  */
 501 typedef struct _binternal {
 502         db_indx_t  len;         /* 00-01: Key/data item length. */
 503         u_int8_t   type;        /*    02: Page type AND DELETE FLAG. */
 504         u_int8_t   unused;      /*    03: Padding, unused. */
 505         db_pgno_t  pgno;        /* 04-07: Page number of referenced page. */
 506         db_recno_t nrecs;       /* 08-11: Subtree record count. */
 507         u_int8_t   data[1];     /* Variable length key item. */
 508 } BINTERNAL;
 509
 510 /* Get a BINTERNAL item for a specific index. */
 511 #define GET_BINTERNAL(pg, indx)                                         \
 512         ((BINTERNAL *)P_ENTRY(pg, indx))
 513
 514 /*
 515  * Page space required to add a new BINTERNAL item to the page, with and
 516  * without the index value.
 517  */
 518 #define BINTERNAL_SIZE(len)                                             \
 519         ALIGN((len) + SSZA(BINTERNAL, data), 4)
 520 #define BINTERNAL_PSIZE(len)                                            \
 521         (BINTERNAL_SIZE(len) + sizeof(db_indx_t))
 522
 523 /************************************************************************
 524  RECNO INTERNAL PAGE LAYOUT
 525  ************************************************************************/
 526
 527 /*
 528  * The recno internal entry.
 529  *
 530  *      +-----------------------+
 531  *      | leaf pgno | # of recs |
 532  *      +-----------------------+
 533  *
 534  * XXX
 535  * Why not fold this into the db_indx_t structure, it's fixed length.
 536  */
 537 typedef struct _rinternal {
 538         db_pgno_t  pgno;        /* 00-03: Page number of referenced page. */
 539         db_recno_t nrecs;       /* 04-07: Subtree record count. */
 540 } RINTERNAL;
 541
 542 /* Get a RINTERNAL item for a specific index. */
 543 #define GET_RINTERNAL(pg, indx)                                         \
 544         ((RINTERNAL *)P_ENTRY(pg, indx))
 545
 546 /*
 547  * Page space required to add a new RINTERNAL item to the page, with and
 548  * without the index value.
 549  */
 550 #define RINTERNAL_SIZE                                                  \
 551         ALIGN(sizeof(RINTERNAL), 4)
 552 #define RINTERNAL_PSIZE                                                 \
 553         (RINTERNAL_SIZE + sizeof(db_indx_t))
 554 #endif /* _DB_PAGE_H_ */