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