db2/btree/btree_auto.c

   1 /* Do not edit: automatically built by dist/db_gen.sh. */
   2 #include "config.h"
   3
   4 #ifndef NO_SYSTEM_INCLUDES
   5 #include <ctype.h>
   6 #include <errno.h>
   7 #include <stddef.h>
   8 #include <stdlib.h>
   9 #include <string.h>
  10 #endif
  11
  12 #include "db_int.h"
  13 #include "shqueue.h"
  14 #include "db_page.h"
  15 #include "db_dispatch.h"
  16 #include "btree.h"
  17 #include "db_am.h"
  18 #include "common_ext.h"
  19
  20 /*
  21  * PUBLIC: int __bam_pg_alloc_log
  22  * PUBLIC:     __P((DB_LOG *, DB_TXN *, DB_LSN *, u_int32_t,
  23  * PUBLIC:     u_int32_t, DB_LSN *, DB_LSN *, db_pgno_t,
  24  * PUBLIC:     u_int32_t, db_pgno_t));
  25  */
  26 int __bam_pg_alloc_log(logp, txnid, ret_lsnp, flags,
  27         fileid, meta_lsn, page_lsn, pgno, ptype, next)
  28         DB_LOG *logp;
  29         DB_TXN *txnid;
  30         DB_LSN *ret_lsnp;
  31         u_int32_t flags;
  32         u_int32_t fileid;
  33         DB_LSN * meta_lsn;
  34         DB_LSN * page_lsn;
  35         db_pgno_t pgno;
  36         u_int32_t ptype;
  37         db_pgno_t next;
  38 {
  39         DBT logrec;
  40         DB_LSN *lsnp, null_lsn;
  41         u_int32_t rectype, txn_num;
  42         int ret;
  43         u_int8_t *bp;
  44
  45         rectype = DB_bam_pg_alloc;
  46         txn_num = txnid == NULL ? 0 : txnid->txnid;
  47         if (txnid == NULL) {
  48                 null_lsn.file = 0;
  49                 null_lsn.offset = 0;
  50                 lsnp = &null_lsn;
  51         } else
  52                 lsnp = &txnid->last_lsn;
  53         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  54             + sizeof(fileid)
  55             + sizeof(*meta_lsn)
  56             + sizeof(*page_lsn)
  57             + sizeof(pgno)
  58             + sizeof(ptype)
  59             + sizeof(next);
  60         if ((logrec.data = (void *)malloc(logrec.size)) == NULL)
  61                 return (ENOMEM);
  62
  63         bp = logrec.data;
  64         memcpy(bp, &rectype, sizeof(rectype));
  65         bp += sizeof(rectype);
  66         memcpy(bp, &txn_num, sizeof(txn_num));
  67         bp += sizeof(txn_num);
  68         memcpy(bp, lsnp, sizeof(DB_LSN));
  69         bp += sizeof(DB_LSN);
  70         memcpy(bp, &fileid, sizeof(fileid));
  71         bp += sizeof(fileid);
  72         if (meta_lsn != NULL)
  73                 memcpy(bp, meta_lsn, sizeof(*meta_lsn));
  74         else
  75                 memset(bp, 0, sizeof(*meta_lsn));
  76         bp += sizeof(*meta_lsn);
  77         if (page_lsn != NULL)
  78                 memcpy(bp, page_lsn, sizeof(*page_lsn));
  79         else
  80                 memset(bp, 0, sizeof(*page_lsn));
  81         bp += sizeof(*page_lsn);
  82         memcpy(bp, &pgno, sizeof(pgno));
  83         bp += sizeof(pgno);
  84         memcpy(bp, &ptype, sizeof(ptype));
  85         bp += sizeof(ptype);
  86         memcpy(bp, &next, sizeof(next));
  87         bp += sizeof(next);
  88 #ifdef DEBUG
  89         if ((u_int32_t)(bp - (u_int8_t *)logrec.data) != logrec.size)
  90                 fprintf(stderr, "Error in log record length");
  91 #endif
  92         ret = log_put(logp, ret_lsnp, (DBT *)&logrec, flags);
  93         if (txnid != NULL)
  94                 txnid->last_lsn = *ret_lsnp;
  95         free(logrec.data);
  96         return (ret);
  97 }
  98
  99 /*
 100  * PUBLIC: int __bam_pg_alloc_print
 101  * PUBLIC:    __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
 102  */
 103
 104 int
 105 __bam_pg_alloc_print(notused1, dbtp, lsnp, notused3, notused4)
 106         DB_LOG *notused1;
 107         DBT *dbtp;
 108         DB_LSN *lsnp;
 109         int notused3;
 110         void *notused4;
 111 {
 112         __bam_pg_alloc_args *argp;
 113         u_int32_t i;
 114         int c, ret;
 115
 116         i = 0;
 117         c = 0;
 118         notused1 = NULL;
 119         notused3 = 0;
 120         notused4 = NULL;
 121
 122         if ((ret = __bam_pg_alloc_read(dbtp->data, &argp)) != 0)
 123                 return (ret);
 124         printf("[%lu][%lu]bam_pg_alloc: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
 125             (u_long)lsnp->file,
 126             (u_long)lsnp->offset,
 127             (u_long)argp->type,
 128             (u_long)argp->txnid->txnid,
 129             (u_long)argp->prev_lsn.file,
 130             (u_long)argp->prev_lsn.offset);
 131         printf("\tfileid: %lu\n", (u_long)argp->fileid);
 132         printf("\tmeta_lsn: [%lu][%lu]\n",
 133             (u_long)argp->meta_lsn.file, (u_long)argp->meta_lsn.offset);
 134         printf("\tpage_lsn: [%lu][%lu]\n",
 135             (u_long)argp->page_lsn.file, (u_long)argp->page_lsn.offset);
 136         printf("\tpgno: %lu\n", (u_long)argp->pgno);
 137         printf("\tptype: %lu\n", (u_long)argp->ptype);
 138         printf("\tnext: %lu\n", (u_long)argp->next);
 139         printf("\n");
 140         free(argp);
 141         return (0);
 142 }
 143
 144 /*
 145  * PUBLIC: int __bam_pg_alloc_read __P((void *, __bam_pg_alloc_args **));
 146  */
 147 int
 148 __bam_pg_alloc_read(recbuf, argpp)
 149         void *recbuf;
 150         __bam_pg_alloc_args **argpp;
 151 {
 152         __bam_pg_alloc_args *argp;
 153         u_int8_t *bp;
 154
 155         argp = (__bam_pg_alloc_args *)malloc(sizeof(__bam_pg_alloc_args) +
 156             sizeof(DB_TXN));
 157         if (argp == NULL)
 158                 return (ENOMEM);
 159         argp->txnid = (DB_TXN *)&argp[1];
 160         bp = recbuf;
 161         memcpy(&argp->type, bp, sizeof(argp->type));
 162         bp += sizeof(argp->type);
 163         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
 164         bp += sizeof(argp->txnid->txnid);
 165         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
 166         bp += sizeof(DB_LSN);
 167         memcpy(&argp->fileid, bp, sizeof(argp->fileid));
 168         bp += sizeof(argp->fileid);
 169         memcpy(&argp->meta_lsn, bp,  sizeof(argp->meta_lsn));
 170         bp += sizeof(argp->meta_lsn);
 171         memcpy(&argp->page_lsn, bp,  sizeof(argp->page_lsn));
 172         bp += sizeof(argp->page_lsn);
 173         memcpy(&argp->pgno, bp, sizeof(argp->pgno));
 174         bp += sizeof(argp->pgno);
 175         memcpy(&argp->ptype, bp, sizeof(argp->ptype));
 176         bp += sizeof(argp->ptype);
 177         memcpy(&argp->next, bp, sizeof(argp->next));
 178         bp += sizeof(argp->next);
 179         *argpp = argp;
 180         return (0);
 181 }
 182
 183 /*
 184  * PUBLIC: int __bam_pg_free_log
 185  * PUBLIC:     __P((DB_LOG *, DB_TXN *, DB_LSN *, u_int32_t,
 186  * PUBLIC:     u_int32_t, db_pgno_t, DB_LSN *, DBT *,
 187  * PUBLIC:     db_pgno_t));
 188  */
 189 int __bam_pg_free_log(logp, txnid, ret_lsnp, flags,
 190         fileid, pgno, meta_lsn, header, next)
 191         DB_LOG *logp;
 192         DB_TXN *txnid;
 193         DB_LSN *ret_lsnp;
 194         u_int32_t flags;
 195         u_int32_t fileid;
 196         db_pgno_t pgno;
 197         DB_LSN * meta_lsn;
 198         DBT *header;
 199         db_pgno_t next;
 200 {
 201         DBT logrec;
 202         DB_LSN *lsnp, null_lsn;
 203         u_int32_t zero;
 204         u_int32_t rectype, txn_num;
 205         int ret;
 206         u_int8_t *bp;
 207
 208         rectype = DB_bam_pg_free;
 209         txn_num = txnid == NULL ? 0 : txnid->txnid;
 210         if (txnid == NULL) {
 211                 null_lsn.file = 0;
 212                 null_lsn.offset = 0;
 213                 lsnp = &null_lsn;
 214         } else
 215                 lsnp = &txnid->last_lsn;
 216         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
 217             + sizeof(fileid)
 218             + sizeof(pgno)
 219             + sizeof(*meta_lsn)
 220             + sizeof(u_int32_t) + (header == NULL ? 0 : header->size)
 221             + sizeof(next);
 222         if ((logrec.data = (void *)malloc(logrec.size)) == NULL)
 223                 return (ENOMEM);
 224
 225         bp = logrec.data;
 226         memcpy(bp, &rectype, sizeof(rectype));
 227         bp += sizeof(rectype);
 228         memcpy(bp, &txn_num, sizeof(txn_num));
 229         bp += sizeof(txn_num);
 230         memcpy(bp, lsnp, sizeof(DB_LSN));
 231         bp += sizeof(DB_LSN);
 232         memcpy(bp, &fileid, sizeof(fileid));
 233         bp += sizeof(fileid);
 234         memcpy(bp, &pgno, sizeof(pgno));
 235         bp += sizeof(pgno);
 236         if (meta_lsn != NULL)
 237                 memcpy(bp, meta_lsn, sizeof(*meta_lsn));
 238         else
 239                 memset(bp, 0, sizeof(*meta_lsn));
 240         bp += sizeof(*meta_lsn);
 241         if (header == NULL) {
 242                 zero = 0;
 243                 memcpy(bp, &zero, sizeof(u_int32_t));
 244                 bp += sizeof(u_int32_t);
 245         } else {
 246                 memcpy(bp, &header->size, sizeof(header->size));
 247                 bp += sizeof(header->size);
 248                 memcpy(bp, header->data, header->size);
 249                 bp += header->size;
 250         }
 251         memcpy(bp, &next, sizeof(next));
 252         bp += sizeof(next);
 253 #ifdef DEBUG
 254         if ((u_int32_t)(bp - (u_int8_t *)logrec.data) != logrec.size)
 255                 fprintf(stderr, "Error in log record length");
 256 #endif
 257         ret = log_put(logp, ret_lsnp, (DBT *)&logrec, flags);
 258         if (txnid != NULL)
 259                 txnid->last_lsn = *ret_lsnp;
 260         free(logrec.data);
 261         return (ret);
 262 }
 263
 264 /*
 265  * PUBLIC: int __bam_pg_free_print
 266  * PUBLIC:    __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
 267  */
 268
 269 int
 270 __bam_pg_free_print(notused1, dbtp, lsnp, notused3, notused4)
 271         DB_LOG *notused1;
 272         DBT *dbtp;
 273         DB_LSN *lsnp;
 274         int notused3;
 275         void *notused4;
 276 {
 277         __bam_pg_free_args *argp;
 278         u_int32_t i;
 279         int c, ret;
 280
 281         i = 0;
 282         c = 0;
 283         notused1 = NULL;
 284         notused3 = 0;
 285         notused4 = NULL;
 286
 287         if ((ret = __bam_pg_free_read(dbtp->data, &argp)) != 0)
 288                 return (ret);
 289         printf("[%lu][%lu]bam_pg_free: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
 290             (u_long)lsnp->file,
 291             (u_long)lsnp->offset,
 292             (u_long)argp->type,
 293             (u_long)argp->txnid->txnid,
 294             (u_long)argp->prev_lsn.file,
 295             (u_long)argp->prev_lsn.offset);
 296         printf("\tfileid: %lu\n", (u_long)argp->fileid);
 297         printf("\tpgno: %lu\n", (u_long)argp->pgno);
 298         printf("\tmeta_lsn: [%lu][%lu]\n",
 299             (u_long)argp->meta_lsn.file, (u_long)argp->meta_lsn.offset);
 300         printf("\theader: ");
 301         for (i = 0; i < argp->header.size; i++) {
 302                 c = ((char *)argp->header.data)[i];
 303                 if (isprint(c) || c == 0xa)
 304                         putchar(c);
 305                 else
 306                         printf("%#x ", c);
 307         }
 308         printf("\n");
 309         printf("\tnext: %lu\n", (u_long)argp->next);
 310         printf("\n");
 311         free(argp);
 312         return (0);
 313 }
 314
 315 /*
 316  * PUBLIC: int __bam_pg_free_read __P((void *, __bam_pg_free_args **));
 317  */
 318 int
 319 __bam_pg_free_read(recbuf, argpp)
 320         void *recbuf;
 321         __bam_pg_free_args **argpp;
 322 {
 323         __bam_pg_free_args *argp;
 324         u_int8_t *bp;
 325
 326         argp = (__bam_pg_free_args *)malloc(sizeof(__bam_pg_free_args) +
 327             sizeof(DB_TXN));
 328         if (argp == NULL)
 329                 return (ENOMEM);
 330         argp->txnid = (DB_TXN *)&argp[1];
 331         bp = recbuf;
 332         memcpy(&argp->type, bp, sizeof(argp->type));
 333         bp += sizeof(argp->type);
 334         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
 335         bp += sizeof(argp->txnid->txnid);
 336         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
 337         bp += sizeof(DB_LSN);
 338         memcpy(&argp->fileid, bp, sizeof(argp->fileid));
 339         bp += sizeof(argp->fileid);
 340         memcpy(&argp->pgno, bp, sizeof(argp->pgno));
 341         bp += sizeof(argp->pgno);
 342         memcpy(&argp->meta_lsn, bp,  sizeof(argp->meta_lsn));
 343         bp += sizeof(argp->meta_lsn);
 344         memcpy(&argp->header.size, bp, sizeof(u_int32_t));
 345         bp += sizeof(u_int32_t);
 346         argp->header.data = bp;
 347         bp += argp->header.size;
 348         memcpy(&argp->next, bp, sizeof(argp->next));
 349         bp += sizeof(argp->next);
 350         *argpp = argp;
 351         return (0);
 352 }
 353
 354 /*
 355  * PUBLIC: int __bam_split_log
 356  * PUBLIC:     __P((DB_LOG *, DB_TXN *, DB_LSN *, u_int32_t,
 357  * PUBLIC:     u_int32_t, db_pgno_t, DB_LSN *, db_pgno_t,
 358  * PUBLIC:     DB_LSN *, u_int32_t, db_pgno_t, DB_LSN *,
 359  * PUBLIC:     DBT *));
 360  */
 361 int __bam_split_log(logp, txnid, ret_lsnp, flags,
 362         fileid, left, llsn, right, rlsn, indx,
 363         npgno, nlsn, pg)
 364         DB_LOG *logp;
 365         DB_TXN *txnid;
 366         DB_LSN *ret_lsnp;
 367         u_int32_t flags;
 368         u_int32_t fileid;
 369         db_pgno_t left;
 370         DB_LSN * llsn;
 371         db_pgno_t right;
 372         DB_LSN * rlsn;
 373         u_int32_t indx;
 374         db_pgno_t npgno;
 375         DB_LSN * nlsn;
 376         DBT *pg;
 377 {
 378         DBT logrec;
 379         DB_LSN *lsnp, null_lsn;
 380         u_int32_t zero;
 381         u_int32_t rectype, txn_num;
 382         int ret;
 383         u_int8_t *bp;
 384
 385         rectype = DB_bam_split;
 386         txn_num = txnid == NULL ? 0 : txnid->txnid;
 387         if (txnid == NULL) {
 388                 null_lsn.file = 0;
 389                 null_lsn.offset = 0;
 390                 lsnp = &null_lsn;
 391         } else
 392                 lsnp = &txnid->last_lsn;
 393         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
 394             + sizeof(fileid)
 395             + sizeof(left)
 396             + sizeof(*llsn)
 397             + sizeof(right)
 398             + sizeof(*rlsn)
 399             + sizeof(indx)
 400             + sizeof(npgno)
 401             + sizeof(*nlsn)
 402             + sizeof(u_int32_t) + (pg == NULL ? 0 : pg->size);
 403         if ((logrec.data = (void *)malloc(logrec.size)) == NULL)
 404                 return (ENOMEM);
 405
 406         bp = logrec.data;
 407         memcpy(bp, &rectype, sizeof(rectype));
 408         bp += sizeof(rectype);
 409         memcpy(bp, &txn_num, sizeof(txn_num));
 410         bp += sizeof(txn_num);
 411         memcpy(bp, lsnp, sizeof(DB_LSN));
 412         bp += sizeof(DB_LSN);
 413         memcpy(bp, &fileid, sizeof(fileid));
 414         bp += sizeof(fileid);
 415         memcpy(bp, &left, sizeof(left));
 416         bp += sizeof(left);
 417         if (llsn != NULL)
 418                 memcpy(bp, llsn, sizeof(*llsn));
 419         else
 420                 memset(bp, 0, sizeof(*llsn));
 421         bp += sizeof(*llsn);
 422         memcpy(bp, &right, sizeof(right));
 423         bp += sizeof(right);
 424         if (rlsn != NULL)
 425                 memcpy(bp, rlsn, sizeof(*rlsn));
 426         else
 427                 memset(bp, 0, sizeof(*rlsn));
 428         bp += sizeof(*rlsn);
 429         memcpy(bp, &indx, sizeof(indx));
 430         bp += sizeof(indx);
 431         memcpy(bp, &npgno, sizeof(npgno));
 432         bp += sizeof(npgno);
 433         if (nlsn != NULL)
 434                 memcpy(bp, nlsn, sizeof(*nlsn));
 435         else
 436                 memset(bp, 0, sizeof(*nlsn));
 437         bp += sizeof(*nlsn);
 438         if (pg == NULL) {
 439                 zero = 0;
 440                 memcpy(bp, &zero, sizeof(u_int32_t));
 441                 bp += sizeof(u_int32_t);
 442         } else {
 443                 memcpy(bp, &pg->size, sizeof(pg->size));
 444                 bp += sizeof(pg->size);
 445                 memcpy(bp, pg->data, pg->size);
 446                 bp += pg->size;
 447         }
 448 #ifdef DEBUG
 449         if ((u_int32_t)(bp - (u_int8_t *)logrec.data) != logrec.size)
 450                 fprintf(stderr, "Error in log record length");
 451 #endif
 452         ret = log_put(logp, ret_lsnp, (DBT *)&logrec, flags);
 453         if (txnid != NULL)
 454                 txnid->last_lsn = *ret_lsnp;
 455         free(logrec.data);
 456         return (ret);
 457 }
 458
 459 /*
 460  * PUBLIC: int __bam_split_print
 461  * PUBLIC:    __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
 462  */
 463
 464 int
 465 __bam_split_print(notused1, dbtp, lsnp, notused3, notused4)
 466         DB_LOG *notused1;
 467         DBT *dbtp;
 468         DB_LSN *lsnp;
 469         int notused3;
 470         void *notused4;
 471 {
 472         __bam_split_args *argp;
 473         u_int32_t i;
 474         int c, ret;
 475
 476         i = 0;
 477         c = 0;
 478         notused1 = NULL;
 479         notused3 = 0;
 480         notused4 = NULL;
 481
 482         if ((ret = __bam_split_read(dbtp->data, &argp)) != 0)
 483                 return (ret);
 484         printf("[%lu][%lu]bam_split: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
 485             (u_long)lsnp->file,
 486             (u_long)lsnp->offset,
 487             (u_long)argp->type,
 488             (u_long)argp->txnid->txnid,
 489             (u_long)argp->prev_lsn.file,
 490             (u_long)argp->prev_lsn.offset);
 491         printf("\tfileid: %lu\n", (u_long)argp->fileid);
 492         printf("\tleft: %lu\n", (u_long)argp->left);
 493         printf("\tllsn: [%lu][%lu]\n",
 494             (u_long)argp->llsn.file, (u_long)argp->llsn.offset);
 495         printf("\tright: %lu\n", (u_long)argp->right);
 496         printf("\trlsn: [%lu][%lu]\n",
 497             (u_long)argp->rlsn.file, (u_long)argp->rlsn.offset);
 498         printf("\tindx: %lu\n", (u_long)argp->indx);
 499         printf("\tnpgno: %lu\n", (u_long)argp->npgno);
 500         printf("\tnlsn: [%lu][%lu]\n",
 501             (u_long)argp->nlsn.file, (u_long)argp->nlsn.offset);
 502         printf("\tpg: ");
 503         for (i = 0; i < argp->pg.size; i++) {
 504                 c = ((char *)argp->pg.data)[i];
 505                 if (isprint(c) || c == 0xa)
 506                         putchar(c);
 507                 else
 508                         printf("%#x ", c);
 509         }
 510         printf("\n");
 511         printf("\n");
 512         free(argp);
 513         return (0);
 514 }
 515
 516 /*
 517  * PUBLIC: int __bam_split_read __P((void *, __bam_split_args **));
 518  */
 519 int
 520 __bam_split_read(recbuf, argpp)
 521         void *recbuf;
 522         __bam_split_args **argpp;
 523 {
 524         __bam_split_args *argp;
 525         u_int8_t *bp;
 526
 527         argp = (__bam_split_args *)malloc(sizeof(__bam_split_args) +
 528             sizeof(DB_TXN));
 529         if (argp == NULL)
 530                 return (ENOMEM);
 531         argp->txnid = (DB_TXN *)&argp[1];
 532         bp = recbuf;
 533         memcpy(&argp->type, bp, sizeof(argp->type));
 534         bp += sizeof(argp->type);
 535         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
 536         bp += sizeof(argp->txnid->txnid);
 537         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
 538         bp += sizeof(DB_LSN);
 539         memcpy(&argp->fileid, bp, sizeof(argp->fileid));
 540         bp += sizeof(argp->fileid);
 541         memcpy(&argp->left, bp, sizeof(argp->left));
 542         bp += sizeof(argp->left);
 543         memcpy(&argp->llsn, bp,  sizeof(argp->llsn));
 544         bp += sizeof(argp->llsn);
 545         memcpy(&argp->right, bp, sizeof(argp->right));
 546         bp += sizeof(argp->right);
 547         memcpy(&argp->rlsn, bp,  sizeof(argp->rlsn));
 548         bp += sizeof(argp->rlsn);
 549         memcpy(&argp->indx, bp, sizeof(argp->indx));
 550         bp += sizeof(argp->indx);
 551         memcpy(&argp->npgno, bp, sizeof(argp->npgno));
 552         bp += sizeof(argp->npgno);
 553         memcpy(&argp->nlsn, bp,  sizeof(argp->nlsn));
 554         bp += sizeof(argp->nlsn);
 555         memcpy(&argp->pg.size, bp, sizeof(u_int32_t));
 556         bp += sizeof(u_int32_t);
 557         argp->pg.data = bp;
 558         bp += argp->pg.size;
 559         *argpp = argp;
 560         return (0);
 561 }
 562
 563 /*
 564  * PUBLIC: int __bam_rsplit_log
 565  * PUBLIC:     __P((DB_LOG *, DB_TXN *, DB_LSN *, u_int32_t,
 566  * PUBLIC:     u_int32_t, db_pgno_t, DBT *, DBT *,
 567  * PUBLIC:     DB_LSN *));
 568  */
 569 int __bam_rsplit_log(logp, txnid, ret_lsnp, flags,
 570         fileid, pgno, pgdbt, rootent, rootlsn)
 571         DB_LOG *logp;
 572         DB_TXN *txnid;
 573         DB_LSN *ret_lsnp;
 574         u_int32_t flags;
 575         u_int32_t fileid;
 576         db_pgno_t pgno;
 577         DBT *pgdbt;
 578         DBT *rootent;
 579         DB_LSN * rootlsn;
 580 {
 581         DBT logrec;
 582         DB_LSN *lsnp, null_lsn;
 583         u_int32_t zero;
 584         u_int32_t rectype, txn_num;
 585         int ret;
 586         u_int8_t *bp;
 587
 588         rectype = DB_bam_rsplit;
 589         txn_num = txnid == NULL ? 0 : txnid->txnid;
 590         if (txnid == NULL) {
 591                 null_lsn.file = 0;
 592                 null_lsn.offset = 0;
 593                 lsnp = &null_lsn;
 594         } else
 595                 lsnp = &txnid->last_lsn;
 596         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
 597             + sizeof(fileid)
 598             + sizeof(pgno)
 599             + sizeof(u_int32_t) + (pgdbt == NULL ? 0 : pgdbt->size)
 600             + sizeof(u_int32_t) + (rootent == NULL ? 0 : rootent->size)
 601             + sizeof(*rootlsn);
 602         if ((logrec.data = (void *)malloc(logrec.size)) == NULL)
 603                 return (ENOMEM);
 604
 605         bp = logrec.data;
 606         memcpy(bp, &rectype, sizeof(rectype));
 607         bp += sizeof(rectype);
 608         memcpy(bp, &txn_num, sizeof(txn_num));
 609         bp += sizeof(txn_num);
 610         memcpy(bp, lsnp, sizeof(DB_LSN));
 611         bp += sizeof(DB_LSN);
 612         memcpy(bp, &fileid, sizeof(fileid));
 613         bp += sizeof(fileid);
 614         memcpy(bp, &pgno, sizeof(pgno));
 615         bp += sizeof(pgno);
 616         if (pgdbt == NULL) {
 617                 zero = 0;
 618                 memcpy(bp, &zero, sizeof(u_int32_t));
 619                 bp += sizeof(u_int32_t);
 620         } else {
 621                 memcpy(bp, &pgdbt->size, sizeof(pgdbt->size));
 622                 bp += sizeof(pgdbt->size);
 623                 memcpy(bp, pgdbt->data, pgdbt->size);
 624                 bp += pgdbt->size;
 625         }
 626         if (rootent == NULL) {
 627                 zero = 0;
 628                 memcpy(bp, &zero, sizeof(u_int32_t));
 629                 bp += sizeof(u_int32_t);
 630         } else {
 631                 memcpy(bp, &rootent->size, sizeof(rootent->size));
 632                 bp += sizeof(rootent->size);
 633                 memcpy(bp, rootent->data, rootent->size);
 634                 bp += rootent->size;
 635         }
 636         if (rootlsn != NULL)
 637                 memcpy(bp, rootlsn, sizeof(*rootlsn));
 638         else
 639                 memset(bp, 0, sizeof(*rootlsn));
 640         bp += sizeof(*rootlsn);
 641 #ifdef DEBUG
 642         if ((u_int32_t)(bp - (u_int8_t *)logrec.data) != logrec.size)
 643                 fprintf(stderr, "Error in log record length");
 644 #endif
 645         ret = log_put(logp, ret_lsnp, (DBT *)&logrec, flags);
 646         if (txnid != NULL)
 647                 txnid->last_lsn = *ret_lsnp;
 648         free(logrec.data);
 649         return (ret);
 650 }
 651
 652 /*
 653  * PUBLIC: int __bam_rsplit_print
 654  * PUBLIC:    __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
 655  */
 656
 657 int
 658 __bam_rsplit_print(notused1, dbtp, lsnp, notused3, notused4)
 659         DB_LOG *notused1;
 660         DBT *dbtp;
 661         DB_LSN *lsnp;
 662         int notused3;
 663         void *notused4;
 664 {
 665         __bam_rsplit_args *argp;
 666         u_int32_t i;
 667         int c, ret;
 668
 669         i = 0;
 670         c = 0;
 671         notused1 = NULL;
 672         notused3 = 0;
 673         notused4 = NULL;
 674
 675         if ((ret = __bam_rsplit_read(dbtp->data, &argp)) != 0)
 676                 return (ret);
 677         printf("[%lu][%lu]bam_rsplit: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
 678             (u_long)lsnp->file,
 679             (u_long)lsnp->offset,
 680             (u_long)argp->type,
 681             (u_long)argp->txnid->txnid,
 682             (u_long)argp->prev_lsn.file,
 683             (u_long)argp->prev_lsn.offset);
 684         printf("\tfileid: %lu\n", (u_long)argp->fileid);
 685         printf("\tpgno: %lu\n", (u_long)argp->pgno);
 686         printf("\tpgdbt: ");
 687         for (i = 0; i < argp->pgdbt.size; i++) {
 688                 c = ((char *)argp->pgdbt.data)[i];
 689                 if (isprint(c) || c == 0xa)
 690                         putchar(c);
 691                 else
 692                         printf("%#x ", c);
 693         }
 694         printf("\n");
 695         printf("\trootent: ");
 696         for (i = 0; i < argp->rootent.size; i++) {
 697                 c = ((char *)argp->rootent.data)[i];
 698                 if (isprint(c) || c == 0xa)
 699                         putchar(c);
 700                 else
 701                         printf("%#x ", c);
 702         }
 703         printf("\n");
 704         printf("\trootlsn: [%lu][%lu]\n",
 705             (u_long)argp->rootlsn.file, (u_long)argp->rootlsn.offset);
 706         printf("\n");
 707         free(argp);
 708         return (0);
 709 }
 710
 711 /*
 712  * PUBLIC: int __bam_rsplit_read __P((void *, __bam_rsplit_args **));
 713  */
 714 int
 715 __bam_rsplit_read(recbuf, argpp)
 716         void *recbuf;
 717         __bam_rsplit_args **argpp;
 718 {
 719         __bam_rsplit_args *argp;
 720         u_int8_t *bp;
 721
 722         argp = (__bam_rsplit_args *)malloc(sizeof(__bam_rsplit_args) +
 723             sizeof(DB_TXN));
 724         if (argp == NULL)
 725                 return (ENOMEM);
 726         argp->txnid = (DB_TXN *)&argp[1];
 727         bp = recbuf;
 728         memcpy(&argp->type, bp, sizeof(argp->type));
 729         bp += sizeof(argp->type);
 730         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
 731         bp += sizeof(argp->txnid->txnid);
 732         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
 733         bp += sizeof(DB_LSN);
 734         memcpy(&argp->fileid, bp, sizeof(argp->fileid));
 735         bp += sizeof(argp->fileid);
 736         memcpy(&argp->pgno, bp, sizeof(argp->pgno));
 737         bp += sizeof(argp->pgno);
 738         memcpy(&argp->pgdbt.size, bp, sizeof(u_int32_t));
 739         bp += sizeof(u_int32_t);
 740         argp->pgdbt.data = bp;
 741         bp += argp->pgdbt.size;
 742         memcpy(&argp->rootent.size, bp, sizeof(u_int32_t));
 743         bp += sizeof(u_int32_t);
 744         argp->rootent.data = bp;
 745         bp += argp->rootent.size;
 746         memcpy(&argp->rootlsn, bp,  sizeof(argp->rootlsn));
 747         bp += sizeof(argp->rootlsn);
 748         *argpp = argp;
 749         return (0);
 750 }
 751
 752 /*
 753  * PUBLIC: int __bam_adj_log
 754  * PUBLIC:     __P((DB_LOG *, DB_TXN *, DB_LSN *, u_int32_t,
 755  * PUBLIC:     u_int32_t, db_pgno_t, DB_LSN *, u_int32_t,
 756  * PUBLIC:     u_int32_t, u_int32_t));
 757  */
 758 int __bam_adj_log(logp, txnid, ret_lsnp, flags,
 759         fileid, pgno, lsn, indx, indx_copy, is_insert)
 760         DB_LOG *logp;
 761         DB_TXN *txnid;
 762         DB_LSN *ret_lsnp;
 763         u_int32_t flags;
 764         u_int32_t fileid;
 765         db_pgno_t pgno;
 766         DB_LSN * lsn;
 767         u_int32_t indx;
 768         u_int32_t indx_copy;
 769         u_int32_t is_insert;
 770 {
 771         DBT logrec;
 772         DB_LSN *lsnp, null_lsn;
 773         u_int32_t rectype, txn_num;
 774         int ret;
 775         u_int8_t *bp;
 776
 777         rectype = DB_bam_adj;
 778         txn_num = txnid == NULL ? 0 : txnid->txnid;
 779         if (txnid == NULL) {
 780                 null_lsn.file = 0;
 781                 null_lsn.offset = 0;
 782                 lsnp = &null_lsn;
 783         } else
 784                 lsnp = &txnid->last_lsn;
 785         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
 786             + sizeof(fileid)
 787             + sizeof(pgno)
 788             + sizeof(*lsn)
 789             + sizeof(indx)
 790             + sizeof(indx_copy)
 791             + sizeof(is_insert);
 792         if ((logrec.data = (void *)malloc(logrec.size)) == NULL)
 793                 return (ENOMEM);
 794
 795         bp = logrec.data;
 796         memcpy(bp, &rectype, sizeof(rectype));
 797         bp += sizeof(rectype);
 798         memcpy(bp, &txn_num, sizeof(txn_num));
 799         bp += sizeof(txn_num);
 800         memcpy(bp, lsnp, sizeof(DB_LSN));
 801         bp += sizeof(DB_LSN);
 802         memcpy(bp, &fileid, sizeof(fileid));
 803         bp += sizeof(fileid);
 804         memcpy(bp, &pgno, sizeof(pgno));
 805         bp += sizeof(pgno);
 806         if (lsn != NULL)
 807                 memcpy(bp, lsn, sizeof(*lsn));
 808         else
 809                 memset(bp, 0, sizeof(*lsn));
 810         bp += sizeof(*lsn);
 811         memcpy(bp, &indx, sizeof(indx));
 812         bp += sizeof(indx);
 813         memcpy(bp, &indx_copy, sizeof(indx_copy));
 814         bp += sizeof(indx_copy);
 815         memcpy(bp, &is_insert, sizeof(is_insert));
 816         bp += sizeof(is_insert);
 817 #ifdef DEBUG
 818         if ((u_int32_t)(bp - (u_int8_t *)logrec.data) != logrec.size)
 819                 fprintf(stderr, "Error in log record length");
 820 #endif
 821         ret = log_put(logp, ret_lsnp, (DBT *)&logrec, flags);
 822         if (txnid != NULL)
 823                 txnid->last_lsn = *ret_lsnp;
 824         free(logrec.data);
 825         return (ret);
 826 }
 827
 828 /*
 829  * PUBLIC: int __bam_adj_print
 830  * PUBLIC:    __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
 831  */
 832
 833 int
 834 __bam_adj_print(notused1, dbtp, lsnp, notused3, notused4)
 835         DB_LOG *notused1;
 836         DBT *dbtp;
 837         DB_LSN *lsnp;
 838         int notused3;
 839         void *notused4;
 840 {
 841         __bam_adj_args *argp;
 842         u_int32_t i;
 843         int c, ret;
 844
 845         i = 0;
 846         c = 0;
 847         notused1 = NULL;
 848         notused3 = 0;
 849         notused4 = NULL;
 850
 851         if ((ret = __bam_adj_read(dbtp->data, &argp)) != 0)
 852                 return (ret);
 853         printf("[%lu][%lu]bam_adj: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
 854             (u_long)lsnp->file,
 855             (u_long)lsnp->offset,
 856             (u_long)argp->type,
 857             (u_long)argp->txnid->txnid,
 858             (u_long)argp->prev_lsn.file,
 859             (u_long)argp->prev_lsn.offset);
 860         printf("\tfileid: %lu\n", (u_long)argp->fileid);
 861         printf("\tpgno: %lu\n", (u_long)argp->pgno);
 862         printf("\tlsn: [%lu][%lu]\n",
 863             (u_long)argp->lsn.file, (u_long)argp->lsn.offset);
 864         printf("\tindx: %lu\n", (u_long)argp->indx);
 865         printf("\tindx_copy: %lu\n", (u_long)argp->indx_copy);
 866         printf("\tis_insert: %lu\n", (u_long)argp->is_insert);
 867         printf("\n");
 868         free(argp);
 869         return (0);
 870 }
 871
 872 /*
 873  * PUBLIC: int __bam_adj_read __P((void *, __bam_adj_args **));
 874  */
 875 int
 876 __bam_adj_read(recbuf, argpp)
 877         void *recbuf;
 878         __bam_adj_args **argpp;
 879 {
 880         __bam_adj_args *argp;
 881         u_int8_t *bp;
 882
 883         argp = (__bam_adj_args *)malloc(sizeof(__bam_adj_args) +
 884             sizeof(DB_TXN));
 885         if (argp == NULL)
 886                 return (ENOMEM);
 887         argp->txnid = (DB_TXN *)&argp[1];
 888         bp = recbuf;
 889         memcpy(&argp->type, bp, sizeof(argp->type));
 890         bp += sizeof(argp->type);
 891         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
 892         bp += sizeof(argp->txnid->txnid);
 893         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
 894         bp += sizeof(DB_LSN);
 895         memcpy(&argp->fileid, bp, sizeof(argp->fileid));
 896         bp += sizeof(argp->fileid);
 897         memcpy(&argp->pgno, bp, sizeof(argp->pgno));
 898         bp += sizeof(argp->pgno);
 899         memcpy(&argp->lsn, bp,  sizeof(argp->lsn));
 900         bp += sizeof(argp->lsn);
 901         memcpy(&argp->indx, bp, sizeof(argp->indx));
 902         bp += sizeof(argp->indx);
 903         memcpy(&argp->indx_copy, bp, sizeof(argp->indx_copy));
 904         bp += sizeof(argp->indx_copy);
 905         memcpy(&argp->is_insert, bp, sizeof(argp->is_insert));
 906         bp += sizeof(argp->is_insert);
 907         *argpp = argp;
 908         return (0);
 909 }
 910
 911 /*
 912  * PUBLIC: int __bam_cadjust_log
 913  * PUBLIC:     __P((DB_LOG *, DB_TXN *, DB_LSN *, u_int32_t,
 914  * PUBLIC:     u_int32_t, db_pgno_t, DB_LSN *, u_int32_t,
 915  * PUBLIC:     int32_t, int32_t));
 916  */
 917 int __bam_cadjust_log(logp, txnid, ret_lsnp, flags,
 918         fileid, pgno, lsn, indx, adjust, total)
 919         DB_LOG *logp;
 920         DB_TXN *txnid;
 921         DB_LSN *ret_lsnp;
 922         u_int32_t flags;
 923         u_int32_t fileid;
 924         db_pgno_t pgno;
 925         DB_LSN * lsn;
 926         u_int32_t indx;
 927         int32_t adjust;
 928         int32_t total;
 929 {
 930         DBT logrec;
 931         DB_LSN *lsnp, null_lsn;
 932         u_int32_t rectype, txn_num;
 933         int ret;
 934         u_int8_t *bp;
 935
 936         rectype = DB_bam_cadjust;
 937         txn_num = txnid == NULL ? 0 : txnid->txnid;
 938         if (txnid == NULL) {
 939                 null_lsn.file = 0;
 940                 null_lsn.offset = 0;
 941                 lsnp = &null_lsn;
 942         } else
 943                 lsnp = &txnid->last_lsn;
 944         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
 945             + sizeof(fileid)
 946             + sizeof(pgno)
 947             + sizeof(*lsn)
 948             + sizeof(indx)
 949             + sizeof(adjust)
 950             + sizeof(total);
 951         if ((logrec.data = (void *)malloc(logrec.size)) == NULL)
 952                 return (ENOMEM);
 953
 954         bp = logrec.data;
 955         memcpy(bp, &rectype, sizeof(rectype));
 956         bp += sizeof(rectype);
 957         memcpy(bp, &txn_num, sizeof(txn_num));
 958         bp += sizeof(txn_num);
 959         memcpy(bp, lsnp, sizeof(DB_LSN));
 960         bp += sizeof(DB_LSN);
 961         memcpy(bp, &fileid, sizeof(fileid));
 962         bp += sizeof(fileid);
 963         memcpy(bp, &pgno, sizeof(pgno));
 964         bp += sizeof(pgno);
 965         if (lsn != NULL)
 966                 memcpy(bp, lsn, sizeof(*lsn));
 967         else
 968                 memset(bp, 0, sizeof(*lsn));
 969         bp += sizeof(*lsn);
 970         memcpy(bp, &indx, sizeof(indx));
 971         bp += sizeof(indx);
 972         memcpy(bp, &adjust, sizeof(adjust));
 973         bp += sizeof(adjust);
 974         memcpy(bp, &total, sizeof(total));
 975         bp += sizeof(total);
 976 #ifdef DEBUG
 977         if ((u_int32_t)(bp - (u_int8_t *)logrec.data) != logrec.size)
 978                 fprintf(stderr, "Error in log record length");
 979 #endif
 980         ret = log_put(logp, ret_lsnp, (DBT *)&logrec, flags);
 981         if (txnid != NULL)
 982                 txnid->last_lsn = *ret_lsnp;
 983         free(logrec.data);
 984         return (ret);
 985 }
 986
 987 /*
 988  * PUBLIC: int __bam_cadjust_print
 989  * PUBLIC:    __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
 990  */
 991
 992 int
 993 __bam_cadjust_print(notused1, dbtp, lsnp, notused3, notused4)
 994         DB_LOG *notused1;
 995         DBT *dbtp;
 996         DB_LSN *lsnp;
 997         int notused3;
 998         void *notused4;
 999 {
1000         __bam_cadjust_args *argp;
1001         u_int32_t i;
1002         int c, ret;
1003
1004         i = 0;
1005         c = 0;
1006         notused1 = NULL;
1007         notused3 = 0;
1008         notused4 = NULL;
1009
1010         if ((ret = __bam_cadjust_read(dbtp->data, &argp)) != 0)
1011                 return (ret);
1012         printf("[%lu][%lu]bam_cadjust: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
1013             (u_long)lsnp->file,
1014             (u_long)lsnp->offset,
1015             (u_long)argp->type,
1016             (u_long)argp->txnid->txnid,
1017             (u_long)argp->prev_lsn.file,
1018             (u_long)argp->prev_lsn.offset);
1019         printf("\tfileid: %lu\n", (u_long)argp->fileid);
1020         printf("\tpgno: %lu\n", (u_long)argp->pgno);
1021         printf("\tlsn: [%lu][%lu]\n",
1022             (u_long)argp->lsn.file, (u_long)argp->lsn.offset);
1023         printf("\tindx: %lu\n", (u_long)argp->indx);
1024         printf("\tadjust: %ld\n", (long)argp->adjust);
1025         printf("\ttotal: %ld\n", (long)argp->total);
1026         printf("\n");
1027         free(argp);
1028         return (0);
1029 }
1030
1031 /*
1032  * PUBLIC: int __bam_cadjust_read __P((void *, __bam_cadjust_args **));
1033  */
1034 int
1035 __bam_cadjust_read(recbuf, argpp)
1036         void *recbuf;
1037         __bam_cadjust_args **argpp;
1038 {
1039         __bam_cadjust_args *argp;
1040         u_int8_t *bp;
1041
1042         argp = (__bam_cadjust_args *)malloc(sizeof(__bam_cadjust_args) +
1043             sizeof(DB_TXN));
1044         if (argp == NULL)
1045                 return (ENOMEM);
1046         argp->txnid = (DB_TXN *)&argp[1];
1047         bp = recbuf;
1048         memcpy(&argp->type, bp, sizeof(argp->type));
1049         bp += sizeof(argp->type);
1050         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
1051         bp += sizeof(argp->txnid->txnid);
1052         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
1053         bp += sizeof(DB_LSN);
1054         memcpy(&argp->fileid, bp, sizeof(argp->fileid));
1055         bp += sizeof(argp->fileid);
1056         memcpy(&argp->pgno, bp, sizeof(argp->pgno));
1057         bp += sizeof(argp->pgno);
1058         memcpy(&argp->lsn, bp,  sizeof(argp->lsn));
1059         bp += sizeof(argp->lsn);
1060         memcpy(&argp->indx, bp, sizeof(argp->indx));
1061         bp += sizeof(argp->indx);
1062         memcpy(&argp->adjust, bp, sizeof(argp->adjust));
1063         bp += sizeof(argp->adjust);
1064         memcpy(&argp->total, bp, sizeof(argp->total));
1065         bp += sizeof(argp->total);
1066         *argpp = argp;
1067         return (0);
1068 }
1069
1070 /*
1071  * PUBLIC: int __bam_cdel_log
1072  * PUBLIC:     __P((DB_LOG *, DB_TXN *, DB_LSN *, u_int32_t,
1073  * PUBLIC:     u_int32_t, db_pgno_t, DB_LSN *, u_int32_t));
1074  */
1075 int __bam_cdel_log(logp, txnid, ret_lsnp, flags,
1076         fileid, pgno, lsn, indx)
1077         DB_LOG *logp;
1078         DB_TXN *txnid;
1079         DB_LSN *ret_lsnp;
1080         u_int32_t flags;
1081         u_int32_t fileid;
1082         db_pgno_t pgno;
1083         DB_LSN * lsn;
1084         u_int32_t indx;
1085 {
1086         DBT logrec;
1087         DB_LSN *lsnp, null_lsn;
1088         u_int32_t rectype, txn_num;
1089         int ret;
1090         u_int8_t *bp;
1091
1092         rectype = DB_bam_cdel;
1093         txn_num = txnid == NULL ? 0 : txnid->txnid;
1094         if (txnid == NULL) {
1095                 null_lsn.file = 0;
1096                 null_lsn.offset = 0;
1097                 lsnp = &null_lsn;
1098         } else
1099                 lsnp = &txnid->last_lsn;
1100         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
1101             + sizeof(fileid)
1102             + sizeof(pgno)
1103             + sizeof(*lsn)
1104             + sizeof(indx);
1105         if ((logrec.data = (void *)malloc(logrec.size)) == NULL)
1106                 return (ENOMEM);
1107
1108         bp = logrec.data;
1109         memcpy(bp, &rectype, sizeof(rectype));
1110         bp += sizeof(rectype);
1111         memcpy(bp, &txn_num, sizeof(txn_num));
1112         bp += sizeof(txn_num);
1113         memcpy(bp, lsnp, sizeof(DB_LSN));
1114         bp += sizeof(DB_LSN);
1115         memcpy(bp, &fileid, sizeof(fileid));
1116         bp += sizeof(fileid);
1117         memcpy(bp, &pgno, sizeof(pgno));
1118         bp += sizeof(pgno);
1119         if (lsn != NULL)
1120                 memcpy(bp, lsn, sizeof(*lsn));
1121         else
1122                 memset(bp, 0, sizeof(*lsn));
1123         bp += sizeof(*lsn);
1124         memcpy(bp, &indx, sizeof(indx));
1125         bp += sizeof(indx);
1126 #ifdef DEBUG
1127         if ((u_int32_t)(bp - (u_int8_t *)logrec.data) != logrec.size)
1128                 fprintf(stderr, "Error in log record length");
1129 #endif
1130         ret = log_put(logp, ret_lsnp, (DBT *)&logrec, flags);
1131         if (txnid != NULL)
1132                 txnid->last_lsn = *ret_lsnp;
1133         free(logrec.data);
1134         return (ret);
1135 }
1136
1137 /*
1138  * PUBLIC: int __bam_cdel_print
1139  * PUBLIC:    __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
1140  */
1141
1142 int
1143 __bam_cdel_print(notused1, dbtp, lsnp, notused3, notused4)
1144         DB_LOG *notused1;
1145         DBT *dbtp;
1146         DB_LSN *lsnp;
1147         int notused3;
1148         void *notused4;
1149 {
1150         __bam_cdel_args *argp;
1151         u_int32_t i;
1152         int c, ret;
1153
1154         i = 0;
1155         c = 0;
1156         notused1 = NULL;
1157         notused3 = 0;
1158         notused4 = NULL;
1159
1160         if ((ret = __bam_cdel_read(dbtp->data, &argp)) != 0)
1161                 return (ret);
1162         printf("[%lu][%lu]bam_cdel: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
1163             (u_long)lsnp->file,
1164             (u_long)lsnp->offset,
1165             (u_long)argp->type,
1166             (u_long)argp->txnid->txnid,
1167             (u_long)argp->prev_lsn.file,
1168             (u_long)argp->prev_lsn.offset);
1169         printf("\tfileid: %lu\n", (u_long)argp->fileid);
1170         printf("\tpgno: %lu\n", (u_long)argp->pgno);
1171         printf("\tlsn: [%lu][%lu]\n",
1172             (u_long)argp->lsn.file, (u_long)argp->lsn.offset);
1173         printf("\tindx: %lu\n", (u_long)argp->indx);
1174         printf("\n");
1175         free(argp);
1176         return (0);
1177 }
1178
1179 /*
1180  * PUBLIC: int __bam_cdel_read __P((void *, __bam_cdel_args **));
1181  */
1182 int
1183 __bam_cdel_read(recbuf, argpp)
1184         void *recbuf;
1185         __bam_cdel_args **argpp;
1186 {
1187         __bam_cdel_args *argp;
1188         u_int8_t *bp;
1189
1190         argp = (__bam_cdel_args *)malloc(sizeof(__bam_cdel_args) +
1191             sizeof(DB_TXN));
1192         if (argp == NULL)
1193                 return (ENOMEM);
1194         argp->txnid = (DB_TXN *)&argp[1];
1195         bp = recbuf;
1196         memcpy(&argp->type, bp, sizeof(argp->type));
1197         bp += sizeof(argp->type);
1198         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
1199         bp += sizeof(argp->txnid->txnid);
1200         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
1201         bp += sizeof(DB_LSN);
1202         memcpy(&argp->fileid, bp, sizeof(argp->fileid));
1203         bp += sizeof(argp->fileid);
1204         memcpy(&argp->pgno, bp, sizeof(argp->pgno));
1205         bp += sizeof(argp->pgno);
1206         memcpy(&argp->lsn, bp,  sizeof(argp->lsn));
1207         bp += sizeof(argp->lsn);
1208         memcpy(&argp->indx, bp, sizeof(argp->indx));
1209         bp += sizeof(argp->indx);
1210         *argpp = argp;
1211         return (0);
1212 }
1213
1214 /*
1215  * PUBLIC: int __bam_init_print __P((DB_ENV *));
1216  */
1217 int
1218 __bam_init_print(dbenv)
1219         DB_ENV *dbenv;
1220 {
1221         int ret;
1222
1223         if ((ret = __db_add_recovery(dbenv,
1224             __bam_pg_alloc_print, DB_bam_pg_alloc)) != 0)
1225                 return (ret);
1226         if ((ret = __db_add_recovery(dbenv,
1227             __bam_pg_free_print, DB_bam_pg_free)) != 0)
1228                 return (ret);
1229         if ((ret = __db_add_recovery(dbenv,
1230             __bam_split_print, DB_bam_split)) != 0)
1231                 return (ret);
1232         if ((ret = __db_add_recovery(dbenv,
1233             __bam_rsplit_print, DB_bam_rsplit)) != 0)
1234                 return (ret);
1235         if ((ret = __db_add_recovery(dbenv,
1236             __bam_adj_print, DB_bam_adj)) != 0)
1237                 return (ret);
1238         if ((ret = __db_add_recovery(dbenv,
1239             __bam_cadjust_print, DB_bam_cadjust)) != 0)
1240                 return (ret);
1241         if ((ret = __db_add_recovery(dbenv,
1242             __bam_cdel_print, DB_bam_cdel)) != 0)
1243                 return (ret);
1244         return (0);
1245 }
1246
1247 /*
1248  * PUBLIC: int __bam_init_recover __P((DB_ENV *));
1249  */
1250 int
1251 __bam_init_recover(dbenv)
1252         DB_ENV *dbenv;
1253 {
1254         int ret;
1255
1256         if ((ret = __db_add_recovery(dbenv,
1257             __bam_pg_alloc_recover, DB_bam_pg_alloc)) != 0)
1258                 return (ret);
1259         if ((ret = __db_add_recovery(dbenv,
1260             __bam_pg_free_recover, DB_bam_pg_free)) != 0)
1261                 return (ret);
1262         if ((ret = __db_add_recovery(dbenv,
1263             __bam_split_recover, DB_bam_split)) != 0)
1264                 return (ret);
1265         if ((ret = __db_add_recovery(dbenv,
1266             __bam_rsplit_recover, DB_bam_rsplit)) != 0)
1267                 return (ret);
1268         if ((ret = __db_add_recovery(dbenv,
1269             __bam_adj_recover, DB_bam_adj)) != 0)
1270                 return (ret);
1271         if ((ret = __db_add_recovery(dbenv,
1272             __bam_cadjust_recover, DB_bam_cadjust)) != 0)
1273                 return (ret);
1274         if ((ret = __db_add_recovery(dbenv,
1275             __bam_cdel_recover, DB_bam_cdel)) != 0)
1276                 return (ret);
1277         return (0);
1278 }
1279