db2/db/db_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 "db_am.h"
  17 #include "common_ext.h"
  18
  19 /*
  20  * PUBLIC: int __db_addrem_log
  21  * PUBLIC:     __P((DB_LOG *, DB_TXN *, DB_LSN *, u_int32_t,
  22  * PUBLIC:     u_int32_t, u_int32_t, db_pgno_t, u_int32_t,
  23  * PUBLIC:     size_t, DBT *, DBT *, DB_LSN *));
  24  */
  25 int __db_addrem_log(logp, txnid, ret_lsnp, flags,
  26         opcode, fileid, pgno, indx, nbytes, hdr,
  27         dbt, pagelsn)
  28         DB_LOG *logp;
  29         DB_TXN *txnid;
  30         DB_LSN *ret_lsnp;
  31         u_int32_t flags;
  32         u_int32_t opcode;
  33         u_int32_t fileid;
  34         db_pgno_t pgno;
  35         u_int32_t indx;
  36         size_t nbytes;
  37         DBT *hdr;
  38         DBT *dbt;
  39         DB_LSN * pagelsn;
  40 {
  41         DBT logrec;
  42         DB_LSN *lsnp, null_lsn;
  43         u_int32_t zero;
  44         u_int32_t rectype, txn_num;
  45         int ret;
  46         u_int8_t *bp;
  47
  48         rectype = DB_db_addrem;
  49         txn_num = txnid == NULL ? 0 : txnid->txnid;
  50         if (txnid == NULL) {
  51                 null_lsn.file = 0;
  52                 null_lsn.offset = 0;
  53                 lsnp = &null_lsn;
  54         } else
  55                 lsnp = &txnid->last_lsn;
  56         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  57             + sizeof(opcode)
  58             + sizeof(fileid)
  59             + sizeof(pgno)
  60             + sizeof(indx)
  61             + sizeof(nbytes)
  62             + sizeof(u_int32_t) + (hdr == NULL ? 0 : hdr->size)
  63             + sizeof(u_int32_t) + (dbt == NULL ? 0 : dbt->size)
  64             + sizeof(*pagelsn);
  65         if ((logrec.data = (void *)__db_malloc(logrec.size)) == NULL)
  66                 return (ENOMEM);
  67
  68         bp = logrec.data;
  69         memcpy(bp, &rectype, sizeof(rectype));
  70         bp += sizeof(rectype);
  71         memcpy(bp, &txn_num, sizeof(txn_num));
  72         bp += sizeof(txn_num);
  73         memcpy(bp, lsnp, sizeof(DB_LSN));
  74         bp += sizeof(DB_LSN);
  75         memcpy(bp, &opcode, sizeof(opcode));
  76         bp += sizeof(opcode);
  77         memcpy(bp, &fileid, sizeof(fileid));
  78         bp += sizeof(fileid);
  79         memcpy(bp, &pgno, sizeof(pgno));
  80         bp += sizeof(pgno);
  81         memcpy(bp, &indx, sizeof(indx));
  82         bp += sizeof(indx);
  83         memcpy(bp, &nbytes, sizeof(nbytes));
  84         bp += sizeof(nbytes);
  85         if (hdr == NULL) {
  86                 zero = 0;
  87                 memcpy(bp, &zero, sizeof(u_int32_t));
  88                 bp += sizeof(u_int32_t);
  89         } else {
  90                 memcpy(bp, &hdr->size, sizeof(hdr->size));
  91                 bp += sizeof(hdr->size);
  92                 memcpy(bp, hdr->data, hdr->size);
  93                 bp += hdr->size;
  94         }
  95         if (dbt == NULL) {
  96                 zero = 0;
  97                 memcpy(bp, &zero, sizeof(u_int32_t));
  98                 bp += sizeof(u_int32_t);
  99         } else {
 100                 memcpy(bp, &dbt->size, sizeof(dbt->size));
 101                 bp += sizeof(dbt->size);
 102                 memcpy(bp, dbt->data, dbt->size);
 103                 bp += dbt->size;
 104         }
 105         if (pagelsn != NULL)
 106                 memcpy(bp, pagelsn, sizeof(*pagelsn));
 107         else
 108                 memset(bp, 0, sizeof(*pagelsn));
 109         bp += sizeof(*pagelsn);
 110 #ifdef DEBUG
 111         if ((u_int32_t)(bp - (u_int8_t *)logrec.data) != logrec.size)
 112                 fprintf(stderr, "Error in log record length");
 113 #endif
 114         ret = log_put(logp, ret_lsnp, (DBT *)&logrec, flags);
 115         if (txnid != NULL)
 116                 txnid->last_lsn = *ret_lsnp;
 117         __db_free(logrec.data);
 118         return (ret);
 119 }
 120
 121 /*
 122  * PUBLIC: int __db_addrem_print
 123  * PUBLIC:    __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
 124  */
 125
 126 int
 127 __db_addrem_print(notused1, dbtp, lsnp, notused3, notused4)
 128         DB_LOG *notused1;
 129         DBT *dbtp;
 130         DB_LSN *lsnp;
 131         int notused3;
 132         void *notused4;
 133 {
 134         __db_addrem_args *argp;
 135         u_int32_t i;
 136         int c, ret;
 137
 138         i = 0;
 139         c = 0;
 140         notused1 = NULL;
 141         notused3 = 0;
 142         notused4 = NULL;
 143
 144         if ((ret = __db_addrem_read(dbtp->data, &argp)) != 0)
 145                 return (ret);
 146         printf("[%lu][%lu]db_addrem: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
 147             (u_long)lsnp->file,
 148             (u_long)lsnp->offset,
 149             (u_long)argp->type,
 150             (u_long)argp->txnid->txnid,
 151             (u_long)argp->prev_lsn.file,
 152             (u_long)argp->prev_lsn.offset);
 153         printf("\topcode: %lu\n", (u_long)argp->opcode);
 154         printf("\tfileid: %lu\n", (u_long)argp->fileid);
 155         printf("\tpgno: %lu\n", (u_long)argp->pgno);
 156         printf("\tindx: %lu\n", (u_long)argp->indx);
 157         printf("\tnbytes: %lu\n", (u_long)argp->nbytes);
 158         printf("\thdr: ");
 159         for (i = 0; i < argp->hdr.size; i++) {
 160                 c = ((char *)argp->hdr.data)[i];
 161                 if (isprint(c) || c == 0xa)
 162                         putchar(c);
 163                 else
 164                         printf("%#x ", c);
 165         }
 166         printf("\n");
 167         printf("\tdbt: ");
 168         for (i = 0; i < argp->dbt.size; i++) {
 169                 c = ((char *)argp->dbt.data)[i];
 170                 if (isprint(c) || c == 0xa)
 171                         putchar(c);
 172                 else
 173                         printf("%#x ", c);
 174         }
 175         printf("\n");
 176         printf("\tpagelsn: [%lu][%lu]\n",
 177             (u_long)argp->pagelsn.file, (u_long)argp->pagelsn.offset);
 178         printf("\n");
 179         __db_free(argp);
 180         return (0);
 181 }
 182
 183 /*
 184  * PUBLIC: int __db_addrem_read __P((void *, __db_addrem_args **));
 185  */
 186 int
 187 __db_addrem_read(recbuf, argpp)
 188         void *recbuf;
 189         __db_addrem_args **argpp;
 190 {
 191         __db_addrem_args *argp;
 192         u_int8_t *bp;
 193
 194         argp = (__db_addrem_args *)__db_malloc(sizeof(__db_addrem_args) +
 195             sizeof(DB_TXN));
 196         if (argp == NULL)
 197                 return (ENOMEM);
 198         argp->txnid = (DB_TXN *)&argp[1];
 199         bp = recbuf;
 200         memcpy(&argp->type, bp, sizeof(argp->type));
 201         bp += sizeof(argp->type);
 202         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
 203         bp += sizeof(argp->txnid->txnid);
 204         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
 205         bp += sizeof(DB_LSN);
 206         memcpy(&argp->opcode, bp, sizeof(argp->opcode));
 207         bp += sizeof(argp->opcode);
 208         memcpy(&argp->fileid, bp, sizeof(argp->fileid));
 209         bp += sizeof(argp->fileid);
 210         memcpy(&argp->pgno, bp, sizeof(argp->pgno));
 211         bp += sizeof(argp->pgno);
 212         memcpy(&argp->indx, bp, sizeof(argp->indx));
 213         bp += sizeof(argp->indx);
 214         memcpy(&argp->nbytes, bp, sizeof(argp->nbytes));
 215         bp += sizeof(argp->nbytes);
 216         memcpy(&argp->hdr.size, bp, sizeof(u_int32_t));
 217         bp += sizeof(u_int32_t);
 218         argp->hdr.data = bp;
 219         bp += argp->hdr.size;
 220         memcpy(&argp->dbt.size, bp, sizeof(u_int32_t));
 221         bp += sizeof(u_int32_t);
 222         argp->dbt.data = bp;
 223         bp += argp->dbt.size;
 224         memcpy(&argp->pagelsn, bp,  sizeof(argp->pagelsn));
 225         bp += sizeof(argp->pagelsn);
 226         *argpp = argp;
 227         return (0);
 228 }
 229
 230 /*
 231  * PUBLIC: int __db_split_log
 232  * PUBLIC:     __P((DB_LOG *, DB_TXN *, DB_LSN *, u_int32_t,
 233  * PUBLIC:     u_int32_t, u_int32_t, db_pgno_t, DBT *,
 234  * PUBLIC:     DB_LSN *));
 235  */
 236 int __db_split_log(logp, txnid, ret_lsnp, flags,
 237         opcode, fileid, pgno, pageimage, pagelsn)
 238         DB_LOG *logp;
 239         DB_TXN *txnid;
 240         DB_LSN *ret_lsnp;
 241         u_int32_t flags;
 242         u_int32_t opcode;
 243         u_int32_t fileid;
 244         db_pgno_t pgno;
 245         DBT *pageimage;
 246         DB_LSN * pagelsn;
 247 {
 248         DBT logrec;
 249         DB_LSN *lsnp, null_lsn;
 250         u_int32_t zero;
 251         u_int32_t rectype, txn_num;
 252         int ret;
 253         u_int8_t *bp;
 254
 255         rectype = DB_db_split;
 256         txn_num = txnid == NULL ? 0 : txnid->txnid;
 257         if (txnid == NULL) {
 258                 null_lsn.file = 0;
 259                 null_lsn.offset = 0;
 260                 lsnp = &null_lsn;
 261         } else
 262                 lsnp = &txnid->last_lsn;
 263         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
 264             + sizeof(opcode)
 265             + sizeof(fileid)
 266             + sizeof(pgno)
 267             + sizeof(u_int32_t) + (pageimage == NULL ? 0 : pageimage->size)
 268             + sizeof(*pagelsn);
 269         if ((logrec.data = (void *)__db_malloc(logrec.size)) == NULL)
 270                 return (ENOMEM);
 271
 272         bp = logrec.data;
 273         memcpy(bp, &rectype, sizeof(rectype));
 274         bp += sizeof(rectype);
 275         memcpy(bp, &txn_num, sizeof(txn_num));
 276         bp += sizeof(txn_num);
 277         memcpy(bp, lsnp, sizeof(DB_LSN));
 278         bp += sizeof(DB_LSN);
 279         memcpy(bp, &opcode, sizeof(opcode));
 280         bp += sizeof(opcode);
 281         memcpy(bp, &fileid, sizeof(fileid));
 282         bp += sizeof(fileid);
 283         memcpy(bp, &pgno, sizeof(pgno));
 284         bp += sizeof(pgno);
 285         if (pageimage == NULL) {
 286                 zero = 0;
 287                 memcpy(bp, &zero, sizeof(u_int32_t));
 288                 bp += sizeof(u_int32_t);
 289         } else {
 290                 memcpy(bp, &pageimage->size, sizeof(pageimage->size));
 291                 bp += sizeof(pageimage->size);
 292                 memcpy(bp, pageimage->data, pageimage->size);
 293                 bp += pageimage->size;
 294         }
 295         if (pagelsn != NULL)
 296                 memcpy(bp, pagelsn, sizeof(*pagelsn));
 297         else
 298                 memset(bp, 0, sizeof(*pagelsn));
 299         bp += sizeof(*pagelsn);
 300 #ifdef DEBUG
 301         if ((u_int32_t)(bp - (u_int8_t *)logrec.data) != logrec.size)
 302                 fprintf(stderr, "Error in log record length");
 303 #endif
 304         ret = log_put(logp, ret_lsnp, (DBT *)&logrec, flags);
 305         if (txnid != NULL)
 306                 txnid->last_lsn = *ret_lsnp;
 307         __db_free(logrec.data);
 308         return (ret);
 309 }
 310
 311 /*
 312  * PUBLIC: int __db_split_print
 313  * PUBLIC:    __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
 314  */
 315
 316 int
 317 __db_split_print(notused1, dbtp, lsnp, notused3, notused4)
 318         DB_LOG *notused1;
 319         DBT *dbtp;
 320         DB_LSN *lsnp;
 321         int notused3;
 322         void *notused4;
 323 {
 324         __db_split_args *argp;
 325         u_int32_t i;
 326         int c, ret;
 327
 328         i = 0;
 329         c = 0;
 330         notused1 = NULL;
 331         notused3 = 0;
 332         notused4 = NULL;
 333
 334         if ((ret = __db_split_read(dbtp->data, &argp)) != 0)
 335                 return (ret);
 336         printf("[%lu][%lu]db_split: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
 337             (u_long)lsnp->file,
 338             (u_long)lsnp->offset,
 339             (u_long)argp->type,
 340             (u_long)argp->txnid->txnid,
 341             (u_long)argp->prev_lsn.file,
 342             (u_long)argp->prev_lsn.offset);
 343         printf("\topcode: %lu\n", (u_long)argp->opcode);
 344         printf("\tfileid: %lu\n", (u_long)argp->fileid);
 345         printf("\tpgno: %lu\n", (u_long)argp->pgno);
 346         printf("\tpageimage: ");
 347         for (i = 0; i < argp->pageimage.size; i++) {
 348                 c = ((char *)argp->pageimage.data)[i];
 349                 if (isprint(c) || c == 0xa)
 350                         putchar(c);
 351                 else
 352                         printf("%#x ", c);
 353         }
 354         printf("\n");
 355         printf("\tpagelsn: [%lu][%lu]\n",
 356             (u_long)argp->pagelsn.file, (u_long)argp->pagelsn.offset);
 357         printf("\n");
 358         __db_free(argp);
 359         return (0);
 360 }
 361
 362 /*
 363  * PUBLIC: int __db_split_read __P((void *, __db_split_args **));
 364  */
 365 int
 366 __db_split_read(recbuf, argpp)
 367         void *recbuf;
 368         __db_split_args **argpp;
 369 {
 370         __db_split_args *argp;
 371         u_int8_t *bp;
 372
 373         argp = (__db_split_args *)__db_malloc(sizeof(__db_split_args) +
 374             sizeof(DB_TXN));
 375         if (argp == NULL)
 376                 return (ENOMEM);
 377         argp->txnid = (DB_TXN *)&argp[1];
 378         bp = recbuf;
 379         memcpy(&argp->type, bp, sizeof(argp->type));
 380         bp += sizeof(argp->type);
 381         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
 382         bp += sizeof(argp->txnid->txnid);
 383         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
 384         bp += sizeof(DB_LSN);
 385         memcpy(&argp->opcode, bp, sizeof(argp->opcode));
 386         bp += sizeof(argp->opcode);
 387         memcpy(&argp->fileid, bp, sizeof(argp->fileid));
 388         bp += sizeof(argp->fileid);
 389         memcpy(&argp->pgno, bp, sizeof(argp->pgno));
 390         bp += sizeof(argp->pgno);
 391         memcpy(&argp->pageimage.size, bp, sizeof(u_int32_t));
 392         bp += sizeof(u_int32_t);
 393         argp->pageimage.data = bp;
 394         bp += argp->pageimage.size;
 395         memcpy(&argp->pagelsn, bp,  sizeof(argp->pagelsn));
 396         bp += sizeof(argp->pagelsn);
 397         *argpp = argp;
 398         return (0);
 399 }
 400
 401 /*
 402  * PUBLIC: int __db_big_log
 403  * PUBLIC:     __P((DB_LOG *, DB_TXN *, DB_LSN *, u_int32_t,
 404  * PUBLIC:     u_int32_t, u_int32_t, db_pgno_t, db_pgno_t,
 405  * PUBLIC:     db_pgno_t, DBT *, DB_LSN *, DB_LSN *,
 406  * PUBLIC:     DB_LSN *));
 407  */
 408 int __db_big_log(logp, txnid, ret_lsnp, flags,
 409         opcode, fileid, pgno, prev_pgno, next_pgno, dbt,
 410         pagelsn, prevlsn, nextlsn)
 411         DB_LOG *logp;
 412         DB_TXN *txnid;
 413         DB_LSN *ret_lsnp;
 414         u_int32_t flags;
 415         u_int32_t opcode;
 416         u_int32_t fileid;
 417         db_pgno_t pgno;
 418         db_pgno_t prev_pgno;
 419         db_pgno_t next_pgno;
 420         DBT *dbt;
 421         DB_LSN * pagelsn;
 422         DB_LSN * prevlsn;
 423         DB_LSN * nextlsn;
 424 {
 425         DBT logrec;
 426         DB_LSN *lsnp, null_lsn;
 427         u_int32_t zero;
 428         u_int32_t rectype, txn_num;
 429         int ret;
 430         u_int8_t *bp;
 431
 432         rectype = DB_db_big;
 433         txn_num = txnid == NULL ? 0 : txnid->txnid;
 434         if (txnid == NULL) {
 435                 null_lsn.file = 0;
 436                 null_lsn.offset = 0;
 437                 lsnp = &null_lsn;
 438         } else
 439                 lsnp = &txnid->last_lsn;
 440         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
 441             + sizeof(opcode)
 442             + sizeof(fileid)
 443             + sizeof(pgno)
 444             + sizeof(prev_pgno)
 445             + sizeof(next_pgno)
 446             + sizeof(u_int32_t) + (dbt == NULL ? 0 : dbt->size)
 447             + sizeof(*pagelsn)
 448             + sizeof(*prevlsn)
 449             + sizeof(*nextlsn);
 450         if ((logrec.data = (void *)__db_malloc(logrec.size)) == NULL)
 451                 return (ENOMEM);
 452
 453         bp = logrec.data;
 454         memcpy(bp, &rectype, sizeof(rectype));
 455         bp += sizeof(rectype);
 456         memcpy(bp, &txn_num, sizeof(txn_num));
 457         bp += sizeof(txn_num);
 458         memcpy(bp, lsnp, sizeof(DB_LSN));
 459         bp += sizeof(DB_LSN);
 460         memcpy(bp, &opcode, sizeof(opcode));
 461         bp += sizeof(opcode);
 462         memcpy(bp, &fileid, sizeof(fileid));
 463         bp += sizeof(fileid);
 464         memcpy(bp, &pgno, sizeof(pgno));
 465         bp += sizeof(pgno);
 466         memcpy(bp, &prev_pgno, sizeof(prev_pgno));
 467         bp += sizeof(prev_pgno);
 468         memcpy(bp, &next_pgno, sizeof(next_pgno));
 469         bp += sizeof(next_pgno);
 470         if (dbt == NULL) {
 471                 zero = 0;
 472                 memcpy(bp, &zero, sizeof(u_int32_t));
 473                 bp += sizeof(u_int32_t);
 474         } else {
 475                 memcpy(bp, &dbt->size, sizeof(dbt->size));
 476                 bp += sizeof(dbt->size);
 477                 memcpy(bp, dbt->data, dbt->size);
 478                 bp += dbt->size;
 479         }
 480         if (pagelsn != NULL)
 481                 memcpy(bp, pagelsn, sizeof(*pagelsn));
 482         else
 483                 memset(bp, 0, sizeof(*pagelsn));
 484         bp += sizeof(*pagelsn);
 485         if (prevlsn != NULL)
 486                 memcpy(bp, prevlsn, sizeof(*prevlsn));
 487         else
 488                 memset(bp, 0, sizeof(*prevlsn));
 489         bp += sizeof(*prevlsn);
 490         if (nextlsn != NULL)
 491                 memcpy(bp, nextlsn, sizeof(*nextlsn));
 492         else
 493                 memset(bp, 0, sizeof(*nextlsn));
 494         bp += sizeof(*nextlsn);
 495 #ifdef DEBUG
 496         if ((u_int32_t)(bp - (u_int8_t *)logrec.data) != logrec.size)
 497                 fprintf(stderr, "Error in log record length");
 498 #endif
 499         ret = log_put(logp, ret_lsnp, (DBT *)&logrec, flags);
 500         if (txnid != NULL)
 501                 txnid->last_lsn = *ret_lsnp;
 502         __db_free(logrec.data);
 503         return (ret);
 504 }
 505
 506 /*
 507  * PUBLIC: int __db_big_print
 508  * PUBLIC:    __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
 509  */
 510
 511 int
 512 __db_big_print(notused1, dbtp, lsnp, notused3, notused4)
 513         DB_LOG *notused1;
 514         DBT *dbtp;
 515         DB_LSN *lsnp;
 516         int notused3;
 517         void *notused4;
 518 {
 519         __db_big_args *argp;
 520         u_int32_t i;
 521         int c, ret;
 522
 523         i = 0;
 524         c = 0;
 525         notused1 = NULL;
 526         notused3 = 0;
 527         notused4 = NULL;
 528
 529         if ((ret = __db_big_read(dbtp->data, &argp)) != 0)
 530                 return (ret);
 531         printf("[%lu][%lu]db_big: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
 532             (u_long)lsnp->file,
 533             (u_long)lsnp->offset,
 534             (u_long)argp->type,
 535             (u_long)argp->txnid->txnid,
 536             (u_long)argp->prev_lsn.file,
 537             (u_long)argp->prev_lsn.offset);
 538         printf("\topcode: %lu\n", (u_long)argp->opcode);
 539         printf("\tfileid: %lu\n", (u_long)argp->fileid);
 540         printf("\tpgno: %lu\n", (u_long)argp->pgno);
 541         printf("\tprev_pgno: %lu\n", (u_long)argp->prev_pgno);
 542         printf("\tnext_pgno: %lu\n", (u_long)argp->next_pgno);
 543         printf("\tdbt: ");
 544         for (i = 0; i < argp->dbt.size; i++) {
 545                 c = ((char *)argp->dbt.data)[i];
 546                 if (isprint(c) || c == 0xa)
 547                         putchar(c);
 548                 else
 549                         printf("%#x ", c);
 550         }
 551         printf("\n");
 552         printf("\tpagelsn: [%lu][%lu]\n",
 553             (u_long)argp->pagelsn.file, (u_long)argp->pagelsn.offset);
 554         printf("\tprevlsn: [%lu][%lu]\n",
 555             (u_long)argp->prevlsn.file, (u_long)argp->prevlsn.offset);
 556         printf("\tnextlsn: [%lu][%lu]\n",
 557             (u_long)argp->nextlsn.file, (u_long)argp->nextlsn.offset);
 558         printf("\n");
 559         __db_free(argp);
 560         return (0);
 561 }
 562
 563 /*
 564  * PUBLIC: int __db_big_read __P((void *, __db_big_args **));
 565  */
 566 int
 567 __db_big_read(recbuf, argpp)
 568         void *recbuf;
 569         __db_big_args **argpp;
 570 {
 571         __db_big_args *argp;
 572         u_int8_t *bp;
 573
 574         argp = (__db_big_args *)__db_malloc(sizeof(__db_big_args) +
 575             sizeof(DB_TXN));
 576         if (argp == NULL)
 577                 return (ENOMEM);
 578         argp->txnid = (DB_TXN *)&argp[1];
 579         bp = recbuf;
 580         memcpy(&argp->type, bp, sizeof(argp->type));
 581         bp += sizeof(argp->type);
 582         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
 583         bp += sizeof(argp->txnid->txnid);
 584         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
 585         bp += sizeof(DB_LSN);
 586         memcpy(&argp->opcode, bp, sizeof(argp->opcode));
 587         bp += sizeof(argp->opcode);
 588         memcpy(&argp->fileid, bp, sizeof(argp->fileid));
 589         bp += sizeof(argp->fileid);
 590         memcpy(&argp->pgno, bp, sizeof(argp->pgno));
 591         bp += sizeof(argp->pgno);
 592         memcpy(&argp->prev_pgno, bp, sizeof(argp->prev_pgno));
 593         bp += sizeof(argp->prev_pgno);
 594         memcpy(&argp->next_pgno, bp, sizeof(argp->next_pgno));
 595         bp += sizeof(argp->next_pgno);
 596         memcpy(&argp->dbt.size, bp, sizeof(u_int32_t));
 597         bp += sizeof(u_int32_t);
 598         argp->dbt.data = bp;
 599         bp += argp->dbt.size;
 600         memcpy(&argp->pagelsn, bp,  sizeof(argp->pagelsn));
 601         bp += sizeof(argp->pagelsn);
 602         memcpy(&argp->prevlsn, bp,  sizeof(argp->prevlsn));
 603         bp += sizeof(argp->prevlsn);
 604         memcpy(&argp->nextlsn, bp,  sizeof(argp->nextlsn));
 605         bp += sizeof(argp->nextlsn);
 606         *argpp = argp;
 607         return (0);
 608 }
 609
 610 /*
 611  * PUBLIC: int __db_ovref_log
 612  * PUBLIC:     __P((DB_LOG *, DB_TXN *, DB_LSN *, u_int32_t,
 613  * PUBLIC:     u_int32_t, db_pgno_t, int32_t, DB_LSN *));
 614  */
 615 int __db_ovref_log(logp, txnid, ret_lsnp, flags,
 616         fileid, pgno, adjust, lsn)
 617         DB_LOG *logp;
 618         DB_TXN *txnid;
 619         DB_LSN *ret_lsnp;
 620         u_int32_t flags;
 621         u_int32_t fileid;
 622         db_pgno_t pgno;
 623         int32_t adjust;
 624         DB_LSN * lsn;
 625 {
 626         DBT logrec;
 627         DB_LSN *lsnp, null_lsn;
 628         u_int32_t rectype, txn_num;
 629         int ret;
 630         u_int8_t *bp;
 631
 632         rectype = DB_db_ovref;
 633         txn_num = txnid == NULL ? 0 : txnid->txnid;
 634         if (txnid == NULL) {
 635                 null_lsn.file = 0;
 636                 null_lsn.offset = 0;
 637                 lsnp = &null_lsn;
 638         } else
 639                 lsnp = &txnid->last_lsn;
 640         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
 641             + sizeof(fileid)
 642             + sizeof(pgno)
 643             + sizeof(adjust)
 644             + sizeof(*lsn);
 645         if ((logrec.data = (void *)__db_malloc(logrec.size)) == NULL)
 646                 return (ENOMEM);
 647
 648         bp = logrec.data;
 649         memcpy(bp, &rectype, sizeof(rectype));
 650         bp += sizeof(rectype);
 651         memcpy(bp, &txn_num, sizeof(txn_num));
 652         bp += sizeof(txn_num);
 653         memcpy(bp, lsnp, sizeof(DB_LSN));
 654         bp += sizeof(DB_LSN);
 655         memcpy(bp, &fileid, sizeof(fileid));
 656         bp += sizeof(fileid);
 657         memcpy(bp, &pgno, sizeof(pgno));
 658         bp += sizeof(pgno);
 659         memcpy(bp, &adjust, sizeof(adjust));
 660         bp += sizeof(adjust);
 661         if (lsn != NULL)
 662                 memcpy(bp, lsn, sizeof(*lsn));
 663         else
 664                 memset(bp, 0, sizeof(*lsn));
 665         bp += sizeof(*lsn);
 666 #ifdef DEBUG
 667         if ((u_int32_t)(bp - (u_int8_t *)logrec.data) != logrec.size)
 668                 fprintf(stderr, "Error in log record length");
 669 #endif
 670         ret = log_put(logp, ret_lsnp, (DBT *)&logrec, flags);
 671         if (txnid != NULL)
 672                 txnid->last_lsn = *ret_lsnp;
 673         __db_free(logrec.data);
 674         return (ret);
 675 }
 676
 677 /*
 678  * PUBLIC: int __db_ovref_print
 679  * PUBLIC:    __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
 680  */
 681
 682 int
 683 __db_ovref_print(notused1, dbtp, lsnp, notused3, notused4)
 684         DB_LOG *notused1;
 685         DBT *dbtp;
 686         DB_LSN *lsnp;
 687         int notused3;
 688         void *notused4;
 689 {
 690         __db_ovref_args *argp;
 691         u_int32_t i;
 692         int c, ret;
 693
 694         i = 0;
 695         c = 0;
 696         notused1 = NULL;
 697         notused3 = 0;
 698         notused4 = NULL;
 699
 700         if ((ret = __db_ovref_read(dbtp->data, &argp)) != 0)
 701                 return (ret);
 702         printf("[%lu][%lu]db_ovref: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
 703             (u_long)lsnp->file,
 704             (u_long)lsnp->offset,
 705             (u_long)argp->type,
 706             (u_long)argp->txnid->txnid,
 707             (u_long)argp->prev_lsn.file,
 708             (u_long)argp->prev_lsn.offset);
 709         printf("\tfileid: %lu\n", (u_long)argp->fileid);
 710         printf("\tpgno: %lu\n", (u_long)argp->pgno);
 711         printf("\tadjust: %ld\n", (long)argp->adjust);
 712         printf("\tlsn: [%lu][%lu]\n",
 713             (u_long)argp->lsn.file, (u_long)argp->lsn.offset);
 714         printf("\n");
 715         __db_free(argp);
 716         return (0);
 717 }
 718
 719 /*
 720  * PUBLIC: int __db_ovref_read __P((void *, __db_ovref_args **));
 721  */
 722 int
 723 __db_ovref_read(recbuf, argpp)
 724         void *recbuf;
 725         __db_ovref_args **argpp;
 726 {
 727         __db_ovref_args *argp;
 728         u_int8_t *bp;
 729
 730         argp = (__db_ovref_args *)__db_malloc(sizeof(__db_ovref_args) +
 731             sizeof(DB_TXN));
 732         if (argp == NULL)
 733                 return (ENOMEM);
 734         argp->txnid = (DB_TXN *)&argp[1];
 735         bp = recbuf;
 736         memcpy(&argp->type, bp, sizeof(argp->type));
 737         bp += sizeof(argp->type);
 738         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
 739         bp += sizeof(argp->txnid->txnid);
 740         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
 741         bp += sizeof(DB_LSN);
 742         memcpy(&argp->fileid, bp, sizeof(argp->fileid));
 743         bp += sizeof(argp->fileid);
 744         memcpy(&argp->pgno, bp, sizeof(argp->pgno));
 745         bp += sizeof(argp->pgno);
 746         memcpy(&argp->adjust, bp, sizeof(argp->adjust));
 747         bp += sizeof(argp->adjust);
 748         memcpy(&argp->lsn, bp,  sizeof(argp->lsn));
 749         bp += sizeof(argp->lsn);
 750         *argpp = argp;
 751         return (0);
 752 }
 753
 754 /*
 755  * PUBLIC: int __db_relink_log
 756  * PUBLIC:     __P((DB_LOG *, DB_TXN *, DB_LSN *, u_int32_t,
 757  * PUBLIC:     u_int32_t, db_pgno_t, DB_LSN *, db_pgno_t,
 758  * PUBLIC:     DB_LSN *, db_pgno_t, DB_LSN *));
 759  */
 760 int __db_relink_log(logp, txnid, ret_lsnp, flags,
 761         fileid, pgno, lsn, prev, lsn_prev, next,
 762         lsn_next)
 763         DB_LOG *logp;
 764         DB_TXN *txnid;
 765         DB_LSN *ret_lsnp;
 766         u_int32_t flags;
 767         u_int32_t fileid;
 768         db_pgno_t pgno;
 769         DB_LSN * lsn;
 770         db_pgno_t prev;
 771         DB_LSN * lsn_prev;
 772         db_pgno_t next;
 773         DB_LSN * lsn_next;
 774 {
 775         DBT logrec;
 776         DB_LSN *lsnp, null_lsn;
 777         u_int32_t rectype, txn_num;
 778         int ret;
 779         u_int8_t *bp;
 780
 781         rectype = DB_db_relink;
 782         txn_num = txnid == NULL ? 0 : txnid->txnid;
 783         if (txnid == NULL) {
 784                 null_lsn.file = 0;
 785                 null_lsn.offset = 0;
 786                 lsnp = &null_lsn;
 787         } else
 788                 lsnp = &txnid->last_lsn;
 789         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
 790             + sizeof(fileid)
 791             + sizeof(pgno)
 792             + sizeof(*lsn)
 793             + sizeof(prev)
 794             + sizeof(*lsn_prev)
 795             + sizeof(next)
 796             + sizeof(*lsn_next);
 797         if ((logrec.data = (void *)__db_malloc(logrec.size)) == NULL)
 798                 return (ENOMEM);
 799
 800         bp = logrec.data;
 801         memcpy(bp, &rectype, sizeof(rectype));
 802         bp += sizeof(rectype);
 803         memcpy(bp, &txn_num, sizeof(txn_num));
 804         bp += sizeof(txn_num);
 805         memcpy(bp, lsnp, sizeof(DB_LSN));
 806         bp += sizeof(DB_LSN);
 807         memcpy(bp, &fileid, sizeof(fileid));
 808         bp += sizeof(fileid);
 809         memcpy(bp, &pgno, sizeof(pgno));
 810         bp += sizeof(pgno);
 811         if (lsn != NULL)
 812                 memcpy(bp, lsn, sizeof(*lsn));
 813         else
 814                 memset(bp, 0, sizeof(*lsn));
 815         bp += sizeof(*lsn);
 816         memcpy(bp, &prev, sizeof(prev));
 817         bp += sizeof(prev);
 818         if (lsn_prev != NULL)
 819                 memcpy(bp, lsn_prev, sizeof(*lsn_prev));
 820         else
 821                 memset(bp, 0, sizeof(*lsn_prev));
 822         bp += sizeof(*lsn_prev);
 823         memcpy(bp, &next, sizeof(next));
 824         bp += sizeof(next);
 825         if (lsn_next != NULL)
 826                 memcpy(bp, lsn_next, sizeof(*lsn_next));
 827         else
 828                 memset(bp, 0, sizeof(*lsn_next));
 829         bp += sizeof(*lsn_next);
 830 #ifdef DEBUG
 831         if ((u_int32_t)(bp - (u_int8_t *)logrec.data) != logrec.size)
 832                 fprintf(stderr, "Error in log record length");
 833 #endif
 834         ret = log_put(logp, ret_lsnp, (DBT *)&logrec, flags);
 835         if (txnid != NULL)
 836                 txnid->last_lsn = *ret_lsnp;
 837         __db_free(logrec.data);
 838         return (ret);
 839 }
 840
 841 /*
 842  * PUBLIC: int __db_relink_print
 843  * PUBLIC:    __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
 844  */
 845
 846 int
 847 __db_relink_print(notused1, dbtp, lsnp, notused3, notused4)
 848         DB_LOG *notused1;
 849         DBT *dbtp;
 850         DB_LSN *lsnp;
 851         int notused3;
 852         void *notused4;
 853 {
 854         __db_relink_args *argp;
 855         u_int32_t i;
 856         int c, ret;
 857
 858         i = 0;
 859         c = 0;
 860         notused1 = NULL;
 861         notused3 = 0;
 862         notused4 = NULL;
 863
 864         if ((ret = __db_relink_read(dbtp->data, &argp)) != 0)
 865                 return (ret);
 866         printf("[%lu][%lu]db_relink: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
 867             (u_long)lsnp->file,
 868             (u_long)lsnp->offset,
 869             (u_long)argp->type,
 870             (u_long)argp->txnid->txnid,
 871             (u_long)argp->prev_lsn.file,
 872             (u_long)argp->prev_lsn.offset);
 873         printf("\tfileid: %lu\n", (u_long)argp->fileid);
 874         printf("\tpgno: %lu\n", (u_long)argp->pgno);
 875         printf("\tlsn: [%lu][%lu]\n",
 876             (u_long)argp->lsn.file, (u_long)argp->lsn.offset);
 877         printf("\tprev: %lu\n", (u_long)argp->prev);
 878         printf("\tlsn_prev: [%lu][%lu]\n",
 879             (u_long)argp->lsn_prev.file, (u_long)argp->lsn_prev.offset);
 880         printf("\tnext: %lu\n", (u_long)argp->next);
 881         printf("\tlsn_next: [%lu][%lu]\n",
 882             (u_long)argp->lsn_next.file, (u_long)argp->lsn_next.offset);
 883         printf("\n");
 884         __db_free(argp);
 885         return (0);
 886 }
 887
 888 /*
 889  * PUBLIC: int __db_relink_read __P((void *, __db_relink_args **));
 890  */
 891 int
 892 __db_relink_read(recbuf, argpp)
 893         void *recbuf;
 894         __db_relink_args **argpp;
 895 {
 896         __db_relink_args *argp;
 897         u_int8_t *bp;
 898
 899         argp = (__db_relink_args *)__db_malloc(sizeof(__db_relink_args) +
 900             sizeof(DB_TXN));
 901         if (argp == NULL)
 902                 return (ENOMEM);
 903         argp->txnid = (DB_TXN *)&argp[1];
 904         bp = recbuf;
 905         memcpy(&argp->type, bp, sizeof(argp->type));
 906         bp += sizeof(argp->type);
 907         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
 908         bp += sizeof(argp->txnid->txnid);
 909         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
 910         bp += sizeof(DB_LSN);
 911         memcpy(&argp->fileid, bp, sizeof(argp->fileid));
 912         bp += sizeof(argp->fileid);
 913         memcpy(&argp->pgno, bp, sizeof(argp->pgno));
 914         bp += sizeof(argp->pgno);
 915         memcpy(&argp->lsn, bp,  sizeof(argp->lsn));
 916         bp += sizeof(argp->lsn);
 917         memcpy(&argp->prev, bp, sizeof(argp->prev));
 918         bp += sizeof(argp->prev);
 919         memcpy(&argp->lsn_prev, bp,  sizeof(argp->lsn_prev));
 920         bp += sizeof(argp->lsn_prev);
 921         memcpy(&argp->next, bp, sizeof(argp->next));
 922         bp += sizeof(argp->next);
 923         memcpy(&argp->lsn_next, bp,  sizeof(argp->lsn_next));
 924         bp += sizeof(argp->lsn_next);
 925         *argpp = argp;
 926         return (0);
 927 }
 928
 929 /*
 930  * PUBLIC: int __db_addpage_log
 931  * PUBLIC:     __P((DB_LOG *, DB_TXN *, DB_LSN *, u_int32_t,
 932  * PUBLIC:     u_int32_t, db_pgno_t, DB_LSN *, db_pgno_t,
 933  * PUBLIC:     DB_LSN *));
 934  */
 935 int __db_addpage_log(logp, txnid, ret_lsnp, flags,
 936         fileid, pgno, lsn, nextpgno, nextlsn)
 937         DB_LOG *logp;
 938         DB_TXN *txnid;
 939         DB_LSN *ret_lsnp;
 940         u_int32_t flags;
 941         u_int32_t fileid;
 942         db_pgno_t pgno;
 943         DB_LSN * lsn;
 944         db_pgno_t nextpgno;
 945         DB_LSN * nextlsn;
 946 {
 947         DBT logrec;
 948         DB_LSN *lsnp, null_lsn;
 949         u_int32_t rectype, txn_num;
 950         int ret;
 951         u_int8_t *bp;
 952
 953         rectype = DB_db_addpage;
 954         txn_num = txnid == NULL ? 0 : txnid->txnid;
 955         if (txnid == NULL) {
 956                 null_lsn.file = 0;
 957                 null_lsn.offset = 0;
 958                 lsnp = &null_lsn;
 959         } else
 960                 lsnp = &txnid->last_lsn;
 961         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
 962             + sizeof(fileid)
 963             + sizeof(pgno)
 964             + sizeof(*lsn)
 965             + sizeof(nextpgno)
 966             + sizeof(*nextlsn);
 967         if ((logrec.data = (void *)__db_malloc(logrec.size)) == NULL)
 968                 return (ENOMEM);
 969
 970         bp = logrec.data;
 971         memcpy(bp, &rectype, sizeof(rectype));
 972         bp += sizeof(rectype);
 973         memcpy(bp, &txn_num, sizeof(txn_num));
 974         bp += sizeof(txn_num);
 975         memcpy(bp, lsnp, sizeof(DB_LSN));
 976         bp += sizeof(DB_LSN);
 977         memcpy(bp, &fileid, sizeof(fileid));
 978         bp += sizeof(fileid);
 979         memcpy(bp, &pgno, sizeof(pgno));
 980         bp += sizeof(pgno);
 981         if (lsn != NULL)
 982                 memcpy(bp, lsn, sizeof(*lsn));
 983         else
 984                 memset(bp, 0, sizeof(*lsn));
 985         bp += sizeof(*lsn);
 986         memcpy(bp, &nextpgno, sizeof(nextpgno));
 987         bp += sizeof(nextpgno);
 988         if (nextlsn != NULL)
 989                 memcpy(bp, nextlsn, sizeof(*nextlsn));
 990         else
 991                 memset(bp, 0, sizeof(*nextlsn));
 992         bp += sizeof(*nextlsn);
 993 #ifdef DEBUG
 994         if ((u_int32_t)(bp - (u_int8_t *)logrec.data) != logrec.size)
 995                 fprintf(stderr, "Error in log record length");
 996 #endif
 997         ret = log_put(logp, ret_lsnp, (DBT *)&logrec, flags);
 998         if (txnid != NULL)
 999                 txnid->last_lsn = *ret_lsnp;
1000         __db_free(logrec.data);
1001         return (ret);
1002 }
1003
1004 /*
1005  * PUBLIC: int __db_addpage_print
1006  * PUBLIC:    __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
1007  */
1008
1009 int
1010 __db_addpage_print(notused1, dbtp, lsnp, notused3, notused4)
1011         DB_LOG *notused1;
1012         DBT *dbtp;
1013         DB_LSN *lsnp;
1014         int notused3;
1015         void *notused4;
1016 {
1017         __db_addpage_args *argp;
1018         u_int32_t i;
1019         int c, ret;
1020
1021         i = 0;
1022         c = 0;
1023         notused1 = NULL;
1024         notused3 = 0;
1025         notused4 = NULL;
1026
1027         if ((ret = __db_addpage_read(dbtp->data, &argp)) != 0)
1028                 return (ret);
1029         printf("[%lu][%lu]db_addpage: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
1030             (u_long)lsnp->file,
1031             (u_long)lsnp->offset,
1032             (u_long)argp->type,
1033             (u_long)argp->txnid->txnid,
1034             (u_long)argp->prev_lsn.file,
1035             (u_long)argp->prev_lsn.offset);
1036         printf("\tfileid: %lu\n", (u_long)argp->fileid);
1037         printf("\tpgno: %lu\n", (u_long)argp->pgno);
1038         printf("\tlsn: [%lu][%lu]\n",
1039             (u_long)argp->lsn.file, (u_long)argp->lsn.offset);
1040         printf("\tnextpgno: %lu\n", (u_long)argp->nextpgno);
1041         printf("\tnextlsn: [%lu][%lu]\n",
1042             (u_long)argp->nextlsn.file, (u_long)argp->nextlsn.offset);
1043         printf("\n");
1044         __db_free(argp);
1045         return (0);
1046 }
1047
1048 /*
1049  * PUBLIC: int __db_addpage_read __P((void *, __db_addpage_args **));
1050  */
1051 int
1052 __db_addpage_read(recbuf, argpp)
1053         void *recbuf;
1054         __db_addpage_args **argpp;
1055 {
1056         __db_addpage_args *argp;
1057         u_int8_t *bp;
1058
1059         argp = (__db_addpage_args *)__db_malloc(sizeof(__db_addpage_args) +
1060             sizeof(DB_TXN));
1061         if (argp == NULL)
1062                 return (ENOMEM);
1063         argp->txnid = (DB_TXN *)&argp[1];
1064         bp = recbuf;
1065         memcpy(&argp->type, bp, sizeof(argp->type));
1066         bp += sizeof(argp->type);
1067         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
1068         bp += sizeof(argp->txnid->txnid);
1069         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
1070         bp += sizeof(DB_LSN);
1071         memcpy(&argp->fileid, bp, sizeof(argp->fileid));
1072         bp += sizeof(argp->fileid);
1073         memcpy(&argp->pgno, bp, sizeof(argp->pgno));
1074         bp += sizeof(argp->pgno);
1075         memcpy(&argp->lsn, bp,  sizeof(argp->lsn));
1076         bp += sizeof(argp->lsn);
1077         memcpy(&argp->nextpgno, bp, sizeof(argp->nextpgno));
1078         bp += sizeof(argp->nextpgno);
1079         memcpy(&argp->nextlsn, bp,  sizeof(argp->nextlsn));
1080         bp += sizeof(argp->nextlsn);
1081         *argpp = argp;
1082         return (0);
1083 }
1084
1085 /*
1086  * PUBLIC: int __db_debug_log
1087  * PUBLIC:     __P((DB_LOG *, DB_TXN *, DB_LSN *, u_int32_t,
1088  * PUBLIC:     DBT *, u_int32_t, DBT *, DBT *,
1089  * PUBLIC:     u_int32_t));
1090  */
1091 int __db_debug_log(logp, txnid, ret_lsnp, flags,
1092         op, fileid, key, data, arg_flags)
1093         DB_LOG *logp;
1094         DB_TXN *txnid;
1095         DB_LSN *ret_lsnp;
1096         u_int32_t flags;
1097         DBT *op;
1098         u_int32_t fileid;
1099         DBT *key;
1100         DBT *data;
1101         u_int32_t arg_flags;
1102 {
1103         DBT logrec;
1104         DB_LSN *lsnp, null_lsn;
1105         u_int32_t zero;
1106         u_int32_t rectype, txn_num;
1107         int ret;
1108         u_int8_t *bp;
1109
1110         rectype = DB_db_debug;
1111         txn_num = txnid == NULL ? 0 : txnid->txnid;
1112         if (txnid == NULL) {
1113                 null_lsn.file = 0;
1114                 null_lsn.offset = 0;
1115                 lsnp = &null_lsn;
1116         } else
1117                 lsnp = &txnid->last_lsn;
1118         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
1119             + sizeof(u_int32_t) + (op == NULL ? 0 : op->size)
1120             + sizeof(fileid)
1121             + sizeof(u_int32_t) + (key == NULL ? 0 : key->size)
1122             + sizeof(u_int32_t) + (data == NULL ? 0 : data->size)
1123             + sizeof(arg_flags);
1124         if ((logrec.data = (void *)__db_malloc(logrec.size)) == NULL)
1125                 return (ENOMEM);
1126
1127         bp = logrec.data;
1128         memcpy(bp, &rectype, sizeof(rectype));
1129         bp += sizeof(rectype);
1130         memcpy(bp, &txn_num, sizeof(txn_num));
1131         bp += sizeof(txn_num);
1132         memcpy(bp, lsnp, sizeof(DB_LSN));
1133         bp += sizeof(DB_LSN);
1134         if (op == NULL) {
1135                 zero = 0;
1136                 memcpy(bp, &zero, sizeof(u_int32_t));
1137                 bp += sizeof(u_int32_t);
1138         } else {
1139                 memcpy(bp, &op->size, sizeof(op->size));
1140                 bp += sizeof(op->size);
1141                 memcpy(bp, op->data, op->size);
1142                 bp += op->size;
1143         }
1144         memcpy(bp, &fileid, sizeof(fileid));
1145         bp += sizeof(fileid);
1146         if (key == NULL) {
1147                 zero = 0;
1148                 memcpy(bp, &zero, sizeof(u_int32_t));
1149                 bp += sizeof(u_int32_t);
1150         } else {
1151                 memcpy(bp, &key->size, sizeof(key->size));
1152                 bp += sizeof(key->size);
1153                 memcpy(bp, key->data, key->size);
1154                 bp += key->size;
1155         }
1156         if (data == NULL) {
1157                 zero = 0;
1158                 memcpy(bp, &zero, sizeof(u_int32_t));
1159                 bp += sizeof(u_int32_t);
1160         } else {
1161                 memcpy(bp, &data->size, sizeof(data->size));
1162                 bp += sizeof(data->size);
1163                 memcpy(bp, data->data, data->size);
1164                 bp += data->size;
1165         }
1166         memcpy(bp, &arg_flags, sizeof(arg_flags));
1167         bp += sizeof(arg_flags);
1168 #ifdef DEBUG
1169         if ((u_int32_t)(bp - (u_int8_t *)logrec.data) != logrec.size)
1170                 fprintf(stderr, "Error in log record length");
1171 #endif
1172         ret = log_put(logp, ret_lsnp, (DBT *)&logrec, flags);
1173         if (txnid != NULL)
1174                 txnid->last_lsn = *ret_lsnp;
1175         __db_free(logrec.data);
1176         return (ret);
1177 }
1178
1179 /*
1180  * PUBLIC: int __db_debug_print
1181  * PUBLIC:    __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
1182  */
1183
1184 int
1185 __db_debug_print(notused1, dbtp, lsnp, notused3, notused4)
1186         DB_LOG *notused1;
1187         DBT *dbtp;
1188         DB_LSN *lsnp;
1189         int notused3;
1190         void *notused4;
1191 {
1192         __db_debug_args *argp;
1193         u_int32_t i;
1194         int c, ret;
1195
1196         i = 0;
1197         c = 0;
1198         notused1 = NULL;
1199         notused3 = 0;
1200         notused4 = NULL;
1201
1202         if ((ret = __db_debug_read(dbtp->data, &argp)) != 0)
1203                 return (ret);
1204         printf("[%lu][%lu]db_debug: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
1205             (u_long)lsnp->file,
1206             (u_long)lsnp->offset,
1207             (u_long)argp->type,
1208             (u_long)argp->txnid->txnid,
1209             (u_long)argp->prev_lsn.file,
1210             (u_long)argp->prev_lsn.offset);
1211         printf("\top: ");
1212         for (i = 0; i < argp->op.size; i++) {
1213                 c = ((char *)argp->op.data)[i];
1214                 if (isprint(c) || c == 0xa)
1215                         putchar(c);
1216                 else
1217                         printf("%#x ", c);
1218         }
1219         printf("\n");
1220         printf("\tfileid: %lu\n", (u_long)argp->fileid);
1221         printf("\tkey: ");
1222         for (i = 0; i < argp->key.size; i++) {
1223                 c = ((char *)argp->key.data)[i];
1224                 if (isprint(c) || c == 0xa)
1225                         putchar(c);
1226                 else
1227                         printf("%#x ", c);
1228         }
1229         printf("\n");
1230         printf("\tdata: ");
1231         for (i = 0; i < argp->data.size; i++) {
1232                 c = ((char *)argp->data.data)[i];
1233                 if (isprint(c) || c == 0xa)
1234                         putchar(c);
1235                 else
1236                         printf("%#x ", c);
1237         }
1238         printf("\n");
1239         printf("\targ_flags: %lu\n", (u_long)argp->arg_flags);
1240         printf("\n");
1241         __db_free(argp);
1242         return (0);
1243 }
1244
1245 /*
1246  * PUBLIC: int __db_debug_read __P((void *, __db_debug_args **));
1247  */
1248 int
1249 __db_debug_read(recbuf, argpp)
1250         void *recbuf;
1251         __db_debug_args **argpp;
1252 {
1253         __db_debug_args *argp;
1254         u_int8_t *bp;
1255
1256         argp = (__db_debug_args *)__db_malloc(sizeof(__db_debug_args) +
1257             sizeof(DB_TXN));
1258         if (argp == NULL)
1259                 return (ENOMEM);
1260         argp->txnid = (DB_TXN *)&argp[1];
1261         bp = recbuf;
1262         memcpy(&argp->type, bp, sizeof(argp->type));
1263         bp += sizeof(argp->type);
1264         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
1265         bp += sizeof(argp->txnid->txnid);
1266         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
1267         bp += sizeof(DB_LSN);
1268         memcpy(&argp->op.size, bp, sizeof(u_int32_t));
1269         bp += sizeof(u_int32_t);
1270         argp->op.data = bp;
1271         bp += argp->op.size;
1272         memcpy(&argp->fileid, bp, sizeof(argp->fileid));
1273         bp += sizeof(argp->fileid);
1274         memcpy(&argp->key.size, bp, sizeof(u_int32_t));
1275         bp += sizeof(u_int32_t);
1276         argp->key.data = bp;
1277         bp += argp->key.size;
1278         memcpy(&argp->data.size, bp, sizeof(u_int32_t));
1279         bp += sizeof(u_int32_t);
1280         argp->data.data = bp;
1281         bp += argp->data.size;
1282         memcpy(&argp->arg_flags, bp, sizeof(argp->arg_flags));
1283         bp += sizeof(argp->arg_flags);
1284         *argpp = argp;
1285         return (0);
1286 }
1287
1288 /*
1289  * PUBLIC: int __db_noop_log
1290  * PUBLIC:     __P((DB_LOG *, DB_TXN *, DB_LSN *, u_int32_t));
1291  */
1292 int __db_noop_log(logp, txnid, ret_lsnp, flags)
1293         DB_LOG *logp;
1294         DB_TXN *txnid;
1295         DB_LSN *ret_lsnp;
1296         u_int32_t flags;
1297 {
1298         DBT logrec;
1299         DB_LSN *lsnp, null_lsn;
1300         u_int32_t rectype, txn_num;
1301         int ret;
1302         u_int8_t *bp;
1303
1304         rectype = DB_db_noop;
1305         txn_num = txnid == NULL ? 0 : txnid->txnid;
1306         if (txnid == NULL) {
1307                 null_lsn.file = 0;
1308                 null_lsn.offset = 0;
1309                 lsnp = &null_lsn;
1310         } else
1311                 lsnp = &txnid->last_lsn;
1312         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN);
1313         if ((logrec.data = (void *)__db_malloc(logrec.size)) == NULL)
1314                 return (ENOMEM);
1315
1316         bp = logrec.data;
1317         memcpy(bp, &rectype, sizeof(rectype));
1318         bp += sizeof(rectype);
1319         memcpy(bp, &txn_num, sizeof(txn_num));
1320         bp += sizeof(txn_num);
1321         memcpy(bp, lsnp, sizeof(DB_LSN));
1322         bp += sizeof(DB_LSN);
1323 #ifdef DEBUG
1324         if ((u_int32_t)(bp - (u_int8_t *)logrec.data) != logrec.size)
1325                 fprintf(stderr, "Error in log record length");
1326 #endif
1327         ret = log_put(logp, ret_lsnp, (DBT *)&logrec, flags);
1328         if (txnid != NULL)
1329                 txnid->last_lsn = *ret_lsnp;
1330         __db_free(logrec.data);
1331         return (ret);
1332 }
1333
1334 /*
1335  * PUBLIC: int __db_noop_print
1336  * PUBLIC:    __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
1337  */
1338
1339 int
1340 __db_noop_print(notused1, dbtp, lsnp, notused3, notused4)
1341         DB_LOG *notused1;
1342         DBT *dbtp;
1343         DB_LSN *lsnp;
1344         int notused3;
1345         void *notused4;
1346 {
1347         __db_noop_args *argp;
1348         u_int32_t i;
1349         int c, ret;
1350
1351         i = 0;
1352         c = 0;
1353         notused1 = NULL;
1354         notused3 = 0;
1355         notused4 = NULL;
1356
1357         if ((ret = __db_noop_read(dbtp->data, &argp)) != 0)
1358                 return (ret);
1359         printf("[%lu][%lu]db_noop: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
1360             (u_long)lsnp->file,
1361             (u_long)lsnp->offset,
1362             (u_long)argp->type,
1363             (u_long)argp->txnid->txnid,
1364             (u_long)argp->prev_lsn.file,
1365             (u_long)argp->prev_lsn.offset);
1366         printf("\n");
1367         __db_free(argp);
1368         return (0);
1369 }
1370
1371 /*
1372  * PUBLIC: int __db_noop_read __P((void *, __db_noop_args **));
1373  */
1374 int
1375 __db_noop_read(recbuf, argpp)
1376         void *recbuf;
1377         __db_noop_args **argpp;
1378 {
1379         __db_noop_args *argp;
1380         u_int8_t *bp;
1381
1382         argp = (__db_noop_args *)__db_malloc(sizeof(__db_noop_args) +
1383             sizeof(DB_TXN));
1384         if (argp == NULL)
1385                 return (ENOMEM);
1386         argp->txnid = (DB_TXN *)&argp[1];
1387         bp = recbuf;
1388         memcpy(&argp->type, bp, sizeof(argp->type));
1389         bp += sizeof(argp->type);
1390         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
1391         bp += sizeof(argp->txnid->txnid);
1392         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
1393         bp += sizeof(DB_LSN);
1394         *argpp = argp;
1395         return (0);
1396 }
1397
1398 /*
1399  * PUBLIC: int __db_init_print __P((DB_ENV *));
1400  */
1401 int
1402 __db_init_print(dbenv)
1403         DB_ENV *dbenv;
1404 {
1405         int ret;
1406
1407         if ((ret = __db_add_recovery(dbenv,
1408             __db_addrem_print, DB_db_addrem)) != 0)
1409                 return (ret);
1410         if ((ret = __db_add_recovery(dbenv,
1411             __db_split_print, DB_db_split)) != 0)
1412                 return (ret);
1413         if ((ret = __db_add_recovery(dbenv,
1414             __db_big_print, DB_db_big)) != 0)
1415                 return (ret);
1416         if ((ret = __db_add_recovery(dbenv,
1417             __db_ovref_print, DB_db_ovref)) != 0)
1418                 return (ret);
1419         if ((ret = __db_add_recovery(dbenv,
1420             __db_relink_print, DB_db_relink)) != 0)
1421                 return (ret);
1422         if ((ret = __db_add_recovery(dbenv,
1423             __db_addpage_print, DB_db_addpage)) != 0)
1424                 return (ret);
1425         if ((ret = __db_add_recovery(dbenv,
1426             __db_debug_print, DB_db_debug)) != 0)
1427                 return (ret);
1428         if ((ret = __db_add_recovery(dbenv,
1429             __db_noop_print, DB_db_noop)) != 0)
1430                 return (ret);
1431         return (0);
1432 }
1433
1434 /*
1435  * PUBLIC: int __db_init_recover __P((DB_ENV *));
1436  */
1437 int
1438 __db_init_recover(dbenv)
1439         DB_ENV *dbenv;
1440 {
1441         int ret;
1442
1443         if ((ret = __db_add_recovery(dbenv,
1444             __db_addrem_recover, DB_db_addrem)) != 0)
1445                 return (ret);
1446         if ((ret = __db_add_recovery(dbenv,
1447             __db_split_recover, DB_db_split)) != 0)
1448                 return (ret);
1449         if ((ret = __db_add_recovery(dbenv,
1450             __db_big_recover, DB_db_big)) != 0)
1451                 return (ret);
1452         if ((ret = __db_add_recovery(dbenv,
1453             __db_ovref_recover, DB_db_ovref)) != 0)
1454                 return (ret);
1455         if ((ret = __db_add_recovery(dbenv,
1456             __db_relink_recover, DB_db_relink)) != 0)
1457                 return (ret);
1458         if ((ret = __db_add_recovery(dbenv,
1459             __db_addpage_recover, DB_db_addpage)) != 0)
1460                 return (ret);
1461         if ((ret = __db_add_recovery(dbenv,
1462             __db_debug_recover, DB_db_debug)) != 0)
1463                 return (ret);
1464         if ((ret = __db_add_recovery(dbenv,
1465             __db_noop_recover, DB_db_noop)) != 0)
1466                 return (ret);
1467         return (0);
1468 }
1469