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