开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
btree_auto.c
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：63k
源码类别：

MySQL数据库

开发平台：

Visual C++

btree_auto.c：源码内容
  1. /* Do not edit: automatically built by gen_rec.awk. */
  2. #include "db_config.h"
  4. #ifndef NO_SYSTEM_INCLUDES
  5. #include <sys/types.h>
  7. #include <ctype.h>
  8. #include <string.h>
  9. #endif
  11. #include "db_int.h"
  12. #include "dbinc/crypto.h"
  13. #include "dbinc/db_page.h"
  14. #include "dbinc/db_dispatch.h"
  15. #include "dbinc/db_am.h"
  16. #include "dbinc/btree.h"
  17. #include "dbinc/log.h"
  18. #include "dbinc/rep.h"
  19. #include "dbinc/txn.h"
  21. /*
  22.  * PUBLIC: int __bam_split_log __P((DB *, DB_TXN *, DB_LSN *,
  23.  * PUBLIC:     u_int32_t, db_pgno_t, DB_LSN *, db_pgno_t, DB_LSN *, u_int32_t,
  24.  * PUBLIC:     db_pgno_t, DB_LSN *, db_pgno_t, const DBT *, u_int32_t));
  25.  */
  26. int
  27. __bam_split_log(dbp, txnid, ret_lsnp, flags, left, llsn, right, rlsn, indx,
  28.     npgno, nlsn, root_pgno, pg, opflags)
  29. DB *dbp;
  30. DB_TXN *txnid;
  31. DB_LSN *ret_lsnp;
  32. u_int32_t flags;
  33. db_pgno_t left;
  34. DB_LSN * llsn;
  35. db_pgno_t right;
  36. DB_LSN * rlsn;
  37. u_int32_t indx;
  38. db_pgno_t npgno;
  39. DB_LSN * nlsn;
  40. db_pgno_t root_pgno;
  41. const DBT *pg;
  42. u_int32_t opflags;
  43. {
  44. DBT logrec;
  45. DB_ENV *dbenv;
  46. DB_LSN *lsnp, null_lsn;
  47. u_int32_t zero;
  48. u_int32_t uinttmp;
  49. u_int32_t npad, rectype, txn_num;
  50. int ret;
  51. u_int8_t *bp;
  53. dbenv = dbp->dbenv;
  54. rectype = DB___bam_split;
  55. npad = 0;
  57. if (txnid == NULL) {
  58. txn_num = 0;
  59. null_lsn.file = 0;
  60. null_lsn.offset = 0;
  61. lsnp = &null_lsn;
  62. } else {
  63. if (TAILQ_FIRST(&txnid->kids) != NULL &&
  64.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  65. return (ret);
  66. txn_num = txnid->txnid;
  67. lsnp = &txnid->last_lsn;
  68. }
  70. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  71.     + sizeof(u_int32_t)
  72.     + sizeof(u_int32_t)
  73.     + sizeof(*llsn)
  74.     + sizeof(u_int32_t)
  75.     + sizeof(*rlsn)
  76.     + sizeof(u_int32_t)
  77.     + sizeof(u_int32_t)
  78.     + sizeof(*nlsn)
  79.     + sizeof(u_int32_t)
  80.     + sizeof(u_int32_t) + (pg == NULL ? 0 : pg->size)
  81.     + sizeof(u_int32_t);
  82. if (CRYPTO_ON(dbenv)) {
  83. npad =
  84.     ((DB_CIPHER *)dbenv->crypto_handle)->adj_size(logrec.size);
  85. logrec.size += npad;
  86. }
  88. if ((ret = __os_malloc(dbenv,
  89.     logrec.size, &logrec.data)) != 0)
  90. return (ret);
  92. if (npad > 0)
  93. memset((u_int8_t *)logrec.data + logrec.size - npad, 0, npad);
  95. bp = logrec.data;
  97. memcpy(bp, &rectype, sizeof(rectype));
  98. bp += sizeof(rectype);
  100. memcpy(bp, &txn_num, sizeof(txn_num));
  101. bp += sizeof(txn_num);
  103. memcpy(bp, lsnp, sizeof(DB_LSN));
  104. bp += sizeof(DB_LSN);
  106. DB_ASSERT(dbp->log_filename != NULL);
  107. if (dbp->log_filename->id == DB_LOGFILEID_INVALID &&
  108.     (ret = __dbreg_lazy_id(dbp)) != 0)
  109. return (ret);
  111. uinttmp = (u_int32_t)dbp->log_filename->id;
  112. memcpy(bp, &uinttmp, sizeof(uinttmp));
  113. bp += sizeof(uinttmp);
  115. uinttmp = (u_int32_t)left;
  116. memcpy(bp, &uinttmp, sizeof(uinttmp));
  117. bp += sizeof(uinttmp);
  119. if (llsn != NULL)
  120. memcpy(bp, llsn, sizeof(*llsn));
  121. else
  122. memset(bp, 0, sizeof(*llsn));
  123. bp += sizeof(*llsn);
  125. uinttmp = (u_int32_t)right;
  126. memcpy(bp, &uinttmp, sizeof(uinttmp));
  127. bp += sizeof(uinttmp);
  129. if (rlsn != NULL)
  130. memcpy(bp, rlsn, sizeof(*rlsn));
  131. else
  132. memset(bp, 0, sizeof(*rlsn));
  133. bp += sizeof(*rlsn);
  135. uinttmp = (u_int32_t)indx;
  136. memcpy(bp, &uinttmp, sizeof(uinttmp));
  137. bp += sizeof(uinttmp);
  139. uinttmp = (u_int32_t)npgno;
  140. memcpy(bp, &uinttmp, sizeof(uinttmp));
  141. bp += sizeof(uinttmp);
  143. if (nlsn != NULL)
  144. memcpy(bp, nlsn, sizeof(*nlsn));
  145. else
  146. memset(bp, 0, sizeof(*nlsn));
  147. bp += sizeof(*nlsn);
  149. uinttmp = (u_int32_t)root_pgno;
  150. memcpy(bp, &uinttmp, sizeof(uinttmp));
  151. bp += sizeof(uinttmp);
  153. if (pg == NULL) {
  154. zero = 0;
  155. memcpy(bp, &zero, sizeof(u_int32_t));
  156. bp += sizeof(u_int32_t);
  157. } else {
  158. memcpy(bp, &pg->size, sizeof(pg->size));
  159. bp += sizeof(pg->size);
  160. memcpy(bp, pg->data, pg->size);
  161. bp += pg->size;
  162. }
  164. uinttmp = (u_int32_t)opflags;
  165. memcpy(bp, &uinttmp, sizeof(uinttmp));
  166. bp += sizeof(uinttmp);
  168. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
  169. ret = dbenv->log_put(dbenv,
  170.    ret_lsnp, (DBT *)&logrec, flags | DB_NOCOPY);
  171. if (txnid != NULL && ret == 0)
  172. txnid->last_lsn = *ret_lsnp;
  173. #ifdef LOG_DIAGNOSTIC
  174. if (ret != 0)
  175. (void)__bam_split_print(dbenv,
  176.     (DBT *)&logrec, ret_lsnp, NULL, NULL);
  177. #endif
  178. __os_free(dbenv, logrec.data);
  179. return (ret);
  180. }
  182. /*
  183.  * PUBLIC: int __bam_split_getpgnos __P((DB_ENV *, DBT *, DB_LSN *,
  184.  * PUBLIC:     db_recops, void *));
  185.  */
  186. int
  187. __bam_split_getpgnos(dbenv, rec, lsnp, notused1, summary)
  188. DB_ENV *dbenv;
  189. DBT *rec;
  190. DB_LSN *lsnp;
  191. db_recops notused1;
  192. void *summary;
  193. {
  194. DB *dbp;
  195. TXN_RECS *t;
  196. __bam_split_args *argp;
  197. u_int32_t ret;
  199. COMPQUIET(notused1, DB_TXN_ABORT);
  201. argp = NULL;
  202. t = (TXN_RECS *)summary;
  204. if ((ret = __bam_split_read(dbenv, rec->data, &argp)) != 0)
  205. return (ret);
  207. if ((ret = __dbreg_id_to_db(dbenv,
  208.     argp->txnid, &dbp, argp->fileid, 0)) != 0)
  209. goto err;
  211. if ((ret = __rep_check_alloc(dbenv, t, 3)) != 0)
  212. goto err;
  214. t->array[t->npages].flags = 0;
  215. t->array[t->npages].fid = argp->fileid;
  216. t->array[t->npages].lsn = *lsnp;
  217. t->array[t->npages].pgdesc.pgno = argp->left;
  218. t->array[t->npages].pgdesc.type = DB_PAGE_LOCK;
  219. memcpy(t->array[t->npages].pgdesc.fileid, dbp->fileid,
  220.     DB_FILE_ID_LEN);
  221. t->npages++;
  222. t->array[t->npages].flags = 0;
  223. t->array[t->npages].fid = argp->fileid;
  224. t->array[t->npages].lsn = *lsnp;
  225. t->array[t->npages].pgdesc.pgno = argp->right;
  226. t->array[t->npages].pgdesc.type = DB_PAGE_LOCK;
  227. memcpy(t->array[t->npages].pgdesc.fileid, dbp->fileid,
  228.     DB_FILE_ID_LEN);
  229. t->npages++;
  230. if (argp->root_pgno != PGNO_INVALID) {
  231. t->array[t->npages].flags = 0;
  232. t->array[t->npages].fid = argp->fileid;
  233. t->array[t->npages].lsn = *lsnp;
  234. t->array[t->npages].pgdesc.pgno = argp->root_pgno;
  235. t->array[t->npages].pgdesc.type = DB_PAGE_LOCK;
  236. memcpy(t->array[t->npages].pgdesc.fileid, dbp->fileid,
  237.     DB_FILE_ID_LEN);
  238. t->npages++;
  239. }
  241. err: if (argp != NULL)
  242. __os_free(dbenv, argp);
  243. return (ret);
  244. }
  246. /*
  247.  * PUBLIC: int __bam_split_print __P((DB_ENV *, DBT *, DB_LSN *,
  248.  * PUBLIC:     db_recops, void *));
  249.  */
  250. int
  251. __bam_split_print(dbenv, dbtp, lsnp, notused2, notused3)
  252. DB_ENV *dbenv;
  253. DBT *dbtp;
  254. DB_LSN *lsnp;
  255. db_recops notused2;
  256. void *notused3;
  257. {
  258. __bam_split_args *argp;
  259. u_int32_t i;
  260. int ch;
  261. int ret;
  263. notused2 = DB_TXN_ABORT;
  264. notused3 = NULL;
  266. if ((ret = __bam_split_read(dbenv, dbtp->data, &argp)) != 0)
  267. return (ret);
  268. (void)printf(
  269.     "[%lu][%lu]__bam_split: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  270.     (u_long)lsnp->file,
  271.     (u_long)lsnp->offset,
  272.     (u_long)argp->type,
  273.     (u_long)argp->txnid->txnid,
  274.     (u_long)argp->prev_lsn.file,
  275.     (u_long)argp->prev_lsn.offset);
  276. (void)printf("tfileid: %ldn", (long)argp->fileid);
  277. (void)printf("tleft: %lun", (u_long)argp->left);
  278. (void)printf("tllsn: [%lu][%lu]n",
  279.     (u_long)argp->llsn.file, (u_long)argp->llsn.offset);
  280. (void)printf("tright: %lun", (u_long)argp->right);
  281. (void)printf("trlsn: [%lu][%lu]n",
  282.     (u_long)argp->rlsn.file, (u_long)argp->rlsn.offset);
  283. (void)printf("tindx: %lun", (u_long)argp->indx);
  284. (void)printf("tnpgno: %lun", (u_long)argp->npgno);
  285. (void)printf("tnlsn: [%lu][%lu]n",
  286.     (u_long)argp->nlsn.file, (u_long)argp->nlsn.offset);
  287. (void)printf("troot_pgno: %lun", (u_long)argp->root_pgno);
  288. (void)printf("tpg: ");
  289. for (i = 0; i < argp->pg.size; i++) {
  290. ch = ((u_int8_t *)argp->pg.data)[i];
  291. printf(isprint(ch) || ch == 0x0a ? "%c" : "%#x ", ch);
  292. }
  293. (void)printf("n");
  294. (void)printf("topflags: %lun", (u_long)argp->opflags);
  295. (void)printf("n");
  296. __os_free(dbenv, argp);
  297. return (0);
  298. }
  300. /*
  301.  * PUBLIC: int __bam_split_read __P((DB_ENV *, void *, __bam_split_args **));
  302.  */
  303. int
  304. __bam_split_read(dbenv, recbuf, argpp)
  305. DB_ENV *dbenv;
  306. void *recbuf;
  307. __bam_split_args **argpp;
  308. {
  309. __bam_split_args *argp;
  310. u_int32_t uinttmp;
  311. u_int8_t *bp;
  312. int ret;
  314. if ((ret = __os_malloc(dbenv,
  315.     sizeof(__bam_split_args) + sizeof(DB_TXN), &argp)) != 0)
  316. return (ret);
  318. argp->txnid = (DB_TXN *)&argp[1];
  320. bp = recbuf;
  321. memcpy(&argp->type, bp, sizeof(argp->type));
  322. bp += sizeof(argp->type);
  324. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  325. bp += sizeof(argp->txnid->txnid);
  327. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  328. bp += sizeof(DB_LSN);
  330. memcpy(&uinttmp, bp, sizeof(uinttmp));
  331. argp->fileid = (int32_t)uinttmp;
  332. bp += sizeof(uinttmp);
  334. memcpy(&uinttmp, bp, sizeof(uinttmp));
  335. argp->left = (db_pgno_t)uinttmp;
  336. bp += sizeof(uinttmp);
  338. memcpy(&argp->llsn, bp,  sizeof(argp->llsn));
  339. bp += sizeof(argp->llsn);
  341. memcpy(&uinttmp, bp, sizeof(uinttmp));
  342. argp->right = (db_pgno_t)uinttmp;
  343. bp += sizeof(uinttmp);
  345. memcpy(&argp->rlsn, bp,  sizeof(argp->rlsn));
  346. bp += sizeof(argp->rlsn);
  348. memcpy(&uinttmp, bp, sizeof(uinttmp));
  349. argp->indx = (u_int32_t)uinttmp;
  350. bp += sizeof(uinttmp);
  352. memcpy(&uinttmp, bp, sizeof(uinttmp));
  353. argp->npgno = (db_pgno_t)uinttmp;
  354. bp += sizeof(uinttmp);
  356. memcpy(&argp->nlsn, bp,  sizeof(argp->nlsn));
  357. bp += sizeof(argp->nlsn);
  359. memcpy(&uinttmp, bp, sizeof(uinttmp));
  360. argp->root_pgno = (db_pgno_t)uinttmp;
  361. bp += sizeof(uinttmp);
  363. memset(&argp->pg, 0, sizeof(argp->pg));
  364. memcpy(&argp->pg.size, bp, sizeof(u_int32_t));
  365. bp += sizeof(u_int32_t);
  366. argp->pg.data = bp;
  367. bp += argp->pg.size;
  369. memcpy(&uinttmp, bp, sizeof(uinttmp));
  370. argp->opflags = (u_int32_t)uinttmp;
  371. bp += sizeof(uinttmp);
  373. *argpp = argp;
  374. return (0);
  375. }
  377. /*
  378.  * PUBLIC: int __bam_rsplit_log __P((DB *, DB_TXN *, DB_LSN *,
  379.  * PUBLIC:     u_int32_t, db_pgno_t, const DBT *, db_pgno_t, db_pgno_t,
  380.  * PUBLIC:     const DBT *, DB_LSN *));
  381.  */
  382. int
  383. __bam_rsplit_log(dbp, txnid, ret_lsnp, flags, pgno, pgdbt, root_pgno, nrec, rootent,
  384.     rootlsn)
  385. DB *dbp;
  386. DB_TXN *txnid;
  387. DB_LSN *ret_lsnp;
  388. u_int32_t flags;
  389. db_pgno_t pgno;
  390. const DBT *pgdbt;
  391. db_pgno_t root_pgno;
  392. db_pgno_t nrec;
  393. const DBT *rootent;
  394. DB_LSN * rootlsn;
  395. {
  396. DBT logrec;
  397. DB_ENV *dbenv;
  398. DB_LSN *lsnp, null_lsn;
  399. u_int32_t zero;
  400. u_int32_t uinttmp;
  401. u_int32_t npad, rectype, txn_num;
  402. int ret;
  403. u_int8_t *bp;
  405. dbenv = dbp->dbenv;
  406. rectype = DB___bam_rsplit;
  407. npad = 0;
  409. if (txnid == NULL) {
  410. txn_num = 0;
  411. null_lsn.file = 0;
  412. null_lsn.offset = 0;
  413. lsnp = &null_lsn;
  414. } else {
  415. if (TAILQ_FIRST(&txnid->kids) != NULL &&
  416.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  417. return (ret);
  418. txn_num = txnid->txnid;
  419. lsnp = &txnid->last_lsn;
  420. }
  422. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  423.     + sizeof(u_int32_t)
  424.     + sizeof(u_int32_t)
  425.     + sizeof(u_int32_t) + (pgdbt == NULL ? 0 : pgdbt->size)
  426.     + sizeof(u_int32_t)
  427.     + sizeof(u_int32_t)
  428.     + sizeof(u_int32_t) + (rootent == NULL ? 0 : rootent->size)
  429.     + sizeof(*rootlsn);
  430. if (CRYPTO_ON(dbenv)) {
  431. npad =
  432.     ((DB_CIPHER *)dbenv->crypto_handle)->adj_size(logrec.size);
  433. logrec.size += npad;
  434. }
  436. if ((ret = __os_malloc(dbenv,
  437.     logrec.size, &logrec.data)) != 0)
  438. return (ret);
  440. if (npad > 0)
  441. memset((u_int8_t *)logrec.data + logrec.size - npad, 0, npad);
  443. bp = logrec.data;
  445. memcpy(bp, &rectype, sizeof(rectype));
  446. bp += sizeof(rectype);
  448. memcpy(bp, &txn_num, sizeof(txn_num));
  449. bp += sizeof(txn_num);
  451. memcpy(bp, lsnp, sizeof(DB_LSN));
  452. bp += sizeof(DB_LSN);
  454. DB_ASSERT(dbp->log_filename != NULL);
  455. if (dbp->log_filename->id == DB_LOGFILEID_INVALID &&
  456.     (ret = __dbreg_lazy_id(dbp)) != 0)
  457. return (ret);
  459. uinttmp = (u_int32_t)dbp->log_filename->id;
  460. memcpy(bp, &uinttmp, sizeof(uinttmp));
  461. bp += sizeof(uinttmp);
  463. uinttmp = (u_int32_t)pgno;
  464. memcpy(bp, &uinttmp, sizeof(uinttmp));
  465. bp += sizeof(uinttmp);
  467. if (pgdbt == NULL) {
  468. zero = 0;
  469. memcpy(bp, &zero, sizeof(u_int32_t));
  470. bp += sizeof(u_int32_t);
  471. } else {
  472. memcpy(bp, &pgdbt->size, sizeof(pgdbt->size));
  473. bp += sizeof(pgdbt->size);
  474. memcpy(bp, pgdbt->data, pgdbt->size);
  475. bp += pgdbt->size;
  476. }
  478. uinttmp = (u_int32_t)root_pgno;
  479. memcpy(bp, &uinttmp, sizeof(uinttmp));
  480. bp += sizeof(uinttmp);
  482. uinttmp = (u_int32_t)nrec;
  483. memcpy(bp, &uinttmp, sizeof(uinttmp));
  484. bp += sizeof(uinttmp);
  486. if (rootent == NULL) {
  487. zero = 0;
  488. memcpy(bp, &zero, sizeof(u_int32_t));
  489. bp += sizeof(u_int32_t);
  490. } else {
  491. memcpy(bp, &rootent->size, sizeof(rootent->size));
  492. bp += sizeof(rootent->size);
  493. memcpy(bp, rootent->data, rootent->size);
  494. bp += rootent->size;
  495. }
  497. if (rootlsn != NULL)
  498. memcpy(bp, rootlsn, sizeof(*rootlsn));
  499. else
  500. memset(bp, 0, sizeof(*rootlsn));
  501. bp += sizeof(*rootlsn);
  503. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
  504. ret = dbenv->log_put(dbenv,
  505.    ret_lsnp, (DBT *)&logrec, flags | DB_NOCOPY);
  506. if (txnid != NULL && ret == 0)
  507. txnid->last_lsn = *ret_lsnp;
  508. #ifdef LOG_DIAGNOSTIC
  509. if (ret != 0)
  510. (void)__bam_rsplit_print(dbenv,
  511.     (DBT *)&logrec, ret_lsnp, NULL, NULL);
  512. #endif
  513. __os_free(dbenv, logrec.data);
  514. return (ret);
  515. }
  517. /*
  518.  * PUBLIC: int __bam_rsplit_getpgnos __P((DB_ENV *, DBT *, DB_LSN *,
  519.  * PUBLIC:     db_recops, void *));
  520.  */
  521. int
  522. __bam_rsplit_getpgnos(dbenv, rec, lsnp, notused1, summary)
  523. DB_ENV *dbenv;
  524. DBT *rec;
  525. DB_LSN *lsnp;
  526. db_recops notused1;
  527. void *summary;
  528. {
  529. DB *dbp;
  530. TXN_RECS *t;
  531. __bam_rsplit_args *argp;
  532. u_int32_t ret;
  534. COMPQUIET(notused1, DB_TXN_ABORT);
  536. argp = NULL;
  537. t = (TXN_RECS *)summary;
  539. if ((ret = __bam_rsplit_read(dbenv, rec->data, &argp)) != 0)
  540. return (ret);
  542. if ((ret = __dbreg_id_to_db(dbenv,
  543.     argp->txnid, &dbp, argp->fileid, 0)) != 0)
  544. goto err;
  546. if ((ret = __rep_check_alloc(dbenv, t, 2)) != 0)
  547. goto err;
  549. t->array[t->npages].flags = 0;
  550. t->array[t->npages].fid = argp->fileid;
  551. t->array[t->npages].lsn = *lsnp;
  552. t->array[t->npages].pgdesc.pgno = argp->pgno;
  553. t->array[t->npages].pgdesc.type = DB_PAGE_LOCK;
  554. memcpy(t->array[t->npages].pgdesc.fileid, dbp->fileid,
  555.     DB_FILE_ID_LEN);
  556. t->npages++;
  557. t->array[t->npages].flags = 0;
  558. t->array[t->npages].fid = argp->fileid;
  559. t->array[t->npages].lsn = *lsnp;
  560. t->array[t->npages].pgdesc.pgno = argp->root_pgno;
  561. t->array[t->npages].pgdesc.type = DB_PAGE_LOCK;
  562. memcpy(t->array[t->npages].pgdesc.fileid, dbp->fileid,
  563.     DB_FILE_ID_LEN);
  564. t->npages++;
  566. err: if (argp != NULL)
  567. __os_free(dbenv, argp);
  568. return (ret);
  569. }
  571. /*
  572.  * PUBLIC: int __bam_rsplit_print __P((DB_ENV *, DBT *, DB_LSN *,
  573.  * PUBLIC:     db_recops, void *));
  574.  */
  575. int
  576. __bam_rsplit_print(dbenv, dbtp, lsnp, notused2, notused3)
  577. DB_ENV *dbenv;
  578. DBT *dbtp;
  579. DB_LSN *lsnp;
  580. db_recops notused2;
  581. void *notused3;
  582. {
  583. __bam_rsplit_args *argp;
  584. u_int32_t i;
  585. int ch;
  586. int ret;
  588. notused2 = DB_TXN_ABORT;
  589. notused3 = NULL;
  591. if ((ret = __bam_rsplit_read(dbenv, dbtp->data, &argp)) != 0)
  592. return (ret);
  593. (void)printf(
  594.     "[%lu][%lu]__bam_rsplit: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  595.     (u_long)lsnp->file,
  596.     (u_long)lsnp->offset,
  597.     (u_long)argp->type,
  598.     (u_long)argp->txnid->txnid,
  599.     (u_long)argp->prev_lsn.file,
  600.     (u_long)argp->prev_lsn.offset);
  601. (void)printf("tfileid: %ldn", (long)argp->fileid);
  602. (void)printf("tpgno: %lun", (u_long)argp->pgno);
  603. (void)printf("tpgdbt: ");
  604. for (i = 0; i < argp->pgdbt.size; i++) {
  605. ch = ((u_int8_t *)argp->pgdbt.data)[i];
  606. printf(isprint(ch) || ch == 0x0a ? "%c" : "%#x ", ch);
  607. }
  608. (void)printf("n");
  609. (void)printf("troot_pgno: %lun", (u_long)argp->root_pgno);
  610. (void)printf("tnrec: %lun", (u_long)argp->nrec);
  611. (void)printf("trootent: ");
  612. for (i = 0; i < argp->rootent.size; i++) {
  613. ch = ((u_int8_t *)argp->rootent.data)[i];
  614. printf(isprint(ch) || ch == 0x0a ? "%c" : "%#x ", ch);
  615. }
  616. (void)printf("n");
  617. (void)printf("trootlsn: [%lu][%lu]n",
  618.     (u_long)argp->rootlsn.file, (u_long)argp->rootlsn.offset);
  619. (void)printf("n");
  620. __os_free(dbenv, argp);
  621. return (0);
  622. }
  624. /*
  625.  * PUBLIC: int __bam_rsplit_read __P((DB_ENV *, void *, __bam_rsplit_args **));
  626.  */
  627. int
  628. __bam_rsplit_read(dbenv, recbuf, argpp)
  629. DB_ENV *dbenv;
  630. void *recbuf;
  631. __bam_rsplit_args **argpp;
  632. {
  633. __bam_rsplit_args *argp;
  634. u_int32_t uinttmp;
  635. u_int8_t *bp;
  636. int ret;
  638. if ((ret = __os_malloc(dbenv,
  639.     sizeof(__bam_rsplit_args) + sizeof(DB_TXN), &argp)) != 0)
  640. return (ret);
  642. argp->txnid = (DB_TXN *)&argp[1];
  644. bp = recbuf;
  645. memcpy(&argp->type, bp, sizeof(argp->type));
  646. bp += sizeof(argp->type);
  648. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  649. bp += sizeof(argp->txnid->txnid);
  651. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  652. bp += sizeof(DB_LSN);
  654. memcpy(&uinttmp, bp, sizeof(uinttmp));
  655. argp->fileid = (int32_t)uinttmp;
  656. bp += sizeof(uinttmp);
  658. memcpy(&uinttmp, bp, sizeof(uinttmp));
  659. argp->pgno = (db_pgno_t)uinttmp;
  660. bp += sizeof(uinttmp);
  662. memset(&argp->pgdbt, 0, sizeof(argp->pgdbt));
  663. memcpy(&argp->pgdbt.size, bp, sizeof(u_int32_t));
  664. bp += sizeof(u_int32_t);
  665. argp->pgdbt.data = bp;
  666. bp += argp->pgdbt.size;
  668. memcpy(&uinttmp, bp, sizeof(uinttmp));
  669. argp->root_pgno = (db_pgno_t)uinttmp;
  670. bp += sizeof(uinttmp);
  672. memcpy(&uinttmp, bp, sizeof(uinttmp));
  673. argp->nrec = (db_pgno_t)uinttmp;
  674. bp += sizeof(uinttmp);
  676. memset(&argp->rootent, 0, sizeof(argp->rootent));
  677. memcpy(&argp->rootent.size, bp, sizeof(u_int32_t));
  678. bp += sizeof(u_int32_t);
  679. argp->rootent.data = bp;
  680. bp += argp->rootent.size;
  682. memcpy(&argp->rootlsn, bp,  sizeof(argp->rootlsn));
  683. bp += sizeof(argp->rootlsn);
  685. *argpp = argp;
  686. return (0);
  687. }
  689. /*
  690.  * PUBLIC: int __bam_adj_log __P((DB *, DB_TXN *, DB_LSN *,
  691.  * PUBLIC:     u_int32_t, db_pgno_t, DB_LSN *, u_int32_t, u_int32_t,
  692.  * PUBLIC:     u_int32_t));
  693.  */
  694. int
  695. __bam_adj_log(dbp, txnid, ret_lsnp, flags, pgno, lsn, indx, indx_copy, is_insert)
  696. DB *dbp;
  697. DB_TXN *txnid;
  698. DB_LSN *ret_lsnp;
  699. u_int32_t flags;
  700. db_pgno_t pgno;
  701. DB_LSN * lsn;
  702. u_int32_t indx;
  703. u_int32_t indx_copy;
  704. u_int32_t is_insert;
  705. {
  706. DBT logrec;
  707. DB_ENV *dbenv;
  708. DB_LSN *lsnp, null_lsn;
  709. u_int32_t uinttmp;
  710. u_int32_t npad, rectype, txn_num;
  711. int ret;
  712. u_int8_t *bp;
  714. dbenv = dbp->dbenv;
  715. rectype = DB___bam_adj;
  716. npad = 0;
  718. if (txnid == NULL) {
  719. txn_num = 0;
  720. null_lsn.file = 0;
  721. null_lsn.offset = 0;
  722. lsnp = &null_lsn;
  723. } else {
  724. if (TAILQ_FIRST(&txnid->kids) != NULL &&
  725.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  726. return (ret);
  727. txn_num = txnid->txnid;
  728. lsnp = &txnid->last_lsn;
  729. }
  731. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  732.     + sizeof(u_int32_t)
  733.     + sizeof(u_int32_t)
  734.     + sizeof(*lsn)
  735.     + sizeof(u_int32_t)
  736.     + sizeof(u_int32_t)
  737.     + sizeof(u_int32_t);
  738. if (CRYPTO_ON(dbenv)) {
  739. npad =
  740.     ((DB_CIPHER *)dbenv->crypto_handle)->adj_size(logrec.size);
  741. logrec.size += npad;
  742. }
  744. if ((ret = __os_malloc(dbenv,
  745.     logrec.size, &logrec.data)) != 0)
  746. return (ret);
  748. if (npad > 0)
  749. memset((u_int8_t *)logrec.data + logrec.size - npad, 0, npad);
  751. bp = logrec.data;
  753. memcpy(bp, &rectype, sizeof(rectype));
  754. bp += sizeof(rectype);
  756. memcpy(bp, &txn_num, sizeof(txn_num));
  757. bp += sizeof(txn_num);
  759. memcpy(bp, lsnp, sizeof(DB_LSN));
  760. bp += sizeof(DB_LSN);
  762. DB_ASSERT(dbp->log_filename != NULL);
  763. if (dbp->log_filename->id == DB_LOGFILEID_INVALID &&
  764.     (ret = __dbreg_lazy_id(dbp)) != 0)
  765. return (ret);
  767. uinttmp = (u_int32_t)dbp->log_filename->id;
  768. memcpy(bp, &uinttmp, sizeof(uinttmp));
  769. bp += sizeof(uinttmp);
  771. uinttmp = (u_int32_t)pgno;
  772. memcpy(bp, &uinttmp, sizeof(uinttmp));
  773. bp += sizeof(uinttmp);
  775. if (lsn != NULL)
  776. memcpy(bp, lsn, sizeof(*lsn));
  777. else
  778. memset(bp, 0, sizeof(*lsn));
  779. bp += sizeof(*lsn);
  781. uinttmp = (u_int32_t)indx;
  782. memcpy(bp, &uinttmp, sizeof(uinttmp));
  783. bp += sizeof(uinttmp);
  785. uinttmp = (u_int32_t)indx_copy;
  786. memcpy(bp, &uinttmp, sizeof(uinttmp));
  787. bp += sizeof(uinttmp);
  789. uinttmp = (u_int32_t)is_insert;
  790. memcpy(bp, &uinttmp, sizeof(uinttmp));
  791. bp += sizeof(uinttmp);
  793. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
  794. ret = dbenv->log_put(dbenv,
  795.    ret_lsnp, (DBT *)&logrec, flags | DB_NOCOPY);
  796. if (txnid != NULL && ret == 0)
  797. txnid->last_lsn = *ret_lsnp;
  798. #ifdef LOG_DIAGNOSTIC
  799. if (ret != 0)
  800. (void)__bam_adj_print(dbenv,
  801.     (DBT *)&logrec, ret_lsnp, NULL, NULL);
  802. #endif
  803. __os_free(dbenv, logrec.data);
  804. return (ret);
  805. }
  807. /*
  808.  * PUBLIC: int __bam_adj_getpgnos __P((DB_ENV *, DBT *, DB_LSN *,
  809.  * PUBLIC:     db_recops, void *));
  810.  */
  811. int
  812. __bam_adj_getpgnos(dbenv, rec, lsnp, notused1, summary)
  813. DB_ENV *dbenv;
  814. DBT *rec;
  815. DB_LSN *lsnp;
  816. db_recops notused1;
  817. void *summary;
  818. {
  819. DB *dbp;
  820. TXN_RECS *t;
  821. __bam_adj_args *argp;
  822. u_int32_t ret;
  824. COMPQUIET(notused1, DB_TXN_ABORT);
  826. argp = NULL;
  827. t = (TXN_RECS *)summary;
  829. if ((ret = __bam_adj_read(dbenv, rec->data, &argp)) != 0)
  830. return (ret);
  832. if ((ret = __dbreg_id_to_db(dbenv,
  833.     argp->txnid, &dbp, argp->fileid, 0)) != 0)
  834. goto err;
  836. if ((ret = __rep_check_alloc(dbenv, t, 1)) != 0)
  837. goto err;
  839. t->array[t->npages].flags = 0;
  840. t->array[t->npages].fid = argp->fileid;
  841. t->array[t->npages].lsn = *lsnp;
  842. t->array[t->npages].pgdesc.pgno = argp->pgno;
  843. t->array[t->npages].pgdesc.type = DB_PAGE_LOCK;
  844. memcpy(t->array[t->npages].pgdesc.fileid, dbp->fileid,
  845.     DB_FILE_ID_LEN);
  846. t->npages++;
  848. err: if (argp != NULL)
  849. __os_free(dbenv, argp);
  850. return (ret);
  851. }
  853. /*
  854.  * PUBLIC: int __bam_adj_print __P((DB_ENV *, DBT *, DB_LSN *,
  855.  * PUBLIC:     db_recops, void *));
  856.  */
  857. int
  858. __bam_adj_print(dbenv, dbtp, lsnp, notused2, notused3)
  859. DB_ENV *dbenv;
  860. DBT *dbtp;
  861. DB_LSN *lsnp;
  862. db_recops notused2;
  863. void *notused3;
  864. {
  865. __bam_adj_args *argp;
  866. int ret;
  868. notused2 = DB_TXN_ABORT;
  869. notused3 = NULL;
  871. if ((ret = __bam_adj_read(dbenv, dbtp->data, &argp)) != 0)
  872. return (ret);
  873. (void)printf(
  874.     "[%lu][%lu]__bam_adj: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  875.     (u_long)lsnp->file,
  876.     (u_long)lsnp->offset,
  877.     (u_long)argp->type,
  878.     (u_long)argp->txnid->txnid,
  879.     (u_long)argp->prev_lsn.file,
  880.     (u_long)argp->prev_lsn.offset);
  881. (void)printf("tfileid: %ldn", (long)argp->fileid);
  882. (void)printf("tpgno: %lun", (u_long)argp->pgno);
  883. (void)printf("tlsn: [%lu][%lu]n",
  884.     (u_long)argp->lsn.file, (u_long)argp->lsn.offset);
  885. (void)printf("tindx: %lun", (u_long)argp->indx);
  886. (void)printf("tindx_copy: %lun", (u_long)argp->indx_copy);
  887. (void)printf("tis_insert: %lun", (u_long)argp->is_insert);
  888. (void)printf("n");
  889. __os_free(dbenv, argp);
  890. return (0);
  891. }
  893. /*
  894.  * PUBLIC: int __bam_adj_read __P((DB_ENV *, void *, __bam_adj_args **));
  895.  */
  896. int
  897. __bam_adj_read(dbenv, recbuf, argpp)
  898. DB_ENV *dbenv;
  899. void *recbuf;
  900. __bam_adj_args **argpp;
  901. {
  902. __bam_adj_args *argp;
  903. u_int32_t uinttmp;
  904. u_int8_t *bp;
  905. int ret;
  907. if ((ret = __os_malloc(dbenv,
  908.     sizeof(__bam_adj_args) + sizeof(DB_TXN), &argp)) != 0)
  909. return (ret);
  911. argp->txnid = (DB_TXN *)&argp[1];
  913. bp = recbuf;
  914. memcpy(&argp->type, bp, sizeof(argp->type));
  915. bp += sizeof(argp->type);
  917. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  918. bp += sizeof(argp->txnid->txnid);
  920. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  921. bp += sizeof(DB_LSN);
  923. memcpy(&uinttmp, bp, sizeof(uinttmp));
  924. argp->fileid = (int32_t)uinttmp;
  925. bp += sizeof(uinttmp);
  927. memcpy(&uinttmp, bp, sizeof(uinttmp));
  928. argp->pgno = (db_pgno_t)uinttmp;
  929. bp += sizeof(uinttmp);
  931. memcpy(&argp->lsn, bp,  sizeof(argp->lsn));
  932. bp += sizeof(argp->lsn);
  934. memcpy(&uinttmp, bp, sizeof(uinttmp));
  935. argp->indx = (u_int32_t)uinttmp;
  936. bp += sizeof(uinttmp);
  938. memcpy(&uinttmp, bp, sizeof(uinttmp));
  939. argp->indx_copy = (u_int32_t)uinttmp;
  940. bp += sizeof(uinttmp);
  942. memcpy(&uinttmp, bp, sizeof(uinttmp));
  943. argp->is_insert = (u_int32_t)uinttmp;
  944. bp += sizeof(uinttmp);
  946. *argpp = argp;
  947. return (0);
  948. }
  950. /*
  951.  * PUBLIC: int __bam_cadjust_log __P((DB *, DB_TXN *, DB_LSN *,
  952.  * PUBLIC:     u_int32_t, db_pgno_t, DB_LSN *, u_int32_t, int32_t, u_int32_t));
  953.  */
  954. int
  955. __bam_cadjust_log(dbp, txnid, ret_lsnp, flags, pgno, lsn, indx, adjust, opflags)
  956. DB *dbp;
  957. DB_TXN *txnid;
  958. DB_LSN *ret_lsnp;
  959. u_int32_t flags;
  960. db_pgno_t pgno;
  961. DB_LSN * lsn;
  962. u_int32_t indx;
  963. int32_t adjust;
  964. u_int32_t opflags;
  965. {
  966. DBT logrec;
  967. DB_ENV *dbenv;
  968. DB_LSN *lsnp, null_lsn;
  969. u_int32_t uinttmp;
  970. u_int32_t npad, rectype, txn_num;
  971. int ret;
  972. u_int8_t *bp;
  974. dbenv = dbp->dbenv;
  975. rectype = DB___bam_cadjust;
  976. npad = 0;
  978. if (txnid == NULL) {
  979. txn_num = 0;
  980. null_lsn.file = 0;
  981. null_lsn.offset = 0;
  982. lsnp = &null_lsn;
  983. } else {
  984. if (TAILQ_FIRST(&txnid->kids) != NULL &&
  985.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  986. return (ret);
  987. txn_num = txnid->txnid;
  988. lsnp = &txnid->last_lsn;
  989. }
  991. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  992.     + sizeof(u_int32_t)
  993.     + sizeof(u_int32_t)
  994.     + sizeof(*lsn)
  995.     + sizeof(u_int32_t)
  996.     + sizeof(u_int32_t)
  997.     + sizeof(u_int32_t);
  998. if (CRYPTO_ON(dbenv)) {
  999. npad =
  1000.     ((DB_CIPHER *)dbenv->crypto_handle)->adj_size(logrec.size);
  1001. logrec.size += npad;
  1002. }
  1004. if ((ret = __os_malloc(dbenv,
  1005.     logrec.size, &logrec.data)) != 0)
  1006. return (ret);
  1008. if (npad > 0)
  1009. memset((u_int8_t *)logrec.data + logrec.size - npad, 0, npad);
  1011. bp = logrec.data;
  1013. memcpy(bp, &rectype, sizeof(rectype));
  1014. bp += sizeof(rectype);
  1016. memcpy(bp, &txn_num, sizeof(txn_num));
  1017. bp += sizeof(txn_num);
  1019. memcpy(bp, lsnp, sizeof(DB_LSN));
  1020. bp += sizeof(DB_LSN);
  1022. DB_ASSERT(dbp->log_filename != NULL);
  1023. if (dbp->log_filename->id == DB_LOGFILEID_INVALID &&
  1024.     (ret = __dbreg_lazy_id(dbp)) != 0)
  1025. return (ret);
  1027. uinttmp = (u_int32_t)dbp->log_filename->id;
  1028. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1029. bp += sizeof(uinttmp);
  1031. uinttmp = (u_int32_t)pgno;
  1032. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1033. bp += sizeof(uinttmp);
  1035. if (lsn != NULL)
  1036. memcpy(bp, lsn, sizeof(*lsn));
  1037. else
  1038. memset(bp, 0, sizeof(*lsn));
  1039. bp += sizeof(*lsn);
  1041. uinttmp = (u_int32_t)indx;
  1042. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1043. bp += sizeof(uinttmp);
  1045. uinttmp = (u_int32_t)adjust;
  1046. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1047. bp += sizeof(uinttmp);
  1049. uinttmp = (u_int32_t)opflags;
  1050. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1051. bp += sizeof(uinttmp);
  1053. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
  1054. ret = dbenv->log_put(dbenv,
  1055.    ret_lsnp, (DBT *)&logrec, flags | DB_NOCOPY);
  1056. if (txnid != NULL && ret == 0)
  1057. txnid->last_lsn = *ret_lsnp;
  1058. #ifdef LOG_DIAGNOSTIC
  1059. if (ret != 0)
  1060. (void)__bam_cadjust_print(dbenv,
  1061.     (DBT *)&logrec, ret_lsnp, NULL, NULL);
  1062. #endif
  1063. __os_free(dbenv, logrec.data);
  1064. return (ret);
  1065. }
  1067. /*
  1068.  * PUBLIC: int __bam_cadjust_getpgnos __P((DB_ENV *, DBT *, DB_LSN *,
  1069.  * PUBLIC:     db_recops, void *));
  1070.  */
  1071. int
  1072. __bam_cadjust_getpgnos(dbenv, rec, lsnp, notused1, summary)
  1073. DB_ENV *dbenv;
  1074. DBT *rec;
  1075. DB_LSN *lsnp;
  1076. db_recops notused1;
  1077. void *summary;
  1078. {
  1079. DB *dbp;
  1080. TXN_RECS *t;
  1081. __bam_cadjust_args *argp;
  1082. u_int32_t ret;
  1084. COMPQUIET(notused1, DB_TXN_ABORT);
  1086. argp = NULL;
  1087. t = (TXN_RECS *)summary;
  1089. if ((ret = __bam_cadjust_read(dbenv, rec->data, &argp)) != 0)
  1090. return (ret);
  1092. if ((ret = __dbreg_id_to_db(dbenv,
  1093.     argp->txnid, &dbp, argp->fileid, 0)) != 0)
  1094. goto err;
  1096. if ((ret = __rep_check_alloc(dbenv, t, 1)) != 0)
  1097. goto err;
  1099. t->array[t->npages].flags = 0;
  1100. t->array[t->npages].fid = argp->fileid;
  1101. t->array[t->npages].lsn = *lsnp;
  1102. t->array[t->npages].pgdesc.pgno = argp->pgno;
  1103. t->array[t->npages].pgdesc.type = DB_PAGE_LOCK;
  1104. memcpy(t->array[t->npages].pgdesc.fileid, dbp->fileid,
  1105.     DB_FILE_ID_LEN);
  1106. t->npages++;
  1108. err: if (argp != NULL)
  1109. __os_free(dbenv, argp);
  1110. return (ret);
  1111. }
  1113. /*
  1114.  * PUBLIC: int __bam_cadjust_print __P((DB_ENV *, DBT *, DB_LSN *,
  1115.  * PUBLIC:     db_recops, void *));
  1116.  */
  1117. int
  1118. __bam_cadjust_print(dbenv, dbtp, lsnp, notused2, notused3)
  1119. DB_ENV *dbenv;
  1120. DBT *dbtp;
  1121. DB_LSN *lsnp;
  1122. db_recops notused2;
  1123. void *notused3;
  1124. {
  1125. __bam_cadjust_args *argp;
  1126. int ret;
  1128. notused2 = DB_TXN_ABORT;
  1129. notused3 = NULL;
  1131. if ((ret = __bam_cadjust_read(dbenv, dbtp->data, &argp)) != 0)
  1132. return (ret);
  1133. (void)printf(
  1134.     "[%lu][%lu]__bam_cadjust: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  1135.     (u_long)lsnp->file,
  1136.     (u_long)lsnp->offset,
  1137.     (u_long)argp->type,
  1138.     (u_long)argp->txnid->txnid,
  1139.     (u_long)argp->prev_lsn.file,
  1140.     (u_long)argp->prev_lsn.offset);
  1141. (void)printf("tfileid: %ldn", (long)argp->fileid);
  1142. (void)printf("tpgno: %lun", (u_long)argp->pgno);
  1143. (void)printf("tlsn: [%lu][%lu]n",
  1144.     (u_long)argp->lsn.file, (u_long)argp->lsn.offset);
  1145. (void)printf("tindx: %lun", (u_long)argp->indx);
  1146. (void)printf("tadjust: %ldn", (long)argp->adjust);
  1147. (void)printf("topflags: %lun", (u_long)argp->opflags);
  1148. (void)printf("n");
  1149. __os_free(dbenv, argp);
  1150. return (0);
  1151. }
  1153. /*
  1154.  * PUBLIC: int __bam_cadjust_read __P((DB_ENV *, void *,
  1155.  * PUBLIC:     __bam_cadjust_args **));
  1156.  */
  1157. int
  1158. __bam_cadjust_read(dbenv, recbuf, argpp)
  1159. DB_ENV *dbenv;
  1160. void *recbuf;
  1161. __bam_cadjust_args **argpp;
  1162. {
  1163. __bam_cadjust_args *argp;
  1164. u_int32_t uinttmp;
  1165. u_int8_t *bp;
  1166. int ret;
  1168. if ((ret = __os_malloc(dbenv,
  1169.     sizeof(__bam_cadjust_args) + sizeof(DB_TXN), &argp)) != 0)
  1170. return (ret);
  1172. argp->txnid = (DB_TXN *)&argp[1];
  1174. bp = recbuf;
  1175. memcpy(&argp->type, bp, sizeof(argp->type));
  1176. bp += sizeof(argp->type);
  1178. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  1179. bp += sizeof(argp->txnid->txnid);
  1181. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  1182. bp += sizeof(DB_LSN);
  1184. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1185. argp->fileid = (int32_t)uinttmp;
  1186. bp += sizeof(uinttmp);
  1188. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1189. argp->pgno = (db_pgno_t)uinttmp;
  1190. bp += sizeof(uinttmp);
  1192. memcpy(&argp->lsn, bp,  sizeof(argp->lsn));
  1193. bp += sizeof(argp->lsn);
  1195. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1196. argp->indx = (u_int32_t)uinttmp;
  1197. bp += sizeof(uinttmp);
  1199. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1200. argp->adjust = (int32_t)uinttmp;
  1201. bp += sizeof(uinttmp);
  1203. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1204. argp->opflags = (u_int32_t)uinttmp;
  1205. bp += sizeof(uinttmp);
  1207. *argpp = argp;
  1208. return (0);
  1209. }
  1211. /*
  1212.  * PUBLIC: int __bam_cdel_log __P((DB *, DB_TXN *, DB_LSN *,
  1213.  * PUBLIC:     u_int32_t, db_pgno_t, DB_LSN *, u_int32_t));
  1214.  */
  1215. int
  1216. __bam_cdel_log(dbp, txnid, ret_lsnp, flags, pgno, lsn, indx)
  1217. DB *dbp;
  1218. DB_TXN *txnid;
  1219. DB_LSN *ret_lsnp;
  1220. u_int32_t flags;
  1221. db_pgno_t pgno;
  1222. DB_LSN * lsn;
  1223. u_int32_t indx;
  1224. {
  1225. DBT logrec;
  1226. DB_ENV *dbenv;
  1227. DB_LSN *lsnp, null_lsn;
  1228. u_int32_t uinttmp;
  1229. u_int32_t npad, rectype, txn_num;
  1230. int ret;
  1231. u_int8_t *bp;
  1233. dbenv = dbp->dbenv;
  1234. rectype = DB___bam_cdel;
  1235. npad = 0;
  1237. if (txnid == NULL) {
  1238. txn_num = 0;
  1239. null_lsn.file = 0;
  1240. null_lsn.offset = 0;
  1241. lsnp = &null_lsn;
  1242. } else {
  1243. if (TAILQ_FIRST(&txnid->kids) != NULL &&
  1244.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  1245. return (ret);
  1246. txn_num = txnid->txnid;
  1247. lsnp = &txnid->last_lsn;
  1248. }
  1250. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  1251.     + sizeof(u_int32_t)
  1252.     + sizeof(u_int32_t)
  1253.     + sizeof(*lsn)
  1254.     + sizeof(u_int32_t);
  1255. if (CRYPTO_ON(dbenv)) {
  1256. npad =
  1257.     ((DB_CIPHER *)dbenv->crypto_handle)->adj_size(logrec.size);
  1258. logrec.size += npad;
  1259. }
  1261. if ((ret = __os_malloc(dbenv,
  1262.     logrec.size, &logrec.data)) != 0)
  1263. return (ret);
  1265. if (npad > 0)
  1266. memset((u_int8_t *)logrec.data + logrec.size - npad, 0, npad);
  1268. bp = logrec.data;
  1270. memcpy(bp, &rectype, sizeof(rectype));
  1271. bp += sizeof(rectype);
  1273. memcpy(bp, &txn_num, sizeof(txn_num));
  1274. bp += sizeof(txn_num);
  1276. memcpy(bp, lsnp, sizeof(DB_LSN));
  1277. bp += sizeof(DB_LSN);
  1279. DB_ASSERT(dbp->log_filename != NULL);
  1280. if (dbp->log_filename->id == DB_LOGFILEID_INVALID &&
  1281.     (ret = __dbreg_lazy_id(dbp)) != 0)
  1282. return (ret);
  1284. uinttmp = (u_int32_t)dbp->log_filename->id;
  1285. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1286. bp += sizeof(uinttmp);
  1288. uinttmp = (u_int32_t)pgno;
  1289. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1290. bp += sizeof(uinttmp);
  1292. if (lsn != NULL)
  1293. memcpy(bp, lsn, sizeof(*lsn));
  1294. else
  1295. memset(bp, 0, sizeof(*lsn));
  1296. bp += sizeof(*lsn);
  1298. uinttmp = (u_int32_t)indx;
  1299. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1300. bp += sizeof(uinttmp);
  1302. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
  1303. ret = dbenv->log_put(dbenv,
  1304.    ret_lsnp, (DBT *)&logrec, flags | DB_NOCOPY);
  1305. if (txnid != NULL && ret == 0)
  1306. txnid->last_lsn = *ret_lsnp;
  1307. #ifdef LOG_DIAGNOSTIC
  1308. if (ret != 0)
  1309. (void)__bam_cdel_print(dbenv,
  1310.     (DBT *)&logrec, ret_lsnp, NULL, NULL);
  1311. #endif
  1312. __os_free(dbenv, logrec.data);
  1313. return (ret);
  1314. }
  1316. /*
  1317.  * PUBLIC: int __bam_cdel_getpgnos __P((DB_ENV *, DBT *, DB_LSN *,
  1318.  * PUBLIC:     db_recops, void *));
  1319.  */
  1320. int
  1321. __bam_cdel_getpgnos(dbenv, rec, lsnp, notused1, summary)
  1322. DB_ENV *dbenv;
  1323. DBT *rec;
  1324. DB_LSN *lsnp;
  1325. db_recops notused1;
  1326. void *summary;
  1327. {
  1328. DB *dbp;
  1329. TXN_RECS *t;
  1330. __bam_cdel_args *argp;
  1331. u_int32_t ret;
  1333. COMPQUIET(notused1, DB_TXN_ABORT);
  1335. argp = NULL;
  1336. t = (TXN_RECS *)summary;
  1338. if ((ret = __bam_cdel_read(dbenv, rec->data, &argp)) != 0)
  1339. return (ret);
  1341. if ((ret = __dbreg_id_to_db(dbenv,
  1342.     argp->txnid, &dbp, argp->fileid, 0)) != 0)
  1343. goto err;
  1345. if ((ret = __rep_check_alloc(dbenv, t, 1)) != 0)
  1346. goto err;
  1348. t->array[t->npages].flags = 0;
  1349. t->array[t->npages].fid = argp->fileid;
  1350. t->array[t->npages].lsn = *lsnp;
  1351. t->array[t->npages].pgdesc.pgno = argp->pgno;
  1352. t->array[t->npages].pgdesc.type = DB_PAGE_LOCK;
  1353. memcpy(t->array[t->npages].pgdesc.fileid, dbp->fileid,
  1354.     DB_FILE_ID_LEN);
  1355. t->npages++;
  1357. err: if (argp != NULL)
  1358. __os_free(dbenv, argp);
  1359. return (ret);
  1360. }
  1362. /*
  1363.  * PUBLIC: int __bam_cdel_print __P((DB_ENV *, DBT *, DB_LSN *,
  1364.  * PUBLIC:     db_recops, void *));
  1365.  */
  1366. int
  1367. __bam_cdel_print(dbenv, dbtp, lsnp, notused2, notused3)
  1368. DB_ENV *dbenv;
  1369. DBT *dbtp;
  1370. DB_LSN *lsnp;
  1371. db_recops notused2;
  1372. void *notused3;
  1373. {
  1374. __bam_cdel_args *argp;
  1375. int ret;
  1377. notused2 = DB_TXN_ABORT;
  1378. notused3 = NULL;
  1380. if ((ret = __bam_cdel_read(dbenv, dbtp->data, &argp)) != 0)
  1381. return (ret);
  1382. (void)printf(
  1383.     "[%lu][%lu]__bam_cdel: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  1384.     (u_long)lsnp->file,
  1385.     (u_long)lsnp->offset,
  1386.     (u_long)argp->type,
  1387.     (u_long)argp->txnid->txnid,
  1388.     (u_long)argp->prev_lsn.file,
  1389.     (u_long)argp->prev_lsn.offset);
  1390. (void)printf("tfileid: %ldn", (long)argp->fileid);
  1391. (void)printf("tpgno: %lun", (u_long)argp->pgno);
  1392. (void)printf("tlsn: [%lu][%lu]n",
  1393.     (u_long)argp->lsn.file, (u_long)argp->lsn.offset);
  1394. (void)printf("tindx: %lun", (u_long)argp->indx);
  1395. (void)printf("n");
  1396. __os_free(dbenv, argp);
  1397. return (0);
  1398. }
  1400. /*
  1401.  * PUBLIC: int __bam_cdel_read __P((DB_ENV *, void *, __bam_cdel_args **));
  1402.  */
  1403. int
  1404. __bam_cdel_read(dbenv, recbuf, argpp)
  1405. DB_ENV *dbenv;
  1406. void *recbuf;
  1407. __bam_cdel_args **argpp;
  1408. {
  1409. __bam_cdel_args *argp;
  1410. u_int32_t uinttmp;
  1411. u_int8_t *bp;
  1412. int ret;
  1414. if ((ret = __os_malloc(dbenv,
  1415.     sizeof(__bam_cdel_args) + sizeof(DB_TXN), &argp)) != 0)
  1416. return (ret);
  1418. argp->txnid = (DB_TXN *)&argp[1];
  1420. bp = recbuf;
  1421. memcpy(&argp->type, bp, sizeof(argp->type));
  1422. bp += sizeof(argp->type);
  1424. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  1425. bp += sizeof(argp->txnid->txnid);
  1427. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  1428. bp += sizeof(DB_LSN);
  1430. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1431. argp->fileid = (int32_t)uinttmp;
  1432. bp += sizeof(uinttmp);
  1434. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1435. argp->pgno = (db_pgno_t)uinttmp;
  1436. bp += sizeof(uinttmp);
  1438. memcpy(&argp->lsn, bp,  sizeof(argp->lsn));
  1439. bp += sizeof(argp->lsn);
  1441. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1442. argp->indx = (u_int32_t)uinttmp;
  1443. bp += sizeof(uinttmp);
  1445. *argpp = argp;
  1446. return (0);
  1447. }
  1449. /*
  1450.  * PUBLIC: int __bam_repl_log __P((DB *, DB_TXN *, DB_LSN *,
  1451.  * PUBLIC:     u_int32_t, db_pgno_t, DB_LSN *, u_int32_t, u_int32_t,
  1452.  * PUBLIC:     const DBT *, const DBT *, u_int32_t, u_int32_t));
  1453.  */
  1454. int
  1455. __bam_repl_log(dbp, txnid, ret_lsnp, flags, pgno, lsn, indx, isdeleted, orig,
  1456.     repl, prefix, suffix)
  1457. DB *dbp;
  1458. DB_TXN *txnid;
  1459. DB_LSN *ret_lsnp;
  1460. u_int32_t flags;
  1461. db_pgno_t pgno;
  1462. DB_LSN * lsn;
  1463. u_int32_t indx;
  1464. u_int32_t isdeleted;
  1465. const DBT *orig;
  1466. const DBT *repl;
  1467. u_int32_t prefix;
  1468. u_int32_t suffix;
  1469. {
  1470. DBT logrec;
  1471. DB_ENV *dbenv;
  1472. DB_LSN *lsnp, null_lsn;
  1473. u_int32_t zero;
  1474. u_int32_t uinttmp;
  1475. u_int32_t npad, rectype, txn_num;
  1476. int ret;
  1477. u_int8_t *bp;
  1479. dbenv = dbp->dbenv;
  1480. rectype = DB___bam_repl;
  1481. npad = 0;
  1483. if (txnid == NULL) {
  1484. txn_num = 0;
  1485. null_lsn.file = 0;
  1486. null_lsn.offset = 0;
  1487. lsnp = &null_lsn;
  1488. } else {
  1489. if (TAILQ_FIRST(&txnid->kids) != NULL &&
  1490.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  1491. return (ret);
  1492. txn_num = txnid->txnid;
  1493. lsnp = &txnid->last_lsn;
  1494. }
  1496. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  1497.     + sizeof(u_int32_t)
  1498.     + sizeof(u_int32_t)
  1499.     + sizeof(*lsn)
  1500.     + sizeof(u_int32_t)
  1501.     + sizeof(u_int32_t)
  1502.     + sizeof(u_int32_t) + (orig == NULL ? 0 : orig->size)
  1503.     + sizeof(u_int32_t) + (repl == NULL ? 0 : repl->size)
  1504.     + sizeof(u_int32_t)
  1505.     + sizeof(u_int32_t);
  1506. if (CRYPTO_ON(dbenv)) {
  1507. npad =
  1508.     ((DB_CIPHER *)dbenv->crypto_handle)->adj_size(logrec.size);
  1509. logrec.size += npad;
  1510. }
  1512. if ((ret = __os_malloc(dbenv,
  1513.     logrec.size, &logrec.data)) != 0)
  1514. return (ret);
  1516. if (npad > 0)
  1517. memset((u_int8_t *)logrec.data + logrec.size - npad, 0, npad);
  1519. bp = logrec.data;
  1521. memcpy(bp, &rectype, sizeof(rectype));
  1522. bp += sizeof(rectype);
  1524. memcpy(bp, &txn_num, sizeof(txn_num));
  1525. bp += sizeof(txn_num);
  1527. memcpy(bp, lsnp, sizeof(DB_LSN));
  1528. bp += sizeof(DB_LSN);
  1530. DB_ASSERT(dbp->log_filename != NULL);
  1531. if (dbp->log_filename->id == DB_LOGFILEID_INVALID &&
  1532.     (ret = __dbreg_lazy_id(dbp)) != 0)
  1533. return (ret);
  1535. uinttmp = (u_int32_t)dbp->log_filename->id;
  1536. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1537. bp += sizeof(uinttmp);
  1539. uinttmp = (u_int32_t)pgno;
  1540. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1541. bp += sizeof(uinttmp);
  1543. if (lsn != NULL)
  1544. memcpy(bp, lsn, sizeof(*lsn));
  1545. else
  1546. memset(bp, 0, sizeof(*lsn));
  1547. bp += sizeof(*lsn);
  1549. uinttmp = (u_int32_t)indx;
  1550. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1551. bp += sizeof(uinttmp);
  1553. uinttmp = (u_int32_t)isdeleted;
  1554. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1555. bp += sizeof(uinttmp);
  1557. if (orig == NULL) {
  1558. zero = 0;
  1559. memcpy(bp, &zero, sizeof(u_int32_t));
  1560. bp += sizeof(u_int32_t);
  1561. } else {
  1562. memcpy(bp, &orig->size, sizeof(orig->size));
  1563. bp += sizeof(orig->size);
  1564. memcpy(bp, orig->data, orig->size);
  1565. bp += orig->size;
  1566. }
  1568. if (repl == NULL) {
  1569. zero = 0;
  1570. memcpy(bp, &zero, sizeof(u_int32_t));
  1571. bp += sizeof(u_int32_t);
  1572. } else {
  1573. memcpy(bp, &repl->size, sizeof(repl->size));
  1574. bp += sizeof(repl->size);
  1575. memcpy(bp, repl->data, repl->size);
  1576. bp += repl->size;
  1577. }
  1579. uinttmp = (u_int32_t)prefix;
  1580. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1581. bp += sizeof(uinttmp);
  1583. uinttmp = (u_int32_t)suffix;
  1584. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1585. bp += sizeof(uinttmp);
  1587. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
  1588. ret = dbenv->log_put(dbenv,
  1589.    ret_lsnp, (DBT *)&logrec, flags | DB_NOCOPY);
  1590. if (txnid != NULL && ret == 0)
  1591. txnid->last_lsn = *ret_lsnp;
  1592. #ifdef LOG_DIAGNOSTIC
  1593. if (ret != 0)
  1594. (void)__bam_repl_print(dbenv,
  1595.     (DBT *)&logrec, ret_lsnp, NULL, NULL);
  1596. #endif
  1597. __os_free(dbenv, logrec.data);
  1598. return (ret);
  1599. }
  1601. /*
  1602.  * PUBLIC: int __bam_repl_getpgnos __P((DB_ENV *, DBT *, DB_LSN *,
  1603.  * PUBLIC:     db_recops, void *));
  1604.  */
  1605. int
  1606. __bam_repl_getpgnos(dbenv, rec, lsnp, notused1, summary)
  1607. DB_ENV *dbenv;
  1608. DBT *rec;
  1609. DB_LSN *lsnp;
  1610. db_recops notused1;
  1611. void *summary;
  1612. {
  1613. DB *dbp;
  1614. TXN_RECS *t;
  1615. __bam_repl_args *argp;
  1616. u_int32_t ret;
  1618. COMPQUIET(notused1, DB_TXN_ABORT);
  1620. argp = NULL;
  1621. t = (TXN_RECS *)summary;
  1623. if ((ret = __bam_repl_read(dbenv, rec->data, &argp)) != 0)
  1624. return (ret);
  1626. if ((ret = __dbreg_id_to_db(dbenv,
  1627.     argp->txnid, &dbp, argp->fileid, 0)) != 0)
  1628. goto err;
  1630. if ((ret = __rep_check_alloc(dbenv, t, 1)) != 0)
  1631. goto err;
  1633. t->array[t->npages].flags = 0;
  1634. t->array[t->npages].fid = argp->fileid;
  1635. t->array[t->npages].lsn = *lsnp;
  1636. t->array[t->npages].pgdesc.pgno = argp->pgno;
  1637. t->array[t->npages].pgdesc.type = DB_PAGE_LOCK;
  1638. memcpy(t->array[t->npages].pgdesc.fileid, dbp->fileid,
  1639.     DB_FILE_ID_LEN);
  1640. t->npages++;
  1642. err: if (argp != NULL)
  1643. __os_free(dbenv, argp);
  1644. return (ret);
  1645. }
  1647. /*
  1648.  * PUBLIC: int __bam_repl_print __P((DB_ENV *, DBT *, DB_LSN *,
  1649.  * PUBLIC:     db_recops, void *));
  1650.  */
  1651. int
  1652. __bam_repl_print(dbenv, dbtp, lsnp, notused2, notused3)
  1653. DB_ENV *dbenv;
  1654. DBT *dbtp;
  1655. DB_LSN *lsnp;
  1656. db_recops notused2;
  1657. void *notused3;
  1658. {
  1659. __bam_repl_args *argp;
  1660. u_int32_t i;
  1661. int ch;
  1662. int ret;
  1664. notused2 = DB_TXN_ABORT;
  1665. notused3 = NULL;
  1667. if ((ret = __bam_repl_read(dbenv, dbtp->data, &argp)) != 0)
  1668. return (ret);
  1669. (void)printf(
  1670.     "[%lu][%lu]__bam_repl: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  1671.     (u_long)lsnp->file,
  1672.     (u_long)lsnp->offset,
  1673.     (u_long)argp->type,
  1674.     (u_long)argp->txnid->txnid,
  1675.     (u_long)argp->prev_lsn.file,
  1676.     (u_long)argp->prev_lsn.offset);
  1677. (void)printf("tfileid: %ldn", (long)argp->fileid);
  1678. (void)printf("tpgno: %lun", (u_long)argp->pgno);
  1679. (void)printf("tlsn: [%lu][%lu]n",
  1680.     (u_long)argp->lsn.file, (u_long)argp->lsn.offset);
  1681. (void)printf("tindx: %lun", (u_long)argp->indx);
  1682. (void)printf("tisdeleted: %lun", (u_long)argp->isdeleted);
  1683. (void)printf("torig: ");
  1684. for (i = 0; i < argp->orig.size; i++) {
  1685. ch = ((u_int8_t *)argp->orig.data)[i];
  1686. printf(isprint(ch) || ch == 0x0a ? "%c" : "%#x ", ch);
  1687. }
  1688. (void)printf("n");
  1689. (void)printf("trepl: ");
  1690. for (i = 0; i < argp->repl.size; i++) {
  1691. ch = ((u_int8_t *)argp->repl.data)[i];
  1692. printf(isprint(ch) || ch == 0x0a ? "%c" : "%#x ", ch);
  1693. }
  1694. (void)printf("n");
  1695. (void)printf("tprefix: %lun", (u_long)argp->prefix);
  1696. (void)printf("tsuffix: %lun", (u_long)argp->suffix);
  1697. (void)printf("n");
  1698. __os_free(dbenv, argp);
  1699. return (0);
  1700. }
  1702. /*
  1703.  * PUBLIC: int __bam_repl_read __P((DB_ENV *, void *, __bam_repl_args **));
  1704.  */
  1705. int
  1706. __bam_repl_read(dbenv, recbuf, argpp)
  1707. DB_ENV *dbenv;
  1708. void *recbuf;
  1709. __bam_repl_args **argpp;
  1710. {
  1711. __bam_repl_args *argp;
  1712. u_int32_t uinttmp;
  1713. u_int8_t *bp;
  1714. int ret;
  1716. if ((ret = __os_malloc(dbenv,
  1717.     sizeof(__bam_repl_args) + sizeof(DB_TXN), &argp)) != 0)
  1718. return (ret);
  1720. argp->txnid = (DB_TXN *)&argp[1];
  1722. bp = recbuf;
  1723. memcpy(&argp->type, bp, sizeof(argp->type));
  1724. bp += sizeof(argp->type);
  1726. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  1727. bp += sizeof(argp->txnid->txnid);
  1729. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  1730. bp += sizeof(DB_LSN);
  1732. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1733. argp->fileid = (int32_t)uinttmp;
  1734. bp += sizeof(uinttmp);
  1736. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1737. argp->pgno = (db_pgno_t)uinttmp;
  1738. bp += sizeof(uinttmp);
  1740. memcpy(&argp->lsn, bp,  sizeof(argp->lsn));
  1741. bp += sizeof(argp->lsn);
  1743. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1744. argp->indx = (u_int32_t)uinttmp;
  1745. bp += sizeof(uinttmp);
  1747. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1748. argp->isdeleted = (u_int32_t)uinttmp;
  1749. bp += sizeof(uinttmp);
  1751. memset(&argp->orig, 0, sizeof(argp->orig));
  1752. memcpy(&argp->orig.size, bp, sizeof(u_int32_t));
  1753. bp += sizeof(u_int32_t);
  1754. argp->orig.data = bp;
  1755. bp += argp->orig.size;
  1757. memset(&argp->repl, 0, sizeof(argp->repl));
  1758. memcpy(&argp->repl.size, bp, sizeof(u_int32_t));
  1759. bp += sizeof(u_int32_t);
  1760. argp->repl.data = bp;
  1761. bp += argp->repl.size;
  1763. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1764. argp->prefix = (u_int32_t)uinttmp;
  1765. bp += sizeof(uinttmp);
  1767. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1768. argp->suffix = (u_int32_t)uinttmp;
  1769. bp += sizeof(uinttmp);
  1771. *argpp = argp;
  1772. return (0);
  1773. }
  1775. /*
  1776.  * PUBLIC: int __bam_root_log __P((DB *, DB_TXN *, DB_LSN *,
  1777.  * PUBLIC:     u_int32_t, db_pgno_t, db_pgno_t, DB_LSN *));
  1778.  */
  1779. int
  1780. __bam_root_log(dbp, txnid, ret_lsnp, flags, meta_pgno, root_pgno, meta_lsn)
  1781. DB *dbp;
  1782. DB_TXN *txnid;
  1783. DB_LSN *ret_lsnp;
  1784. u_int32_t flags;
  1785. db_pgno_t meta_pgno;
  1786. db_pgno_t root_pgno;
  1787. DB_LSN * meta_lsn;
  1788. {
  1789. DBT logrec;
  1790. DB_ENV *dbenv;
  1791. DB_LSN *lsnp, null_lsn;
  1792. u_int32_t uinttmp;
  1793. u_int32_t npad, rectype, txn_num;
  1794. int ret;
  1795. u_int8_t *bp;
  1797. dbenv = dbp->dbenv;
  1798. rectype = DB___bam_root;
  1799. npad = 0;
  1801. if (txnid == NULL) {
  1802. txn_num = 0;
  1803. null_lsn.file = 0;
  1804. null_lsn.offset = 0;
  1805. lsnp = &null_lsn;
  1806. } else {
  1807. if (TAILQ_FIRST(&txnid->kids) != NULL &&
  1808.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  1809. return (ret);
  1810. txn_num = txnid->txnid;
  1811. lsnp = &txnid->last_lsn;
  1812. }
  1814. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  1815.     + sizeof(u_int32_t)
  1816.     + sizeof(u_int32_t)
  1817.     + sizeof(u_int32_t)
  1818.     + sizeof(*meta_lsn);
  1819. if (CRYPTO_ON(dbenv)) {
  1820. npad =
  1821.     ((DB_CIPHER *)dbenv->crypto_handle)->adj_size(logrec.size);
  1822. logrec.size += npad;
  1823. }
  1825. if ((ret = __os_malloc(dbenv,
  1826.     logrec.size, &logrec.data)) != 0)
  1827. return (ret);
  1829. if (npad > 0)
  1830. memset((u_int8_t *)logrec.data + logrec.size - npad, 0, npad);
  1832. bp = logrec.data;
  1834. memcpy(bp, &rectype, sizeof(rectype));
  1835. bp += sizeof(rectype);
  1837. memcpy(bp, &txn_num, sizeof(txn_num));
  1838. bp += sizeof(txn_num);
  1840. memcpy(bp, lsnp, sizeof(DB_LSN));
  1841. bp += sizeof(DB_LSN);
  1843. DB_ASSERT(dbp->log_filename != NULL);
  1844. if (dbp->log_filename->id == DB_LOGFILEID_INVALID &&
  1845.     (ret = __dbreg_lazy_id(dbp)) != 0)
  1846. return (ret);
  1848. uinttmp = (u_int32_t)dbp->log_filename->id;
  1849. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1850. bp += sizeof(uinttmp);
  1852. uinttmp = (u_int32_t)meta_pgno;
  1853. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1854. bp += sizeof(uinttmp);
  1856. uinttmp = (u_int32_t)root_pgno;
  1857. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1858. bp += sizeof(uinttmp);
  1860. if (meta_lsn != NULL)
  1861. memcpy(bp, meta_lsn, sizeof(*meta_lsn));
  1862. else
  1863. memset(bp, 0, sizeof(*meta_lsn));
  1864. bp += sizeof(*meta_lsn);
  1866. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
  1867. ret = dbenv->log_put(dbenv,
  1868.    ret_lsnp, (DBT *)&logrec, flags | DB_NOCOPY);
  1869. if (txnid != NULL && ret == 0)
  1870. txnid->last_lsn = *ret_lsnp;
  1871. #ifdef LOG_DIAGNOSTIC
  1872. if (ret != 0)
  1873. (void)__bam_root_print(dbenv,
  1874.     (DBT *)&logrec, ret_lsnp, NULL, NULL);
  1875. #endif
  1876. __os_free(dbenv, logrec.data);
  1877. return (ret);
  1878. }
  1880. /*
  1881.  * PUBLIC: int __bam_root_getpgnos __P((DB_ENV *, DBT *, DB_LSN *,
  1882.  * PUBLIC:     db_recops, void *));
  1883.  */
  1884. int
  1885. __bam_root_getpgnos(dbenv, rec, lsnp, notused1, summary)
  1886. DB_ENV *dbenv;
  1887. DBT *rec;
  1888. DB_LSN *lsnp;
  1889. db_recops notused1;
  1890. void *summary;
  1891. {
  1892. DB *dbp;
  1893. TXN_RECS *t;
  1894. __bam_root_args *argp;
  1895. u_int32_t ret;
  1897. COMPQUIET(notused1, DB_TXN_ABORT);
  1899. argp = NULL;
  1900. t = (TXN_RECS *)summary;
  1902. if ((ret = __bam_root_read(dbenv, rec->data, &argp)) != 0)
  1903. return (ret);
  1905. if ((ret = __dbreg_id_to_db(dbenv,
  1906.     argp->txnid, &dbp, argp->fileid, 0)) != 0)
  1907. goto err;
  1909. if ((ret = __rep_check_alloc(dbenv, t, 2)) != 0)
  1910. goto err;
  1912. t->array[t->npages].flags = 0;
  1913. t->array[t->npages].fid = argp->fileid;
  1914. t->array[t->npages].lsn = *lsnp;
  1915. t->array[t->npages].pgdesc.pgno = argp->meta_pgno;
  1916. t->array[t->npages].pgdesc.type = DB_PAGE_LOCK;
  1917. memcpy(t->array[t->npages].pgdesc.fileid, dbp->fileid,
  1918.     DB_FILE_ID_LEN);
  1919. t->npages++;
  1920. t->array[t->npages].flags = 0;
  1921. t->array[t->npages].fid = argp->fileid;
  1922. t->array[t->npages].lsn = *lsnp;
  1923. t->array[t->npages].pgdesc.pgno = argp->root_pgno;
  1924. t->array[t->npages].pgdesc.type = DB_PAGE_LOCK;
  1925. memcpy(t->array[t->npages].pgdesc.fileid, dbp->fileid,
  1926.     DB_FILE_ID_LEN);
  1927. t->npages++;
  1929. err: if (argp != NULL)
  1930. __os_free(dbenv, argp);
  1931. return (ret);
  1932. }
  1934. /*
  1935.  * PUBLIC: int __bam_root_print __P((DB_ENV *, DBT *, DB_LSN *,
  1936.  * PUBLIC:     db_recops, void *));
  1937.  */
  1938. int
  1939. __bam_root_print(dbenv, dbtp, lsnp, notused2, notused3)
  1940. DB_ENV *dbenv;
  1941. DBT *dbtp;
  1942. DB_LSN *lsnp;
  1943. db_recops notused2;
  1944. void *notused3;
  1945. {
  1946. __bam_root_args *argp;
  1947. int ret;
  1949. notused2 = DB_TXN_ABORT;
  1950. notused3 = NULL;
  1952. if ((ret = __bam_root_read(dbenv, dbtp->data, &argp)) != 0)
  1953. return (ret);
  1954. (void)printf(
  1955.     "[%lu][%lu]__bam_root: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  1956.     (u_long)lsnp->file,
  1957.     (u_long)lsnp->offset,
  1958.     (u_long)argp->type,
  1959.     (u_long)argp->txnid->txnid,
  1960.     (u_long)argp->prev_lsn.file,
  1961.     (u_long)argp->prev_lsn.offset);
  1962. (void)printf("tfileid: %ldn", (long)argp->fileid);
  1963. (void)printf("tmeta_pgno: %lun", (u_long)argp->meta_pgno);
  1964. (void)printf("troot_pgno: %lun", (u_long)argp->root_pgno);
  1965. (void)printf("tmeta_lsn: [%lu][%lu]n",
  1966.     (u_long)argp->meta_lsn.file, (u_long)argp->meta_lsn.offset);
  1967. (void)printf("n");
  1968. __os_free(dbenv, argp);
  1969. return (0);
  1970. }
  1972. /*
  1973.  * PUBLIC: int __bam_root_read __P((DB_ENV *, void *, __bam_root_args **));
  1974.  */
  1975. int
  1976. __bam_root_read(dbenv, recbuf, argpp)
  1977. DB_ENV *dbenv;
  1978. void *recbuf;
  1979. __bam_root_args **argpp;
  1980. {
  1981. __bam_root_args *argp;
  1982. u_int32_t uinttmp;
  1983. u_int8_t *bp;
  1984. int ret;
  1986. if ((ret = __os_malloc(dbenv,
  1987.     sizeof(__bam_root_args) + sizeof(DB_TXN), &argp)) != 0)
  1988. return (ret);
  1990. argp->txnid = (DB_TXN *)&argp[1];
  1992. bp = recbuf;
  1993. memcpy(&argp->type, bp, sizeof(argp->type));
  1994. bp += sizeof(argp->type);
  1996. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  1997. bp += sizeof(argp->txnid->txnid);
  1999. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  2000. bp += sizeof(DB_LSN);
  2002. memcpy(&uinttmp, bp, sizeof(uinttmp));
  2003. argp->fileid = (int32_t)uinttmp;
  2004. bp += sizeof(uinttmp);
  2006. memcpy(&uinttmp, bp, sizeof(uinttmp));
  2007. argp->meta_pgno = (db_pgno_t)uinttmp;
  2008. bp += sizeof(uinttmp);
  2010. memcpy(&uinttmp, bp, sizeof(uinttmp));
  2011. argp->root_pgno = (db_pgno_t)uinttmp;
  2012. bp += sizeof(uinttmp);
  2014. memcpy(&argp->meta_lsn, bp,  sizeof(argp->meta_lsn));
  2015. bp += sizeof(argp->meta_lsn);
  2017. *argpp = argp;
  2018. return (0);
  2019. }
  2021. /*
  2022.  * PUBLIC: int __bam_curadj_log __P((DB *, DB_TXN *, DB_LSN *,
  2023.  * PUBLIC:     u_int32_t, db_ca_mode, db_pgno_t, db_pgno_t, db_pgno_t,
  2024.  * PUBLIC:     u_int32_t, u_int32_t, u_int32_t));
  2025.  */
  2026. int
  2027. __bam_curadj_log(dbp, txnid, ret_lsnp, flags, mode, from_pgno, to_pgno, left_pgno, first_indx,
  2028.     from_indx, to_indx)
  2029. DB *dbp;
  2030. DB_TXN *txnid;
  2031. DB_LSN *ret_lsnp;
  2032. u_int32_t flags;
  2033. db_ca_mode mode;
  2034. db_pgno_t from_pgno;
  2035. db_pgno_t to_pgno;
  2036. db_pgno_t left_pgno;
  2037. u_int32_t first_indx;
  2038. u_int32_t from_indx;
  2039. u_int32_t to_indx;
  2040. {
  2041. DBT logrec;
  2042. DB_ENV *dbenv;
  2043. DB_LSN *lsnp, null_lsn;
  2044. u_int32_t uinttmp;
  2045. u_int32_t npad, rectype, txn_num;
  2046. int ret;
  2047. u_int8_t *bp;
  2049. dbenv = dbp->dbenv;
  2050. rectype = DB___bam_curadj;
  2051. npad = 0;
  2053. if (txnid == NULL) {
  2054. txn_num = 0;
  2055. null_lsn.file = 0;
  2056. null_lsn.offset = 0;
  2057. lsnp = &null_lsn;
  2058. } else {
  2059. if (TAILQ_FIRST(&txnid->kids) != NULL &&
  2060.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  2061. return (ret);
  2062. txn_num = txnid->txnid;
  2063. lsnp = &txnid->last_lsn;
  2064. }
  2066. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  2067.     + sizeof(u_int32_t)
  2068.     + sizeof(u_int32_t)
  2069.     + sizeof(u_int32_t)
  2070.     + sizeof(u_int32_t)
  2071.     + sizeof(u_int32_t)
  2072.     + sizeof(u_int32_t)
  2073.     + sizeof(u_int32_t)
  2074.     + sizeof(u_int32_t);
  2075. if (CRYPTO_ON(dbenv)) {
  2076. npad =
  2077.     ((DB_CIPHER *)dbenv->crypto_handle)->adj_size(logrec.size);
  2078. logrec.size += npad;
  2079. }
  2081. if ((ret = __os_malloc(dbenv,
  2082.     logrec.size, &logrec.data)) != 0)
  2083. return (ret);
  2085. if (npad > 0)
  2086. memset((u_int8_t *)logrec.data + logrec.size - npad, 0, npad);
  2088. bp = logrec.data;
  2090. memcpy(bp, &rectype, sizeof(rectype));
  2091. bp += sizeof(rectype);
  2093. memcpy(bp, &txn_num, sizeof(txn_num));
  2094. bp += sizeof(txn_num);
  2096. memcpy(bp, lsnp, sizeof(DB_LSN));
  2097. bp += sizeof(DB_LSN);
  2099. DB_ASSERT(dbp->log_filename != NULL);
  2100. if (dbp->log_filename->id == DB_LOGFILEID_INVALID &&
  2101.     (ret = __dbreg_lazy_id(dbp)) != 0)
  2102. return (ret);
  2104. uinttmp = (u_int32_t)dbp->log_filename->id;
  2105. memcpy(bp, &uinttmp, sizeof(uinttmp));
  2106. bp += sizeof(uinttmp);
  2108. uinttmp = (u_int32_t)mode;
  2109. memcpy(bp, &uinttmp, sizeof(uinttmp));
  2110. bp += sizeof(uinttmp);
  2112. uinttmp = (u_int32_t)from_pgno;
  2113. memcpy(bp, &uinttmp, sizeof(uinttmp));
  2114. bp += sizeof(uinttmp);
  2116. uinttmp = (u_int32_t)to_pgno;
  2117. memcpy(bp, &uinttmp, sizeof(uinttmp));
  2118. bp += sizeof(uinttmp);
  2120. uinttmp = (u_int32_t)left_pgno;
  2121. memcpy(bp, &uinttmp, sizeof(uinttmp));
  2122. bp += sizeof(uinttmp);
  2124. uinttmp = (u_int32_t)first_indx;
  2125. memcpy(bp, &uinttmp, sizeof(uinttmp));
  2126. bp += sizeof(uinttmp);
  2128. uinttmp = (u_int32_t)from_indx;
  2129. memcpy(bp, &uinttmp, sizeof(uinttmp));
  2130. bp += sizeof(uinttmp);
  2132. uinttmp = (u_int32_t)to_indx;
  2133. memcpy(bp, &uinttmp, sizeof(uinttmp));
  2134. bp += sizeof(uinttmp);
  2136. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
  2137. ret = dbenv->log_put(dbenv,
  2138.    ret_lsnp, (DBT *)&logrec, flags | DB_NOCOPY);
  2139. if (txnid != NULL && ret == 0)
  2140. txnid->last_lsn = *ret_lsnp;
  2141. #ifdef LOG_DIAGNOSTIC
  2142. if (ret != 0)
  2143. (void)__bam_curadj_print(dbenv,
  2144.     (DBT *)&logrec, ret_lsnp, NULL, NULL);
  2145. #endif
  2146. __os_free(dbenv, logrec.data);
  2147. return (ret);
  2148. }
  2150. /*
  2151.  * PUBLIC: int __bam_curadj_getpgnos __P((DB_ENV *, DBT *, DB_LSN *,
  2152.  * PUBLIC:     db_recops, void *));
  2153.  */
  2154. int
  2155. __bam_curadj_getpgnos(dbenv, rec, lsnp, notused1, summary)
  2156. DB_ENV *dbenv;
  2157. DBT *rec;
  2158. DB_LSN *lsnp;
  2159. db_recops notused1;
  2160. void *summary;
  2161. {
  2162. TXN_RECS *t;
  2163. int ret;
  2164. COMPQUIET(rec, NULL);
  2165. COMPQUIET(notused1, DB_TXN_ABORT);
  2167. t = (TXN_RECS *)summary;
  2169. if ((ret = __rep_check_alloc(dbenv, t, 1)) != 0)
  2170. return (ret);
  2172. t->array[t->npages].flags = LSN_PAGE_NOLOCK;
  2173. t->array[t->npages].lsn = *lsnp;
  2174. t->array[t->npages].fid = DB_LOGFILEID_INVALID;
  2175. memset(&t->array[t->npages].pgdesc, 0,
  2176.     sizeof(t->array[t->npages].pgdesc));
  2178. t->npages++;
  2180. return (0);
  2181. }
  2183. /*
  2184.  * PUBLIC: int __bam_curadj_print __P((DB_ENV *, DBT *, DB_LSN *,
  2185.  * PUBLIC:     db_recops, void *));
  2186.  */
  2187. int
  2188. __bam_curadj_print(dbenv, dbtp, lsnp, notused2, notused3)
  2189. DB_ENV *dbenv;
  2190. DBT *dbtp;
  2191. DB_LSN *lsnp;
  2192. db_recops notused2;
  2193. void *notused3;
  2194. {
  2195. __bam_curadj_args *argp;
  2196. int ret;
  2198. notused2 = DB_TXN_ABORT;
  2199. notused3 = NULL;
  2201. if ((ret = __bam_curadj_read(dbenv, dbtp->data, &argp)) != 0)
  2202. return (ret);
  2203. (void)printf(
  2204.     "[%lu][%lu]__bam_curadj: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  2205.     (u_long)lsnp->file,
  2206.     (u_long)lsnp->offset,
  2207.     (u_long)argp->type,
  2208.     (u_long)argp->txnid->txnid,
  2209.     (u_long)argp->prev_lsn.file,
  2210.     (u_long)argp->prev_lsn.offset);
  2211. (void)printf("tfileid: %ldn", (long)argp->fileid);
  2212. (void)printf("tmode: %ldn", (long)argp->mode);
  2213. (void)printf("tfrom_pgno: %lun", (u_long)argp->from_pgno);
  2214. (void)printf("tto_pgno: %lun", (u_long)argp->to_pgno);
  2215. (void)printf("tleft_pgno: %lun", (u_long)argp->left_pgno);
  2216. (void)printf("tfirst_indx: %lun", (u_long)argp->first_indx);
  2217. (void)printf("tfrom_indx: %lun", (u_long)argp->from_indx);
  2218. (void)printf("tto_indx: %lun", (u_long)argp->to_indx);
  2219. (void)printf("n");
  2220. __os_free(dbenv, argp);
  2221. return (0);
  2222. }
  2224. /*
  2225.  * PUBLIC: int __bam_curadj_read __P((DB_ENV *, void *, __bam_curadj_args **));
  2226.  */
  2227. int
  2228. __bam_curadj_read(dbenv, recbuf, argpp)
  2229. DB_ENV *dbenv;
  2230. void *recbuf;
  2231. __bam_curadj_args **argpp;
  2232. {
  2233. __bam_curadj_args *argp;
  2234. u_int32_t uinttmp;
  2235. u_int8_t *bp;
  2236. int ret;
  2238. if ((ret = __os_malloc(dbenv,
  2239.     sizeof(__bam_curadj_args) + sizeof(DB_TXN), &argp)) != 0)
  2240. return (ret);
  2242. argp->txnid = (DB_TXN *)&argp[1];
  2244. bp = recbuf;
  2245. memcpy(&argp->type, bp, sizeof(argp->type));
  2246. bp += sizeof(argp->type);
  2248. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  2249. bp += sizeof(argp->txnid->txnid);
  2251. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  2252. bp += sizeof(DB_LSN);
  2254. memcpy(&uinttmp, bp, sizeof(uinttmp));
  2255. argp->fileid = (int32_t)uinttmp;
  2256. bp += sizeof(uinttmp);
  2258. memcpy(&uinttmp, bp, sizeof(uinttmp));
  2259. argp->mode = (db_ca_mode)uinttmp;
  2260. bp += sizeof(uinttmp);
  2262. memcpy(&uinttmp, bp, sizeof(uinttmp));
  2263. argp->from_pgno = (db_pgno_t)uinttmp;
  2264. bp += sizeof(uinttmp);
  2266. memcpy(&uinttmp, bp, sizeof(uinttmp));
  2267. argp->to_pgno = (db_pgno_t)uinttmp;
  2268. bp += sizeof(uinttmp);
  2270. memcpy(&uinttmp, bp, sizeof(uinttmp));
  2271. argp->left_pgno = (db_pgno_t)uinttmp;
  2272. bp += sizeof(uinttmp);
  2274. memcpy(&uinttmp, bp, sizeof(uinttmp));
  2275. argp->first_indx = (u_int32_t)uinttmp;
  2276. bp += sizeof(uinttmp);
  2278. memcpy(&uinttmp, bp, sizeof(uinttmp));
  2279. argp->from_indx = (u_int32_t)uinttmp;
  2280. bp += sizeof(uinttmp);
  2282. memcpy(&uinttmp, bp, sizeof(uinttmp));
  2283. argp->to_indx = (u_int32_t)uinttmp;
  2284. bp += sizeof(uinttmp);
  2286. *argpp = argp;
  2287. return (0);
  2288. }
  2290. /*
  2291.  * PUBLIC: int __bam_rcuradj_log __P((DB *, DB_TXN *, DB_LSN *,
  2292.  * PUBLIC:     u_int32_t, ca_recno_arg, db_pgno_t, db_recno_t, u_int32_t));
  2293.  */
  2294. int
  2295. __bam_rcuradj_log(dbp, txnid, ret_lsnp, flags, mode, root, recno, order)
  2296. DB *dbp;
  2297. DB_TXN *txnid;
  2298. DB_LSN *ret_lsnp;
  2299. u_int32_t flags;
  2300. ca_recno_arg mode;
  2301. db_pgno_t root;
  2302. db_recno_t recno;
  2303. u_int32_t order;
  2304. {
  2305. DBT logrec;
  2306. DB_ENV *dbenv;
  2307. DB_LSN *lsnp, null_lsn;
  2308. u_int32_t uinttmp;
  2309. u_int32_t npad, rectype, txn_num;
  2310. int ret;
  2311. u_int8_t *bp;
  2313. dbenv = dbp->dbenv;
  2314. rectype = DB___bam_rcuradj;
  2315. npad = 0;
  2317. if (txnid == NULL) {
  2318. txn_num = 0;
  2319. null_lsn.file = 0;
  2320. null_lsn.offset = 0;
  2321. lsnp = &null_lsn;
  2322. } else {
  2323. if (TAILQ_FIRST(&txnid->kids) != NULL &&
  2324.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  2325. return (ret);
  2326. txn_num = txnid->txnid;
  2327. lsnp = &txnid->last_lsn;
  2328. }
  2330. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  2331.     + sizeof(u_int32_t)
  2332.     + sizeof(u_int32_t)
  2333.     + sizeof(u_int32_t)
  2334.     + sizeof(u_int32_t)
  2335.     + sizeof(u_int32_t);
  2336. if (CRYPTO_ON(dbenv)) {
  2337. npad =
  2338.     ((DB_CIPHER *)dbenv->crypto_handle)->adj_size(logrec.size);
  2339. logrec.size += npad;
  2340. }
  2342. if ((ret = __os_malloc(dbenv,
  2343.     logrec.size, &logrec.data)) != 0)
  2344. return (ret);
  2346. if (npad > 0)
  2347. memset((u_int8_t *)logrec.data + logrec.size - npad, 0, npad);
  2349. bp = logrec.data;
  2351. memcpy(bp, &rectype, sizeof(rectype));
  2352. bp += sizeof(rectype);
  2354. memcpy(bp, &txn_num, sizeof(txn_num));
  2355. bp += sizeof(txn_num);
  2357. memcpy(bp, lsnp, sizeof(DB_LSN));
  2358. bp += sizeof(DB_LSN);
  2360. DB_ASSERT(dbp->log_filename != NULL);
  2361. if (dbp->log_filename->id == DB_LOGFILEID_INVALID &&
  2362.     (ret = __dbreg_lazy_id(dbp)) != 0)
  2363. return (ret);
  2365. uinttmp = (u_int32_t)dbp->log_filename->id;
  2366. memcpy(bp, &uinttmp, sizeof(uinttmp));
  2367. bp += sizeof(uinttmp);
  2369. uinttmp = (u_int32_t)mode;
  2370. memcpy(bp, &uinttmp, sizeof(uinttmp));
  2371. bp += sizeof(uinttmp);
  2373. uinttmp = (u_int32_t)root;
  2374. memcpy(bp, &uinttmp, sizeof(uinttmp));
  2375. bp += sizeof(uinttmp);
  2377. uinttmp = (u_int32_t)recno;
  2378. memcpy(bp, &uinttmp, sizeof(uinttmp));
  2379. bp += sizeof(uinttmp);
  2381. uinttmp = (u_int32_t)order;
  2382. memcpy(bp, &uinttmp, sizeof(uinttmp));
  2383. bp += sizeof(uinttmp);
  2385. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
  2386. ret = dbenv->log_put(dbenv,
  2387.    ret_lsnp, (DBT *)&logrec, flags | DB_NOCOPY);
  2388. if (txnid != NULL && ret == 0)
  2389. txnid->last_lsn = *ret_lsnp;
  2390. #ifdef LOG_DIAGNOSTIC
  2391. if (ret != 0)
  2392. (void)__bam_rcuradj_print(dbenv,
  2393.     (DBT *)&logrec, ret_lsnp, NULL, NULL);
  2394. #endif
  2395. __os_free(dbenv, logrec.data);
  2396. return (ret);
  2397. }
  2399. /*
  2400.  * PUBLIC: int __bam_rcuradj_getpgnos __P((DB_ENV *, DBT *, DB_LSN *,
  2401.  * PUBLIC:     db_recops, void *));
  2402.  */
  2403. int
  2404. __bam_rcuradj_getpgnos(dbenv, rec, lsnp, notused1, summary)
  2405. DB_ENV *dbenv;
  2406. DBT *rec;
  2407. DB_LSN *lsnp;
  2408. db_recops notused1;
  2409. void *summary;
  2410. {
  2411. TXN_RECS *t;
  2412. int ret;
  2413. COMPQUIET(rec, NULL);
  2414. COMPQUIET(notused1, DB_TXN_ABORT);
  2416. t = (TXN_RECS *)summary;
  2418. if ((ret = __rep_check_alloc(dbenv, t, 1)) != 0)
  2419. return (ret);
  2421. t->array[t->npages].flags = LSN_PAGE_NOLOCK;
  2422. t->array[t->npages].lsn = *lsnp;
  2423. t->array[t->npages].fid = DB_LOGFILEID_INVALID;
  2424. memset(&t->array[t->npages].pgdesc, 0,
  2425.     sizeof(t->array[t->npages].pgdesc));
  2427. t->npages++;
  2429. return (0);
  2430. }
  2432. /*
  2433.  * PUBLIC: int __bam_rcuradj_print __P((DB_ENV *, DBT *, DB_LSN *,
  2434.  * PUBLIC:     db_recops, void *));
  2435.  */
  2436. int
  2437. __bam_rcuradj_print(dbenv, dbtp, lsnp, notused2, notused3)
  2438. DB_ENV *dbenv;
  2439. DBT *dbtp;
  2440. DB_LSN *lsnp;
  2441. db_recops notused2;
  2442. void *notused3;
  2443. {
  2444. __bam_rcuradj_args *argp;
  2445. int ret;
  2447. notused2 = DB_TXN_ABORT;
  2448. notused3 = NULL;
  2450. if ((ret = __bam_rcuradj_read(dbenv, dbtp->data, &argp)) != 0)
  2451. return (ret);
  2452. (void)printf(
  2453.     "[%lu][%lu]__bam_rcuradj: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  2454.     (u_long)lsnp->file,
  2455.     (u_long)lsnp->offset,
  2456.     (u_long)argp->type,
  2457.     (u_long)argp->txnid->txnid,
  2458.     (u_long)argp->prev_lsn.file,
  2459.     (u_long)argp->prev_lsn.offset);
  2460. (void)printf("tfileid: %ldn", (long)argp->fileid);
  2461. (void)printf("tmode: %ldn", (long)argp->mode);
  2462. (void)printf("troot: %ldn", (long)argp->root);
  2463. (void)printf("trecno: %ldn", (long)argp->recno);
  2464. (void)printf("torder: %ldn", (long)argp->order);
  2465. (void)printf("n");
  2466. __os_free(dbenv, argp);
  2467. return (0);
  2468. }
  2470. /*
  2471.  * PUBLIC: int __bam_rcuradj_read __P((DB_ENV *, void *,
  2472.  * PUBLIC:     __bam_rcuradj_args **));
  2473.  */
  2474. int
  2475. __bam_rcuradj_read(dbenv, recbuf, argpp)
  2476. DB_ENV *dbenv;
  2477. void *recbuf;
  2478. __bam_rcuradj_args **argpp;
  2479. {
  2480. __bam_rcuradj_args *argp;
  2481. u_int32_t uinttmp;
  2482. u_int8_t *bp;
  2483. int ret;
  2485. if ((ret = __os_malloc(dbenv,
  2486.     sizeof(__bam_rcuradj_args) + sizeof(DB_TXN), &argp)) != 0)
  2487. return (ret);
  2489. argp->txnid = (DB_TXN *)&argp[1];
  2491. bp = recbuf;
  2492. memcpy(&argp->type, bp, sizeof(argp->type));
  2493. bp += sizeof(argp->type);
  2495. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  2496. bp += sizeof(argp->txnid->txnid);
  2498. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  2499. bp += sizeof(DB_LSN);
  2501. memcpy(&uinttmp, bp, sizeof(uinttmp));
  2502. argp->fileid = (int32_t)uinttmp;
  2503. bp += sizeof(uinttmp);
  2505. memcpy(&uinttmp, bp, sizeof(uinttmp));
  2506. argp->mode = (ca_recno_arg)uinttmp;
  2507. bp += sizeof(uinttmp);
  2509. memcpy(&uinttmp, bp, sizeof(uinttmp));
  2510. argp->root = (db_pgno_t)uinttmp;
  2511. bp += sizeof(uinttmp);
  2513. memcpy(&uinttmp, bp, sizeof(uinttmp));
  2514. argp->recno = (db_recno_t)uinttmp;
  2515. bp += sizeof(uinttmp);
  2517. memcpy(&uinttmp, bp, sizeof(uinttmp));
  2518. argp->order = (u_int32_t)uinttmp;
  2519. bp += sizeof(uinttmp);
  2521. *argpp = argp;
  2522. return (0);
  2523. }
  2525. /*
  2526.  * PUBLIC: int __bam_init_print __P((DB_ENV *, int (***)(DB_ENV *,
  2527.  * PUBLIC:     DBT *, DB_LSN *, db_recops, void *), size_t *));
  2528.  */
  2529. int
  2530. __bam_init_print(dbenv, dtabp, dtabsizep)
  2531. DB_ENV *dbenv;
  2532. int (***dtabp)__P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  2533. size_t *dtabsizep;
  2534. {
  2535. int ret;
  2537. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2538.     __bam_split_print, DB___bam_split)) != 0)
  2539. return (ret);
  2540. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2541.     __bam_rsplit_print, DB___bam_rsplit)) != 0)
  2542. return (ret);
  2543. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2544.     __bam_adj_print, DB___bam_adj)) != 0)
  2545. return (ret);
  2546. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2547.     __bam_cadjust_print, DB___bam_cadjust)) != 0)
  2548. return (ret);
  2549. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2550.     __bam_cdel_print, DB___bam_cdel)) != 0)
  2551. return (ret);
  2552. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2553.     __bam_repl_print, DB___bam_repl)) != 0)
  2554. return (ret);
  2555. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2556.     __bam_root_print, DB___bam_root)) != 0)
  2557. return (ret);
  2558. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2559.     __bam_curadj_print, DB___bam_curadj)) != 0)
  2560. return (ret);
  2561. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2562.     __bam_rcuradj_print, DB___bam_rcuradj)) != 0)
  2563. return (ret);
  2564. return (0);
  2565. }
  2567. /*
  2568.  * PUBLIC: int __bam_init_getpgnos __P((DB_ENV *, int (***)(DB_ENV *,
  2569.  * PUBLIC:     DBT *, DB_LSN *, db_recops, void *), size_t *));
  2570.  */
  2571. int
  2572. __bam_init_getpgnos(dbenv, dtabp, dtabsizep)
  2573. DB_ENV *dbenv;
  2574. int (***dtabp)__P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  2575. size_t *dtabsizep;
  2576. {
  2577. int ret;
  2579. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2580.     __bam_split_getpgnos, DB___bam_split)) != 0)
  2581. return (ret);
  2582. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2583.     __bam_rsplit_getpgnos, DB___bam_rsplit)) != 0)
  2584. return (ret);
  2585. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2586.     __bam_adj_getpgnos, DB___bam_adj)) != 0)
  2587. return (ret);
  2588. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2589.     __bam_cadjust_getpgnos, DB___bam_cadjust)) != 0)
  2590. return (ret);
  2591. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2592.     __bam_cdel_getpgnos, DB___bam_cdel)) != 0)
  2593. return (ret);
  2594. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2595.     __bam_repl_getpgnos, DB___bam_repl)) != 0)
  2596. return (ret);
  2597. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2598.     __bam_root_getpgnos, DB___bam_root)) != 0)
  2599. return (ret);
  2600. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2601.     __bam_curadj_getpgnos, DB___bam_curadj)) != 0)
  2602. return (ret);
  2603. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2604.     __bam_rcuradj_getpgnos, DB___bam_rcuradj)) != 0)
  2605. return (ret);
  2606. return (0);
  2607. }
  2609. /*
  2610.  * PUBLIC: int __bam_init_recover __P((DB_ENV *, int (***)(DB_ENV *,
  2611.  * PUBLIC:     DBT *, DB_LSN *, db_recops, void *), size_t *));
  2612.  */
  2613. int
  2614. __bam_init_recover(dbenv, dtabp, dtabsizep)
  2615. DB_ENV *dbenv;
  2616. int (***dtabp)__P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  2617. size_t *dtabsizep;
  2618. {
  2619. int ret;
  2621. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2622.     __bam_split_recover, DB___bam_split)) != 0)
  2623. return (ret);
  2624. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2625.     __bam_rsplit_recover, DB___bam_rsplit)) != 0)
  2626. return (ret);
  2627. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2628.     __bam_adj_recover, DB___bam_adj)) != 0)
  2629. return (ret);
  2630. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2631.     __bam_cadjust_recover, DB___bam_cadjust)) != 0)
  2632. return (ret);
  2633. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2634.     __bam_cdel_recover, DB___bam_cdel)) != 0)
  2635. return (ret);
  2636. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2637.     __bam_repl_recover, DB___bam_repl)) != 0)
  2638. return (ret);
  2639. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2640.     __bam_root_recover, DB___bam_root)) != 0)
  2641. return (ret);
  2642. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2643.     __bam_curadj_recover, DB___bam_curadj)) != 0)
  2644. return (ret);
  2645. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2646.     __bam_rcuradj_recover, DB___bam_rcuradj)) != 0)
  2647. return (ret);
  2648. return (0);
  2649. }