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 *, const DBT *, const 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         const DBT *key;
  39         const 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 *)__db_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         __db_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 int
 123 __ham_insdel_print(notused1, dbtp, lsnp, notused3, notused4)
 124         DB_LOG *notused1;
 125         DBT *dbtp;
 126         DB_LSN *lsnp;
 127         int notused3;
 128         void *notused4;
 129 {
 130         __ham_insdel_args *argp;
 131         u_int32_t i;
 132         int c, ret;
 133
 134         i = 0;
 135         c = 0;
 136         notused1 = NULL;
 137         notused3 = 0;
 138         notused4 = NULL;
 139
 140         if ((ret = __ham_insdel_read(dbtp->data, &argp)) != 0)
 141                 return (ret);
 142         printf("[%lu][%lu]ham_insdel: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
 143             (u_long)lsnp->file,
 144             (u_long)lsnp->offset,
 145             (u_long)argp->type,
 146             (u_long)argp->txnid->txnid,
 147             (u_long)argp->prev_lsn.file,
 148             (u_long)argp->prev_lsn.offset);
 149         printf("\topcode: %lu\n", (u_long)argp->opcode);
 150         printf("\tfileid: %lu\n", (u_long)argp->fileid);
 151         printf("\tpgno: %lu\n", (u_long)argp->pgno);
 152         printf("\tndx: %lu\n", (u_long)argp->ndx);
 153         printf("\tpagelsn: [%lu][%lu]\n",
 154             (u_long)argp->pagelsn.file, (u_long)argp->pagelsn.offset);
 155         printf("\tkey: ");
 156         for (i = 0; i < argp->key.size; i++) {
 157                 c = ((char *)argp->key.data)[i];
 158                 if (isprint(c) || c == 0xa)
 159                         putchar(c);
 160                 else
 161                         printf("%#x ", c);
 162         }
 163         printf("\n");
 164         printf("\tdata: ");
 165         for (i = 0; i < argp->data.size; i++) {
 166                 c = ((char *)argp->data.data)[i];
 167                 if (isprint(c) || c == 0xa)
 168                         putchar(c);
 169                 else
 170                         printf("%#x ", c);
 171         }
 172         printf("\n");
 173         printf("\n");
 174         __db_free(argp);
 175         return (0);
 176 }
 177
 178 /*
 179  * PUBLIC: int __ham_insdel_read __P((void *, __ham_insdel_args **));
 180  */
 181 int
 182 __ham_insdel_read(recbuf, argpp)
 183         void *recbuf;
 184         __ham_insdel_args **argpp;
 185 {
 186         __ham_insdel_args *argp;
 187         u_int8_t *bp;
 188
 189         argp = (__ham_insdel_args *)__db_malloc(sizeof(__ham_insdel_args) +
 190             sizeof(DB_TXN));
 191         if (argp == NULL)
 192                 return (ENOMEM);
 193         argp->txnid = (DB_TXN *)&argp[1];
 194         bp = recbuf;
 195         memcpy(&argp->type, bp, sizeof(argp->type));
 196         bp += sizeof(argp->type);
 197         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
 198         bp += sizeof(argp->txnid->txnid);
 199         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
 200         bp += sizeof(DB_LSN);
 201         memcpy(&argp->opcode, bp, sizeof(argp->opcode));
 202         bp += sizeof(argp->opcode);
 203         memcpy(&argp->fileid, bp, sizeof(argp->fileid));
 204         bp += sizeof(argp->fileid);
 205         memcpy(&argp->pgno, bp, sizeof(argp->pgno));
 206         bp += sizeof(argp->pgno);
 207         memcpy(&argp->ndx, bp, sizeof(argp->ndx));
 208         bp += sizeof(argp->ndx);
 209         memcpy(&argp->pagelsn, bp,  sizeof(argp->pagelsn));
 210         bp += sizeof(argp->pagelsn);
 211         memcpy(&argp->key.size, bp, sizeof(u_int32_t));
 212         bp += sizeof(u_int32_t);
 213         argp->key.data = bp;
 214         bp += argp->key.size;
 215         memcpy(&argp->data.size, bp, sizeof(u_int32_t));
 216         bp += sizeof(u_int32_t);
 217         argp->data.data = bp;
 218         bp += argp->data.size;
 219         *argpp = argp;
 220         return (0);
 221 }
 222
 223 /*
 224  * PUBLIC: int __ham_newpage_log
 225  * PUBLIC:     __P((DB_LOG *, DB_TXN *, DB_LSN *, u_int32_t,
 226  * PUBLIC:     u_int32_t, u_int32_t, db_pgno_t, DB_LSN *,
 227  * PUBLIC:     db_pgno_t, DB_LSN *, db_pgno_t, DB_LSN *));
 228  */
 229 int __ham_newpage_log(logp, txnid, ret_lsnp, flags,
 230         opcode, fileid, prev_pgno, prevlsn, new_pgno, pagelsn,
 231         next_pgno, nextlsn)
 232         DB_LOG *logp;
 233         DB_TXN *txnid;
 234         DB_LSN *ret_lsnp;
 235         u_int32_t flags;
 236         u_int32_t opcode;
 237         u_int32_t fileid;
 238         db_pgno_t prev_pgno;
 239         DB_LSN * prevlsn;
 240         db_pgno_t new_pgno;
 241         DB_LSN * pagelsn;
 242         db_pgno_t next_pgno;
 243         DB_LSN * nextlsn;
 244 {
 245         DBT logrec;
 246         DB_LSN *lsnp, null_lsn;
 247         u_int32_t rectype, txn_num;
 248         int ret;
 249         u_int8_t *bp;
 250
 251         rectype = DB_ham_newpage;
 252         txn_num = txnid == NULL ? 0 : txnid->txnid;
 253         if (txnid == NULL) {
 254                 null_lsn.file = 0;
 255                 null_lsn.offset = 0;
 256                 lsnp = &null_lsn;
 257         } else
 258                 lsnp = &txnid->last_lsn;
 259         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
 260             + sizeof(opcode)
 261             + sizeof(fileid)
 262             + sizeof(prev_pgno)
 263             + sizeof(*prevlsn)
 264             + sizeof(new_pgno)
 265             + sizeof(*pagelsn)
 266             + sizeof(next_pgno)
 267             + sizeof(*nextlsn);
 268         if ((logrec.data = (void *)__db_malloc(logrec.size)) == NULL)
 269                 return (ENOMEM);
 270
 271         bp = logrec.data;
 272         memcpy(bp, &rectype, sizeof(rectype));
 273         bp += sizeof(rectype);
 274         memcpy(bp, &txn_num, sizeof(txn_num));
 275         bp += sizeof(txn_num);
 276         memcpy(bp, lsnp, sizeof(DB_LSN));
 277         bp += sizeof(DB_LSN);
 278         memcpy(bp, &opcode, sizeof(opcode));
 279         bp += sizeof(opcode);
 280         memcpy(bp, &fileid, sizeof(fileid));
 281         bp += sizeof(fileid);
 282         memcpy(bp, &prev_pgno, sizeof(prev_pgno));
 283         bp += sizeof(prev_pgno);
 284         if (prevlsn != NULL)
 285                 memcpy(bp, prevlsn, sizeof(*prevlsn));
 286         else
 287                 memset(bp, 0, sizeof(*prevlsn));
 288         bp += sizeof(*prevlsn);
 289         memcpy(bp, &new_pgno, sizeof(new_pgno));
 290         bp += sizeof(new_pgno);
 291         if (pagelsn != NULL)
 292                 memcpy(bp, pagelsn, sizeof(*pagelsn));
 293         else
 294                 memset(bp, 0, sizeof(*pagelsn));
 295         bp += sizeof(*pagelsn);
 296         memcpy(bp, &next_pgno, sizeof(next_pgno));
 297         bp += sizeof(next_pgno);
 298         if (nextlsn != NULL)
 299                 memcpy(bp, nextlsn, sizeof(*nextlsn));
 300         else
 301                 memset(bp, 0, sizeof(*nextlsn));
 302         bp += sizeof(*nextlsn);
 303 #ifdef DEBUG
 304         if ((u_int32_t)(bp - (u_int8_t *)logrec.data) != logrec.size)
 305                 fprintf(stderr, "Error in log record length");
 306 #endif
 307         ret = log_put(logp, ret_lsnp, (DBT *)&logrec, flags);
 308         if (txnid != NULL)
 309                 txnid->last_lsn = *ret_lsnp;
 310         __db_free(logrec.data);
 311         return (ret);
 312 }
 313
 314 /*
 315  * PUBLIC: int __ham_newpage_print
 316  * PUBLIC:    __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
 317  */
 318 int
 319 __ham_newpage_print(notused1, dbtp, lsnp, notused3, notused4)
 320         DB_LOG *notused1;
 321         DBT *dbtp;
 322         DB_LSN *lsnp;
 323         int notused3;
 324         void *notused4;
 325 {
 326         __ham_newpage_args *argp;
 327         u_int32_t i;
 328         int c, ret;
 329
 330         i = 0;
 331         c = 0;
 332         notused1 = NULL;
 333         notused3 = 0;
 334         notused4 = NULL;
 335
 336         if ((ret = __ham_newpage_read(dbtp->data, &argp)) != 0)
 337                 return (ret);
 338         printf("[%lu][%lu]ham_newpage: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
 339             (u_long)lsnp->file,
 340             (u_long)lsnp->offset,
 341             (u_long)argp->type,
 342             (u_long)argp->txnid->txnid,
 343             (u_long)argp->prev_lsn.file,
 344             (u_long)argp->prev_lsn.offset);
 345         printf("\topcode: %lu\n", (u_long)argp->opcode);
 346         printf("\tfileid: %lu\n", (u_long)argp->fileid);
 347         printf("\tprev_pgno: %lu\n", (u_long)argp->prev_pgno);
 348         printf("\tprevlsn: [%lu][%lu]\n",
 349             (u_long)argp->prevlsn.file, (u_long)argp->prevlsn.offset);
 350         printf("\tnew_pgno: %lu\n", (u_long)argp->new_pgno);
 351         printf("\tpagelsn: [%lu][%lu]\n",
 352             (u_long)argp->pagelsn.file, (u_long)argp->pagelsn.offset);
 353         printf("\tnext_pgno: %lu\n", (u_long)argp->next_pgno);
 354         printf("\tnextlsn: [%lu][%lu]\n",
 355             (u_long)argp->nextlsn.file, (u_long)argp->nextlsn.offset);
 356         printf("\n");
 357         __db_free(argp);
 358         return (0);
 359 }
 360
 361 /*
 362  * PUBLIC: int __ham_newpage_read __P((void *, __ham_newpage_args **));
 363  */
 364 int
 365 __ham_newpage_read(recbuf, argpp)
 366         void *recbuf;
 367         __ham_newpage_args **argpp;
 368 {
 369         __ham_newpage_args *argp;
 370         u_int8_t *bp;
 371
 372         argp = (__ham_newpage_args *)__db_malloc(sizeof(__ham_newpage_args) +
 373             sizeof(DB_TXN));
 374         if (argp == NULL)
 375                 return (ENOMEM);
 376         argp->txnid = (DB_TXN *)&argp[1];
 377         bp = recbuf;
 378         memcpy(&argp->type, bp, sizeof(argp->type));
 379         bp += sizeof(argp->type);
 380         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
 381         bp += sizeof(argp->txnid->txnid);
 382         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
 383         bp += sizeof(DB_LSN);
 384         memcpy(&argp->opcode, bp, sizeof(argp->opcode));
 385         bp += sizeof(argp->opcode);
 386         memcpy(&argp->fileid, bp, sizeof(argp->fileid));
 387         bp += sizeof(argp->fileid);
 388         memcpy(&argp->prev_pgno, bp, sizeof(argp->prev_pgno));
 389         bp += sizeof(argp->prev_pgno);
 390         memcpy(&argp->prevlsn, bp,  sizeof(argp->prevlsn));
 391         bp += sizeof(argp->prevlsn);
 392         memcpy(&argp->new_pgno, bp, sizeof(argp->new_pgno));
 393         bp += sizeof(argp->new_pgno);
 394         memcpy(&argp->pagelsn, bp,  sizeof(argp->pagelsn));
 395         bp += sizeof(argp->pagelsn);
 396         memcpy(&argp->next_pgno, bp, sizeof(argp->next_pgno));
 397         bp += sizeof(argp->next_pgno);
 398         memcpy(&argp->nextlsn, bp,  sizeof(argp->nextlsn));
 399         bp += sizeof(argp->nextlsn);
 400         *argpp = argp;
 401         return (0);
 402 }
 403
 404 /*
 405  * PUBLIC: int __ham_splitmeta_log
 406  * PUBLIC:     __P((DB_LOG *, DB_TXN *, DB_LSN *, u_int32_t,
 407  * PUBLIC:     u_int32_t, u_int32_t, u_int32_t, u_int32_t,
 408  * PUBLIC:     DB_LSN *));
 409  */
 410 int __ham_splitmeta_log(logp, txnid, ret_lsnp, flags,
 411         fileid, bucket, ovflpoint, spares, metalsn)
 412         DB_LOG *logp;
 413         DB_TXN *txnid;
 414         DB_LSN *ret_lsnp;
 415         u_int32_t flags;
 416         u_int32_t fileid;
 417         u_int32_t bucket;
 418         u_int32_t ovflpoint;
 419         u_int32_t spares;
 420         DB_LSN * metalsn;
 421 {
 422         DBT logrec;
 423         DB_LSN *lsnp, null_lsn;
 424         u_int32_t rectype, txn_num;
 425         int ret;
 426         u_int8_t *bp;
 427
 428         rectype = DB_ham_splitmeta;
 429         txn_num = txnid == NULL ? 0 : txnid->txnid;
 430         if (txnid == NULL) {
 431                 null_lsn.file = 0;
 432                 null_lsn.offset = 0;
 433                 lsnp = &null_lsn;
 434         } else
 435                 lsnp = &txnid->last_lsn;
 436         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
 437             + sizeof(fileid)
 438             + sizeof(bucket)
 439             + sizeof(ovflpoint)
 440             + sizeof(spares)
 441             + sizeof(*metalsn);
 442         if ((logrec.data = (void *)__db_malloc(logrec.size)) == NULL)
 443                 return (ENOMEM);
 444
 445         bp = logrec.data;
 446         memcpy(bp, &rectype, sizeof(rectype));
 447         bp += sizeof(rectype);
 448         memcpy(bp, &txn_num, sizeof(txn_num));
 449         bp += sizeof(txn_num);
 450         memcpy(bp, lsnp, sizeof(DB_LSN));
 451         bp += sizeof(DB_LSN);
 452         memcpy(bp, &fileid, sizeof(fileid));
 453         bp += sizeof(fileid);
 454         memcpy(bp, &bucket, sizeof(bucket));
 455         bp += sizeof(bucket);
 456         memcpy(bp, &ovflpoint, sizeof(ovflpoint));
 457         bp += sizeof(ovflpoint);
 458         memcpy(bp, &spares, sizeof(spares));
 459         bp += sizeof(spares);
 460         if (metalsn != NULL)
 461                 memcpy(bp, metalsn, sizeof(*metalsn));
 462         else
 463                 memset(bp, 0, sizeof(*metalsn));
 464         bp += sizeof(*metalsn);
 465 #ifdef DEBUG
 466         if ((u_int32_t)(bp - (u_int8_t *)logrec.data) != logrec.size)
 467                 fprintf(stderr, "Error in log record length");
 468 #endif
 469         ret = log_put(logp, ret_lsnp, (DBT *)&logrec, flags);
 470         if (txnid != NULL)
 471                 txnid->last_lsn = *ret_lsnp;
 472         __db_free(logrec.data);
 473         return (ret);
 474 }
 475
 476 /*
 477  * PUBLIC: int __ham_splitmeta_print
 478  * PUBLIC:    __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
 479  */
 480 int
 481 __ham_splitmeta_print(notused1, dbtp, lsnp, notused3, notused4)
 482         DB_LOG *notused1;
 483         DBT *dbtp;
 484         DB_LSN *lsnp;
 485         int notused3;
 486         void *notused4;
 487 {
 488         __ham_splitmeta_args *argp;
 489         u_int32_t i;
 490         int c, ret;
 491
 492         i = 0;
 493         c = 0;
 494         notused1 = NULL;
 495         notused3 = 0;
 496         notused4 = NULL;
 497
 498         if ((ret = __ham_splitmeta_read(dbtp->data, &argp)) != 0)
 499                 return (ret);
 500         printf("[%lu][%lu]ham_splitmeta: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
 501             (u_long)lsnp->file,
 502             (u_long)lsnp->offset,
 503             (u_long)argp->type,
 504             (u_long)argp->txnid->txnid,
 505             (u_long)argp->prev_lsn.file,
 506             (u_long)argp->prev_lsn.offset);
 507         printf("\tfileid: %lu\n", (u_long)argp->fileid);
 508         printf("\tbucket: %lu\n", (u_long)argp->bucket);
 509         printf("\tovflpoint: %lu\n", (u_long)argp->ovflpoint);
 510         printf("\tspares: %lu\n", (u_long)argp->spares);
 511         printf("\tmetalsn: [%lu][%lu]\n",
 512             (u_long)argp->metalsn.file, (u_long)argp->metalsn.offset);
 513         printf("\n");
 514         __db_free(argp);
 515         return (0);
 516 }
 517
 518 /*
 519  * PUBLIC: int __ham_splitmeta_read __P((void *, __ham_splitmeta_args **));
 520  */
 521 int
 522 __ham_splitmeta_read(recbuf, argpp)
 523         void *recbuf;
 524         __ham_splitmeta_args **argpp;
 525 {
 526         __ham_splitmeta_args *argp;
 527         u_int8_t *bp;
 528
 529         argp = (__ham_splitmeta_args *)__db_malloc(sizeof(__ham_splitmeta_args) +
 530             sizeof(DB_TXN));
 531         if (argp == NULL)
 532                 return (ENOMEM);
 533         argp->txnid = (DB_TXN *)&argp[1];
 534         bp = recbuf;
 535         memcpy(&argp->type, bp, sizeof(argp->type));
 536         bp += sizeof(argp->type);
 537         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
 538         bp += sizeof(argp->txnid->txnid);
 539         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
 540         bp += sizeof(DB_LSN);
 541         memcpy(&argp->fileid, bp, sizeof(argp->fileid));
 542         bp += sizeof(argp->fileid);
 543         memcpy(&argp->bucket, bp, sizeof(argp->bucket));
 544         bp += sizeof(argp->bucket);
 545         memcpy(&argp->ovflpoint, bp, sizeof(argp->ovflpoint));
 546         bp += sizeof(argp->ovflpoint);
 547         memcpy(&argp->spares, bp, sizeof(argp->spares));
 548         bp += sizeof(argp->spares);
 549         memcpy(&argp->metalsn, bp,  sizeof(argp->metalsn));
 550         bp += sizeof(argp->metalsn);
 551         *argpp = argp;
 552         return (0);
 553 }
 554
 555 /*
 556  * PUBLIC: int __ham_splitdata_log
 557  * PUBLIC:     __P((DB_LOG *, DB_TXN *, DB_LSN *, u_int32_t,
 558  * PUBLIC:     u_int32_t, u_int32_t, db_pgno_t, const DBT *,
 559  * PUBLIC:     DB_LSN *));
 560  */
 561 int __ham_splitdata_log(logp, txnid, ret_lsnp, flags,
 562         fileid, opcode, pgno, pageimage, pagelsn)
 563         DB_LOG *logp;
 564         DB_TXN *txnid;
 565         DB_LSN *ret_lsnp;
 566         u_int32_t flags;
 567         u_int32_t fileid;
 568         u_int32_t opcode;
 569         db_pgno_t pgno;
 570         const DBT *pageimage;
 571         DB_LSN * pagelsn;
 572 {
 573         DBT logrec;
 574         DB_LSN *lsnp, null_lsn;
 575         u_int32_t zero;
 576         u_int32_t rectype, txn_num;
 577         int ret;
 578         u_int8_t *bp;
 579
 580         rectype = DB_ham_splitdata;
 581         txn_num = txnid == NULL ? 0 : txnid->txnid;
 582         if (txnid == NULL) {
 583                 null_lsn.file = 0;
 584                 null_lsn.offset = 0;
 585                 lsnp = &null_lsn;
 586         } else
 587                 lsnp = &txnid->last_lsn;
 588         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
 589             + sizeof(fileid)
 590             + sizeof(opcode)
 591             + sizeof(pgno)
 592             + sizeof(u_int32_t) + (pageimage == NULL ? 0 : pageimage->size)
 593             + sizeof(*pagelsn);
 594         if ((logrec.data = (void *)__db_malloc(logrec.size)) == NULL)
 595                 return (ENOMEM);
 596
 597         bp = logrec.data;
 598         memcpy(bp, &rectype, sizeof(rectype));
 599         bp += sizeof(rectype);
 600         memcpy(bp, &txn_num, sizeof(txn_num));
 601         bp += sizeof(txn_num);
 602         memcpy(bp, lsnp, sizeof(DB_LSN));
 603         bp += sizeof(DB_LSN);
 604         memcpy(bp, &fileid, sizeof(fileid));
 605         bp += sizeof(fileid);
 606         memcpy(bp, &opcode, sizeof(opcode));
 607         bp += sizeof(opcode);
 608         memcpy(bp, &pgno, sizeof(pgno));
 609         bp += sizeof(pgno);
 610         if (pageimage == NULL) {
 611                 zero = 0;
 612                 memcpy(bp, &zero, sizeof(u_int32_t));
 613                 bp += sizeof(u_int32_t);
 614         } else {
 615                 memcpy(bp, &pageimage->size, sizeof(pageimage->size));
 616                 bp += sizeof(pageimage->size);
 617                 memcpy(bp, pageimage->data, pageimage->size);
 618                 bp += pageimage->size;
 619         }
 620         if (pagelsn != NULL)
 621                 memcpy(bp, pagelsn, sizeof(*pagelsn));
 622         else
 623                 memset(bp, 0, sizeof(*pagelsn));
 624         bp += sizeof(*pagelsn);
 625 #ifdef DEBUG
 626         if ((u_int32_t)(bp - (u_int8_t *)logrec.data) != logrec.size)
 627                 fprintf(stderr, "Error in log record length");
 628 #endif
 629         ret = log_put(logp, ret_lsnp, (DBT *)&logrec, flags);
 630         if (txnid != NULL)
 631                 txnid->last_lsn = *ret_lsnp;
 632         __db_free(logrec.data);
 633         return (ret);
 634 }
 635
 636 /*
 637  * PUBLIC: int __ham_splitdata_print
 638  * PUBLIC:    __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
 639  */
 640 int
 641 __ham_splitdata_print(notused1, dbtp, lsnp, notused3, notused4)
 642         DB_LOG *notused1;
 643         DBT *dbtp;
 644         DB_LSN *lsnp;
 645         int notused3;
 646         void *notused4;
 647 {
 648         __ham_splitdata_args *argp;
 649         u_int32_t i;
 650         int c, ret;
 651
 652         i = 0;
 653         c = 0;
 654         notused1 = NULL;
 655         notused3 = 0;
 656         notused4 = NULL;
 657
 658         if ((ret = __ham_splitdata_read(dbtp->data, &argp)) != 0)
 659                 return (ret);
 660         printf("[%lu][%lu]ham_splitdata: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
 661             (u_long)lsnp->file,
 662             (u_long)lsnp->offset,
 663             (u_long)argp->type,
 664             (u_long)argp->txnid->txnid,
 665             (u_long)argp->prev_lsn.file,
 666             (u_long)argp->prev_lsn.offset);
 667         printf("\tfileid: %lu\n", (u_long)argp->fileid);
 668         printf("\topcode: %lu\n", (u_long)argp->opcode);
 669         printf("\tpgno: %lu\n", (u_long)argp->pgno);
 670         printf("\tpageimage: ");
 671         for (i = 0; i < argp->pageimage.size; i++) {
 672                 c = ((char *)argp->pageimage.data)[i];
 673                 if (isprint(c) || c == 0xa)
 674                         putchar(c);
 675                 else
 676                         printf("%#x ", c);
 677         }
 678         printf("\n");
 679         printf("\tpagelsn: [%lu][%lu]\n",
 680             (u_long)argp->pagelsn.file, (u_long)argp->pagelsn.offset);
 681         printf("\n");
 682         __db_free(argp);
 683         return (0);
 684 }
 685
 686 /*
 687  * PUBLIC: int __ham_splitdata_read __P((void *, __ham_splitdata_args **));
 688  */
 689 int
 690 __ham_splitdata_read(recbuf, argpp)
 691         void *recbuf;
 692         __ham_splitdata_args **argpp;
 693 {
 694         __ham_splitdata_args *argp;
 695         u_int8_t *bp;
 696
 697         argp = (__ham_splitdata_args *)__db_malloc(sizeof(__ham_splitdata_args) +
 698             sizeof(DB_TXN));
 699         if (argp == NULL)
 700                 return (ENOMEM);
 701         argp->txnid = (DB_TXN *)&argp[1];
 702         bp = recbuf;
 703         memcpy(&argp->type, bp, sizeof(argp->type));
 704         bp += sizeof(argp->type);
 705         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
 706         bp += sizeof(argp->txnid->txnid);
 707         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
 708         bp += sizeof(DB_LSN);
 709         memcpy(&argp->fileid, bp, sizeof(argp->fileid));
 710         bp += sizeof(argp->fileid);
 711         memcpy(&argp->opcode, bp, sizeof(argp->opcode));
 712         bp += sizeof(argp->opcode);
 713         memcpy(&argp->pgno, bp, sizeof(argp->pgno));
 714         bp += sizeof(argp->pgno);
 715         memcpy(&argp->pageimage.size, bp, sizeof(u_int32_t));
 716         bp += sizeof(u_int32_t);
 717         argp->pageimage.data = bp;
 718         bp += argp->pageimage.size;
 719         memcpy(&argp->pagelsn, bp,  sizeof(argp->pagelsn));
 720         bp += sizeof(argp->pagelsn);
 721         *argpp = argp;
 722         return (0);
 723 }
 724
 725 /*
 726  * PUBLIC: int __ham_replace_log
 727  * PUBLIC:     __P((DB_LOG *, DB_TXN *, DB_LSN *, u_int32_t,
 728  * PUBLIC:     u_int32_t, db_pgno_t, u_int32_t, DB_LSN *,
 729  * PUBLIC:     int32_t, const DBT *, const DBT *, u_int32_t));
 730  */
 731 int __ham_replace_log(logp, txnid, ret_lsnp, flags,
 732         fileid, pgno, ndx, pagelsn, off, olditem,
 733         newitem, makedup)
 734         DB_LOG *logp;
 735         DB_TXN *txnid;
 736         DB_LSN *ret_lsnp;
 737         u_int32_t flags;
 738         u_int32_t fileid;
 739         db_pgno_t pgno;
 740         u_int32_t ndx;
 741         DB_LSN * pagelsn;
 742         int32_t off;
 743         const DBT *olditem;
 744         const DBT *newitem;
 745         u_int32_t makedup;
 746 {
 747         DBT logrec;
 748         DB_LSN *lsnp, null_lsn;
 749         u_int32_t zero;
 750         u_int32_t rectype, txn_num;
 751         int ret;
 752         u_int8_t *bp;
 753
 754         rectype = DB_ham_replace;
 755         txn_num = txnid == NULL ? 0 : txnid->txnid;
 756         if (txnid == NULL) {
 757                 null_lsn.file = 0;
 758                 null_lsn.offset = 0;
 759                 lsnp = &null_lsn;
 760         } else
 761                 lsnp = &txnid->last_lsn;
 762         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
 763             + sizeof(fileid)
 764             + sizeof(pgno)
 765             + sizeof(ndx)
 766             + sizeof(*pagelsn)
 767             + sizeof(off)
 768             + sizeof(u_int32_t) + (olditem == NULL ? 0 : olditem->size)
 769             + sizeof(u_int32_t) + (newitem == NULL ? 0 : newitem->size)
 770             + sizeof(makedup);
 771         if ((logrec.data = (void *)__db_malloc(logrec.size)) == NULL)
 772                 return (ENOMEM);
 773
 774         bp = logrec.data;
 775         memcpy(bp, &rectype, sizeof(rectype));
 776         bp += sizeof(rectype);
 777         memcpy(bp, &txn_num, sizeof(txn_num));
 778         bp += sizeof(txn_num);
 779         memcpy(bp, lsnp, sizeof(DB_LSN));
 780         bp += sizeof(DB_LSN);
 781         memcpy(bp, &fileid, sizeof(fileid));
 782         bp += sizeof(fileid);
 783         memcpy(bp, &pgno, sizeof(pgno));
 784         bp += sizeof(pgno);
 785         memcpy(bp, &ndx, sizeof(ndx));
 786         bp += sizeof(ndx);
 787         if (pagelsn != NULL)
 788                 memcpy(bp, pagelsn, sizeof(*pagelsn));
 789         else
 790                 memset(bp, 0, sizeof(*pagelsn));
 791         bp += sizeof(*pagelsn);
 792         memcpy(bp, &off, sizeof(off));
 793         bp += sizeof(off);
 794         if (olditem == NULL) {
 795                 zero = 0;
 796                 memcpy(bp, &zero, sizeof(u_int32_t));
 797                 bp += sizeof(u_int32_t);
 798         } else {
 799                 memcpy(bp, &olditem->size, sizeof(olditem->size));
 800                 bp += sizeof(olditem->size);
 801                 memcpy(bp, olditem->data, olditem->size);
 802                 bp += olditem->size;
 803         }
 804         if (newitem == NULL) {
 805                 zero = 0;
 806                 memcpy(bp, &zero, sizeof(u_int32_t));
 807                 bp += sizeof(u_int32_t);
 808         } else {
 809                 memcpy(bp, &newitem->size, sizeof(newitem->size));
 810                 bp += sizeof(newitem->size);
 811                 memcpy(bp, newitem->data, newitem->size);
 812                 bp += newitem->size;
 813         }
 814         memcpy(bp, &makedup, sizeof(makedup));
 815         bp += sizeof(makedup);
 816 #ifdef DEBUG
 817         if ((u_int32_t)(bp - (u_int8_t *)logrec.data) != logrec.size)
 818                 fprintf(stderr, "Error in log record length");
 819 #endif
 820         ret = log_put(logp, ret_lsnp, (DBT *)&logrec, flags);
 821         if (txnid != NULL)
 822                 txnid->last_lsn = *ret_lsnp;
 823         __db_free(logrec.data);
 824         return (ret);
 825 }
 826
 827 /*
 828  * PUBLIC: int __ham_replace_print
 829  * PUBLIC:    __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
 830  */
 831 int
 832 __ham_replace_print(notused1, dbtp, lsnp, notused3, notused4)
 833         DB_LOG *notused1;
 834         DBT *dbtp;
 835         DB_LSN *lsnp;
 836         int notused3;
 837         void *notused4;
 838 {
 839         __ham_replace_args *argp;
 840         u_int32_t i;
 841         int c, ret;
 842
 843         i = 0;
 844         c = 0;
 845         notused1 = NULL;
 846         notused3 = 0;
 847         notused4 = NULL;
 848
 849         if ((ret = __ham_replace_read(dbtp->data, &argp)) != 0)
 850                 return (ret);
 851         printf("[%lu][%lu]ham_replace: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
 852             (u_long)lsnp->file,
 853             (u_long)lsnp->offset,
 854             (u_long)argp->type,
 855             (u_long)argp->txnid->txnid,
 856             (u_long)argp->prev_lsn.file,
 857             (u_long)argp->prev_lsn.offset);
 858         printf("\tfileid: %lu\n", (u_long)argp->fileid);
 859         printf("\tpgno: %lu\n", (u_long)argp->pgno);
 860         printf("\tndx: %lu\n", (u_long)argp->ndx);
 861         printf("\tpagelsn: [%lu][%lu]\n",
 862             (u_long)argp->pagelsn.file, (u_long)argp->pagelsn.offset);
 863         printf("\toff: %ld\n", (long)argp->off);
 864         printf("\tolditem: ");
 865         for (i = 0; i < argp->olditem.size; i++) {
 866                 c = ((char *)argp->olditem.data)[i];
 867                 if (isprint(c) || c == 0xa)
 868                         putchar(c);
 869                 else
 870                         printf("%#x ", c);
 871         }
 872         printf("\n");
 873         printf("\tnewitem: ");
 874         for (i = 0; i < argp->newitem.size; i++) {
 875                 c = ((char *)argp->newitem.data)[i];
 876                 if (isprint(c) || c == 0xa)
 877                         putchar(c);
 878                 else
 879                         printf("%#x ", c);
 880         }
 881         printf("\n");
 882         printf("\tmakedup: %lu\n", (u_long)argp->makedup);
 883         printf("\n");
 884         __db_free(argp);
 885         return (0);
 886 }
 887
 888 /*
 889  * PUBLIC: int __ham_replace_read __P((void *, __ham_replace_args **));
 890  */
 891 int
 892 __ham_replace_read(recbuf, argpp)
 893         void *recbuf;
 894         __ham_replace_args **argpp;
 895 {
 896         __ham_replace_args *argp;
 897         u_int8_t *bp;
 898
 899         argp = (__ham_replace_args *)__db_malloc(sizeof(__ham_replace_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->ndx, bp, sizeof(argp->ndx));
 916         bp += sizeof(argp->ndx);
 917         memcpy(&argp->pagelsn, bp,  sizeof(argp->pagelsn));
 918         bp += sizeof(argp->pagelsn);
 919         memcpy(&argp->off, bp, sizeof(argp->off));
 920         bp += sizeof(argp->off);
 921         memcpy(&argp->olditem.size, bp, sizeof(u_int32_t));
 922         bp += sizeof(u_int32_t);
 923         argp->olditem.data = bp;
 924         bp += argp->olditem.size;
 925         memcpy(&argp->newitem.size, bp, sizeof(u_int32_t));
 926         bp += sizeof(u_int32_t);
 927         argp->newitem.data = bp;
 928         bp += argp->newitem.size;
 929         memcpy(&argp->makedup, bp, sizeof(argp->makedup));
 930         bp += sizeof(argp->makedup);
 931         *argpp = argp;
 932         return (0);
 933 }
 934
 935 /*
 936  * PUBLIC: int __ham_newpgno_log
 937  * PUBLIC:     __P((DB_LOG *, DB_TXN *, DB_LSN *, u_int32_t,
 938  * PUBLIC:     u_int32_t, u_int32_t, db_pgno_t, db_pgno_t,
 939  * PUBLIC:     u_int32_t, db_pgno_t, u_int32_t, DB_LSN *,
 940  * PUBLIC:     DB_LSN *));
 941  */
 942 int __ham_newpgno_log(logp, txnid, ret_lsnp, flags,
 943         opcode, fileid, pgno, free_pgno, old_type, old_pgno,
 944         new_type, pagelsn, metalsn)
 945         DB_LOG *logp;
 946         DB_TXN *txnid;
 947         DB_LSN *ret_lsnp;
 948         u_int32_t flags;
 949         u_int32_t opcode;
 950         u_int32_t fileid;
 951         db_pgno_t pgno;
 952         db_pgno_t free_pgno;
 953         u_int32_t old_type;
 954         db_pgno_t old_pgno;
 955         u_int32_t new_type;
 956         DB_LSN * pagelsn;
 957         DB_LSN * metalsn;
 958 {
 959         DBT logrec;
 960         DB_LSN *lsnp, null_lsn;
 961         u_int32_t rectype, txn_num;
 962         int ret;
 963         u_int8_t *bp;
 964
 965         rectype = DB_ham_newpgno;
 966         txn_num = txnid == NULL ? 0 : txnid->txnid;
 967         if (txnid == NULL) {
 968                 null_lsn.file = 0;
 969                 null_lsn.offset = 0;
 970                 lsnp = &null_lsn;
 971         } else
 972                 lsnp = &txnid->last_lsn;
 973         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
 974             + sizeof(opcode)
 975             + sizeof(fileid)
 976             + sizeof(pgno)
 977             + sizeof(free_pgno)
 978             + sizeof(old_type)
 979             + sizeof(old_pgno)
 980             + sizeof(new_type)
 981             + sizeof(*pagelsn)
 982             + sizeof(*metalsn);
 983         if ((logrec.data = (void *)__db_malloc(logrec.size)) == NULL)
 984                 return (ENOMEM);
 985
 986         bp = logrec.data;
 987         memcpy(bp, &rectype, sizeof(rectype));
 988         bp += sizeof(rectype);
 989         memcpy(bp, &txn_num, sizeof(txn_num));
 990         bp += sizeof(txn_num);
 991         memcpy(bp, lsnp, sizeof(DB_LSN));
 992         bp += sizeof(DB_LSN);
 993         memcpy(bp, &opcode, sizeof(opcode));
 994         bp += sizeof(opcode);
 995         memcpy(bp, &fileid, sizeof(fileid));
 996         bp += sizeof(fileid);
 997         memcpy(bp, &pgno, sizeof(pgno));
 998         bp += sizeof(pgno);
 999         memcpy(bp, &free_pgno, sizeof(free_pgno));
1000         bp += sizeof(free_pgno);
1001         memcpy(bp, &old_type, sizeof(old_type));
1002         bp += sizeof(old_type);
1003         memcpy(bp, &old_pgno, sizeof(old_pgno));
1004         bp += sizeof(old_pgno);
1005         memcpy(bp, &new_type, sizeof(new_type));
1006         bp += sizeof(new_type);
1007         if (pagelsn != NULL)
1008                 memcpy(bp, pagelsn, sizeof(*pagelsn));
1009         else
1010                 memset(bp, 0, sizeof(*pagelsn));
1011         bp += sizeof(*pagelsn);
1012         if (metalsn != NULL)
1013                 memcpy(bp, metalsn, sizeof(*metalsn));
1014         else
1015                 memset(bp, 0, sizeof(*metalsn));
1016         bp += sizeof(*metalsn);
1017 #ifdef DEBUG
1018         if ((u_int32_t)(bp - (u_int8_t *)logrec.data) != logrec.size)
1019                 fprintf(stderr, "Error in log record length");
1020 #endif
1021         ret = log_put(logp, ret_lsnp, (DBT *)&logrec, flags);
1022         if (txnid != NULL)
1023                 txnid->last_lsn = *ret_lsnp;
1024         __db_free(logrec.data);
1025         return (ret);
1026 }
1027
1028 /*
1029  * PUBLIC: int __ham_newpgno_print
1030  * PUBLIC:    __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
1031  */
1032 int
1033 __ham_newpgno_print(notused1, dbtp, lsnp, notused3, notused4)
1034         DB_LOG *notused1;
1035         DBT *dbtp;
1036         DB_LSN *lsnp;
1037         int notused3;
1038         void *notused4;
1039 {
1040         __ham_newpgno_args *argp;
1041         u_int32_t i;
1042         int c, ret;
1043
1044         i = 0;
1045         c = 0;
1046         notused1 = NULL;
1047         notused3 = 0;
1048         notused4 = NULL;
1049
1050         if ((ret = __ham_newpgno_read(dbtp->data, &argp)) != 0)
1051                 return (ret);
1052         printf("[%lu][%lu]ham_newpgno: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
1053             (u_long)lsnp->file,
1054             (u_long)lsnp->offset,
1055             (u_long)argp->type,
1056             (u_long)argp->txnid->txnid,
1057             (u_long)argp->prev_lsn.file,
1058             (u_long)argp->prev_lsn.offset);
1059         printf("\topcode: %lu\n", (u_long)argp->opcode);
1060         printf("\tfileid: %lu\n", (u_long)argp->fileid);
1061         printf("\tpgno: %lu\n", (u_long)argp->pgno);
1062         printf("\tfree_pgno: %lu\n", (u_long)argp->free_pgno);
1063         printf("\told_type: %lu\n", (u_long)argp->old_type);
1064         printf("\told_pgno: %lu\n", (u_long)argp->old_pgno);
1065         printf("\tnew_type: %lu\n", (u_long)argp->new_type);
1066         printf("\tpagelsn: [%lu][%lu]\n",
1067             (u_long)argp->pagelsn.file, (u_long)argp->pagelsn.offset);
1068         printf("\tmetalsn: [%lu][%lu]\n",
1069             (u_long)argp->metalsn.file, (u_long)argp->metalsn.offset);
1070         printf("\n");
1071         __db_free(argp);
1072         return (0);
1073 }
1074
1075 /*
1076  * PUBLIC: int __ham_newpgno_read __P((void *, __ham_newpgno_args **));
1077  */
1078 int
1079 __ham_newpgno_read(recbuf, argpp)
1080         void *recbuf;
1081         __ham_newpgno_args **argpp;
1082 {
1083         __ham_newpgno_args *argp;
1084         u_int8_t *bp;
1085
1086         argp = (__ham_newpgno_args *)__db_malloc(sizeof(__ham_newpgno_args) +
1087             sizeof(DB_TXN));
1088         if (argp == NULL)
1089                 return (ENOMEM);
1090         argp->txnid = (DB_TXN *)&argp[1];
1091         bp = recbuf;
1092         memcpy(&argp->type, bp, sizeof(argp->type));
1093         bp += sizeof(argp->type);
1094         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
1095         bp += sizeof(argp->txnid->txnid);
1096         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
1097         bp += sizeof(DB_LSN);
1098         memcpy(&argp->opcode, bp, sizeof(argp->opcode));
1099         bp += sizeof(argp->opcode);
1100         memcpy(&argp->fileid, bp, sizeof(argp->fileid));
1101         bp += sizeof(argp->fileid);
1102         memcpy(&argp->pgno, bp, sizeof(argp->pgno));
1103         bp += sizeof(argp->pgno);
1104         memcpy(&argp->free_pgno, bp, sizeof(argp->free_pgno));
1105         bp += sizeof(argp->free_pgno);
1106         memcpy(&argp->old_type, bp, sizeof(argp->old_type));
1107         bp += sizeof(argp->old_type);
1108         memcpy(&argp->old_pgno, bp, sizeof(argp->old_pgno));
1109         bp += sizeof(argp->old_pgno);
1110         memcpy(&argp->new_type, bp, sizeof(argp->new_type));
1111         bp += sizeof(argp->new_type);
1112         memcpy(&argp->pagelsn, bp,  sizeof(argp->pagelsn));
1113         bp += sizeof(argp->pagelsn);
1114         memcpy(&argp->metalsn, bp,  sizeof(argp->metalsn));
1115         bp += sizeof(argp->metalsn);
1116         *argpp = argp;
1117         return (0);
1118 }
1119
1120 /*
1121  * PUBLIC: int __ham_ovfl_log
1122  * PUBLIC:     __P((DB_LOG *, DB_TXN *, DB_LSN *, u_int32_t,
1123  * PUBLIC:     u_int32_t, db_pgno_t, u_int32_t, db_pgno_t,
1124  * PUBLIC:     u_int32_t, DB_LSN *));
1125  */
1126 int __ham_ovfl_log(logp, txnid, ret_lsnp, flags,
1127         fileid, start_pgno, npages, free_pgno, ovflpoint, metalsn)
1128         DB_LOG *logp;
1129         DB_TXN *txnid;
1130         DB_LSN *ret_lsnp;
1131         u_int32_t flags;
1132         u_int32_t fileid;
1133         db_pgno_t start_pgno;
1134         u_int32_t npages;
1135         db_pgno_t free_pgno;
1136         u_int32_t ovflpoint;
1137         DB_LSN * metalsn;
1138 {
1139         DBT logrec;
1140         DB_LSN *lsnp, null_lsn;
1141         u_int32_t rectype, txn_num;
1142         int ret;
1143         u_int8_t *bp;
1144
1145         rectype = DB_ham_ovfl;
1146         txn_num = txnid == NULL ? 0 : txnid->txnid;
1147         if (txnid == NULL) {
1148                 null_lsn.file = 0;
1149                 null_lsn.offset = 0;
1150                 lsnp = &null_lsn;
1151         } else
1152                 lsnp = &txnid->last_lsn;
1153         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
1154             + sizeof(fileid)
1155             + sizeof(start_pgno)
1156             + sizeof(npages)
1157             + sizeof(free_pgno)
1158             + sizeof(ovflpoint)
1159             + sizeof(*metalsn);
1160         if ((logrec.data = (void *)__db_malloc(logrec.size)) == NULL)
1161                 return (ENOMEM);
1162
1163         bp = logrec.data;
1164         memcpy(bp, &rectype, sizeof(rectype));
1165         bp += sizeof(rectype);
1166         memcpy(bp, &txn_num, sizeof(txn_num));
1167         bp += sizeof(txn_num);
1168         memcpy(bp, lsnp, sizeof(DB_LSN));
1169         bp += sizeof(DB_LSN);
1170         memcpy(bp, &fileid, sizeof(fileid));
1171         bp += sizeof(fileid);
1172         memcpy(bp, &start_pgno, sizeof(start_pgno));
1173         bp += sizeof(start_pgno);
1174         memcpy(bp, &npages, sizeof(npages));
1175         bp += sizeof(npages);
1176         memcpy(bp, &free_pgno, sizeof(free_pgno));
1177         bp += sizeof(free_pgno);
1178         memcpy(bp, &ovflpoint, sizeof(ovflpoint));
1179         bp += sizeof(ovflpoint);
1180         if (metalsn != NULL)
1181                 memcpy(bp, metalsn, sizeof(*metalsn));
1182         else
1183                 memset(bp, 0, sizeof(*metalsn));
1184         bp += sizeof(*metalsn);
1185 #ifdef DEBUG
1186         if ((u_int32_t)(bp - (u_int8_t *)logrec.data) != logrec.size)
1187                 fprintf(stderr, "Error in log record length");
1188 #endif
1189         ret = log_put(logp, ret_lsnp, (DBT *)&logrec, flags);
1190         if (txnid != NULL)
1191                 txnid->last_lsn = *ret_lsnp;
1192         __db_free(logrec.data);
1193         return (ret);
1194 }
1195
1196 /*
1197  * PUBLIC: int __ham_ovfl_print
1198  * PUBLIC:    __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
1199  */
1200 int
1201 __ham_ovfl_print(notused1, dbtp, lsnp, notused3, notused4)
1202         DB_LOG *notused1;
1203         DBT *dbtp;
1204         DB_LSN *lsnp;
1205         int notused3;
1206         void *notused4;
1207 {
1208         __ham_ovfl_args *argp;
1209         u_int32_t i;
1210         int c, ret;
1211
1212         i = 0;
1213         c = 0;
1214         notused1 = NULL;
1215         notused3 = 0;
1216         notused4 = NULL;
1217
1218         if ((ret = __ham_ovfl_read(dbtp->data, &argp)) != 0)
1219                 return (ret);
1220         printf("[%lu][%lu]ham_ovfl: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
1221             (u_long)lsnp->file,
1222             (u_long)lsnp->offset,
1223             (u_long)argp->type,
1224             (u_long)argp->txnid->txnid,
1225             (u_long)argp->prev_lsn.file,
1226             (u_long)argp->prev_lsn.offset);
1227         printf("\tfileid: %lu\n", (u_long)argp->fileid);
1228         printf("\tstart_pgno: %lu\n", (u_long)argp->start_pgno);
1229         printf("\tnpages: %lu\n", (u_long)argp->npages);
1230         printf("\tfree_pgno: %lu\n", (u_long)argp->free_pgno);
1231         printf("\tovflpoint: %lu\n", (u_long)argp->ovflpoint);
1232         printf("\tmetalsn: [%lu][%lu]\n",
1233             (u_long)argp->metalsn.file, (u_long)argp->metalsn.offset);
1234         printf("\n");
1235         __db_free(argp);
1236         return (0);
1237 }
1238
1239 /*
1240  * PUBLIC: int __ham_ovfl_read __P((void *, __ham_ovfl_args **));
1241  */
1242 int
1243 __ham_ovfl_read(recbuf, argpp)
1244         void *recbuf;
1245         __ham_ovfl_args **argpp;
1246 {
1247         __ham_ovfl_args *argp;
1248         u_int8_t *bp;
1249
1250         argp = (__ham_ovfl_args *)__db_malloc(sizeof(__ham_ovfl_args) +
1251             sizeof(DB_TXN));
1252         if (argp == NULL)
1253                 return (ENOMEM);
1254         argp->txnid = (DB_TXN *)&argp[1];
1255         bp = recbuf;
1256         memcpy(&argp->type, bp, sizeof(argp->type));
1257         bp += sizeof(argp->type);
1258         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
1259         bp += sizeof(argp->txnid->txnid);
1260         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
1261         bp += sizeof(DB_LSN);
1262         memcpy(&argp->fileid, bp, sizeof(argp->fileid));
1263         bp += sizeof(argp->fileid);
1264         memcpy(&argp->start_pgno, bp, sizeof(argp->start_pgno));
1265         bp += sizeof(argp->start_pgno);
1266         memcpy(&argp->npages, bp, sizeof(argp->npages));
1267         bp += sizeof(argp->npages);
1268         memcpy(&argp->free_pgno, bp, sizeof(argp->free_pgno));
1269         bp += sizeof(argp->free_pgno);
1270         memcpy(&argp->ovflpoint, bp, sizeof(argp->ovflpoint));
1271         bp += sizeof(argp->ovflpoint);
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_copypage_log
1280  * PUBLIC:     __P((DB_LOG *, DB_TXN *, DB_LSN *, u_int32_t,
1281  * PUBLIC:     u_int32_t, db_pgno_t, DB_LSN *, db_pgno_t,
1282  * PUBLIC:     DB_LSN *, db_pgno_t, DB_LSN *, const DBT *));
1283  */
1284 int __ham_copypage_log(logp, txnid, ret_lsnp, flags,
1285         fileid, pgno, pagelsn, next_pgno, nextlsn, nnext_pgno,
1286         nnextlsn, page)
1287         DB_LOG *logp;
1288         DB_TXN *txnid;
1289         DB_LSN *ret_lsnp;
1290         u_int32_t flags;
1291         u_int32_t fileid;
1292         db_pgno_t pgno;
1293         DB_LSN * pagelsn;
1294         db_pgno_t next_pgno;
1295         DB_LSN * nextlsn;
1296         db_pgno_t nnext_pgno;
1297         DB_LSN * nnextlsn;
1298         const DBT *page;
1299 {
1300         DBT logrec;
1301         DB_LSN *lsnp, null_lsn;
1302         u_int32_t zero;
1303         u_int32_t rectype, txn_num;
1304         int ret;
1305         u_int8_t *bp;
1306
1307         rectype = DB_ham_copypage;
1308         txn_num = txnid == NULL ? 0 : txnid->txnid;
1309         if (txnid == NULL) {
1310                 null_lsn.file = 0;
1311                 null_lsn.offset = 0;
1312                 lsnp = &null_lsn;
1313         } else
1314                 lsnp = &txnid->last_lsn;
1315         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
1316             + sizeof(fileid)
1317             + sizeof(pgno)
1318             + sizeof(*pagelsn)
1319             + sizeof(next_pgno)
1320             + sizeof(*nextlsn)
1321             + sizeof(nnext_pgno)
1322             + sizeof(*nnextlsn)
1323             + sizeof(u_int32_t) + (page == NULL ? 0 : page->size);
1324         if ((logrec.data = (void *)__db_malloc(logrec.size)) == NULL)
1325                 return (ENOMEM);
1326
1327         bp = logrec.data;
1328         memcpy(bp, &rectype, sizeof(rectype));
1329         bp += sizeof(rectype);
1330         memcpy(bp, &txn_num, sizeof(txn_num));
1331         bp += sizeof(txn_num);
1332         memcpy(bp, lsnp, sizeof(DB_LSN));
1333         bp += sizeof(DB_LSN);
1334         memcpy(bp, &fileid, sizeof(fileid));
1335         bp += sizeof(fileid);
1336         memcpy(bp, &pgno, sizeof(pgno));
1337         bp += sizeof(pgno);
1338         if (pagelsn != NULL)
1339                 memcpy(bp, pagelsn, sizeof(*pagelsn));
1340         else
1341                 memset(bp, 0, sizeof(*pagelsn));
1342         bp += sizeof(*pagelsn);
1343         memcpy(bp, &next_pgno, sizeof(next_pgno));
1344         bp += sizeof(next_pgno);
1345         if (nextlsn != NULL)
1346                 memcpy(bp, nextlsn, sizeof(*nextlsn));
1347         else
1348                 memset(bp, 0, sizeof(*nextlsn));
1349         bp += sizeof(*nextlsn);
1350         memcpy(bp, &nnext_pgno, sizeof(nnext_pgno));
1351         bp += sizeof(nnext_pgno);
1352         if (nnextlsn != NULL)
1353                 memcpy(bp, nnextlsn, sizeof(*nnextlsn));
1354         else
1355                 memset(bp, 0, sizeof(*nnextlsn));
1356         bp += sizeof(*nnextlsn);
1357         if (page == NULL) {
1358                 zero = 0;
1359                 memcpy(bp, &zero, sizeof(u_int32_t));
1360                 bp += sizeof(u_int32_t);
1361         } else {
1362                 memcpy(bp, &page->size, sizeof(page->size));
1363                 bp += sizeof(page->size);
1364                 memcpy(bp, page->data, page->size);
1365                 bp += page->size;
1366         }
1367 #ifdef DEBUG
1368         if ((u_int32_t)(bp - (u_int8_t *)logrec.data) != logrec.size)
1369                 fprintf(stderr, "Error in log record length");
1370 #endif
1371         ret = log_put(logp, ret_lsnp, (DBT *)&logrec, flags);
1372         if (txnid != NULL)
1373                 txnid->last_lsn = *ret_lsnp;
1374         __db_free(logrec.data);
1375         return (ret);
1376 }
1377
1378 /*
1379  * PUBLIC: int __ham_copypage_print
1380  * PUBLIC:    __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
1381  */
1382 int
1383 __ham_copypage_print(notused1, dbtp, lsnp, notused3, notused4)
1384         DB_LOG *notused1;
1385         DBT *dbtp;
1386         DB_LSN *lsnp;
1387         int notused3;
1388         void *notused4;
1389 {
1390         __ham_copypage_args *argp;
1391         u_int32_t i;
1392         int c, ret;
1393
1394         i = 0;
1395         c = 0;
1396         notused1 = NULL;
1397         notused3 = 0;
1398         notused4 = NULL;
1399
1400         if ((ret = __ham_copypage_read(dbtp->data, &argp)) != 0)
1401                 return (ret);
1402         printf("[%lu][%lu]ham_copypage: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
1403             (u_long)lsnp->file,
1404             (u_long)lsnp->offset,
1405             (u_long)argp->type,
1406             (u_long)argp->txnid->txnid,
1407             (u_long)argp->prev_lsn.file,
1408             (u_long)argp->prev_lsn.offset);
1409         printf("\tfileid: %lu\n", (u_long)argp->fileid);
1410         printf("\tpgno: %lu\n", (u_long)argp->pgno);
1411         printf("\tpagelsn: [%lu][%lu]\n",
1412             (u_long)argp->pagelsn.file, (u_long)argp->pagelsn.offset);
1413         printf("\tnext_pgno: %lu\n", (u_long)argp->next_pgno);
1414         printf("\tnextlsn: [%lu][%lu]\n",
1415             (u_long)argp->nextlsn.file, (u_long)argp->nextlsn.offset);
1416         printf("\tnnext_pgno: %lu\n", (u_long)argp->nnext_pgno);
1417         printf("\tnnextlsn: [%lu][%lu]\n",
1418             (u_long)argp->nnextlsn.file, (u_long)argp->nnextlsn.offset);
1419         printf("\tpage: ");
1420         for (i = 0; i < argp->page.size; i++) {
1421                 c = ((char *)argp->page.data)[i];
1422                 if (isprint(c) || c == 0xa)
1423                         putchar(c);
1424                 else
1425                         printf("%#x ", c);
1426         }
1427         printf("\n");
1428         printf("\n");
1429         __db_free(argp);
1430         return (0);
1431 }
1432
1433 /*
1434  * PUBLIC: int __ham_copypage_read __P((void *, __ham_copypage_args **));
1435  */
1436 int
1437 __ham_copypage_read(recbuf, argpp)
1438         void *recbuf;
1439         __ham_copypage_args **argpp;
1440 {
1441         __ham_copypage_args *argp;
1442         u_int8_t *bp;
1443
1444         argp = (__ham_copypage_args *)__db_malloc(sizeof(__ham_copypage_args) +
1445             sizeof(DB_TXN));
1446         if (argp == NULL)
1447                 return (ENOMEM);
1448         argp->txnid = (DB_TXN *)&argp[1];
1449         bp = recbuf;
1450         memcpy(&argp->type, bp, sizeof(argp->type));
1451         bp += sizeof(argp->type);
1452         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
1453         bp += sizeof(argp->txnid->txnid);
1454         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
1455         bp += sizeof(DB_LSN);
1456         memcpy(&argp->fileid, bp, sizeof(argp->fileid));
1457         bp += sizeof(argp->fileid);
1458         memcpy(&argp->pgno, bp, sizeof(argp->pgno));
1459         bp += sizeof(argp->pgno);
1460         memcpy(&argp->pagelsn, bp,  sizeof(argp->pagelsn));
1461         bp += sizeof(argp->pagelsn);
1462         memcpy(&argp->next_pgno, bp, sizeof(argp->next_pgno));
1463         bp += sizeof(argp->next_pgno);
1464         memcpy(&argp->nextlsn, bp,  sizeof(argp->nextlsn));
1465         bp += sizeof(argp->nextlsn);
1466         memcpy(&argp->nnext_pgno, bp, sizeof(argp->nnext_pgno));
1467         bp += sizeof(argp->nnext_pgno);
1468         memcpy(&argp->nnextlsn, bp,  sizeof(argp->nnextlsn));
1469         bp += sizeof(argp->nnextlsn);
1470         memcpy(&argp->page.size, bp, sizeof(u_int32_t));
1471         bp += sizeof(u_int32_t);
1472         argp->page.data = bp;
1473         bp += argp->page.size;
1474         *argpp = argp;
1475         return (0);
1476 }
1477
1478 /*
1479  * PUBLIC: int __ham_init_print __P((DB_ENV *));
1480  */
1481 int
1482 __ham_init_print(dbenv)
1483         DB_ENV *dbenv;
1484 {
1485         int ret;
1486
1487         if ((ret = __db_add_recovery(dbenv,
1488             __ham_insdel_print, DB_ham_insdel)) != 0)
1489                 return (ret);
1490         if ((ret = __db_add_recovery(dbenv,
1491             __ham_newpage_print, DB_ham_newpage)) != 0)
1492                 return (ret);
1493         if ((ret = __db_add_recovery(dbenv,
1494             __ham_splitmeta_print, DB_ham_splitmeta)) != 0)
1495                 return (ret);
1496         if ((ret = __db_add_recovery(dbenv,
1497             __ham_splitdata_print, DB_ham_splitdata)) != 0)
1498                 return (ret);
1499         if ((ret = __db_add_recovery(dbenv,
1500             __ham_replace_print, DB_ham_replace)) != 0)
1501                 return (ret);
1502         if ((ret = __db_add_recovery(dbenv,
1503             __ham_newpgno_print, DB_ham_newpgno)) != 0)
1504                 return (ret);
1505         if ((ret = __db_add_recovery(dbenv,
1506             __ham_ovfl_print, DB_ham_ovfl)) != 0)
1507                 return (ret);
1508         if ((ret = __db_add_recovery(dbenv,
1509             __ham_copypage_print, DB_ham_copypage)) != 0)
1510                 return (ret);
1511         return (0);
1512 }
1513
1514 /*
1515  * PUBLIC: int __ham_init_recover __P((DB_ENV *));
1516  */
1517 int
1518 __ham_init_recover(dbenv)
1519         DB_ENV *dbenv;
1520 {
1521         int ret;
1522
1523         if ((ret = __db_add_recovery(dbenv,
1524             __ham_insdel_recover, DB_ham_insdel)) != 0)
1525                 return (ret);
1526         if ((ret = __db_add_recovery(dbenv,
1527             __ham_newpage_recover, DB_ham_newpage)) != 0)
1528                 return (ret);
1529         if ((ret = __db_add_recovery(dbenv,
1530             __ham_splitmeta_recover, DB_ham_splitmeta)) != 0)
1531                 return (ret);
1532         if ((ret = __db_add_recovery(dbenv,
1533             __ham_splitdata_recover, DB_ham_splitdata)) != 0)
1534                 return (ret);
1535         if ((ret = __db_add_recovery(dbenv,
1536             __ham_replace_recover, DB_ham_replace)) != 0)
1537                 return (ret);
1538         if ((ret = __db_add_recovery(dbenv,
1539             __ham_newpgno_recover, DB_ham_newpgno)) != 0)
1540                 return (ret);
1541         if ((ret = __db_add_recovery(dbenv,
1542             __ham_ovfl_recover, DB_ham_ovfl)) != 0)
1543                 return (ret);
1544         if ((ret = __db_add_recovery(dbenv,
1545             __ham_copypage_recover, DB_ham_copypage)) != 0)
1546                 return (ret);
1547         return (0);
1548 }
1549