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

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

MySQL数据库

开发平台：

Visual C++

db_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/log.h"
  17. #include "dbinc/rep.h"
  18. #include "dbinc/txn.h"
  20. /*
  21.  * PUBLIC: int __db_addrem_log __P((DB *, DB_TXN *, DB_LSN *,
  22.  * PUBLIC:     u_int32_t, u_int32_t, db_pgno_t, u_int32_t, u_int32_t,
  23.  * PUBLIC:     const DBT *, const DBT *, DB_LSN *));
  24.  */
  25. int
  26. __db_addrem_log(dbp, txnid, ret_lsnp, flags,
  27.     opcode, pgno, indx, nbytes, hdr,
  28.     dbt, pagelsn)
  29. DB *dbp;
  30. DB_TXN *txnid;
  31. DB_LSN *ret_lsnp;
  32. u_int32_t flags;
  33. u_int32_t opcode;
  34. db_pgno_t pgno;
  35. u_int32_t indx;
  36. u_int32_t nbytes;
  37. const DBT *hdr;
  38. const DBT *dbt;
  39. DB_LSN * pagelsn;
  40. {
  41. DBT logrec;
  42. DB_ENV *dbenv;
  43. DB_LSN *lsnp, null_lsn;
  44. u_int32_t zero;
  45. u_int32_t uinttmp;
  46. u_int32_t npad, rectype, txn_num;
  47. int ret;
  48. u_int8_t *bp;
  50. dbenv = dbp->dbenv;
  51. rectype = DB___db_addrem;
  52. npad = 0;
  54. if (txnid == NULL) {
  55. txn_num = 0;
  56. null_lsn.file = 0;
  57. null_lsn.offset = 0;
  58. lsnp = &null_lsn;
  59. } else {
  60. if (TAILQ_FIRST(&txnid->kids) != NULL &&
  61.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  62. return (ret);
  63. txn_num = txnid->txnid;
  64. lsnp = &txnid->last_lsn;
  65. }
  67. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  68.     + sizeof(u_int32_t)
  69.     + sizeof(u_int32_t)
  70.     + sizeof(u_int32_t)
  71.     + sizeof(u_int32_t)
  72.     + sizeof(u_int32_t)
  73.     + sizeof(u_int32_t) + (hdr == NULL ? 0 : hdr->size)
  74.     + sizeof(u_int32_t) + (dbt == NULL ? 0 : dbt->size)
  75.     + sizeof(*pagelsn);
  76. if (CRYPTO_ON(dbenv)) {
  77. npad =
  78.     ((DB_CIPHER *)dbenv->crypto_handle)->adj_size(logrec.size);
  79. logrec.size += npad;
  80. }
  82. if ((ret = __os_malloc(dbenv,
  83.     logrec.size, &logrec.data)) != 0)
  84. return (ret);
  86. if (npad > 0)
  87. memset((u_int8_t *)logrec.data + logrec.size - npad, 0, npad);
  89. bp = logrec.data;
  91. memcpy(bp, &rectype, sizeof(rectype));
  92. bp += sizeof(rectype);
  94. memcpy(bp, &txn_num, sizeof(txn_num));
  95. bp += sizeof(txn_num);
  97. memcpy(bp, lsnp, sizeof(DB_LSN));
  98. bp += sizeof(DB_LSN);
  100. uinttmp = (u_int32_t)opcode;
  101. memcpy(bp, &uinttmp, sizeof(uinttmp));
  102. bp += sizeof(uinttmp);
  104. DB_ASSERT(dbp->log_filename != NULL);
  105. if (dbp->log_filename->id == DB_LOGFILEID_INVALID &&
  106.     (ret = __dbreg_lazy_id(dbp)) != 0)
  107. return (ret);
  109. uinttmp = (u_int32_t)dbp->log_filename->id;
  110. memcpy(bp, &uinttmp, sizeof(uinttmp));
  111. bp += sizeof(uinttmp);
  113. uinttmp = (u_int32_t)pgno;
  114. memcpy(bp, &uinttmp, sizeof(uinttmp));
  115. bp += sizeof(uinttmp);
  117. uinttmp = (u_int32_t)indx;
  118. memcpy(bp, &uinttmp, sizeof(uinttmp));
  119. bp += sizeof(uinttmp);
  121. uinttmp = (u_int32_t)nbytes;
  122. memcpy(bp, &uinttmp, sizeof(uinttmp));
  123. bp += sizeof(uinttmp);
  125. if (hdr == NULL) {
  126. zero = 0;
  127. memcpy(bp, &zero, sizeof(u_int32_t));
  128. bp += sizeof(u_int32_t);
  129. } else {
  130. memcpy(bp, &hdr->size, sizeof(hdr->size));
  131. bp += sizeof(hdr->size);
  132. memcpy(bp, hdr->data, hdr->size);
  133. bp += hdr->size;
  134. }
  136. if (dbt == NULL) {
  137. zero = 0;
  138. memcpy(bp, &zero, sizeof(u_int32_t));
  139. bp += sizeof(u_int32_t);
  140. } else {
  141. memcpy(bp, &dbt->size, sizeof(dbt->size));
  142. bp += sizeof(dbt->size);
  143. memcpy(bp, dbt->data, dbt->size);
  144. bp += dbt->size;
  145. }
  147. if (pagelsn != NULL)
  148. memcpy(bp, pagelsn, sizeof(*pagelsn));
  149. else
  150. memset(bp, 0, sizeof(*pagelsn));
  151. bp += sizeof(*pagelsn);
  153. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
  154. ret = dbenv->log_put(dbenv,
  155.    ret_lsnp, (DBT *)&logrec, flags | DB_NOCOPY);
  156. if (txnid != NULL && ret == 0)
  157. txnid->last_lsn = *ret_lsnp;
  158. #ifdef LOG_DIAGNOSTIC
  159. if (ret != 0)
  160. (void)__db_addrem_print(dbenv,
  161.     (DBT *)&logrec, ret_lsnp, NULL, NULL);
  162. #endif
  163. __os_free(dbenv, logrec.data);
  164. return (ret);
  165. }
  167. /*
  168.  * PUBLIC: int __db_addrem_getpgnos __P((DB_ENV *, DBT *, DB_LSN *,
  169.  * PUBLIC:     db_recops, void *));
  170.  */
  171. int
  172. __db_addrem_getpgnos(dbenv, rec, lsnp, notused1, summary)
  173. DB_ENV *dbenv;
  174. DBT *rec;
  175. DB_LSN *lsnp;
  176. db_recops notused1;
  177. void *summary;
  178. {
  179. DB *dbp;
  180. TXN_RECS *t;
  181. __db_addrem_args *argp;
  182. u_int32_t ret;
  184. COMPQUIET(notused1, DB_TXN_ABORT);
  186. argp = NULL;
  187. t = (TXN_RECS *)summary;
  189. if ((ret = __db_addrem_read(dbenv, rec->data, &argp)) != 0)
  190. return (ret);
  192. if ((ret = __dbreg_id_to_db(dbenv,
  193.     argp->txnid, &dbp, argp->fileid, 0)) != 0)
  194. goto err;
  196. if ((ret = __rep_check_alloc(dbenv, t, 1)) != 0)
  197. goto err;
  199. t->array[t->npages].flags = 0;
  200. t->array[t->npages].fid = argp->fileid;
  201. t->array[t->npages].lsn = *lsnp;
  202. t->array[t->npages].pgdesc.pgno = argp->pgno;
  203. t->array[t->npages].pgdesc.type = DB_PAGE_LOCK;
  204. memcpy(t->array[t->npages].pgdesc.fileid, dbp->fileid,
  205.     DB_FILE_ID_LEN);
  206. t->npages++;
  208. err: if (argp != NULL)
  209. __os_free(dbenv, argp);
  210. return (ret);
  211. }
  213. /*
  214.  * PUBLIC: int __db_addrem_print __P((DB_ENV *, DBT *, DB_LSN *,
  215.  * PUBLIC:     db_recops, void *));
  216.  */
  217. int
  218. __db_addrem_print(dbenv, dbtp, lsnp, notused2, notused3)
  219. DB_ENV *dbenv;
  220. DBT *dbtp;
  221. DB_LSN *lsnp;
  222. db_recops notused2;
  223. void *notused3;
  224. {
  225. __db_addrem_args *argp;
  226. u_int32_t i;
  227. int ch;
  228. int ret;
  230. notused2 = DB_TXN_ABORT;
  231. notused3 = NULL;
  233. if ((ret = __db_addrem_read(dbenv, dbtp->data, &argp)) != 0)
  234. return (ret);
  235. (void)printf(
  236.     "[%lu][%lu]__db_addrem: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  237.     (u_long)lsnp->file,
  238.     (u_long)lsnp->offset,
  239.     (u_long)argp->type,
  240.     (u_long)argp->txnid->txnid,
  241.     (u_long)argp->prev_lsn.file,
  242.     (u_long)argp->prev_lsn.offset);
  243. (void)printf("topcode: %lun", (u_long)argp->opcode);
  244. (void)printf("tfileid: %ldn", (long)argp->fileid);
  245. (void)printf("tpgno: %lun", (u_long)argp->pgno);
  246. (void)printf("tindx: %lun", (u_long)argp->indx);
  247. (void)printf("tnbytes: %lun", (u_long)argp->nbytes);
  248. (void)printf("thdr: ");
  249. for (i = 0; i < argp->hdr.size; i++) {
  250. ch = ((u_int8_t *)argp->hdr.data)[i];
  251. printf(isprint(ch) || ch == 0x0a ? "%c" : "%#x ", ch);
  252. }
  253. (void)printf("n");
  254. (void)printf("tdbt: ");
  255. for (i = 0; i < argp->dbt.size; i++) {
  256. ch = ((u_int8_t *)argp->dbt.data)[i];
  257. printf(isprint(ch) || ch == 0x0a ? "%c" : "%#x ", ch);
  258. }
  259. (void)printf("n");
  260. (void)printf("tpagelsn: [%lu][%lu]n",
  261.     (u_long)argp->pagelsn.file, (u_long)argp->pagelsn.offset);
  262. (void)printf("n");
  263. __os_free(dbenv, argp);
  264. return (0);
  265. }
  267. /*
  268.  * PUBLIC: int __db_addrem_read __P((DB_ENV *, void *, __db_addrem_args **));
  269.  */
  270. int
  271. __db_addrem_read(dbenv, recbuf, argpp)
  272. DB_ENV *dbenv;
  273. void *recbuf;
  274. __db_addrem_args **argpp;
  275. {
  276. __db_addrem_args *argp;
  277. u_int32_t uinttmp;
  278. u_int8_t *bp;
  279. int ret;
  281. if ((ret = __os_malloc(dbenv,
  282.     sizeof(__db_addrem_args) + sizeof(DB_TXN), &argp)) != 0)
  283. return (ret);
  285. argp->txnid = (DB_TXN *)&argp[1];
  287. bp = recbuf;
  288. memcpy(&argp->type, bp, sizeof(argp->type));
  289. bp += sizeof(argp->type);
  291. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  292. bp += sizeof(argp->txnid->txnid);
  294. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  295. bp += sizeof(DB_LSN);
  297. memcpy(&uinttmp, bp, sizeof(uinttmp));
  298. argp->opcode = (u_int32_t)uinttmp;
  299. bp += sizeof(uinttmp);
  301. memcpy(&uinttmp, bp, sizeof(uinttmp));
  302. argp->fileid = (int32_t)uinttmp;
  303. bp += sizeof(uinttmp);
  305. memcpy(&uinttmp, bp, sizeof(uinttmp));
  306. argp->pgno = (db_pgno_t)uinttmp;
  307. bp += sizeof(uinttmp);
  309. memcpy(&uinttmp, bp, sizeof(uinttmp));
  310. argp->indx = (u_int32_t)uinttmp;
  311. bp += sizeof(uinttmp);
  313. memcpy(&uinttmp, bp, sizeof(uinttmp));
  314. argp->nbytes = (u_int32_t)uinttmp;
  315. bp += sizeof(uinttmp);
  317. memset(&argp->hdr, 0, sizeof(argp->hdr));
  318. memcpy(&argp->hdr.size, bp, sizeof(u_int32_t));
  319. bp += sizeof(u_int32_t);
  320. argp->hdr.data = bp;
  321. bp += argp->hdr.size;
  323. memset(&argp->dbt, 0, sizeof(argp->dbt));
  324. memcpy(&argp->dbt.size, bp, sizeof(u_int32_t));
  325. bp += sizeof(u_int32_t);
  326. argp->dbt.data = bp;
  327. bp += argp->dbt.size;
  329. memcpy(&argp->pagelsn, bp,  sizeof(argp->pagelsn));
  330. bp += sizeof(argp->pagelsn);
  332. *argpp = argp;
  333. return (0);
  334. }
  336. /*
  337.  * PUBLIC: int __db_big_log __P((DB *, DB_TXN *, DB_LSN *,
  338.  * PUBLIC:     u_int32_t, u_int32_t, db_pgno_t, db_pgno_t, db_pgno_t,
  339.  * PUBLIC:     const DBT *, DB_LSN *, DB_LSN *, DB_LSN *));
  340.  */
  341. int
  342. __db_big_log(dbp, txnid, ret_lsnp, flags,
  343.     opcode, pgno, prev_pgno, next_pgno, dbt,
  344.     pagelsn, prevlsn, nextlsn)
  345. DB *dbp;
  346. DB_TXN *txnid;
  347. DB_LSN *ret_lsnp;
  348. u_int32_t flags;
  349. u_int32_t opcode;
  350. db_pgno_t pgno;
  351. db_pgno_t prev_pgno;
  352. db_pgno_t next_pgno;
  353. const DBT *dbt;
  354. DB_LSN * pagelsn;
  355. DB_LSN * prevlsn;
  356. DB_LSN * nextlsn;
  357. {
  358. DBT logrec;
  359. DB_ENV *dbenv;
  360. DB_LSN *lsnp, null_lsn;
  361. u_int32_t zero;
  362. u_int32_t uinttmp;
  363. u_int32_t npad, rectype, txn_num;
  364. int ret;
  365. u_int8_t *bp;
  367. dbenv = dbp->dbenv;
  368. rectype = DB___db_big;
  369. npad = 0;
  371. if (txnid == NULL) {
  372. txn_num = 0;
  373. null_lsn.file = 0;
  374. null_lsn.offset = 0;
  375. lsnp = &null_lsn;
  376. } else {
  377. if (TAILQ_FIRST(&txnid->kids) != NULL &&
  378.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  379. return (ret);
  380. txn_num = txnid->txnid;
  381. lsnp = &txnid->last_lsn;
  382. }
  384. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  385.     + sizeof(u_int32_t)
  386.     + sizeof(u_int32_t)
  387.     + sizeof(u_int32_t)
  388.     + sizeof(u_int32_t)
  389.     + sizeof(u_int32_t)
  390.     + sizeof(u_int32_t) + (dbt == NULL ? 0 : dbt->size)
  391.     + sizeof(*pagelsn)
  392.     + sizeof(*prevlsn)
  393.     + sizeof(*nextlsn);
  394. if (CRYPTO_ON(dbenv)) {
  395. npad =
  396.     ((DB_CIPHER *)dbenv->crypto_handle)->adj_size(logrec.size);
  397. logrec.size += npad;
  398. }
  400. if ((ret = __os_malloc(dbenv,
  401.     logrec.size, &logrec.data)) != 0)
  402. return (ret);
  404. if (npad > 0)
  405. memset((u_int8_t *)logrec.data + logrec.size - npad, 0, npad);
  407. bp = logrec.data;
  409. memcpy(bp, &rectype, sizeof(rectype));
  410. bp += sizeof(rectype);
  412. memcpy(bp, &txn_num, sizeof(txn_num));
  413. bp += sizeof(txn_num);
  415. memcpy(bp, lsnp, sizeof(DB_LSN));
  416. bp += sizeof(DB_LSN);
  418. uinttmp = (u_int32_t)opcode;
  419. memcpy(bp, &uinttmp, sizeof(uinttmp));
  420. bp += sizeof(uinttmp);
  422. DB_ASSERT(dbp->log_filename != NULL);
  423. if (dbp->log_filename->id == DB_LOGFILEID_INVALID &&
  424.     (ret = __dbreg_lazy_id(dbp)) != 0)
  425. return (ret);
  427. uinttmp = (u_int32_t)dbp->log_filename->id;
  428. memcpy(bp, &uinttmp, sizeof(uinttmp));
  429. bp += sizeof(uinttmp);
  431. uinttmp = (u_int32_t)pgno;
  432. memcpy(bp, &uinttmp, sizeof(uinttmp));
  433. bp += sizeof(uinttmp);
  435. uinttmp = (u_int32_t)prev_pgno;
  436. memcpy(bp, &uinttmp, sizeof(uinttmp));
  437. bp += sizeof(uinttmp);
  439. uinttmp = (u_int32_t)next_pgno;
  440. memcpy(bp, &uinttmp, sizeof(uinttmp));
  441. bp += sizeof(uinttmp);
  443. if (dbt == NULL) {
  444. zero = 0;
  445. memcpy(bp, &zero, sizeof(u_int32_t));
  446. bp += sizeof(u_int32_t);
  447. } else {
  448. memcpy(bp, &dbt->size, sizeof(dbt->size));
  449. bp += sizeof(dbt->size);
  450. memcpy(bp, dbt->data, dbt->size);
  451. bp += dbt->size;
  452. }
  454. if (pagelsn != NULL)
  455. memcpy(bp, pagelsn, sizeof(*pagelsn));
  456. else
  457. memset(bp, 0, sizeof(*pagelsn));
  458. bp += sizeof(*pagelsn);
  460. if (prevlsn != NULL)
  461. memcpy(bp, prevlsn, sizeof(*prevlsn));
  462. else
  463. memset(bp, 0, sizeof(*prevlsn));
  464. bp += sizeof(*prevlsn);
  466. if (nextlsn != NULL)
  467. memcpy(bp, nextlsn, sizeof(*nextlsn));
  468. else
  469. memset(bp, 0, sizeof(*nextlsn));
  470. bp += sizeof(*nextlsn);
  472. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
  473. ret = dbenv->log_put(dbenv,
  474.    ret_lsnp, (DBT *)&logrec, flags | DB_NOCOPY);
  475. if (txnid != NULL && ret == 0)
  476. txnid->last_lsn = *ret_lsnp;
  477. #ifdef LOG_DIAGNOSTIC
  478. if (ret != 0)
  479. (void)__db_big_print(dbenv,
  480.     (DBT *)&logrec, ret_lsnp, NULL, NULL);
  481. #endif
  482. __os_free(dbenv, logrec.data);
  483. return (ret);
  484. }
  486. /*
  487.  * PUBLIC: int __db_big_getpgnos __P((DB_ENV *, DBT *, DB_LSN *,
  488.  * PUBLIC:     db_recops, void *));
  489.  */
  490. int
  491. __db_big_getpgnos(dbenv, rec, lsnp, notused1, summary)
  492. DB_ENV *dbenv;
  493. DBT *rec;
  494. DB_LSN *lsnp;
  495. db_recops notused1;
  496. void *summary;
  497. {
  498. DB *dbp;
  499. TXN_RECS *t;
  500. __db_big_args *argp;
  501. u_int32_t ret;
  503. COMPQUIET(notused1, DB_TXN_ABORT);
  505. argp = NULL;
  506. t = (TXN_RECS *)summary;
  508. if ((ret = __db_big_read(dbenv, rec->data, &argp)) != 0)
  509. return (ret);
  511. if ((ret = __dbreg_id_to_db(dbenv,
  512.     argp->txnid, &dbp, argp->fileid, 0)) != 0)
  513. goto err;
  515. if ((ret = __rep_check_alloc(dbenv, t, 3)) != 0)
  516. goto err;
  518. t->array[t->npages].flags = 0;
  519. t->array[t->npages].fid = argp->fileid;
  520. t->array[t->npages].lsn = *lsnp;
  521. t->array[t->npages].pgdesc.pgno = argp->pgno;
  522. t->array[t->npages].pgdesc.type = DB_PAGE_LOCK;
  523. memcpy(t->array[t->npages].pgdesc.fileid, dbp->fileid,
  524.     DB_FILE_ID_LEN);
  525. t->npages++;
  526. if (argp->prev_pgno != PGNO_INVALID) {
  527. t->array[t->npages].flags = 0;
  528. t->array[t->npages].fid = argp->fileid;
  529. t->array[t->npages].lsn = *lsnp;
  530. t->array[t->npages].pgdesc.pgno = argp->prev_pgno;
  531. t->array[t->npages].pgdesc.type = DB_PAGE_LOCK;
  532. memcpy(t->array[t->npages].pgdesc.fileid, dbp->fileid,
  533.     DB_FILE_ID_LEN);
  534. t->npages++;
  535. }
  536. if (argp->next_pgno != PGNO_INVALID) {
  537. t->array[t->npages].flags = 0;
  538. t->array[t->npages].fid = argp->fileid;
  539. t->array[t->npages].lsn = *lsnp;
  540. t->array[t->npages].pgdesc.pgno = argp->next_pgno;
  541. t->array[t->npages].pgdesc.type = DB_PAGE_LOCK;
  542. memcpy(t->array[t->npages].pgdesc.fileid, dbp->fileid,
  543.     DB_FILE_ID_LEN);
  544. t->npages++;
  545. }
  547. err: if (argp != NULL)
  548. __os_free(dbenv, argp);
  549. return (ret);
  550. }
  552. /*
  553.  * PUBLIC: int __db_big_print __P((DB_ENV *, DBT *, DB_LSN *,
  554.  * PUBLIC:     db_recops, void *));
  555.  */
  556. int
  557. __db_big_print(dbenv, dbtp, lsnp, notused2, notused3)
  558. DB_ENV *dbenv;
  559. DBT *dbtp;
  560. DB_LSN *lsnp;
  561. db_recops notused2;
  562. void *notused3;
  563. {
  564. __db_big_args *argp;
  565. u_int32_t i;
  566. int ch;
  567. int ret;
  569. notused2 = DB_TXN_ABORT;
  570. notused3 = NULL;
  572. if ((ret = __db_big_read(dbenv, dbtp->data, &argp)) != 0)
  573. return (ret);
  574. (void)printf(
  575.     "[%lu][%lu]__db_big: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  576.     (u_long)lsnp->file,
  577.     (u_long)lsnp->offset,
  578.     (u_long)argp->type,
  579.     (u_long)argp->txnid->txnid,
  580.     (u_long)argp->prev_lsn.file,
  581.     (u_long)argp->prev_lsn.offset);
  582. (void)printf("topcode: %lun", (u_long)argp->opcode);
  583. (void)printf("tfileid: %ldn", (long)argp->fileid);
  584. (void)printf("tpgno: %lun", (u_long)argp->pgno);
  585. (void)printf("tprev_pgno: %lun", (u_long)argp->prev_pgno);
  586. (void)printf("tnext_pgno: %lun", (u_long)argp->next_pgno);
  587. (void)printf("tdbt: ");
  588. for (i = 0; i < argp->dbt.size; i++) {
  589. ch = ((u_int8_t *)argp->dbt.data)[i];
  590. printf(isprint(ch) || ch == 0x0a ? "%c" : "%#x ", ch);
  591. }
  592. (void)printf("n");
  593. (void)printf("tpagelsn: [%lu][%lu]n",
  594.     (u_long)argp->pagelsn.file, (u_long)argp->pagelsn.offset);
  595. (void)printf("tprevlsn: [%lu][%lu]n",
  596.     (u_long)argp->prevlsn.file, (u_long)argp->prevlsn.offset);
  597. (void)printf("tnextlsn: [%lu][%lu]n",
  598.     (u_long)argp->nextlsn.file, (u_long)argp->nextlsn.offset);
  599. (void)printf("n");
  600. __os_free(dbenv, argp);
  601. return (0);
  602. }
  604. /*
  605.  * PUBLIC: int __db_big_read __P((DB_ENV *, void *, __db_big_args **));
  606.  */
  607. int
  608. __db_big_read(dbenv, recbuf, argpp)
  609. DB_ENV *dbenv;
  610. void *recbuf;
  611. __db_big_args **argpp;
  612. {
  613. __db_big_args *argp;
  614. u_int32_t uinttmp;
  615. u_int8_t *bp;
  616. int ret;
  618. if ((ret = __os_malloc(dbenv,
  619.     sizeof(__db_big_args) + sizeof(DB_TXN), &argp)) != 0)
  620. return (ret);
  622. argp->txnid = (DB_TXN *)&argp[1];
  624. bp = recbuf;
  625. memcpy(&argp->type, bp, sizeof(argp->type));
  626. bp += sizeof(argp->type);
  628. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  629. bp += sizeof(argp->txnid->txnid);
  631. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  632. bp += sizeof(DB_LSN);
  634. memcpy(&uinttmp, bp, sizeof(uinttmp));
  635. argp->opcode = (u_int32_t)uinttmp;
  636. bp += sizeof(uinttmp);
  638. memcpy(&uinttmp, bp, sizeof(uinttmp));
  639. argp->fileid = (int32_t)uinttmp;
  640. bp += sizeof(uinttmp);
  642. memcpy(&uinttmp, bp, sizeof(uinttmp));
  643. argp->pgno = (db_pgno_t)uinttmp;
  644. bp += sizeof(uinttmp);
  646. memcpy(&uinttmp, bp, sizeof(uinttmp));
  647. argp->prev_pgno = (db_pgno_t)uinttmp;
  648. bp += sizeof(uinttmp);
  650. memcpy(&uinttmp, bp, sizeof(uinttmp));
  651. argp->next_pgno = (db_pgno_t)uinttmp;
  652. bp += sizeof(uinttmp);
  654. memset(&argp->dbt, 0, sizeof(argp->dbt));
  655. memcpy(&argp->dbt.size, bp, sizeof(u_int32_t));
  656. bp += sizeof(u_int32_t);
  657. argp->dbt.data = bp;
  658. bp += argp->dbt.size;
  660. memcpy(&argp->pagelsn, bp,  sizeof(argp->pagelsn));
  661. bp += sizeof(argp->pagelsn);
  663. memcpy(&argp->prevlsn, bp,  sizeof(argp->prevlsn));
  664. bp += sizeof(argp->prevlsn);
  666. memcpy(&argp->nextlsn, bp,  sizeof(argp->nextlsn));
  667. bp += sizeof(argp->nextlsn);
  669. *argpp = argp;
  670. return (0);
  671. }
  673. /*
  674.  * PUBLIC: int __db_ovref_log __P((DB *, DB_TXN *, DB_LSN *,
  675.  * PUBLIC:     u_int32_t, db_pgno_t, int32_t, DB_LSN *));
  676.  */
  677. int
  678. __db_ovref_log(dbp, txnid, ret_lsnp, flags, pgno, adjust, lsn)
  679. DB *dbp;
  680. DB_TXN *txnid;
  681. DB_LSN *ret_lsnp;
  682. u_int32_t flags;
  683. db_pgno_t pgno;
  684. int32_t adjust;
  685. DB_LSN * lsn;
  686. {
  687. DBT logrec;
  688. DB_ENV *dbenv;
  689. DB_LSN *lsnp, null_lsn;
  690. u_int32_t uinttmp;
  691. u_int32_t npad, rectype, txn_num;
  692. int ret;
  693. u_int8_t *bp;
  695. dbenv = dbp->dbenv;
  696. rectype = DB___db_ovref;
  697. npad = 0;
  699. if (txnid == NULL) {
  700. txn_num = 0;
  701. null_lsn.file = 0;
  702. null_lsn.offset = 0;
  703. lsnp = &null_lsn;
  704. } else {
  705. if (TAILQ_FIRST(&txnid->kids) != NULL &&
  706.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  707. return (ret);
  708. txn_num = txnid->txnid;
  709. lsnp = &txnid->last_lsn;
  710. }
  712. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  713.     + sizeof(u_int32_t)
  714.     + sizeof(u_int32_t)
  715.     + sizeof(u_int32_t)
  716.     + sizeof(*lsn);
  717. if (CRYPTO_ON(dbenv)) {
  718. npad =
  719.     ((DB_CIPHER *)dbenv->crypto_handle)->adj_size(logrec.size);
  720. logrec.size += npad;
  721. }
  723. if ((ret = __os_malloc(dbenv,
  724.     logrec.size, &logrec.data)) != 0)
  725. return (ret);
  727. if (npad > 0)
  728. memset((u_int8_t *)logrec.data + logrec.size - npad, 0, npad);
  730. bp = logrec.data;
  732. memcpy(bp, &rectype, sizeof(rectype));
  733. bp += sizeof(rectype);
  735. memcpy(bp, &txn_num, sizeof(txn_num));
  736. bp += sizeof(txn_num);
  738. memcpy(bp, lsnp, sizeof(DB_LSN));
  739. bp += sizeof(DB_LSN);
  741. DB_ASSERT(dbp->log_filename != NULL);
  742. if (dbp->log_filename->id == DB_LOGFILEID_INVALID &&
  743.     (ret = __dbreg_lazy_id(dbp)) != 0)
  744. return (ret);
  746. uinttmp = (u_int32_t)dbp->log_filename->id;
  747. memcpy(bp, &uinttmp, sizeof(uinttmp));
  748. bp += sizeof(uinttmp);
  750. uinttmp = (u_int32_t)pgno;
  751. memcpy(bp, &uinttmp, sizeof(uinttmp));
  752. bp += sizeof(uinttmp);
  754. uinttmp = (u_int32_t)adjust;
  755. memcpy(bp, &uinttmp, sizeof(uinttmp));
  756. bp += sizeof(uinttmp);
  758. if (lsn != NULL)
  759. memcpy(bp, lsn, sizeof(*lsn));
  760. else
  761. memset(bp, 0, sizeof(*lsn));
  762. bp += sizeof(*lsn);
  764. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
  765. ret = dbenv->log_put(dbenv,
  766.    ret_lsnp, (DBT *)&logrec, flags | DB_NOCOPY);
  767. if (txnid != NULL && ret == 0)
  768. txnid->last_lsn = *ret_lsnp;
  769. #ifdef LOG_DIAGNOSTIC
  770. if (ret != 0)
  771. (void)__db_ovref_print(dbenv,
  772.     (DBT *)&logrec, ret_lsnp, NULL, NULL);
  773. #endif
  774. __os_free(dbenv, logrec.data);
  775. return (ret);
  776. }
  778. /*
  779.  * PUBLIC: int __db_ovref_getpgnos __P((DB_ENV *, DBT *, DB_LSN *,
  780.  * PUBLIC:     db_recops, void *));
  781.  */
  782. int
  783. __db_ovref_getpgnos(dbenv, rec, lsnp, notused1, summary)
  784. DB_ENV *dbenv;
  785. DBT *rec;
  786. DB_LSN *lsnp;
  787. db_recops notused1;
  788. void *summary;
  789. {
  790. DB *dbp;
  791. TXN_RECS *t;
  792. __db_ovref_args *argp;
  793. u_int32_t ret;
  795. COMPQUIET(notused1, DB_TXN_ABORT);
  797. argp = NULL;
  798. t = (TXN_RECS *)summary;
  800. if ((ret = __db_ovref_read(dbenv, rec->data, &argp)) != 0)
  801. return (ret);
  803. if ((ret = __dbreg_id_to_db(dbenv,
  804.     argp->txnid, &dbp, argp->fileid, 0)) != 0)
  805. goto err;
  807. if ((ret = __rep_check_alloc(dbenv, t, 1)) != 0)
  808. goto err;
  810. t->array[t->npages].flags = 0;
  811. t->array[t->npages].fid = argp->fileid;
  812. t->array[t->npages].lsn = *lsnp;
  813. t->array[t->npages].pgdesc.pgno = argp->pgno;
  814. t->array[t->npages].pgdesc.type = DB_PAGE_LOCK;
  815. memcpy(t->array[t->npages].pgdesc.fileid, dbp->fileid,
  816.     DB_FILE_ID_LEN);
  817. t->npages++;
  819. err: if (argp != NULL)
  820. __os_free(dbenv, argp);
  821. return (ret);
  822. }
  824. /*
  825.  * PUBLIC: int __db_ovref_print __P((DB_ENV *, DBT *, DB_LSN *,
  826.  * PUBLIC:     db_recops, void *));
  827.  */
  828. int
  829. __db_ovref_print(dbenv, dbtp, lsnp, notused2, notused3)
  830. DB_ENV *dbenv;
  831. DBT *dbtp;
  832. DB_LSN *lsnp;
  833. db_recops notused2;
  834. void *notused3;
  835. {
  836. __db_ovref_args *argp;
  837. int ret;
  839. notused2 = DB_TXN_ABORT;
  840. notused3 = NULL;
  842. if ((ret = __db_ovref_read(dbenv, dbtp->data, &argp)) != 0)
  843. return (ret);
  844. (void)printf(
  845.     "[%lu][%lu]__db_ovref: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  846.     (u_long)lsnp->file,
  847.     (u_long)lsnp->offset,
  848.     (u_long)argp->type,
  849.     (u_long)argp->txnid->txnid,
  850.     (u_long)argp->prev_lsn.file,
  851.     (u_long)argp->prev_lsn.offset);
  852. (void)printf("tfileid: %ldn", (long)argp->fileid);
  853. (void)printf("tpgno: %lun", (u_long)argp->pgno);
  854. (void)printf("tadjust: %ldn", (long)argp->adjust);
  855. (void)printf("tlsn: [%lu][%lu]n",
  856.     (u_long)argp->lsn.file, (u_long)argp->lsn.offset);
  857. (void)printf("n");
  858. __os_free(dbenv, argp);
  859. return (0);
  860. }
  862. /*
  863.  * PUBLIC: int __db_ovref_read __P((DB_ENV *, void *, __db_ovref_args **));
  864.  */
  865. int
  866. __db_ovref_read(dbenv, recbuf, argpp)
  867. DB_ENV *dbenv;
  868. void *recbuf;
  869. __db_ovref_args **argpp;
  870. {
  871. __db_ovref_args *argp;
  872. u_int32_t uinttmp;
  873. u_int8_t *bp;
  874. int ret;
  876. if ((ret = __os_malloc(dbenv,
  877.     sizeof(__db_ovref_args) + sizeof(DB_TXN), &argp)) != 0)
  878. return (ret);
  880. argp->txnid = (DB_TXN *)&argp[1];
  882. bp = recbuf;
  883. memcpy(&argp->type, bp, sizeof(argp->type));
  884. bp += sizeof(argp->type);
  886. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  887. bp += sizeof(argp->txnid->txnid);
  889. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  890. bp += sizeof(DB_LSN);
  892. memcpy(&uinttmp, bp, sizeof(uinttmp));
  893. argp->fileid = (int32_t)uinttmp;
  894. bp += sizeof(uinttmp);
  896. memcpy(&uinttmp, bp, sizeof(uinttmp));
  897. argp->pgno = (db_pgno_t)uinttmp;
  898. bp += sizeof(uinttmp);
  900. memcpy(&uinttmp, bp, sizeof(uinttmp));
  901. argp->adjust = (int32_t)uinttmp;
  902. bp += sizeof(uinttmp);
  904. memcpy(&argp->lsn, bp,  sizeof(argp->lsn));
  905. bp += sizeof(argp->lsn);
  907. *argpp = argp;
  908. return (0);
  909. }
  911. /*
  912.  * PUBLIC: int __db_relink_log __P((DB *, DB_TXN *, DB_LSN *,
  913.  * PUBLIC:     u_int32_t, u_int32_t, db_pgno_t, DB_LSN *, db_pgno_t, DB_LSN *,
  914.  * PUBLIC:     db_pgno_t, DB_LSN *));
  915.  */
  916. int
  917. __db_relink_log(dbp, txnid, ret_lsnp, flags,
  918.     opcode, pgno, lsn, prev, lsn_prev,
  919.     next, lsn_next)
  920. DB *dbp;
  921. DB_TXN *txnid;
  922. DB_LSN *ret_lsnp;
  923. u_int32_t flags;
  924. u_int32_t opcode;
  925. db_pgno_t pgno;
  926. DB_LSN * lsn;
  927. db_pgno_t prev;
  928. DB_LSN * lsn_prev;
  929. db_pgno_t next;
  930. DB_LSN * lsn_next;
  931. {
  932. DBT logrec;
  933. DB_ENV *dbenv;
  934. DB_LSN *lsnp, null_lsn;
  935. u_int32_t uinttmp;
  936. u_int32_t npad, rectype, txn_num;
  937. int ret;
  938. u_int8_t *bp;
  940. dbenv = dbp->dbenv;
  941. rectype = DB___db_relink;
  942. npad = 0;
  944. if (txnid == NULL) {
  945. txn_num = 0;
  946. null_lsn.file = 0;
  947. null_lsn.offset = 0;
  948. lsnp = &null_lsn;
  949. } else {
  950. if (TAILQ_FIRST(&txnid->kids) != NULL &&
  951.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  952. return (ret);
  953. txn_num = txnid->txnid;
  954. lsnp = &txnid->last_lsn;
  955. }
  957. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  958.     + sizeof(u_int32_t)
  959.     + sizeof(u_int32_t)
  960.     + sizeof(u_int32_t)
  961.     + sizeof(*lsn)
  962.     + sizeof(u_int32_t)
  963.     + sizeof(*lsn_prev)
  964.     + sizeof(u_int32_t)
  965.     + sizeof(*lsn_next);
  966. if (CRYPTO_ON(dbenv)) {
  967. npad =
  968.     ((DB_CIPHER *)dbenv->crypto_handle)->adj_size(logrec.size);
  969. logrec.size += npad;
  970. }
  972. if ((ret = __os_malloc(dbenv,
  973.     logrec.size, &logrec.data)) != 0)
  974. return (ret);
  976. if (npad > 0)
  977. memset((u_int8_t *)logrec.data + logrec.size - npad, 0, npad);
  979. bp = logrec.data;
  981. memcpy(bp, &rectype, sizeof(rectype));
  982. bp += sizeof(rectype);
  984. memcpy(bp, &txn_num, sizeof(txn_num));
  985. bp += sizeof(txn_num);
  987. memcpy(bp, lsnp, sizeof(DB_LSN));
  988. bp += sizeof(DB_LSN);
  990. uinttmp = (u_int32_t)opcode;
  991. memcpy(bp, &uinttmp, sizeof(uinttmp));
  992. bp += sizeof(uinttmp);
  994. DB_ASSERT(dbp->log_filename != NULL);
  995. if (dbp->log_filename->id == DB_LOGFILEID_INVALID &&
  996.     (ret = __dbreg_lazy_id(dbp)) != 0)
  997. return (ret);
  999. uinttmp = (u_int32_t)dbp->log_filename->id;
  1000. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1001. bp += sizeof(uinttmp);
  1003. uinttmp = (u_int32_t)pgno;
  1004. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1005. bp += sizeof(uinttmp);
  1007. if (lsn != NULL)
  1008. memcpy(bp, lsn, sizeof(*lsn));
  1009. else
  1010. memset(bp, 0, sizeof(*lsn));
  1011. bp += sizeof(*lsn);
  1013. uinttmp = (u_int32_t)prev;
  1014. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1015. bp += sizeof(uinttmp);
  1017. if (lsn_prev != NULL)
  1018. memcpy(bp, lsn_prev, sizeof(*lsn_prev));
  1019. else
  1020. memset(bp, 0, sizeof(*lsn_prev));
  1021. bp += sizeof(*lsn_prev);
  1023. uinttmp = (u_int32_t)next;
  1024. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1025. bp += sizeof(uinttmp);
  1027. if (lsn_next != NULL)
  1028. memcpy(bp, lsn_next, sizeof(*lsn_next));
  1029. else
  1030. memset(bp, 0, sizeof(*lsn_next));
  1031. bp += sizeof(*lsn_next);
  1033. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
  1034. ret = dbenv->log_put(dbenv,
  1035.    ret_lsnp, (DBT *)&logrec, flags | DB_NOCOPY);
  1036. if (txnid != NULL && ret == 0)
  1037. txnid->last_lsn = *ret_lsnp;
  1038. #ifdef LOG_DIAGNOSTIC
  1039. if (ret != 0)
  1040. (void)__db_relink_print(dbenv,
  1041.     (DBT *)&logrec, ret_lsnp, NULL, NULL);
  1042. #endif
  1043. __os_free(dbenv, logrec.data);
  1044. return (ret);
  1045. }
  1047. /*
  1048.  * PUBLIC: int __db_relink_getpgnos __P((DB_ENV *, DBT *, DB_LSN *,
  1049.  * PUBLIC:     db_recops, void *));
  1050.  */
  1051. int
  1052. __db_relink_getpgnos(dbenv, rec, lsnp, notused1, summary)
  1053. DB_ENV *dbenv;
  1054. DBT *rec;
  1055. DB_LSN *lsnp;
  1056. db_recops notused1;
  1057. void *summary;
  1058. {
  1059. DB *dbp;
  1060. TXN_RECS *t;
  1061. __db_relink_args *argp;
  1062. u_int32_t ret;
  1064. COMPQUIET(notused1, DB_TXN_ABORT);
  1066. argp = NULL;
  1067. t = (TXN_RECS *)summary;
  1069. if ((ret = __db_relink_read(dbenv, rec->data, &argp)) != 0)
  1070. return (ret);
  1072. if ((ret = __dbreg_id_to_db(dbenv,
  1073.     argp->txnid, &dbp, argp->fileid, 0)) != 0)
  1074. goto err;
  1076. if ((ret = __rep_check_alloc(dbenv, t, 3)) != 0)
  1077. goto err;
  1079. t->array[t->npages].flags = 0;
  1080. t->array[t->npages].fid = argp->fileid;
  1081. t->array[t->npages].lsn = *lsnp;
  1082. t->array[t->npages].pgdesc.pgno = argp->pgno;
  1083. t->array[t->npages].pgdesc.type = DB_PAGE_LOCK;
  1084. memcpy(t->array[t->npages].pgdesc.fileid, dbp->fileid,
  1085.     DB_FILE_ID_LEN);
  1086. t->npages++;
  1087. if (argp->prev != PGNO_INVALID) {
  1088. t->array[t->npages].flags = 0;
  1089. t->array[t->npages].fid = argp->fileid;
  1090. t->array[t->npages].lsn = *lsnp;
  1091. t->array[t->npages].pgdesc.pgno = argp->prev;
  1092. t->array[t->npages].pgdesc.type = DB_PAGE_LOCK;
  1093. memcpy(t->array[t->npages].pgdesc.fileid, dbp->fileid,
  1094.     DB_FILE_ID_LEN);
  1095. t->npages++;
  1096. }
  1097. if (argp->next != PGNO_INVALID) {
  1098. t->array[t->npages].flags = 0;
  1099. t->array[t->npages].fid = argp->fileid;
  1100. t->array[t->npages].lsn = *lsnp;
  1101. t->array[t->npages].pgdesc.pgno = argp->next;
  1102. t->array[t->npages].pgdesc.type = DB_PAGE_LOCK;
  1103. memcpy(t->array[t->npages].pgdesc.fileid, dbp->fileid,
  1104.     DB_FILE_ID_LEN);
  1105. t->npages++;
  1106. }
  1108. err: if (argp != NULL)
  1109. __os_free(dbenv, argp);
  1110. return (ret);
  1111. }
  1113. /*
  1114.  * PUBLIC: int __db_relink_print __P((DB_ENV *, DBT *, DB_LSN *,
  1115.  * PUBLIC:     db_recops, void *));
  1116.  */
  1117. int
  1118. __db_relink_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. __db_relink_args *argp;
  1126. int ret;
  1128. notused2 = DB_TXN_ABORT;
  1129. notused3 = NULL;
  1131. if ((ret = __db_relink_read(dbenv, dbtp->data, &argp)) != 0)
  1132. return (ret);
  1133. (void)printf(
  1134.     "[%lu][%lu]__db_relink: 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("topcode: %lun", (u_long)argp->opcode);
  1142. (void)printf("tfileid: %ldn", (long)argp->fileid);
  1143. (void)printf("tpgno: %lun", (u_long)argp->pgno);
  1144. (void)printf("tlsn: [%lu][%lu]n",
  1145.     (u_long)argp->lsn.file, (u_long)argp->lsn.offset);
  1146. (void)printf("tprev: %lun", (u_long)argp->prev);
  1147. (void)printf("tlsn_prev: [%lu][%lu]n",
  1148.     (u_long)argp->lsn_prev.file, (u_long)argp->lsn_prev.offset);
  1149. (void)printf("tnext: %lun", (u_long)argp->next);
  1150. (void)printf("tlsn_next: [%lu][%lu]n",
  1151.     (u_long)argp->lsn_next.file, (u_long)argp->lsn_next.offset);
  1152. (void)printf("n");
  1153. __os_free(dbenv, argp);
  1154. return (0);
  1155. }
  1157. /*
  1158.  * PUBLIC: int __db_relink_read __P((DB_ENV *, void *, __db_relink_args **));
  1159.  */
  1160. int
  1161. __db_relink_read(dbenv, recbuf, argpp)
  1162. DB_ENV *dbenv;
  1163. void *recbuf;
  1164. __db_relink_args **argpp;
  1165. {
  1166. __db_relink_args *argp;
  1167. u_int32_t uinttmp;
  1168. u_int8_t *bp;
  1169. int ret;
  1171. if ((ret = __os_malloc(dbenv,
  1172.     sizeof(__db_relink_args) + sizeof(DB_TXN), &argp)) != 0)
  1173. return (ret);
  1175. argp->txnid = (DB_TXN *)&argp[1];
  1177. bp = recbuf;
  1178. memcpy(&argp->type, bp, sizeof(argp->type));
  1179. bp += sizeof(argp->type);
  1181. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  1182. bp += sizeof(argp->txnid->txnid);
  1184. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  1185. bp += sizeof(DB_LSN);
  1187. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1188. argp->opcode = (u_int32_t)uinttmp;
  1189. bp += sizeof(uinttmp);
  1191. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1192. argp->fileid = (int32_t)uinttmp;
  1193. bp += sizeof(uinttmp);
  1195. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1196. argp->pgno = (db_pgno_t)uinttmp;
  1197. bp += sizeof(uinttmp);
  1199. memcpy(&argp->lsn, bp,  sizeof(argp->lsn));
  1200. bp += sizeof(argp->lsn);
  1202. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1203. argp->prev = (db_pgno_t)uinttmp;
  1204. bp += sizeof(uinttmp);
  1206. memcpy(&argp->lsn_prev, bp,  sizeof(argp->lsn_prev));
  1207. bp += sizeof(argp->lsn_prev);
  1209. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1210. argp->next = (db_pgno_t)uinttmp;
  1211. bp += sizeof(uinttmp);
  1213. memcpy(&argp->lsn_next, bp,  sizeof(argp->lsn_next));
  1214. bp += sizeof(argp->lsn_next);
  1216. *argpp = argp;
  1217. return (0);
  1218. }
  1220. /*
  1221.  * PUBLIC: int __db_debug_log __P((DB_ENV *, DB_TXN *, DB_LSN *,
  1222.  * PUBLIC:     u_int32_t, const DBT *, int32_t, const DBT *, const DBT *,
  1223.  * PUBLIC:     u_int32_t));
  1224.  */
  1225. int
  1226. __db_debug_log(dbenv, txnid, ret_lsnp, flags,
  1227.     op, fileid, key, data, arg_flags)
  1228. DB_ENV *dbenv;
  1229. DB_TXN *txnid;
  1230. DB_LSN *ret_lsnp;
  1231. u_int32_t flags;
  1232. const DBT *op;
  1233. int32_t fileid;
  1234. const DBT *key;
  1235. const DBT *data;
  1236. u_int32_t arg_flags;
  1237. {
  1238. DBT logrec;
  1239. DB_LSN *lsnp, null_lsn;
  1240. u_int32_t zero;
  1241. u_int32_t uinttmp;
  1242. u_int32_t npad, rectype, txn_num;
  1243. int ret;
  1244. u_int8_t *bp;
  1246. rectype = DB___db_debug;
  1247. npad = 0;
  1249. if (txnid == NULL) {
  1250. txn_num = 0;
  1251. null_lsn.file = 0;
  1252. null_lsn.offset = 0;
  1253. lsnp = &null_lsn;
  1254. } else {
  1255. txn_num = txnid->txnid;
  1256. lsnp = &txnid->last_lsn;
  1257. }
  1259. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  1260.     + sizeof(u_int32_t) + (op == NULL ? 0 : op->size)
  1261.     + sizeof(u_int32_t)
  1262.     + sizeof(u_int32_t) + (key == NULL ? 0 : key->size)
  1263.     + sizeof(u_int32_t) + (data == NULL ? 0 : data->size)
  1264.     + sizeof(u_int32_t);
  1265. if (CRYPTO_ON(dbenv)) {
  1266. npad =
  1267.     ((DB_CIPHER *)dbenv->crypto_handle)->adj_size(logrec.size);
  1268. logrec.size += npad;
  1269. }
  1271. if ((ret = __os_malloc(dbenv,
  1272.     logrec.size, &logrec.data)) != 0)
  1273. return (ret);
  1275. if (npad > 0)
  1276. memset((u_int8_t *)logrec.data + logrec.size - npad, 0, npad);
  1278. bp = logrec.data;
  1280. memcpy(bp, &rectype, sizeof(rectype));
  1281. bp += sizeof(rectype);
  1283. memcpy(bp, &txn_num, sizeof(txn_num));
  1284. bp += sizeof(txn_num);
  1286. memcpy(bp, lsnp, sizeof(DB_LSN));
  1287. bp += sizeof(DB_LSN);
  1289. if (op == NULL) {
  1290. zero = 0;
  1291. memcpy(bp, &zero, sizeof(u_int32_t));
  1292. bp += sizeof(u_int32_t);
  1293. } else {
  1294. memcpy(bp, &op->size, sizeof(op->size));
  1295. bp += sizeof(op->size);
  1296. memcpy(bp, op->data, op->size);
  1297. bp += op->size;
  1298. }
  1300. uinttmp = (u_int32_t)fileid;
  1301. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1302. bp += sizeof(uinttmp);
  1304. if (key == NULL) {
  1305. zero = 0;
  1306. memcpy(bp, &zero, sizeof(u_int32_t));
  1307. bp += sizeof(u_int32_t);
  1308. } else {
  1309. memcpy(bp, &key->size, sizeof(key->size));
  1310. bp += sizeof(key->size);
  1311. memcpy(bp, key->data, key->size);
  1312. bp += key->size;
  1313. }
  1315. if (data == NULL) {
  1316. zero = 0;
  1317. memcpy(bp, &zero, sizeof(u_int32_t));
  1318. bp += sizeof(u_int32_t);
  1319. } else {
  1320. memcpy(bp, &data->size, sizeof(data->size));
  1321. bp += sizeof(data->size);
  1322. memcpy(bp, data->data, data->size);
  1323. bp += data->size;
  1324. }
  1326. uinttmp = (u_int32_t)arg_flags;
  1327. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1328. bp += sizeof(uinttmp);
  1330. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
  1331. ret = dbenv->log_put(dbenv,
  1332.    ret_lsnp, (DBT *)&logrec, flags | DB_NOCOPY);
  1333. if (txnid != NULL && ret == 0)
  1334. txnid->last_lsn = *ret_lsnp;
  1335. #ifdef LOG_DIAGNOSTIC
  1336. if (ret != 0)
  1337. (void)__db_debug_print(dbenv,
  1338.     (DBT *)&logrec, ret_lsnp, NULL, NULL);
  1339. #endif
  1340. __os_free(dbenv, logrec.data);
  1341. return (ret);
  1342. }
  1344. /*
  1345.  * PUBLIC: int __db_debug_getpgnos __P((DB_ENV *, DBT *, DB_LSN *,
  1346.  * PUBLIC:     db_recops, void *));
  1347.  */
  1348. int
  1349. __db_debug_getpgnos(dbenv, rec, lsnp, notused1, summary)
  1350. DB_ENV *dbenv;
  1351. DBT *rec;
  1352. DB_LSN *lsnp;
  1353. db_recops notused1;
  1354. void *summary;
  1355. {
  1356. TXN_RECS *t;
  1357. int ret;
  1358. COMPQUIET(rec, NULL);
  1359. COMPQUIET(notused1, DB_TXN_ABORT);
  1361. t = (TXN_RECS *)summary;
  1363. if ((ret = __rep_check_alloc(dbenv, t, 1)) != 0)
  1364. return (ret);
  1366. t->array[t->npages].flags = LSN_PAGE_NOLOCK;
  1367. t->array[t->npages].lsn = *lsnp;
  1368. t->array[t->npages].fid = DB_LOGFILEID_INVALID;
  1369. memset(&t->array[t->npages].pgdesc, 0,
  1370.     sizeof(t->array[t->npages].pgdesc));
  1372. t->npages++;
  1374. return (0);
  1375. }
  1377. /*
  1378.  * PUBLIC: int __db_debug_print __P((DB_ENV *, DBT *, DB_LSN *,
  1379.  * PUBLIC:     db_recops, void *));
  1380.  */
  1381. int
  1382. __db_debug_print(dbenv, dbtp, lsnp, notused2, notused3)
  1383. DB_ENV *dbenv;
  1384. DBT *dbtp;
  1385. DB_LSN *lsnp;
  1386. db_recops notused2;
  1387. void *notused3;
  1388. {
  1389. __db_debug_args *argp;
  1390. u_int32_t i;
  1391. int ch;
  1392. int ret;
  1394. notused2 = DB_TXN_ABORT;
  1395. notused3 = NULL;
  1397. if ((ret = __db_debug_read(dbenv, dbtp->data, &argp)) != 0)
  1398. return (ret);
  1399. (void)printf(
  1400.     "[%lu][%lu]__db_debug: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  1401.     (u_long)lsnp->file,
  1402.     (u_long)lsnp->offset,
  1403.     (u_long)argp->type,
  1404.     (u_long)argp->txnid->txnid,
  1405.     (u_long)argp->prev_lsn.file,
  1406.     (u_long)argp->prev_lsn.offset);
  1407. (void)printf("top: ");
  1408. for (i = 0; i < argp->op.size; i++) {
  1409. ch = ((u_int8_t *)argp->op.data)[i];
  1410. printf(isprint(ch) || ch == 0x0a ? "%c" : "%#x ", ch);
  1411. }
  1412. (void)printf("n");
  1413. (void)printf("tfileid: %ldn", (long)argp->fileid);
  1414. (void)printf("tkey: ");
  1415. for (i = 0; i < argp->key.size; i++) {
  1416. ch = ((u_int8_t *)argp->key.data)[i];
  1417. printf(isprint(ch) || ch == 0x0a ? "%c" : "%#x ", ch);
  1418. }
  1419. (void)printf("n");
  1420. (void)printf("tdata: ");
  1421. for (i = 0; i < argp->data.size; i++) {
  1422. ch = ((u_int8_t *)argp->data.data)[i];
  1423. printf(isprint(ch) || ch == 0x0a ? "%c" : "%#x ", ch);
  1424. }
  1425. (void)printf("n");
  1426. (void)printf("targ_flags: %lun", (u_long)argp->arg_flags);
  1427. (void)printf("n");
  1428. __os_free(dbenv, argp);
  1429. return (0);
  1430. }
  1432. /*
  1433.  * PUBLIC: int __db_debug_read __P((DB_ENV *, void *, __db_debug_args **));
  1434.  */
  1435. int
  1436. __db_debug_read(dbenv, recbuf, argpp)
  1437. DB_ENV *dbenv;
  1438. void *recbuf;
  1439. __db_debug_args **argpp;
  1440. {
  1441. __db_debug_args *argp;
  1442. u_int32_t uinttmp;
  1443. u_int8_t *bp;
  1444. int ret;
  1446. if ((ret = __os_malloc(dbenv,
  1447.     sizeof(__db_debug_args) + sizeof(DB_TXN), &argp)) != 0)
  1448. return (ret);
  1450. argp->txnid = (DB_TXN *)&argp[1];
  1452. bp = recbuf;
  1453. memcpy(&argp->type, bp, sizeof(argp->type));
  1454. bp += sizeof(argp->type);
  1456. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  1457. bp += sizeof(argp->txnid->txnid);
  1459. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  1460. bp += sizeof(DB_LSN);
  1462. memset(&argp->op, 0, sizeof(argp->op));
  1463. memcpy(&argp->op.size, bp, sizeof(u_int32_t));
  1464. bp += sizeof(u_int32_t);
  1465. argp->op.data = bp;
  1466. bp += argp->op.size;
  1468. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1469. argp->fileid = (int32_t)uinttmp;
  1470. bp += sizeof(uinttmp);
  1472. memset(&argp->key, 0, sizeof(argp->key));
  1473. memcpy(&argp->key.size, bp, sizeof(u_int32_t));
  1474. bp += sizeof(u_int32_t);
  1475. argp->key.data = bp;
  1476. bp += argp->key.size;
  1478. memset(&argp->data, 0, sizeof(argp->data));
  1479. memcpy(&argp->data.size, bp, sizeof(u_int32_t));
  1480. bp += sizeof(u_int32_t);
  1481. argp->data.data = bp;
  1482. bp += argp->data.size;
  1484. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1485. argp->arg_flags = (u_int32_t)uinttmp;
  1486. bp += sizeof(uinttmp);
  1488. *argpp = argp;
  1489. return (0);
  1490. }
  1492. /*
  1493.  * PUBLIC: int __db_noop_log __P((DB *, DB_TXN *, DB_LSN *,
  1494.  * PUBLIC:     u_int32_t, db_pgno_t, DB_LSN *));
  1495.  */
  1496. int
  1497. __db_noop_log(dbp, txnid, ret_lsnp, flags, pgno, prevlsn)
  1498. DB *dbp;
  1499. DB_TXN *txnid;
  1500. DB_LSN *ret_lsnp;
  1501. u_int32_t flags;
  1502. db_pgno_t pgno;
  1503. DB_LSN * prevlsn;
  1504. {
  1505. DBT logrec;
  1506. DB_ENV *dbenv;
  1507. DB_LSN *lsnp, null_lsn;
  1508. u_int32_t uinttmp;
  1509. u_int32_t npad, rectype, txn_num;
  1510. int ret;
  1511. u_int8_t *bp;
  1513. dbenv = dbp->dbenv;
  1514. rectype = DB___db_noop;
  1515. npad = 0;
  1517. if (txnid == NULL) {
  1518. txn_num = 0;
  1519. null_lsn.file = 0;
  1520. null_lsn.offset = 0;
  1521. lsnp = &null_lsn;
  1522. } else {
  1523. if (TAILQ_FIRST(&txnid->kids) != NULL &&
  1524.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  1525. return (ret);
  1526. txn_num = txnid->txnid;
  1527. lsnp = &txnid->last_lsn;
  1528. }
  1530. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  1531.     + sizeof(u_int32_t)
  1532.     + sizeof(u_int32_t)
  1533.     + sizeof(*prevlsn);
  1534. if (CRYPTO_ON(dbenv)) {
  1535. npad =
  1536.     ((DB_CIPHER *)dbenv->crypto_handle)->adj_size(logrec.size);
  1537. logrec.size += npad;
  1538. }
  1540. if ((ret = __os_malloc(dbenv,
  1541.     logrec.size, &logrec.data)) != 0)
  1542. return (ret);
  1544. if (npad > 0)
  1545. memset((u_int8_t *)logrec.data + logrec.size - npad, 0, npad);
  1547. bp = logrec.data;
  1549. memcpy(bp, &rectype, sizeof(rectype));
  1550. bp += sizeof(rectype);
  1552. memcpy(bp, &txn_num, sizeof(txn_num));
  1553. bp += sizeof(txn_num);
  1555. memcpy(bp, lsnp, sizeof(DB_LSN));
  1556. bp += sizeof(DB_LSN);
  1558. DB_ASSERT(dbp->log_filename != NULL);
  1559. if (dbp->log_filename->id == DB_LOGFILEID_INVALID &&
  1560.     (ret = __dbreg_lazy_id(dbp)) != 0)
  1561. return (ret);
  1563. uinttmp = (u_int32_t)dbp->log_filename->id;
  1564. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1565. bp += sizeof(uinttmp);
  1567. uinttmp = (u_int32_t)pgno;
  1568. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1569. bp += sizeof(uinttmp);
  1571. if (prevlsn != NULL)
  1572. memcpy(bp, prevlsn, sizeof(*prevlsn));
  1573. else
  1574. memset(bp, 0, sizeof(*prevlsn));
  1575. bp += sizeof(*prevlsn);
  1577. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
  1578. ret = dbenv->log_put(dbenv,
  1579.    ret_lsnp, (DBT *)&logrec, flags | DB_NOCOPY);
  1580. if (txnid != NULL && ret == 0)
  1581. txnid->last_lsn = *ret_lsnp;
  1582. #ifdef LOG_DIAGNOSTIC
  1583. if (ret != 0)
  1584. (void)__db_noop_print(dbenv,
  1585.     (DBT *)&logrec, ret_lsnp, NULL, NULL);
  1586. #endif
  1587. __os_free(dbenv, logrec.data);
  1588. return (ret);
  1589. }
  1591. /*
  1592.  * PUBLIC: int __db_noop_getpgnos __P((DB_ENV *, DBT *, DB_LSN *,
  1593.  * PUBLIC:     db_recops, void *));
  1594.  */
  1595. int
  1596. __db_noop_getpgnos(dbenv, rec, lsnp, notused1, summary)
  1597. DB_ENV *dbenv;
  1598. DBT *rec;
  1599. DB_LSN *lsnp;
  1600. db_recops notused1;
  1601. void *summary;
  1602. {
  1603. DB *dbp;
  1604. TXN_RECS *t;
  1605. __db_noop_args *argp;
  1606. u_int32_t ret;
  1608. COMPQUIET(notused1, DB_TXN_ABORT);
  1610. argp = NULL;
  1611. t = (TXN_RECS *)summary;
  1613. if ((ret = __db_noop_read(dbenv, rec->data, &argp)) != 0)
  1614. return (ret);
  1616. if ((ret = __dbreg_id_to_db(dbenv,
  1617.     argp->txnid, &dbp, argp->fileid, 0)) != 0)
  1618. goto err;
  1620. if ((ret = __rep_check_alloc(dbenv, t, 1)) != 0)
  1621. goto err;
  1623. t->array[t->npages].flags = 0;
  1624. t->array[t->npages].fid = argp->fileid;
  1625. t->array[t->npages].lsn = *lsnp;
  1626. t->array[t->npages].pgdesc.pgno = argp->pgno;
  1627. t->array[t->npages].pgdesc.type = DB_PAGE_LOCK;
  1628. memcpy(t->array[t->npages].pgdesc.fileid, dbp->fileid,
  1629.     DB_FILE_ID_LEN);
  1630. t->npages++;
  1632. err: if (argp != NULL)
  1633. __os_free(dbenv, argp);
  1634. return (ret);
  1635. }
  1637. /*
  1638.  * PUBLIC: int __db_noop_print __P((DB_ENV *, DBT *, DB_LSN *,
  1639.  * PUBLIC:     db_recops, void *));
  1640.  */
  1641. int
  1642. __db_noop_print(dbenv, dbtp, lsnp, notused2, notused3)
  1643. DB_ENV *dbenv;
  1644. DBT *dbtp;
  1645. DB_LSN *lsnp;
  1646. db_recops notused2;
  1647. void *notused3;
  1648. {
  1649. __db_noop_args *argp;
  1650. int ret;
  1652. notused2 = DB_TXN_ABORT;
  1653. notused3 = NULL;
  1655. if ((ret = __db_noop_read(dbenv, dbtp->data, &argp)) != 0)
  1656. return (ret);
  1657. (void)printf(
  1658.     "[%lu][%lu]__db_noop: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  1659.     (u_long)lsnp->file,
  1660.     (u_long)lsnp->offset,
  1661.     (u_long)argp->type,
  1662.     (u_long)argp->txnid->txnid,
  1663.     (u_long)argp->prev_lsn.file,
  1664.     (u_long)argp->prev_lsn.offset);
  1665. (void)printf("tfileid: %ldn", (long)argp->fileid);
  1666. (void)printf("tpgno: %lun", (u_long)argp->pgno);
  1667. (void)printf("tprevlsn: [%lu][%lu]n",
  1668.     (u_long)argp->prevlsn.file, (u_long)argp->prevlsn.offset);
  1669. (void)printf("n");
  1670. __os_free(dbenv, argp);
  1671. return (0);
  1672. }
  1674. /*
  1675.  * PUBLIC: int __db_noop_read __P((DB_ENV *, void *, __db_noop_args **));
  1676.  */
  1677. int
  1678. __db_noop_read(dbenv, recbuf, argpp)
  1679. DB_ENV *dbenv;
  1680. void *recbuf;
  1681. __db_noop_args **argpp;
  1682. {
  1683. __db_noop_args *argp;
  1684. u_int32_t uinttmp;
  1685. u_int8_t *bp;
  1686. int ret;
  1688. if ((ret = __os_malloc(dbenv,
  1689.     sizeof(__db_noop_args) + sizeof(DB_TXN), &argp)) != 0)
  1690. return (ret);
  1692. argp->txnid = (DB_TXN *)&argp[1];
  1694. bp = recbuf;
  1695. memcpy(&argp->type, bp, sizeof(argp->type));
  1696. bp += sizeof(argp->type);
  1698. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  1699. bp += sizeof(argp->txnid->txnid);
  1701. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  1702. bp += sizeof(DB_LSN);
  1704. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1705. argp->fileid = (int32_t)uinttmp;
  1706. bp += sizeof(uinttmp);
  1708. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1709. argp->pgno = (db_pgno_t)uinttmp;
  1710. bp += sizeof(uinttmp);
  1712. memcpy(&argp->prevlsn, bp,  sizeof(argp->prevlsn));
  1713. bp += sizeof(argp->prevlsn);
  1715. *argpp = argp;
  1716. return (0);
  1717. }
  1719. /*
  1720.  * PUBLIC: int __db_pg_alloc_log __P((DB *, DB_TXN *, DB_LSN *,
  1721.  * PUBLIC:     u_int32_t, DB_LSN *, db_pgno_t, DB_LSN *, db_pgno_t, u_int32_t,
  1722.  * PUBLIC:     db_pgno_t));
  1723.  */
  1724. int
  1725. __db_pg_alloc_log(dbp, txnid, ret_lsnp, flags, meta_lsn, meta_pgno, page_lsn, pgno, ptype,
  1726.     next)
  1727. DB *dbp;
  1728. DB_TXN *txnid;
  1729. DB_LSN *ret_lsnp;
  1730. u_int32_t flags;
  1731. DB_LSN * meta_lsn;
  1732. db_pgno_t meta_pgno;
  1733. DB_LSN * page_lsn;
  1734. db_pgno_t pgno;
  1735. u_int32_t ptype;
  1736. db_pgno_t next;
  1737. {
  1738. DBT logrec;
  1739. DB_ENV *dbenv;
  1740. DB_LSN *lsnp, null_lsn;
  1741. u_int32_t uinttmp;
  1742. u_int32_t npad, rectype, txn_num;
  1743. int ret;
  1744. u_int8_t *bp;
  1746. dbenv = dbp->dbenv;
  1747. rectype = DB___db_pg_alloc;
  1748. npad = 0;
  1750. if (txnid == NULL) {
  1751. txn_num = 0;
  1752. null_lsn.file = 0;
  1753. null_lsn.offset = 0;
  1754. lsnp = &null_lsn;
  1755. } else {
  1756. if (TAILQ_FIRST(&txnid->kids) != NULL &&
  1757.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  1758. return (ret);
  1759. txn_num = txnid->txnid;
  1760. lsnp = &txnid->last_lsn;
  1761. }
  1763. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  1764.     + sizeof(u_int32_t)
  1765.     + sizeof(*meta_lsn)
  1766.     + sizeof(u_int32_t)
  1767.     + sizeof(*page_lsn)
  1768.     + sizeof(u_int32_t)
  1769.     + sizeof(u_int32_t)
  1770.     + sizeof(u_int32_t);
  1771. if (CRYPTO_ON(dbenv)) {
  1772. npad =
  1773.     ((DB_CIPHER *)dbenv->crypto_handle)->adj_size(logrec.size);
  1774. logrec.size += npad;
  1775. }
  1777. if ((ret = __os_malloc(dbenv,
  1778.     logrec.size, &logrec.data)) != 0)
  1779. return (ret);
  1781. if (npad > 0)
  1782. memset((u_int8_t *)logrec.data + logrec.size - npad, 0, npad);
  1784. bp = logrec.data;
  1786. memcpy(bp, &rectype, sizeof(rectype));
  1787. bp += sizeof(rectype);
  1789. memcpy(bp, &txn_num, sizeof(txn_num));
  1790. bp += sizeof(txn_num);
  1792. memcpy(bp, lsnp, sizeof(DB_LSN));
  1793. bp += sizeof(DB_LSN);
  1795. DB_ASSERT(dbp->log_filename != NULL);
  1796. if (dbp->log_filename->id == DB_LOGFILEID_INVALID &&
  1797.     (ret = __dbreg_lazy_id(dbp)) != 0)
  1798. return (ret);
  1800. uinttmp = (u_int32_t)dbp->log_filename->id;
  1801. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1802. bp += sizeof(uinttmp);
  1804. if (meta_lsn != NULL)
  1805. memcpy(bp, meta_lsn, sizeof(*meta_lsn));
  1806. else
  1807. memset(bp, 0, sizeof(*meta_lsn));
  1808. bp += sizeof(*meta_lsn);
  1810. uinttmp = (u_int32_t)meta_pgno;
  1811. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1812. bp += sizeof(uinttmp);
  1814. if (page_lsn != NULL)
  1815. memcpy(bp, page_lsn, sizeof(*page_lsn));
  1816. else
  1817. memset(bp, 0, sizeof(*page_lsn));
  1818. bp += sizeof(*page_lsn);
  1820. uinttmp = (u_int32_t)pgno;
  1821. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1822. bp += sizeof(uinttmp);
  1824. uinttmp = (u_int32_t)ptype;
  1825. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1826. bp += sizeof(uinttmp);
  1828. uinttmp = (u_int32_t)next;
  1829. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1830. bp += sizeof(uinttmp);
  1832. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
  1833. ret = dbenv->log_put(dbenv,
  1834.    ret_lsnp, (DBT *)&logrec, flags | DB_NOCOPY);
  1835. if (txnid != NULL && ret == 0)
  1836. txnid->last_lsn = *ret_lsnp;
  1837. #ifdef LOG_DIAGNOSTIC
  1838. if (ret != 0)
  1839. (void)__db_pg_alloc_print(dbenv,
  1840.     (DBT *)&logrec, ret_lsnp, NULL, NULL);
  1841. #endif
  1842. __os_free(dbenv, logrec.data);
  1843. return (ret);
  1844. }
  1846. /*
  1847.  * PUBLIC: int __db_pg_alloc_getpgnos __P((DB_ENV *, DBT *, DB_LSN *,
  1848.  * PUBLIC:     db_recops, void *));
  1849.  */
  1850. int
  1851. __db_pg_alloc_getpgnos(dbenv, rec, lsnp, notused1, summary)
  1852. DB_ENV *dbenv;
  1853. DBT *rec;
  1854. DB_LSN *lsnp;
  1855. db_recops notused1;
  1856. void *summary;
  1857. {
  1858. DB *dbp;
  1859. TXN_RECS *t;
  1860. __db_pg_alloc_args *argp;
  1861. u_int32_t ret;
  1863. COMPQUIET(notused1, DB_TXN_ABORT);
  1865. argp = NULL;
  1866. t = (TXN_RECS *)summary;
  1868. if ((ret = __db_pg_alloc_read(dbenv, rec->data, &argp)) != 0)
  1869. return (ret);
  1871. if ((ret = __dbreg_id_to_db(dbenv,
  1872.     argp->txnid, &dbp, argp->fileid, 0)) != 0)
  1873. goto err;
  1875. if ((ret = __rep_check_alloc(dbenv, t, 2)) != 0)
  1876. goto err;
  1878. t->array[t->npages].flags = 0;
  1879. t->array[t->npages].fid = argp->fileid;
  1880. t->array[t->npages].lsn = *lsnp;
  1881. t->array[t->npages].pgdesc.pgno = argp->meta_pgno;
  1882. t->array[t->npages].pgdesc.type = DB_PAGE_LOCK;
  1883. memcpy(t->array[t->npages].pgdesc.fileid, dbp->fileid,
  1884.     DB_FILE_ID_LEN);
  1885. t->npages++;
  1886. t->array[t->npages].flags = 0;
  1887. t->array[t->npages].fid = argp->fileid;
  1888. t->array[t->npages].lsn = *lsnp;
  1889. t->array[t->npages].pgdesc.pgno = argp->pgno;
  1890. t->array[t->npages].pgdesc.type = DB_PAGE_LOCK;
  1891. memcpy(t->array[t->npages].pgdesc.fileid, dbp->fileid,
  1892.     DB_FILE_ID_LEN);
  1893. t->npages++;
  1895. err: if (argp != NULL)
  1896. __os_free(dbenv, argp);
  1897. return (ret);
  1898. }
  1900. /*
  1901.  * PUBLIC: int __db_pg_alloc_print __P((DB_ENV *, DBT *, DB_LSN *,
  1902.  * PUBLIC:     db_recops, void *));
  1903.  */
  1904. int
  1905. __db_pg_alloc_print(dbenv, dbtp, lsnp, notused2, notused3)
  1906. DB_ENV *dbenv;
  1907. DBT *dbtp;
  1908. DB_LSN *lsnp;
  1909. db_recops notused2;
  1910. void *notused3;
  1911. {
  1912. __db_pg_alloc_args *argp;
  1913. int ret;
  1915. notused2 = DB_TXN_ABORT;
  1916. notused3 = NULL;
  1918. if ((ret = __db_pg_alloc_read(dbenv, dbtp->data, &argp)) != 0)
  1919. return (ret);
  1920. (void)printf(
  1921.     "[%lu][%lu]__db_pg_alloc: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  1922.     (u_long)lsnp->file,
  1923.     (u_long)lsnp->offset,
  1924.     (u_long)argp->type,
  1925.     (u_long)argp->txnid->txnid,
  1926.     (u_long)argp->prev_lsn.file,
  1927.     (u_long)argp->prev_lsn.offset);
  1928. (void)printf("tfileid: %ldn", (long)argp->fileid);
  1929. (void)printf("tmeta_lsn: [%lu][%lu]n",
  1930.     (u_long)argp->meta_lsn.file, (u_long)argp->meta_lsn.offset);
  1931. (void)printf("tmeta_pgno: %lun", (u_long)argp->meta_pgno);
  1932. (void)printf("tpage_lsn: [%lu][%lu]n",
  1933.     (u_long)argp->page_lsn.file, (u_long)argp->page_lsn.offset);
  1934. (void)printf("tpgno: %lun", (u_long)argp->pgno);
  1935. (void)printf("tptype: %lun", (u_long)argp->ptype);
  1936. (void)printf("tnext: %lun", (u_long)argp->next);
  1937. (void)printf("n");
  1938. __os_free(dbenv, argp);
  1939. return (0);
  1940. }
  1942. /*
  1943.  * PUBLIC: int __db_pg_alloc_read __P((DB_ENV *, void *,
  1944.  * PUBLIC:     __db_pg_alloc_args **));
  1945.  */
  1946. int
  1947. __db_pg_alloc_read(dbenv, recbuf, argpp)
  1948. DB_ENV *dbenv;
  1949. void *recbuf;
  1950. __db_pg_alloc_args **argpp;
  1951. {
  1952. __db_pg_alloc_args *argp;
  1953. u_int32_t uinttmp;
  1954. u_int8_t *bp;
  1955. int ret;
  1957. if ((ret = __os_malloc(dbenv,
  1958.     sizeof(__db_pg_alloc_args) + sizeof(DB_TXN), &argp)) != 0)
  1959. return (ret);
  1961. argp->txnid = (DB_TXN *)&argp[1];
  1963. bp = recbuf;
  1964. memcpy(&argp->type, bp, sizeof(argp->type));
  1965. bp += sizeof(argp->type);
  1967. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  1968. bp += sizeof(argp->txnid->txnid);
  1970. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  1971. bp += sizeof(DB_LSN);
  1973. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1974. argp->fileid = (int32_t)uinttmp;
  1975. bp += sizeof(uinttmp);
  1977. memcpy(&argp->meta_lsn, bp,  sizeof(argp->meta_lsn));
  1978. bp += sizeof(argp->meta_lsn);
  1980. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1981. argp->meta_pgno = (db_pgno_t)uinttmp;
  1982. bp += sizeof(uinttmp);
  1984. memcpy(&argp->page_lsn, bp,  sizeof(argp->page_lsn));
  1985. bp += sizeof(argp->page_lsn);
  1987. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1988. argp->pgno = (db_pgno_t)uinttmp;
  1989. bp += sizeof(uinttmp);
  1991. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1992. argp->ptype = (u_int32_t)uinttmp;
  1993. bp += sizeof(uinttmp);
  1995. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1996. argp->next = (db_pgno_t)uinttmp;
  1997. bp += sizeof(uinttmp);
  1999. *argpp = argp;
  2000. return (0);
  2001. }
  2003. /*
  2004.  * PUBLIC: int __db_pg_free_log __P((DB *, DB_TXN *, DB_LSN *,
  2005.  * PUBLIC:     u_int32_t, db_pgno_t, DB_LSN *, db_pgno_t, const DBT *,
  2006.  * PUBLIC:     db_pgno_t));
  2007.  */
  2008. int
  2009. __db_pg_free_log(dbp, txnid, ret_lsnp, flags, pgno, meta_lsn, meta_pgno, header, next)
  2010. DB *dbp;
  2011. DB_TXN *txnid;
  2012. DB_LSN *ret_lsnp;
  2013. u_int32_t flags;
  2014. db_pgno_t pgno;
  2015. DB_LSN * meta_lsn;
  2016. db_pgno_t meta_pgno;
  2017. const DBT *header;
  2018. db_pgno_t next;
  2019. {
  2020. DBT logrec;
  2021. DB_ENV *dbenv;
  2022. DB_LSN *lsnp, null_lsn;
  2023. u_int32_t zero;
  2024. u_int32_t uinttmp;
  2025. u_int32_t npad, rectype, txn_num;
  2026. int ret;
  2027. u_int8_t *bp;
  2029. dbenv = dbp->dbenv;
  2030. rectype = DB___db_pg_free;
  2031. npad = 0;
  2033. if (txnid == NULL) {
  2034. txn_num = 0;
  2035. null_lsn.file = 0;
  2036. null_lsn.offset = 0;
  2037. lsnp = &null_lsn;
  2038. } else {
  2039. if (TAILQ_FIRST(&txnid->kids) != NULL &&
  2040.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  2041. return (ret);
  2042. txn_num = txnid->txnid;
  2043. lsnp = &txnid->last_lsn;
  2044. }
  2046. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  2047.     + sizeof(u_int32_t)
  2048.     + sizeof(u_int32_t)
  2049.     + sizeof(*meta_lsn)
  2050.     + sizeof(u_int32_t)
  2051.     + sizeof(u_int32_t) + (header == NULL ? 0 : header->size)
  2052.     + sizeof(u_int32_t);
  2053. if (CRYPTO_ON(dbenv)) {
  2054. npad =
  2055.     ((DB_CIPHER *)dbenv->crypto_handle)->adj_size(logrec.size);
  2056. logrec.size += npad;
  2057. }
  2059. if ((ret = __os_malloc(dbenv,
  2060.     logrec.size, &logrec.data)) != 0)
  2061. return (ret);
  2063. if (npad > 0)
  2064. memset((u_int8_t *)logrec.data + logrec.size - npad, 0, npad);
  2066. bp = logrec.data;
  2068. memcpy(bp, &rectype, sizeof(rectype));
  2069. bp += sizeof(rectype);
  2071. memcpy(bp, &txn_num, sizeof(txn_num));
  2072. bp += sizeof(txn_num);
  2074. memcpy(bp, lsnp, sizeof(DB_LSN));
  2075. bp += sizeof(DB_LSN);
  2077. DB_ASSERT(dbp->log_filename != NULL);
  2078. if (dbp->log_filename->id == DB_LOGFILEID_INVALID &&
  2079.     (ret = __dbreg_lazy_id(dbp)) != 0)
  2080. return (ret);
  2082. uinttmp = (u_int32_t)dbp->log_filename->id;
  2083. memcpy(bp, &uinttmp, sizeof(uinttmp));
  2084. bp += sizeof(uinttmp);
  2086. uinttmp = (u_int32_t)pgno;
  2087. memcpy(bp, &uinttmp, sizeof(uinttmp));
  2088. bp += sizeof(uinttmp);
  2090. if (meta_lsn != NULL)
  2091. memcpy(bp, meta_lsn, sizeof(*meta_lsn));
  2092. else
  2093. memset(bp, 0, sizeof(*meta_lsn));
  2094. bp += sizeof(*meta_lsn);
  2096. uinttmp = (u_int32_t)meta_pgno;
  2097. memcpy(bp, &uinttmp, sizeof(uinttmp));
  2098. bp += sizeof(uinttmp);
  2100. if (header == NULL) {
  2101. zero = 0;
  2102. memcpy(bp, &zero, sizeof(u_int32_t));
  2103. bp += sizeof(u_int32_t);
  2104. } else {
  2105. memcpy(bp, &header->size, sizeof(header->size));
  2106. bp += sizeof(header->size);
  2107. memcpy(bp, header->data, header->size);
  2108. bp += header->size;
  2109. }
  2111. uinttmp = (u_int32_t)next;
  2112. memcpy(bp, &uinttmp, sizeof(uinttmp));
  2113. bp += sizeof(uinttmp);
  2115. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
  2116. ret = dbenv->log_put(dbenv,
  2117.    ret_lsnp, (DBT *)&logrec, flags | DB_NOCOPY);
  2118. if (txnid != NULL && ret == 0)
  2119. txnid->last_lsn = *ret_lsnp;
  2120. #ifdef LOG_DIAGNOSTIC
  2121. if (ret != 0)
  2122. (void)__db_pg_free_print(dbenv,
  2123.     (DBT *)&logrec, ret_lsnp, NULL, NULL);
  2124. #endif
  2125. __os_free(dbenv, logrec.data);
  2126. return (ret);
  2127. }
  2129. /*
  2130.  * PUBLIC: int __db_pg_free_getpgnos __P((DB_ENV *, DBT *, DB_LSN *,
  2131.  * PUBLIC:     db_recops, void *));
  2132.  */
  2133. int
  2134. __db_pg_free_getpgnos(dbenv, rec, lsnp, notused1, summary)
  2135. DB_ENV *dbenv;
  2136. DBT *rec;
  2137. DB_LSN *lsnp;
  2138. db_recops notused1;
  2139. void *summary;
  2140. {
  2141. DB *dbp;
  2142. TXN_RECS *t;
  2143. __db_pg_free_args *argp;
  2144. u_int32_t ret;
  2146. COMPQUIET(notused1, DB_TXN_ABORT);
  2148. argp = NULL;
  2149. t = (TXN_RECS *)summary;
  2151. if ((ret = __db_pg_free_read(dbenv, rec->data, &argp)) != 0)
  2152. return (ret);
  2154. if ((ret = __dbreg_id_to_db(dbenv,
  2155.     argp->txnid, &dbp, argp->fileid, 0)) != 0)
  2156. goto err;
  2158. if ((ret = __rep_check_alloc(dbenv, t, 2)) != 0)
  2159. goto err;
  2161. t->array[t->npages].flags = 0;
  2162. t->array[t->npages].fid = argp->fileid;
  2163. t->array[t->npages].lsn = *lsnp;
  2164. t->array[t->npages].pgdesc.pgno = argp->pgno;
  2165. t->array[t->npages].pgdesc.type = DB_PAGE_LOCK;
  2166. memcpy(t->array[t->npages].pgdesc.fileid, dbp->fileid,
  2167.     DB_FILE_ID_LEN);
  2168. t->npages++;
  2169. t->array[t->npages].flags = 0;
  2170. t->array[t->npages].fid = argp->fileid;
  2171. t->array[t->npages].lsn = *lsnp;
  2172. t->array[t->npages].pgdesc.pgno = argp->meta_pgno;
  2173. t->array[t->npages].pgdesc.type = DB_PAGE_LOCK;
  2174. memcpy(t->array[t->npages].pgdesc.fileid, dbp->fileid,
  2175.     DB_FILE_ID_LEN);
  2176. t->npages++;
  2178. err: if (argp != NULL)
  2179. __os_free(dbenv, argp);
  2180. return (ret);
  2181. }
  2183. /*
  2184.  * PUBLIC: int __db_pg_free_print __P((DB_ENV *, DBT *, DB_LSN *,
  2185.  * PUBLIC:     db_recops, void *));
  2186.  */
  2187. int
  2188. __db_pg_free_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. __db_pg_free_args *argp;
  2196. u_int32_t i;
  2197. int ch;
  2198. int ret;
  2200. notused2 = DB_TXN_ABORT;
  2201. notused3 = NULL;
  2203. if ((ret = __db_pg_free_read(dbenv, dbtp->data, &argp)) != 0)
  2204. return (ret);
  2205. (void)printf(
  2206.     "[%lu][%lu]__db_pg_free: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  2207.     (u_long)lsnp->file,
  2208.     (u_long)lsnp->offset,
  2209.     (u_long)argp->type,
  2210.     (u_long)argp->txnid->txnid,
  2211.     (u_long)argp->prev_lsn.file,
  2212.     (u_long)argp->prev_lsn.offset);
  2213. (void)printf("tfileid: %ldn", (long)argp->fileid);
  2214. (void)printf("tpgno: %lun", (u_long)argp->pgno);
  2215. (void)printf("tmeta_lsn: [%lu][%lu]n",
  2216.     (u_long)argp->meta_lsn.file, (u_long)argp->meta_lsn.offset);
  2217. (void)printf("tmeta_pgno: %lun", (u_long)argp->meta_pgno);
  2218. (void)printf("theader: ");
  2219. for (i = 0; i < argp->header.size; i++) {
  2220. ch = ((u_int8_t *)argp->header.data)[i];
  2221. printf(isprint(ch) || ch == 0x0a ? "%c" : "%#x ", ch);
  2222. }
  2223. (void)printf("n");
  2224. (void)printf("tnext: %lun", (u_long)argp->next);
  2225. (void)printf("n");
  2226. __os_free(dbenv, argp);
  2227. return (0);
  2228. }
  2230. /*
  2231.  * PUBLIC: int __db_pg_free_read __P((DB_ENV *, void *, __db_pg_free_args **));
  2232.  */
  2233. int
  2234. __db_pg_free_read(dbenv, recbuf, argpp)
  2235. DB_ENV *dbenv;
  2236. void *recbuf;
  2237. __db_pg_free_args **argpp;
  2238. {
  2239. __db_pg_free_args *argp;
  2240. u_int32_t uinttmp;
  2241. u_int8_t *bp;
  2242. int ret;
  2244. if ((ret = __os_malloc(dbenv,
  2245.     sizeof(__db_pg_free_args) + sizeof(DB_TXN), &argp)) != 0)
  2246. return (ret);
  2248. argp->txnid = (DB_TXN *)&argp[1];
  2250. bp = recbuf;
  2251. memcpy(&argp->type, bp, sizeof(argp->type));
  2252. bp += sizeof(argp->type);
  2254. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  2255. bp += sizeof(argp->txnid->txnid);
  2257. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  2258. bp += sizeof(DB_LSN);
  2260. memcpy(&uinttmp, bp, sizeof(uinttmp));
  2261. argp->fileid = (int32_t)uinttmp;
  2262. bp += sizeof(uinttmp);
  2264. memcpy(&uinttmp, bp, sizeof(uinttmp));
  2265. argp->pgno = (db_pgno_t)uinttmp;
  2266. bp += sizeof(uinttmp);
  2268. memcpy(&argp->meta_lsn, bp,  sizeof(argp->meta_lsn));
  2269. bp += sizeof(argp->meta_lsn);
  2271. memcpy(&uinttmp, bp, sizeof(uinttmp));
  2272. argp->meta_pgno = (db_pgno_t)uinttmp;
  2273. bp += sizeof(uinttmp);
  2275. memset(&argp->header, 0, sizeof(argp->header));
  2276. memcpy(&argp->header.size, bp, sizeof(u_int32_t));
  2277. bp += sizeof(u_int32_t);
  2278. argp->header.data = bp;
  2279. bp += argp->header.size;
  2281. memcpy(&uinttmp, bp, sizeof(uinttmp));
  2282. argp->next = (db_pgno_t)uinttmp;
  2283. bp += sizeof(uinttmp);
  2285. *argpp = argp;
  2286. return (0);
  2287. }
  2289. /*
  2290.  * PUBLIC: int __db_cksum_log __P((DB_ENV *, DB_TXN *, DB_LSN *, u_int32_t));
  2291.  */
  2292. int
  2293. __db_cksum_log(dbenv, txnid, ret_lsnp, flags)
  2294. DB_ENV *dbenv;
  2295. DB_TXN *txnid;
  2296. DB_LSN *ret_lsnp;
  2297. u_int32_t flags;
  2298. {
  2299. DBT logrec;
  2300. DB_LSN *lsnp, null_lsn;
  2301. u_int32_t npad, rectype, txn_num;
  2302. int ret;
  2303. u_int8_t *bp;
  2305. rectype = DB___db_cksum;
  2306. npad = 0;
  2308. if (txnid == NULL) {
  2309. txn_num = 0;
  2310. null_lsn.file = 0;
  2311. null_lsn.offset = 0;
  2312. lsnp = &null_lsn;
  2313. } else {
  2314. if (TAILQ_FIRST(&txnid->kids) != NULL &&
  2315.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  2316. return (ret);
  2317. txn_num = txnid->txnid;
  2318. lsnp = &txnid->last_lsn;
  2319. }
  2321. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN);
  2322. if (CRYPTO_ON(dbenv)) {
  2323. npad =
  2324.     ((DB_CIPHER *)dbenv->crypto_handle)->adj_size(logrec.size);
  2325. logrec.size += npad;
  2326. }
  2328. if ((ret = __os_malloc(dbenv,
  2329.     logrec.size, &logrec.data)) != 0)
  2330. return (ret);
  2332. if (npad > 0)
  2333. memset((u_int8_t *)logrec.data + logrec.size - npad, 0, npad);
  2335. bp = logrec.data;
  2337. memcpy(bp, &rectype, sizeof(rectype));
  2338. bp += sizeof(rectype);
  2340. memcpy(bp, &txn_num, sizeof(txn_num));
  2341. bp += sizeof(txn_num);
  2343. memcpy(bp, lsnp, sizeof(DB_LSN));
  2344. bp += sizeof(DB_LSN);
  2346. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
  2347. ret = dbenv->log_put(dbenv,
  2348.    ret_lsnp, (DBT *)&logrec, flags | DB_NOCOPY);
  2349. if (txnid != NULL && ret == 0)
  2350. txnid->last_lsn = *ret_lsnp;
  2351. #ifdef LOG_DIAGNOSTIC
  2352. if (ret != 0)
  2353. (void)__db_cksum_print(dbenv,
  2354.     (DBT *)&logrec, ret_lsnp, NULL, NULL);
  2355. #endif
  2356. __os_free(dbenv, logrec.data);
  2357. return (ret);
  2358. }
  2360. /*
  2361.  * PUBLIC: int __db_cksum_getpgnos __P((DB_ENV *, DBT *, DB_LSN *,
  2362.  * PUBLIC:     db_recops, void *));
  2363.  */
  2364. int
  2365. __db_cksum_getpgnos(dbenv, rec, lsnp, notused1, summary)
  2366. DB_ENV *dbenv;
  2367. DBT *rec;
  2368. DB_LSN *lsnp;
  2369. db_recops notused1;
  2370. void *summary;
  2371. {
  2372. TXN_RECS *t;
  2373. int ret;
  2374. COMPQUIET(rec, NULL);
  2375. COMPQUIET(notused1, DB_TXN_ABORT);
  2377. t = (TXN_RECS *)summary;
  2379. if ((ret = __rep_check_alloc(dbenv, t, 1)) != 0)
  2380. return (ret);
  2382. t->array[t->npages].flags = LSN_PAGE_NOLOCK;
  2383. t->array[t->npages].lsn = *lsnp;
  2384. t->array[t->npages].fid = DB_LOGFILEID_INVALID;
  2385. memset(&t->array[t->npages].pgdesc, 0,
  2386.     sizeof(t->array[t->npages].pgdesc));
  2388. t->npages++;
  2390. return (0);
  2391. }
  2393. /*
  2394.  * PUBLIC: int __db_cksum_print __P((DB_ENV *, DBT *, DB_LSN *,
  2395.  * PUBLIC:     db_recops, void *));
  2396.  */
  2397. int
  2398. __db_cksum_print(dbenv, dbtp, lsnp, notused2, notused3)
  2399. DB_ENV *dbenv;
  2400. DBT *dbtp;
  2401. DB_LSN *lsnp;
  2402. db_recops notused2;
  2403. void *notused3;
  2404. {
  2405. __db_cksum_args *argp;
  2406. int ret;
  2408. notused2 = DB_TXN_ABORT;
  2409. notused3 = NULL;
  2411. if ((ret = __db_cksum_read(dbenv, dbtp->data, &argp)) != 0)
  2412. return (ret);
  2413. (void)printf(
  2414.     "[%lu][%lu]__db_cksum: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  2415.     (u_long)lsnp->file,
  2416.     (u_long)lsnp->offset,
  2417.     (u_long)argp->type,
  2418.     (u_long)argp->txnid->txnid,
  2419.     (u_long)argp->prev_lsn.file,
  2420.     (u_long)argp->prev_lsn.offset);
  2421. (void)printf("n");
  2422. __os_free(dbenv, argp);
  2423. return (0);
  2424. }
  2426. /*
  2427.  * PUBLIC: int __db_cksum_read __P((DB_ENV *, void *, __db_cksum_args **));
  2428.  */
  2429. int
  2430. __db_cksum_read(dbenv, recbuf, argpp)
  2431. DB_ENV *dbenv;
  2432. void *recbuf;
  2433. __db_cksum_args **argpp;
  2434. {
  2435. __db_cksum_args *argp;
  2436. u_int8_t *bp;
  2437. int ret;
  2439. if ((ret = __os_malloc(dbenv,
  2440.     sizeof(__db_cksum_args) + sizeof(DB_TXN), &argp)) != 0)
  2441. return (ret);
  2443. argp->txnid = (DB_TXN *)&argp[1];
  2445. bp = recbuf;
  2446. memcpy(&argp->type, bp, sizeof(argp->type));
  2447. bp += sizeof(argp->type);
  2449. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  2450. bp += sizeof(argp->txnid->txnid);
  2452. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  2453. bp += sizeof(DB_LSN);
  2455. *argpp = argp;
  2456. return (0);
  2457. }
  2459. /*
  2460.  * PUBLIC: int __db_init_print __P((DB_ENV *, int (***)(DB_ENV *,
  2461.  * PUBLIC:     DBT *, DB_LSN *, db_recops, void *), size_t *));
  2462.  */
  2463. int
  2464. __db_init_print(dbenv, dtabp, dtabsizep)
  2465. DB_ENV *dbenv;
  2466. int (***dtabp)__P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  2467. size_t *dtabsizep;
  2468. {
  2469. int ret;
  2471. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2472.     __db_addrem_print, DB___db_addrem)) != 0)
  2473. return (ret);
  2474. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2475.     __db_big_print, DB___db_big)) != 0)
  2476. return (ret);
  2477. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2478.     __db_ovref_print, DB___db_ovref)) != 0)
  2479. return (ret);
  2480. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2481.     __db_relink_print, DB___db_relink)) != 0)
  2482. return (ret);
  2483. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2484.     __db_debug_print, DB___db_debug)) != 0)
  2485. return (ret);
  2486. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2487.     __db_noop_print, DB___db_noop)) != 0)
  2488. return (ret);
  2489. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2490.     __db_pg_alloc_print, DB___db_pg_alloc)) != 0)
  2491. return (ret);
  2492. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2493.     __db_pg_free_print, DB___db_pg_free)) != 0)
  2494. return (ret);
  2495. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2496.     __db_cksum_print, DB___db_cksum)) != 0)
  2497. return (ret);
  2498. return (0);
  2499. }
  2501. /*
  2502.  * PUBLIC: int __db_init_getpgnos __P((DB_ENV *, int (***)(DB_ENV *,
  2503.  * PUBLIC:     DBT *, DB_LSN *, db_recops, void *), size_t *));
  2504.  */
  2505. int
  2506. __db_init_getpgnos(dbenv, dtabp, dtabsizep)
  2507. DB_ENV *dbenv;
  2508. int (***dtabp)__P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  2509. size_t *dtabsizep;
  2510. {
  2511. int ret;
  2513. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2514.     __db_addrem_getpgnos, DB___db_addrem)) != 0)
  2515. return (ret);
  2516. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2517.     __db_big_getpgnos, DB___db_big)) != 0)
  2518. return (ret);
  2519. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2520.     __db_ovref_getpgnos, DB___db_ovref)) != 0)
  2521. return (ret);
  2522. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2523.     __db_relink_getpgnos, DB___db_relink)) != 0)
  2524. return (ret);
  2525. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2526.     __db_debug_getpgnos, DB___db_debug)) != 0)
  2527. return (ret);
  2528. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2529.     __db_noop_getpgnos, DB___db_noop)) != 0)
  2530. return (ret);
  2531. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2532.     __db_pg_alloc_getpgnos, DB___db_pg_alloc)) != 0)
  2533. return (ret);
  2534. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2535.     __db_pg_free_getpgnos, DB___db_pg_free)) != 0)
  2536. return (ret);
  2537. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2538.     __db_cksum_getpgnos, DB___db_cksum)) != 0)
  2539. return (ret);
  2540. return (0);
  2541. }
  2543. /*
  2544.  * PUBLIC: int __db_init_recover __P((DB_ENV *, int (***)(DB_ENV *,
  2545.  * PUBLIC:     DBT *, DB_LSN *, db_recops, void *), size_t *));
  2546.  */
  2547. int
  2548. __db_init_recover(dbenv, dtabp, dtabsizep)
  2549. DB_ENV *dbenv;
  2550. int (***dtabp)__P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  2551. size_t *dtabsizep;
  2552. {
  2553. int ret;
  2555. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2556.     __db_addrem_recover, DB___db_addrem)) != 0)
  2557. return (ret);
  2558. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2559.     __db_big_recover, DB___db_big)) != 0)
  2560. return (ret);
  2561. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2562.     __db_ovref_recover, DB___db_ovref)) != 0)
  2563. return (ret);
  2564. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2565.     __db_relink_recover, DB___db_relink)) != 0)
  2566. return (ret);
  2567. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2568.     __db_debug_recover, DB___db_debug)) != 0)
  2569. return (ret);
  2570. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2571.     __db_noop_recover, DB___db_noop)) != 0)
  2572. return (ret);
  2573. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2574.     __db_pg_alloc_recover, DB___db_pg_alloc)) != 0)
  2575. return (ret);
  2576. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2577.     __db_pg_free_recover, DB___db_pg_free)) != 0)
  2578. return (ret);
  2579. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2580.     __db_cksum_recover, DB___db_cksum)) != 0)
  2581. return (ret);
  2582. return (0);
  2583. }