common/vi_auto.c

   1 /* Do not edit: automatically built by gen_rec.awk. */
   2 #include <sys/types.h>
   3 #include <sys/queue.h>
   4 #include <sys/stat.h>
   5 #include <bitstring.h>
   6 #include <errno.h>
   7 #include <fcntl.h>
   8 #include <limits.h>
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #include <string.h>
  12 #include "common.h"
  13 #include <db_int.h>
  14 #include "db_page.h"
  15 #include "db_am.h"
  16 #include "rep.h"
  17 #include "txn.h"
  18 /*
  19  * PUBLIC: #ifdef USE_DB4_LOGGING
  20  */
  21 /*
  22  * PUBLIC: int __vi_marker_log __P((DB_ENV *, DB_TXN *, DB_LSN *, u_int32_t,
  23  * PUBLIC:      u_int32_t));
  24  */
  25 int
  26 __vi_marker_log(dbenv, txnid, ret_lsnp, flags,
  27         opcode)
  28         DB_ENV *dbenv;
  29         DB_TXN *txnid;
  30         DB_LSN *ret_lsnp;
  31         u_int32_t flags;
  32         u_int32_t opcode;
  33 {
  34         DBT logrec;
  35         DB_LSN *lsnp, null_lsn;
  36         u_int32_t uinttmp;
  37         u_int32_t rectype, txn_num;
  38         int ret;
  39         u_int8_t *bp;
  40
  41         rectype = DB_vi_marker;
  42         if (txnid != NULL &&
  43             TAILQ_FIRST(&txnid->kids) != NULL &&
  44             (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  45                 return (ret);
  46         txn_num = txnid == NULL ? 0 : txnid->txnid;
  47         if (txnid == NULL) {
  48                 ZERO_LSN(null_lsn);
  49                 lsnp = &null_lsn;
  50         } else
  51                 lsnp = &txnid->last_lsn;
  52         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  53             + sizeof(u_int32_t);
  54         if ((ret = __os_malloc(dbenv, logrec.size, &logrec.data)) != 0)
  55                 return (ret);
  56
  57         bp = logrec.data;
  58
  59         memcpy(bp, &rectype, sizeof(rectype));
  60         bp += sizeof(rectype);
  61
  62         memcpy(bp, &txn_num, sizeof(txn_num));
  63         bp += sizeof(txn_num);
  64
  65         memcpy(bp, lsnp, sizeof(DB_LSN));
  66         bp += sizeof(DB_LSN);
  67
  68         uinttmp = (u_int32_t)opcode;
  69         memcpy(bp, &uinttmp, sizeof(uinttmp));
  70         bp += sizeof(uinttmp);
  71
  72         DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size);
  73         ret = dbenv->log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags);
  74         if (txnid != NULL && ret == 0)
  75                 txnid->last_lsn = *ret_lsnp;
  76 #ifdef LOG_DIAGNOSTIC
  77         if (ret != 0)
  78                 (void)__vi_marker_print(dbenv,
  79                     (DBT *)&logrec, ret_lsnp, NULL, NULL);
  80 #endif
  81         __os_free(dbenv, logrec.data, logrec.size);
  82         return (ret);
  83 }
  84
  85 /*
  86  * PUBLIC: int __vi_marker_getpgnos __P((DB_ENV *, DBT *, DB_LSN *, db_recops,
  87  * PUBLIC:      void *));
  88  */
  89 int
  90 __vi_marker_getpgnos(dbenv, rec, lsnp, notused1, summary)
  91         DB_ENV *dbenv;
  92         DBT *rec;
  93         DB_LSN *lsnp;
  94         db_recops notused1;
  95         void *summary;
  96 {
  97         TXN_RECS *t;
  98         int ret;
  99         COMPQUIET(rec, NULL);
 100         COMPQUIET(notused1, DB_TXN_ABORT);
 101
 102         t = (TXN_RECS *)summary;
 103
 104         if ((ret = __rep_check_alloc(dbenv, t, 1)) != 0)
 105                 return (ret);
 106
 107         t->array[t->npages].flags = LSN_PAGE_NOLOCK;
 108         t->array[t->npages].lsn = *lsnp;
 109         t->array[t->npages].fid = DB_LOGFILEID_INVALID;
 110         memset(&t->array[t->npages].pgdesc, 0,
 111             sizeof(t->array[t->npages].pgdesc));
 112
 113         t->npages++;
 114
 115         return (0);
 116 }
 117
 118 /*
 119  * PUBLIC: int __vi_marker_print __P((DB_ENV *, DBT *, DB_LSN *, db_recops,
 120  * PUBLIC:      void *));
 121  */
 122 int
 123 __vi_marker_print(dbenv, dbtp, lsnp, notused2, notused3)
 124         DB_ENV *dbenv;
 125         DBT *dbtp;
 126         DB_LSN *lsnp;
 127         db_recops notused2;
 128         void *notused3;
 129 {
 130         __vi_marker_args *argp;
 131         int ret;
 132
 133         notused2 = DB_TXN_ABORT;
 134         notused3 = NULL;
 135
 136         if ((ret = __vi_marker_read(dbenv, dbtp->data, &argp)) != 0)
 137                 return (ret);
 138         (void)printf(
 139             "[%lu][%lu]vi_marker: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
 140             (u_long)lsnp->file,
 141             (u_long)lsnp->offset,
 142             (u_long)argp->type,
 143             (u_long)argp->txnid->txnid,
 144             (u_long)argp->prev_lsn.file,
 145             (u_long)argp->prev_lsn.offset);
 146         (void)printf("\topcode: %lu\n", (u_long)argp->opcode);
 147         (void)printf("\n");
 148         __os_free(dbenv, argp, 0);
 149         return (0);
 150 }
 151
 152 /*
 153  * PUBLIC: int __vi_marker_read __P((DB_ENV *, void *, __vi_marker_args **));
 154  */
 155 int
 156 __vi_marker_read(dbenv, recbuf, argpp)
 157         DB_ENV *dbenv;
 158         void *recbuf;
 159         __vi_marker_args **argpp;
 160 {
 161         __vi_marker_args *argp;
 162         int ret;
 163         u_int32_t uinttmp;
 164         u_int8_t *bp;
 165
 166         ret = __os_malloc(dbenv, sizeof(__vi_marker_args) +
 167             sizeof(DB_TXN), &argp);
 168         if (ret != 0)
 169                 return (ret);
 170         argp->txnid = (DB_TXN *)&argp[1];
 171
 172         bp = recbuf;
 173         memcpy(&argp->type, bp, sizeof(argp->type));
 174         bp += sizeof(argp->type);
 175
 176         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
 177         bp += sizeof(argp->txnid->txnid);
 178
 179         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
 180         bp += sizeof(DB_LSN);
 181
 182         memcpy(&uinttmp, bp, sizeof(uinttmp));
 183         argp->opcode = (u_int32_t)uinttmp;
 184         bp += sizeof(uinttmp);
 185
 186         *argpp = argp;
 187         return (0);
 188 }
 189
 190 /*
 191  * PUBLIC: int __vi_cursor_log __P((DB_ENV *, DB_TXN *, DB_LSN *, u_int32_t,
 192  * PUBLIC:      u_int32_t, db_recno_t, size_t));
 193  */
 194 int
 195 __vi_cursor_log(dbenv, txnid, ret_lsnp, flags,
 196         opcode, lno, cno)
 197         DB_ENV *dbenv;
 198         DB_TXN *txnid;
 199         DB_LSN *ret_lsnp;
 200         u_int32_t flags;
 201         u_int32_t opcode;
 202         db_recno_t lno;
 203         size_t cno;
 204 {
 205         DBT logrec;
 206         DB_LSN *lsnp, null_lsn;
 207         u_int32_t uinttmp;
 208         u_int32_t rectype, txn_num;
 209         int ret;
 210         u_int8_t *bp;
 211
 212         rectype = DB_vi_cursor;
 213         if (txnid != NULL &&
 214             TAILQ_FIRST(&txnid->kids) != NULL &&
 215             (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
 216                 return (ret);
 217         txn_num = txnid == NULL ? 0 : txnid->txnid;
 218         if (txnid == NULL) {
 219                 ZERO_LSN(null_lsn);
 220                 lsnp = &null_lsn;
 221         } else
 222                 lsnp = &txnid->last_lsn;
 223         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
 224             + sizeof(u_int32_t)
 225             + sizeof(u_int32_t)
 226             + sizeof(u_int32_t);
 227         if ((ret = __os_malloc(dbenv, logrec.size, &logrec.data)) != 0)
 228                 return (ret);
 229
 230         bp = logrec.data;
 231
 232         memcpy(bp, &rectype, sizeof(rectype));
 233         bp += sizeof(rectype);
 234
 235         memcpy(bp, &txn_num, sizeof(txn_num));
 236         bp += sizeof(txn_num);
 237
 238         memcpy(bp, lsnp, sizeof(DB_LSN));
 239         bp += sizeof(DB_LSN);
 240
 241         uinttmp = (u_int32_t)opcode;
 242         memcpy(bp, &uinttmp, sizeof(uinttmp));
 243         bp += sizeof(uinttmp);
 244
 245         uinttmp = (u_int32_t)lno;
 246         memcpy(bp, &uinttmp, sizeof(uinttmp));
 247         bp += sizeof(uinttmp);
 248
 249         uinttmp = (u_int32_t)cno;
 250         memcpy(bp, &uinttmp, sizeof(uinttmp));
 251         bp += sizeof(uinttmp);
 252
 253         DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size);
 254         ret = dbenv->log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags);
 255         if (txnid != NULL && ret == 0)
 256                 txnid->last_lsn = *ret_lsnp;
 257 #ifdef LOG_DIAGNOSTIC
 258         if (ret != 0)
 259                 (void)__vi_cursor_print(dbenv,
 260                     (DBT *)&logrec, ret_lsnp, NULL, NULL);
 261 #endif
 262         __os_free(dbenv, logrec.data, logrec.size);
 263         return (ret);
 264 }
 265
 266 /*
 267  * PUBLIC: int __vi_cursor_getpgnos __P((DB_ENV *, DBT *, DB_LSN *, db_recops,
 268  * PUBLIC:      void *));
 269  */
 270 int
 271 __vi_cursor_getpgnos(dbenv, rec, lsnp, notused1, summary)
 272         DB_ENV *dbenv;
 273         DBT *rec;
 274         DB_LSN *lsnp;
 275         db_recops notused1;
 276         void *summary;
 277 {
 278         TXN_RECS *t;
 279         int ret;
 280         COMPQUIET(rec, NULL);
 281         COMPQUIET(notused1, DB_TXN_ABORT);
 282
 283         t = (TXN_RECS *)summary;
 284
 285         if ((ret = __rep_check_alloc(dbenv, t, 1)) != 0)
 286                 return (ret);
 287
 288         t->array[t->npages].flags = LSN_PAGE_NOLOCK;
 289         t->array[t->npages].lsn = *lsnp;
 290         t->array[t->npages].fid = DB_LOGFILEID_INVALID;
 291         memset(&t->array[t->npages].pgdesc, 0,
 292             sizeof(t->array[t->npages].pgdesc));
 293
 294         t->npages++;
 295
 296         return (0);
 297 }
 298
 299 /*
 300  * PUBLIC: int __vi_cursor_print __P((DB_ENV *, DBT *, DB_LSN *, db_recops,
 301  * PUBLIC:      void *));
 302  */
 303 int
 304 __vi_cursor_print(dbenv, dbtp, lsnp, notused2, notused3)
 305         DB_ENV *dbenv;
 306         DBT *dbtp;
 307         DB_LSN *lsnp;
 308         db_recops notused2;
 309         void *notused3;
 310 {
 311         __vi_cursor_args *argp;
 312         int ret;
 313
 314         notused2 = DB_TXN_ABORT;
 315         notused3 = NULL;
 316
 317         if ((ret = __vi_cursor_read(dbenv, dbtp->data, &argp)) != 0)
 318                 return (ret);
 319         (void)printf(
 320             "[%lu][%lu]vi_cursor: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
 321             (u_long)lsnp->file,
 322             (u_long)lsnp->offset,
 323             (u_long)argp->type,
 324             (u_long)argp->txnid->txnid,
 325             (u_long)argp->prev_lsn.file,
 326             (u_long)argp->prev_lsn.offset);
 327         (void)printf("\topcode: %lu\n", (u_long)argp->opcode);
 328         (void)printf("\tlno: %lu\n", (u_long)argp->lno);
 329         (void)printf("\tcno: %d\n", argp->cno);
 330         (void)printf("\n");
 331         __os_free(dbenv, argp, 0);
 332         return (0);
 333 }
 334
 335 /*
 336  * PUBLIC: int __vi_cursor_read __P((DB_ENV *, void *, __vi_cursor_args **));
 337  */
 338 int
 339 __vi_cursor_read(dbenv, recbuf, argpp)
 340         DB_ENV *dbenv;
 341         void *recbuf;
 342         __vi_cursor_args **argpp;
 343 {
 344         __vi_cursor_args *argp;
 345         int ret;
 346         u_int32_t uinttmp;
 347         u_int8_t *bp;
 348
 349         ret = __os_malloc(dbenv, sizeof(__vi_cursor_args) +
 350             sizeof(DB_TXN), &argp);
 351         if (ret != 0)
 352                 return (ret);
 353         argp->txnid = (DB_TXN *)&argp[1];
 354
 355         bp = recbuf;
 356         memcpy(&argp->type, bp, sizeof(argp->type));
 357         bp += sizeof(argp->type);
 358
 359         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
 360         bp += sizeof(argp->txnid->txnid);
 361
 362         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
 363         bp += sizeof(DB_LSN);
 364
 365         memcpy(&uinttmp, bp, sizeof(uinttmp));
 366         argp->opcode = (u_int32_t)uinttmp;
 367         bp += sizeof(uinttmp);
 368
 369         memcpy(&uinttmp, bp, sizeof(uinttmp));
 370         argp->lno = (db_recno_t)uinttmp;
 371         bp += sizeof(uinttmp);
 372
 373         memcpy(&uinttmp, bp, sizeof(uinttmp));
 374         argp->cno = (size_t)uinttmp;
 375         bp += sizeof(uinttmp);
 376
 377         *argpp = argp;
 378         return (0);
 379 }
 380
 381 /*
 382  * PUBLIC: int __vi_mark_log __P((DB_ENV *, DB_TXN *, DB_LSN *, u_int32_t,
 383  * PUBLIC:      LMARK *));
 384  */
 385 int
 386 __vi_mark_log(dbenv, txnid, ret_lsnp, flags,
 387         lmp)
 388         DB_ENV *dbenv;
 389         DB_TXN *txnid;
 390         DB_LSN *ret_lsnp;
 391         u_int32_t flags;
 392         LMARK * lmp;
 393 {
 394         DBT logrec;
 395         DB_LSN *lsnp, null_lsn;
 396         u_int32_t rectype, txn_num;
 397         int ret;
 398         u_int8_t *bp;
 399
 400         rectype = DB_vi_mark;
 401         if (txnid != NULL &&
 402             TAILQ_FIRST(&txnid->kids) != NULL &&
 403             (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
 404                 return (ret);
 405         txn_num = txnid == NULL ? 0 : txnid->txnid;
 406         if (txnid == NULL) {
 407                 ZERO_LSN(null_lsn);
 408                 lsnp = &null_lsn;
 409         } else
 410                 lsnp = &txnid->last_lsn;
 411         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
 412             + sizeof(*lmp);
 413         if ((ret = __os_malloc(dbenv, logrec.size, &logrec.data)) != 0)
 414                 return (ret);
 415
 416         bp = logrec.data;
 417
 418         memcpy(bp, &rectype, sizeof(rectype));
 419         bp += sizeof(rectype);
 420
 421         memcpy(bp, &txn_num, sizeof(txn_num));
 422         bp += sizeof(txn_num);
 423
 424         memcpy(bp, lsnp, sizeof(DB_LSN));
 425         bp += sizeof(DB_LSN);
 426
 427         if (lmp != NULL)
 428                 memcpy(bp, lmp, sizeof(*lmp));
 429         else
 430                 memset(bp, 0, sizeof(*lmp));
 431         bp += sizeof(*lmp);
 432
 433         DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size);
 434         ret = dbenv->log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags);
 435         if (txnid != NULL && ret == 0)
 436                 txnid->last_lsn = *ret_lsnp;
 437 #ifdef LOG_DIAGNOSTIC
 438         if (ret != 0)
 439                 (void)__vi_mark_print(dbenv,
 440                     (DBT *)&logrec, ret_lsnp, NULL, NULL);
 441 #endif
 442         __os_free(dbenv, logrec.data, logrec.size);
 443         return (ret);
 444 }
 445
 446 /*
 447  * PUBLIC: int __vi_mark_getpgnos __P((DB_ENV *, DBT *, DB_LSN *, db_recops,
 448  * PUBLIC:      void *));
 449  */
 450 int
 451 __vi_mark_getpgnos(dbenv, rec, lsnp, notused1, summary)
 452         DB_ENV *dbenv;
 453         DBT *rec;
 454         DB_LSN *lsnp;
 455         db_recops notused1;
 456         void *summary;
 457 {
 458         TXN_RECS *t;
 459         int ret;
 460         COMPQUIET(rec, NULL);
 461         COMPQUIET(notused1, DB_TXN_ABORT);
 462
 463         t = (TXN_RECS *)summary;
 464
 465         if ((ret = __rep_check_alloc(dbenv, t, 1)) != 0)
 466                 return (ret);
 467
 468         t->array[t->npages].flags = LSN_PAGE_NOLOCK;
 469         t->array[t->npages].lsn = *lsnp;
 470         t->array[t->npages].fid = DB_LOGFILEID_INVALID;
 471         memset(&t->array[t->npages].pgdesc, 0,
 472             sizeof(t->array[t->npages].pgdesc));
 473
 474         t->npages++;
 475
 476         return (0);
 477 }
 478
 479 /*
 480  * PUBLIC: int __vi_mark_print __P((DB_ENV *, DBT *, DB_LSN *, db_recops,
 481  * PUBLIC:      void *));
 482  */
 483 int
 484 __vi_mark_print(dbenv, dbtp, lsnp, notused2, notused3)
 485         DB_ENV *dbenv;
 486         DBT *dbtp;
 487         DB_LSN *lsnp;
 488         db_recops notused2;
 489         void *notused3;
 490 {
 491         __vi_mark_args *argp;
 492         int ret;
 493
 494         notused2 = DB_TXN_ABORT;
 495         notused3 = NULL;
 496
 497         if ((ret = __vi_mark_read(dbenv, dbtp->data, &argp)) != 0)
 498                 return (ret);
 499         (void)printf(
 500             "[%lu][%lu]vi_mark: 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         (void)printf("\tlmp: %%\n", argp->lmp);
 508         (void)printf("\n");
 509         __os_free(dbenv, argp, 0);
 510         return (0);
 511 }
 512
 513 /*
 514  * PUBLIC: int __vi_mark_read __P((DB_ENV *, void *, __vi_mark_args **));
 515  */
 516 int
 517 __vi_mark_read(dbenv, recbuf, argpp)
 518         DB_ENV *dbenv;
 519         void *recbuf;
 520         __vi_mark_args **argpp;
 521 {
 522         __vi_mark_args *argp;
 523         int ret;
 524         u_int8_t *bp;
 525
 526         ret = __os_malloc(dbenv, sizeof(__vi_mark_args) +
 527             sizeof(DB_TXN), &argp);
 528         if (ret != 0)
 529                 return (ret);
 530         argp->txnid = (DB_TXN *)&argp[1];
 531
 532         bp = recbuf;
 533         memcpy(&argp->type, bp, sizeof(argp->type));
 534         bp += sizeof(argp->type);
 535
 536         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
 537         bp += sizeof(argp->txnid->txnid);
 538
 539         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
 540         bp += sizeof(DB_LSN);
 541
 542         memcpy(&argp->lmp, bp,  sizeof(argp->lmp));
 543         bp += sizeof(argp->lmp);
 544
 545         *argpp = argp;
 546         return (0);
 547 }
 548
 549 /*
 550  * PUBLIC: int __vi_change_log __P((DB_ENV *, DB_TXN *, DB_LSN *, u_int32_t,
 551  * PUBLIC:      u_int32_t, db_recno_t));
 552  */
 553 int
 554 __vi_change_log(dbenv, txnid, ret_lsnp, flags,
 555         opcode, lno)
 556         DB_ENV *dbenv;
 557         DB_TXN *txnid;
 558         DB_LSN *ret_lsnp;
 559         u_int32_t flags;
 560         u_int32_t opcode;
 561         db_recno_t lno;
 562 {
 563         DBT logrec;
 564         DB_LSN *lsnp, null_lsn;
 565         u_int32_t uinttmp;
 566         u_int32_t rectype, txn_num;
 567         int ret;
 568         u_int8_t *bp;
 569
 570         rectype = DB_vi_change;
 571         if (txnid != NULL &&
 572             TAILQ_FIRST(&txnid->kids) != NULL &&
 573             (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
 574                 return (ret);
 575         txn_num = txnid == NULL ? 0 : txnid->txnid;
 576         if (txnid == NULL) {
 577                 ZERO_LSN(null_lsn);
 578                 lsnp = &null_lsn;
 579         } else
 580                 lsnp = &txnid->last_lsn;
 581         logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
 582             + sizeof(u_int32_t)
 583             + sizeof(u_int32_t);
 584         if ((ret = __os_malloc(dbenv, logrec.size, &logrec.data)) != 0)
 585                 return (ret);
 586
 587         bp = logrec.data;
 588
 589         memcpy(bp, &rectype, sizeof(rectype));
 590         bp += sizeof(rectype);
 591
 592         memcpy(bp, &txn_num, sizeof(txn_num));
 593         bp += sizeof(txn_num);
 594
 595         memcpy(bp, lsnp, sizeof(DB_LSN));
 596         bp += sizeof(DB_LSN);
 597
 598         uinttmp = (u_int32_t)opcode;
 599         memcpy(bp, &uinttmp, sizeof(uinttmp));
 600         bp += sizeof(uinttmp);
 601
 602         uinttmp = (u_int32_t)lno;
 603         memcpy(bp, &uinttmp, sizeof(uinttmp));
 604         bp += sizeof(uinttmp);
 605
 606         DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size);
 607         ret = dbenv->log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags);
 608         if (txnid != NULL && ret == 0)
 609                 txnid->last_lsn = *ret_lsnp;
 610 #ifdef LOG_DIAGNOSTIC
 611         if (ret != 0)
 612                 (void)__vi_change_print(dbenv,
 613                     (DBT *)&logrec, ret_lsnp, NULL, NULL);
 614 #endif
 615         __os_free(dbenv, logrec.data, logrec.size);
 616         return (ret);
 617 }
 618
 619 /*
 620  * PUBLIC: int __vi_change_getpgnos __P((DB_ENV *, DBT *, DB_LSN *, db_recops,
 621  * PUBLIC:      void *));
 622  */
 623 int
 624 __vi_change_getpgnos(dbenv, rec, lsnp, notused1, summary)
 625         DB_ENV *dbenv;
 626         DBT *rec;
 627         DB_LSN *lsnp;
 628         db_recops notused1;
 629         void *summary;
 630 {
 631         TXN_RECS *t;
 632         int ret;
 633         COMPQUIET(rec, NULL);
 634         COMPQUIET(notused1, DB_TXN_ABORT);
 635
 636         t = (TXN_RECS *)summary;
 637
 638         if ((ret = __rep_check_alloc(dbenv, t, 1)) != 0)
 639                 return (ret);
 640
 641         t->array[t->npages].flags = LSN_PAGE_NOLOCK;
 642         t->array[t->npages].lsn = *lsnp;
 643         t->array[t->npages].fid = DB_LOGFILEID_INVALID;
 644         memset(&t->array[t->npages].pgdesc, 0,
 645             sizeof(t->array[t->npages].pgdesc));
 646
 647         t->npages++;
 648
 649         return (0);
 650 }
 651
 652 /*
 653  * PUBLIC: int __vi_change_print __P((DB_ENV *, DBT *, DB_LSN *, db_recops,
 654  * PUBLIC:      void *));
 655  */
 656 int
 657 __vi_change_print(dbenv, dbtp, lsnp, notused2, notused3)
 658         DB_ENV *dbenv;
 659         DBT *dbtp;
 660         DB_LSN *lsnp;
 661         db_recops notused2;
 662         void *notused3;
 663 {
 664         __vi_change_args *argp;
 665         int ret;
 666
 667         notused2 = DB_TXN_ABORT;
 668         notused3 = NULL;
 669
 670         if ((ret = __vi_change_read(dbenv, dbtp->data, &argp)) != 0)
 671                 return (ret);
 672         (void)printf(
 673             "[%lu][%lu]vi_change: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
 674             (u_long)lsnp->file,
 675             (u_long)lsnp->offset,
 676             (u_long)argp->type,
 677             (u_long)argp->txnid->txnid,
 678             (u_long)argp->prev_lsn.file,
 679             (u_long)argp->prev_lsn.offset);
 680         (void)printf("\topcode: %lu\n", (u_long)argp->opcode);
 681         (void)printf("\tlno: %lu\n", (u_long)argp->lno);
 682         (void)printf("\n");
 683         __os_free(dbenv, argp, 0);
 684         return (0);
 685 }
 686
 687 /*
 688  * PUBLIC: int __vi_change_read __P((DB_ENV *, void *, __vi_change_args **));
 689  */
 690 int
 691 __vi_change_read(dbenv, recbuf, argpp)
 692         DB_ENV *dbenv;
 693         void *recbuf;
 694         __vi_change_args **argpp;
 695 {
 696         __vi_change_args *argp;
 697         int ret;
 698         u_int32_t uinttmp;
 699         u_int8_t *bp;
 700
 701         ret = __os_malloc(dbenv, sizeof(__vi_change_args) +
 702             sizeof(DB_TXN), &argp);
 703         if (ret != 0)
 704                 return (ret);
 705         argp->txnid = (DB_TXN *)&argp[1];
 706
 707         bp = recbuf;
 708         memcpy(&argp->type, bp, sizeof(argp->type));
 709         bp += sizeof(argp->type);
 710
 711         memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
 712         bp += sizeof(argp->txnid->txnid);
 713
 714         memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
 715         bp += sizeof(DB_LSN);
 716
 717         memcpy(&uinttmp, bp, sizeof(uinttmp));
 718         argp->opcode = (u_int32_t)uinttmp;
 719         bp += sizeof(uinttmp);
 720
 721         memcpy(&uinttmp, bp, sizeof(uinttmp));
 722         argp->lno = (db_recno_t)uinttmp;
 723         bp += sizeof(uinttmp);
 724
 725         *argpp = argp;
 726         return (0);
 727 }
 728
 729 /*
 730  * PUBLIC: int __vi_init_print __P((DB_ENV *, int (***)(DB_ENV *, DBT *,
 731  * PUBLIC:      DB_LSN *, db_recops, void *), size_t *));
 732  */
 733 int
 734 __vi_init_print(dbenv, dtabp, dtabsizep)
 735         DB_ENV *dbenv;
 736         int (***dtabp)__P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
 737         size_t *dtabsizep;
 738 {
 739         int ret;
 740
 741         if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
 742             __vi_marker_print, DB_vi_marker)) != 0)
 743                 return (ret);
 744         if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
 745             __vi_cursor_print, DB_vi_cursor)) != 0)
 746                 return (ret);
 747         if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
 748             __vi_mark_print, DB_vi_mark)) != 0)
 749                 return (ret);
 750         if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
 751             __vi_change_print, DB_vi_change)) != 0)
 752                 return (ret);
 753         return (0);
 754 }
 755
 756 /*
 757  * PUBLIC: int __vi_init_getpgnos __P((DB_ENV *, int (***)(DB_ENV *, DBT *,
 758  * PUBLIC:      DB_LSN *, db_recops, void *), size_t *));
 759  */
 760 int
 761 __vi_init_getpgnos(dbenv, dtabp, dtabsizep)
 762         DB_ENV *dbenv;
 763         int (***dtabp)__P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
 764         size_t *dtabsizep;
 765 {
 766         int ret;
 767
 768         if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
 769             __vi_marker_getpgnos, DB_vi_marker)) != 0)
 770                 return (ret);
 771         if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
 772             __vi_cursor_getpgnos, DB_vi_cursor)) != 0)
 773                 return (ret);
 774         if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
 775             __vi_mark_getpgnos, DB_vi_mark)) != 0)
 776                 return (ret);
 777         if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
 778             __vi_change_getpgnos, DB_vi_change)) != 0)
 779                 return (ret);
 780         return (0);
 781 }
 782
 783 /*
 784  * PUBLIC: int __vi_init_recover __P((DB_ENV *));
 785  */
 786 int
 787 __vi_init_recover(dbenv)
 788         DB_ENV *dbenv;
 789 {
 790         int ret;
 791
 792         if ((ret = __db_add_recovery(dbenv, &dbenv->dtab, &dbenv->dtab_size,
 793             __vi_marker_recover, DB_vi_marker)) != 0)
 794                 return (ret);
 795         if ((ret = __db_add_recovery(dbenv, &dbenv->dtab, &dbenv->dtab_size,
 796             __vi_cursor_recover, DB_vi_cursor)) != 0)
 797                 return (ret);
 798         if ((ret = __db_add_recovery(dbenv, &dbenv->dtab, &dbenv->dtab_size,
 799             __vi_mark_recover, DB_vi_mark)) != 0)
 800                 return (ret);
 801         if ((ret = __db_add_recovery(dbenv, &dbenv->dtab, &dbenv->dtab_size,
 802             __vi_change_recover, DB_vi_change)) != 0)
 803                 return (ret);
 804         return (0);
 805 }
 806 /*
 807  * PUBLIC: #endif
 808  */