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