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

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

MySQL数据库

开发平台：

Visual C++

txn_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 __txn_regop_log __P((DB_ENV *, DB_TXN *, DB_LSN *,
  22.  * PUBLIC:     u_int32_t, u_int32_t, int32_t));
  23.  */
  24. int
  25. __txn_regop_log(dbenv, txnid, ret_lsnp, flags,
  26.     opcode, timestamp)
  27. DB_ENV *dbenv;
  28. DB_TXN *txnid;
  29. DB_LSN *ret_lsnp;
  30. u_int32_t flags;
  31. u_int32_t opcode;
  32. int32_t timestamp;
  33. {
  34. DBT logrec;
  35. DB_LSN *lsnp, null_lsn;
  36. u_int32_t uinttmp;
  37. u_int32_t npad, rectype, txn_num;
  38. int ret;
  39. u_int8_t *bp;
  41. rectype = DB___txn_regop;
  42. npad = 0;
  44. if (txnid == NULL) {
  45. txn_num = 0;
  46. null_lsn.file = 0;
  47. null_lsn.offset = 0;
  48. lsnp = &null_lsn;
  49. } else {
  50. if (TAILQ_FIRST(&txnid->kids) != NULL &&
  51.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  52. return (ret);
  53. txn_num = txnid->txnid;
  54. lsnp = &txnid->last_lsn;
  55. }
  57. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  58.     + sizeof(u_int32_t)
  59.     + sizeof(u_int32_t);
  60. if (CRYPTO_ON(dbenv)) {
  61. npad =
  62.     ((DB_CIPHER *)dbenv->crypto_handle)->adj_size(logrec.size);
  63. logrec.size += npad;
  64. }
  66. if ((ret = __os_malloc(dbenv,
  67.     logrec.size, &logrec.data)) != 0)
  68. return (ret);
  70. if (npad > 0)
  71. memset((u_int8_t *)logrec.data + logrec.size - npad, 0, npad);
  73. bp = logrec.data;
  75. memcpy(bp, &rectype, sizeof(rectype));
  76. bp += sizeof(rectype);
  78. memcpy(bp, &txn_num, sizeof(txn_num));
  79. bp += sizeof(txn_num);
  81. memcpy(bp, lsnp, sizeof(DB_LSN));
  82. bp += sizeof(DB_LSN);
  84. uinttmp = (u_int32_t)opcode;
  85. memcpy(bp, &uinttmp, sizeof(uinttmp));
  86. bp += sizeof(uinttmp);
  88. uinttmp = (u_int32_t)timestamp;
  89. memcpy(bp, &uinttmp, sizeof(uinttmp));
  90. bp += sizeof(uinttmp);
  92. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
  93. ret = dbenv->log_put(dbenv,
  94.    ret_lsnp, (DBT *)&logrec, flags | DB_NOCOPY);
  95. if (txnid != NULL && ret == 0)
  96. txnid->last_lsn = *ret_lsnp;
  97. #ifdef LOG_DIAGNOSTIC
  98. if (ret != 0)
  99. (void)__txn_regop_print(dbenv,
  100.     (DBT *)&logrec, ret_lsnp, NULL, NULL);
  101. #endif
  102. __os_free(dbenv, logrec.data);
  103. return (ret);
  104. }
  106. /*
  107.  * PUBLIC: int __txn_regop_getpgnos __P((DB_ENV *, DBT *, DB_LSN *,
  108.  * PUBLIC:     db_recops, void *));
  109.  */
  110. int
  111. __txn_regop_getpgnos(dbenv, rec, lsnp, notused1, summary)
  112. DB_ENV *dbenv;
  113. DBT *rec;
  114. DB_LSN *lsnp;
  115. db_recops notused1;
  116. void *summary;
  117. {
  118. TXN_RECS *t;
  119. int ret;
  120. COMPQUIET(rec, NULL);
  121. COMPQUIET(notused1, DB_TXN_ABORT);
  123. t = (TXN_RECS *)summary;
  125. if ((ret = __rep_check_alloc(dbenv, t, 1)) != 0)
  126. return (ret);
  128. t->array[t->npages].flags = LSN_PAGE_NOLOCK;
  129. t->array[t->npages].lsn = *lsnp;
  130. t->array[t->npages].fid = DB_LOGFILEID_INVALID;
  131. memset(&t->array[t->npages].pgdesc, 0,
  132.     sizeof(t->array[t->npages].pgdesc));
  134. t->npages++;
  136. return (0);
  137. }
  139. /*
  140.  * PUBLIC: int __txn_regop_print __P((DB_ENV *, DBT *, DB_LSN *,
  141.  * PUBLIC:     db_recops, void *));
  142.  */
  143. int
  144. __txn_regop_print(dbenv, dbtp, lsnp, notused2, notused3)
  145. DB_ENV *dbenv;
  146. DBT *dbtp;
  147. DB_LSN *lsnp;
  148. db_recops notused2;
  149. void *notused3;
  150. {
  151. __txn_regop_args *argp;
  152. int ret;
  154. notused2 = DB_TXN_ABORT;
  155. notused3 = NULL;
  157. if ((ret = __txn_regop_read(dbenv, dbtp->data, &argp)) != 0)
  158. return (ret);
  159. (void)printf(
  160.     "[%lu][%lu]__txn_regop: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  161.     (u_long)lsnp->file,
  162.     (u_long)lsnp->offset,
  163.     (u_long)argp->type,
  164.     (u_long)argp->txnid->txnid,
  165.     (u_long)argp->prev_lsn.file,
  166.     (u_long)argp->prev_lsn.offset);
  167. (void)printf("topcode: %lun", (u_long)argp->opcode);
  168. (void)printf("ttimestamp: %ldn", (long)argp->timestamp);
  169. (void)printf("n");
  170. __os_free(dbenv, argp);
  171. return (0);
  172. }
  174. /*
  175.  * PUBLIC: int __txn_regop_read __P((DB_ENV *, void *, __txn_regop_args **));
  176.  */
  177. int
  178. __txn_regop_read(dbenv, recbuf, argpp)
  179. DB_ENV *dbenv;
  180. void *recbuf;
  181. __txn_regop_args **argpp;
  182. {
  183. __txn_regop_args *argp;
  184. u_int32_t uinttmp;
  185. u_int8_t *bp;
  186. int ret;
  188. if ((ret = __os_malloc(dbenv,
  189.     sizeof(__txn_regop_args) + sizeof(DB_TXN), &argp)) != 0)
  190. return (ret);
  192. argp->txnid = (DB_TXN *)&argp[1];
  194. bp = recbuf;
  195. memcpy(&argp->type, bp, sizeof(argp->type));
  196. bp += sizeof(argp->type);
  198. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  199. bp += sizeof(argp->txnid->txnid);
  201. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  202. bp += sizeof(DB_LSN);
  204. memcpy(&uinttmp, bp, sizeof(uinttmp));
  205. argp->opcode = (u_int32_t)uinttmp;
  206. bp += sizeof(uinttmp);
  208. memcpy(&uinttmp, bp, sizeof(uinttmp));
  209. argp->timestamp = (int32_t)uinttmp;
  210. bp += sizeof(uinttmp);
  212. *argpp = argp;
  213. return (0);
  214. }
  216. /*
  217.  * PUBLIC: int __txn_ckp_log __P((DB_ENV *, DB_TXN *, DB_LSN *,
  218.  * PUBLIC:     u_int32_t, DB_LSN *, DB_LSN *, int32_t));
  219.  */
  220. int
  221. __txn_ckp_log(dbenv, txnid, ret_lsnp, flags,
  222.     ckp_lsn, last_ckp, timestamp)
  223. DB_ENV *dbenv;
  224. DB_TXN *txnid;
  225. DB_LSN *ret_lsnp;
  226. u_int32_t flags;
  227. DB_LSN * ckp_lsn;
  228. DB_LSN * last_ckp;
  229. int32_t timestamp;
  230. {
  231. DBT logrec;
  232. DB_LSN *lsnp, null_lsn;
  233. u_int32_t uinttmp;
  234. u_int32_t npad, rectype, txn_num;
  235. int ret;
  236. u_int8_t *bp;
  238. rectype = DB___txn_ckp;
  239. npad = 0;
  241. if (txnid == NULL) {
  242. txn_num = 0;
  243. null_lsn.file = 0;
  244. null_lsn.offset = 0;
  245. lsnp = &null_lsn;
  246. } else {
  247. if (TAILQ_FIRST(&txnid->kids) != NULL &&
  248.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  249. return (ret);
  250. txn_num = txnid->txnid;
  251. lsnp = &txnid->last_lsn;
  252. }
  254. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  255.     + sizeof(*ckp_lsn)
  256.     + sizeof(*last_ckp)
  257.     + sizeof(u_int32_t);
  258. if (CRYPTO_ON(dbenv)) {
  259. npad =
  260.     ((DB_CIPHER *)dbenv->crypto_handle)->adj_size(logrec.size);
  261. logrec.size += npad;
  262. }
  264. if ((ret = __os_malloc(dbenv,
  265.     logrec.size, &logrec.data)) != 0)
  266. return (ret);
  268. if (npad > 0)
  269. memset((u_int8_t *)logrec.data + logrec.size - npad, 0, npad);
  271. bp = logrec.data;
  273. memcpy(bp, &rectype, sizeof(rectype));
  274. bp += sizeof(rectype);
  276. memcpy(bp, &txn_num, sizeof(txn_num));
  277. bp += sizeof(txn_num);
  279. memcpy(bp, lsnp, sizeof(DB_LSN));
  280. bp += sizeof(DB_LSN);
  282. if (ckp_lsn != NULL)
  283. memcpy(bp, ckp_lsn, sizeof(*ckp_lsn));
  284. else
  285. memset(bp, 0, sizeof(*ckp_lsn));
  286. bp += sizeof(*ckp_lsn);
  288. if (last_ckp != NULL)
  289. memcpy(bp, last_ckp, sizeof(*last_ckp));
  290. else
  291. memset(bp, 0, sizeof(*last_ckp));
  292. bp += sizeof(*last_ckp);
  294. uinttmp = (u_int32_t)timestamp;
  295. memcpy(bp, &uinttmp, sizeof(uinttmp));
  296. bp += sizeof(uinttmp);
  298. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
  299. ret = dbenv->log_put(dbenv,
  300.    ret_lsnp, (DBT *)&logrec, flags | DB_NOCOPY);
  301. if (txnid != NULL && ret == 0)
  302. txnid->last_lsn = *ret_lsnp;
  303. #ifdef LOG_DIAGNOSTIC
  304. if (ret != 0)
  305. (void)__txn_ckp_print(dbenv,
  306.     (DBT *)&logrec, ret_lsnp, NULL, NULL);
  307. #endif
  308. __os_free(dbenv, logrec.data);
  309. return (ret);
  310. }
  312. /*
  313.  * PUBLIC: int __txn_ckp_getpgnos __P((DB_ENV *, DBT *, DB_LSN *,
  314.  * PUBLIC:     db_recops, void *));
  315.  */
  316. int
  317. __txn_ckp_getpgnos(dbenv, rec, lsnp, notused1, summary)
  318. DB_ENV *dbenv;
  319. DBT *rec;
  320. DB_LSN *lsnp;
  321. db_recops notused1;
  322. void *summary;
  323. {
  324. TXN_RECS *t;
  325. int ret;
  326. COMPQUIET(rec, NULL);
  327. COMPQUIET(notused1, DB_TXN_ABORT);
  329. t = (TXN_RECS *)summary;
  331. if ((ret = __rep_check_alloc(dbenv, t, 1)) != 0)
  332. return (ret);
  334. t->array[t->npages].flags = LSN_PAGE_NOLOCK;
  335. t->array[t->npages].lsn = *lsnp;
  336. t->array[t->npages].fid = DB_LOGFILEID_INVALID;
  337. memset(&t->array[t->npages].pgdesc, 0,
  338.     sizeof(t->array[t->npages].pgdesc));
  340. t->npages++;
  342. return (0);
  343. }
  345. /*
  346.  * PUBLIC: int __txn_ckp_print __P((DB_ENV *, DBT *, DB_LSN *,
  347.  * PUBLIC:     db_recops, void *));
  348.  */
  349. int
  350. __txn_ckp_print(dbenv, dbtp, lsnp, notused2, notused3)
  351. DB_ENV *dbenv;
  352. DBT *dbtp;
  353. DB_LSN *lsnp;
  354. db_recops notused2;
  355. void *notused3;
  356. {
  357. __txn_ckp_args *argp;
  358. int ret;
  360. notused2 = DB_TXN_ABORT;
  361. notused3 = NULL;
  363. if ((ret = __txn_ckp_read(dbenv, dbtp->data, &argp)) != 0)
  364. return (ret);
  365. (void)printf(
  366.     "[%lu][%lu]__txn_ckp: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  367.     (u_long)lsnp->file,
  368.     (u_long)lsnp->offset,
  369.     (u_long)argp->type,
  370.     (u_long)argp->txnid->txnid,
  371.     (u_long)argp->prev_lsn.file,
  372.     (u_long)argp->prev_lsn.offset);
  373. (void)printf("tckp_lsn: [%lu][%lu]n",
  374.     (u_long)argp->ckp_lsn.file, (u_long)argp->ckp_lsn.offset);
  375. (void)printf("tlast_ckp: [%lu][%lu]n",
  376.     (u_long)argp->last_ckp.file, (u_long)argp->last_ckp.offset);
  377. (void)printf("ttimestamp: %ldn", (long)argp->timestamp);
  378. (void)printf("n");
  379. __os_free(dbenv, argp);
  380. return (0);
  381. }
  383. /*
  384.  * PUBLIC: int __txn_ckp_read __P((DB_ENV *, void *, __txn_ckp_args **));
  385.  */
  386. int
  387. __txn_ckp_read(dbenv, recbuf, argpp)
  388. DB_ENV *dbenv;
  389. void *recbuf;
  390. __txn_ckp_args **argpp;
  391. {
  392. __txn_ckp_args *argp;
  393. u_int32_t uinttmp;
  394. u_int8_t *bp;
  395. int ret;
  397. if ((ret = __os_malloc(dbenv,
  398.     sizeof(__txn_ckp_args) + sizeof(DB_TXN), &argp)) != 0)
  399. return (ret);
  401. argp->txnid = (DB_TXN *)&argp[1];
  403. bp = recbuf;
  404. memcpy(&argp->type, bp, sizeof(argp->type));
  405. bp += sizeof(argp->type);
  407. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  408. bp += sizeof(argp->txnid->txnid);
  410. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  411. bp += sizeof(DB_LSN);
  413. memcpy(&argp->ckp_lsn, bp,  sizeof(argp->ckp_lsn));
  414. bp += sizeof(argp->ckp_lsn);
  416. memcpy(&argp->last_ckp, bp,  sizeof(argp->last_ckp));
  417. bp += sizeof(argp->last_ckp);
  419. memcpy(&uinttmp, bp, sizeof(uinttmp));
  420. argp->timestamp = (int32_t)uinttmp;
  421. bp += sizeof(uinttmp);
  423. *argpp = argp;
  424. return (0);
  425. }
  427. /*
  428.  * PUBLIC: int __txn_child_log __P((DB_ENV *, DB_TXN *, DB_LSN *,
  429.  * PUBLIC:     u_int32_t, u_int32_t, DB_LSN *));
  430.  */
  431. int
  432. __txn_child_log(dbenv, txnid, ret_lsnp, flags,
  433.     child, c_lsn)
  434. DB_ENV *dbenv;
  435. DB_TXN *txnid;
  436. DB_LSN *ret_lsnp;
  437. u_int32_t flags;
  438. u_int32_t child;
  439. DB_LSN * c_lsn;
  440. {
  441. DBT logrec;
  442. DB_LSN *lsnp, null_lsn;
  443. u_int32_t uinttmp;
  444. u_int32_t npad, rectype, txn_num;
  445. int ret;
  446. u_int8_t *bp;
  448. rectype = DB___txn_child;
  449. npad = 0;
  451. if (txnid == NULL) {
  452. txn_num = 0;
  453. null_lsn.file = 0;
  454. null_lsn.offset = 0;
  455. lsnp = &null_lsn;
  456. } else {
  457. if (TAILQ_FIRST(&txnid->kids) != NULL &&
  458.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  459. return (ret);
  460. txn_num = txnid->txnid;
  461. lsnp = &txnid->last_lsn;
  462. }
  464. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  465.     + sizeof(u_int32_t)
  466.     + sizeof(*c_lsn);
  467. if (CRYPTO_ON(dbenv)) {
  468. npad =
  469.     ((DB_CIPHER *)dbenv->crypto_handle)->adj_size(logrec.size);
  470. logrec.size += npad;
  471. }
  473. if ((ret = __os_malloc(dbenv,
  474.     logrec.size, &logrec.data)) != 0)
  475. return (ret);
  477. if (npad > 0)
  478. memset((u_int8_t *)logrec.data + logrec.size - npad, 0, npad);
  480. bp = logrec.data;
  482. memcpy(bp, &rectype, sizeof(rectype));
  483. bp += sizeof(rectype);
  485. memcpy(bp, &txn_num, sizeof(txn_num));
  486. bp += sizeof(txn_num);
  488. memcpy(bp, lsnp, sizeof(DB_LSN));
  489. bp += sizeof(DB_LSN);
  491. uinttmp = (u_int32_t)child;
  492. memcpy(bp, &uinttmp, sizeof(uinttmp));
  493. bp += sizeof(uinttmp);
  495. if (c_lsn != NULL)
  496. memcpy(bp, c_lsn, sizeof(*c_lsn));
  497. else
  498. memset(bp, 0, sizeof(*c_lsn));
  499. bp += sizeof(*c_lsn);
  501. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
  502. ret = dbenv->log_put(dbenv,
  503.    ret_lsnp, (DBT *)&logrec, flags | DB_NOCOPY);
  504. if (txnid != NULL && ret == 0)
  505. txnid->last_lsn = *ret_lsnp;
  506. #ifdef LOG_DIAGNOSTIC
  507. if (ret != 0)
  508. (void)__txn_child_print(dbenv,
  509.     (DBT *)&logrec, ret_lsnp, NULL, NULL);
  510. #endif
  511. __os_free(dbenv, logrec.data);
  512. return (ret);
  513. }
  515. /*
  516.  * PUBLIC: int __txn_child_getpgnos __P((DB_ENV *, DBT *, DB_LSN *,
  517.  * PUBLIC:     db_recops, void *));
  518.  */
  519. int
  520. __txn_child_getpgnos(dbenv, rec, lsnp, notused1, summary)
  521. DB_ENV *dbenv;
  522. DBT *rec;
  523. DB_LSN *lsnp;
  524. db_recops notused1;
  525. void *summary;
  526. {
  527. TXN_RECS *t;
  528. int ret;
  529. COMPQUIET(rec, NULL);
  530. COMPQUIET(notused1, DB_TXN_ABORT);
  532. t = (TXN_RECS *)summary;
  534. if ((ret = __rep_check_alloc(dbenv, t, 1)) != 0)
  535. return (ret);
  537. t->array[t->npages].flags = LSN_PAGE_NOLOCK;
  538. t->array[t->npages].lsn = *lsnp;
  539. t->array[t->npages].fid = DB_LOGFILEID_INVALID;
  540. memset(&t->array[t->npages].pgdesc, 0,
  541.     sizeof(t->array[t->npages].pgdesc));
  543. t->npages++;
  545. return (0);
  546. }
  548. /*
  549.  * PUBLIC: int __txn_child_print __P((DB_ENV *, DBT *, DB_LSN *,
  550.  * PUBLIC:     db_recops, void *));
  551.  */
  552. int
  553. __txn_child_print(dbenv, dbtp, lsnp, notused2, notused3)
  554. DB_ENV *dbenv;
  555. DBT *dbtp;
  556. DB_LSN *lsnp;
  557. db_recops notused2;
  558. void *notused3;
  559. {
  560. __txn_child_args *argp;
  561. int ret;
  563. notused2 = DB_TXN_ABORT;
  564. notused3 = NULL;
  566. if ((ret = __txn_child_read(dbenv, dbtp->data, &argp)) != 0)
  567. return (ret);
  568. (void)printf(
  569.     "[%lu][%lu]__txn_child: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  570.     (u_long)lsnp->file,
  571.     (u_long)lsnp->offset,
  572.     (u_long)argp->type,
  573.     (u_long)argp->txnid->txnid,
  574.     (u_long)argp->prev_lsn.file,
  575.     (u_long)argp->prev_lsn.offset);
  576. (void)printf("tchild: 0x%lxn", (u_long)argp->child);
  577. (void)printf("tc_lsn: [%lu][%lu]n",
  578.     (u_long)argp->c_lsn.file, (u_long)argp->c_lsn.offset);
  579. (void)printf("n");
  580. __os_free(dbenv, argp);
  581. return (0);
  582. }
  584. /*
  585.  * PUBLIC: int __txn_child_read __P((DB_ENV *, void *, __txn_child_args **));
  586.  */
  587. int
  588. __txn_child_read(dbenv, recbuf, argpp)
  589. DB_ENV *dbenv;
  590. void *recbuf;
  591. __txn_child_args **argpp;
  592. {
  593. __txn_child_args *argp;
  594. u_int32_t uinttmp;
  595. u_int8_t *bp;
  596. int ret;
  598. if ((ret = __os_malloc(dbenv,
  599.     sizeof(__txn_child_args) + sizeof(DB_TXN), &argp)) != 0)
  600. return (ret);
  602. argp->txnid = (DB_TXN *)&argp[1];
  604. bp = recbuf;
  605. memcpy(&argp->type, bp, sizeof(argp->type));
  606. bp += sizeof(argp->type);
  608. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  609. bp += sizeof(argp->txnid->txnid);
  611. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  612. bp += sizeof(DB_LSN);
  614. memcpy(&uinttmp, bp, sizeof(uinttmp));
  615. argp->child = (u_int32_t)uinttmp;
  616. bp += sizeof(uinttmp);
  618. memcpy(&argp->c_lsn, bp,  sizeof(argp->c_lsn));
  619. bp += sizeof(argp->c_lsn);
  621. *argpp = argp;
  622. return (0);
  623. }
  625. /*
  626.  * PUBLIC: int __txn_xa_regop_log __P((DB_ENV *, DB_TXN *, DB_LSN *,
  627.  * PUBLIC:     u_int32_t, u_int32_t, const DBT *, int32_t, u_int32_t, u_int32_t,
  628.  * PUBLIC:     DB_LSN *));
  629.  */
  630. int
  631. __txn_xa_regop_log(dbenv, txnid, ret_lsnp, flags,
  632.     opcode, xid, formatID, gtrid, bqual, begin_lsn)
  633. DB_ENV *dbenv;
  634. DB_TXN *txnid;
  635. DB_LSN *ret_lsnp;
  636. u_int32_t flags;
  637. u_int32_t opcode;
  638. const DBT *xid;
  639. int32_t formatID;
  640. u_int32_t gtrid;
  641. u_int32_t bqual;
  642. DB_LSN * begin_lsn;
  643. {
  644. DBT logrec;
  645. DB_LSN *lsnp, null_lsn;
  646. u_int32_t zero;
  647. u_int32_t uinttmp;
  648. u_int32_t npad, rectype, txn_num;
  649. int ret;
  650. u_int8_t *bp;
  652. rectype = DB___txn_xa_regop;
  653. npad = 0;
  655. if (txnid == NULL) {
  656. txn_num = 0;
  657. null_lsn.file = 0;
  658. null_lsn.offset = 0;
  659. lsnp = &null_lsn;
  660. } else {
  661. if (TAILQ_FIRST(&txnid->kids) != NULL &&
  662.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  663. return (ret);
  664. txn_num = txnid->txnid;
  665. lsnp = &txnid->last_lsn;
  666. }
  668. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  669.     + sizeof(u_int32_t)
  670.     + sizeof(u_int32_t) + (xid == NULL ? 0 : xid->size)
  671.     + sizeof(u_int32_t)
  672.     + sizeof(u_int32_t)
  673.     + sizeof(u_int32_t)
  674.     + sizeof(*begin_lsn);
  675. if (CRYPTO_ON(dbenv)) {
  676. npad =
  677.     ((DB_CIPHER *)dbenv->crypto_handle)->adj_size(logrec.size);
  678. logrec.size += npad;
  679. }
  681. if ((ret = __os_malloc(dbenv,
  682.     logrec.size, &logrec.data)) != 0)
  683. return (ret);
  685. if (npad > 0)
  686. memset((u_int8_t *)logrec.data + logrec.size - npad, 0, npad);
  688. bp = logrec.data;
  690. memcpy(bp, &rectype, sizeof(rectype));
  691. bp += sizeof(rectype);
  693. memcpy(bp, &txn_num, sizeof(txn_num));
  694. bp += sizeof(txn_num);
  696. memcpy(bp, lsnp, sizeof(DB_LSN));
  697. bp += sizeof(DB_LSN);
  699. uinttmp = (u_int32_t)opcode;
  700. memcpy(bp, &uinttmp, sizeof(uinttmp));
  701. bp += sizeof(uinttmp);
  703. if (xid == NULL) {
  704. zero = 0;
  705. memcpy(bp, &zero, sizeof(u_int32_t));
  706. bp += sizeof(u_int32_t);
  707. } else {
  708. memcpy(bp, &xid->size, sizeof(xid->size));
  709. bp += sizeof(xid->size);
  710. memcpy(bp, xid->data, xid->size);
  711. bp += xid->size;
  712. }
  714. uinttmp = (u_int32_t)formatID;
  715. memcpy(bp, &uinttmp, sizeof(uinttmp));
  716. bp += sizeof(uinttmp);
  718. uinttmp = (u_int32_t)gtrid;
  719. memcpy(bp, &uinttmp, sizeof(uinttmp));
  720. bp += sizeof(uinttmp);
  722. uinttmp = (u_int32_t)bqual;
  723. memcpy(bp, &uinttmp, sizeof(uinttmp));
  724. bp += sizeof(uinttmp);
  726. if (begin_lsn != NULL)
  727. memcpy(bp, begin_lsn, sizeof(*begin_lsn));
  728. else
  729. memset(bp, 0, sizeof(*begin_lsn));
  730. bp += sizeof(*begin_lsn);
  732. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
  733. ret = dbenv->log_put(dbenv,
  734.    ret_lsnp, (DBT *)&logrec, flags | DB_NOCOPY);
  735. if (txnid != NULL && ret == 0)
  736. txnid->last_lsn = *ret_lsnp;
  737. #ifdef LOG_DIAGNOSTIC
  738. if (ret != 0)
  739. (void)__txn_xa_regop_print(dbenv,
  740.     (DBT *)&logrec, ret_lsnp, NULL, NULL);
  741. #endif
  742. __os_free(dbenv, logrec.data);
  743. return (ret);
  744. }
  746. /*
  747.  * PUBLIC: int __txn_xa_regop_getpgnos __P((DB_ENV *, DBT *,
  748.  * PUBLIC:     DB_LSN *, db_recops, void *));
  749.  */
  750. int
  751. __txn_xa_regop_getpgnos(dbenv, rec, lsnp, notused1, summary)
  752. DB_ENV *dbenv;
  753. DBT *rec;
  754. DB_LSN *lsnp;
  755. db_recops notused1;
  756. void *summary;
  757. {
  758. TXN_RECS *t;
  759. int ret;
  760. COMPQUIET(rec, NULL);
  761. COMPQUIET(notused1, DB_TXN_ABORT);
  763. t = (TXN_RECS *)summary;
  765. if ((ret = __rep_check_alloc(dbenv, t, 1)) != 0)
  766. return (ret);
  768. t->array[t->npages].flags = LSN_PAGE_NOLOCK;
  769. t->array[t->npages].lsn = *lsnp;
  770. t->array[t->npages].fid = DB_LOGFILEID_INVALID;
  771. memset(&t->array[t->npages].pgdesc, 0,
  772.     sizeof(t->array[t->npages].pgdesc));
  774. t->npages++;
  776. return (0);
  777. }
  779. /*
  780.  * PUBLIC: int __txn_xa_regop_print __P((DB_ENV *, DBT *, DB_LSN *,
  781.  * PUBLIC:     db_recops, void *));
  782.  */
  783. int
  784. __txn_xa_regop_print(dbenv, dbtp, lsnp, notused2, notused3)
  785. DB_ENV *dbenv;
  786. DBT *dbtp;
  787. DB_LSN *lsnp;
  788. db_recops notused2;
  789. void *notused3;
  790. {
  791. __txn_xa_regop_args *argp;
  792. u_int32_t i;
  793. int ch;
  794. int ret;
  796. notused2 = DB_TXN_ABORT;
  797. notused3 = NULL;
  799. if ((ret = __txn_xa_regop_read(dbenv, dbtp->data, &argp)) != 0)
  800. return (ret);
  801. (void)printf(
  802.     "[%lu][%lu]__txn_xa_regop: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  803.     (u_long)lsnp->file,
  804.     (u_long)lsnp->offset,
  805.     (u_long)argp->type,
  806.     (u_long)argp->txnid->txnid,
  807.     (u_long)argp->prev_lsn.file,
  808.     (u_long)argp->prev_lsn.offset);
  809. (void)printf("topcode: %lun", (u_long)argp->opcode);
  810. (void)printf("txid: ");
  811. for (i = 0; i < argp->xid.size; i++) {
  812. ch = ((u_int8_t *)argp->xid.data)[i];
  813. printf(isprint(ch) || ch == 0x0a ? "%c" : "%#x ", ch);
  814. }
  815. (void)printf("n");
  816. (void)printf("tformatID: %ldn", (long)argp->formatID);
  817. (void)printf("tgtrid: %un", argp->gtrid);
  818. (void)printf("tbqual: %un", argp->bqual);
  819. (void)printf("tbegin_lsn: [%lu][%lu]n",
  820.     (u_long)argp->begin_lsn.file, (u_long)argp->begin_lsn.offset);
  821. (void)printf("n");
  822. __os_free(dbenv, argp);
  823. return (0);
  824. }
  826. /*
  827.  * PUBLIC: int __txn_xa_regop_read __P((DB_ENV *, void *,
  828.  * PUBLIC:     __txn_xa_regop_args **));
  829.  */
  830. int
  831. __txn_xa_regop_read(dbenv, recbuf, argpp)
  832. DB_ENV *dbenv;
  833. void *recbuf;
  834. __txn_xa_regop_args **argpp;
  835. {
  836. __txn_xa_regop_args *argp;
  837. u_int32_t uinttmp;
  838. u_int8_t *bp;
  839. int ret;
  841. if ((ret = __os_malloc(dbenv,
  842.     sizeof(__txn_xa_regop_args) + sizeof(DB_TXN), &argp)) != 0)
  843. return (ret);
  845. argp->txnid = (DB_TXN *)&argp[1];
  847. bp = recbuf;
  848. memcpy(&argp->type, bp, sizeof(argp->type));
  849. bp += sizeof(argp->type);
  851. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  852. bp += sizeof(argp->txnid->txnid);
  854. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  855. bp += sizeof(DB_LSN);
  857. memcpy(&uinttmp, bp, sizeof(uinttmp));
  858. argp->opcode = (u_int32_t)uinttmp;
  859. bp += sizeof(uinttmp);
  861. memset(&argp->xid, 0, sizeof(argp->xid));
  862. memcpy(&argp->xid.size, bp, sizeof(u_int32_t));
  863. bp += sizeof(u_int32_t);
  864. argp->xid.data = bp;
  865. bp += argp->xid.size;
  867. memcpy(&uinttmp, bp, sizeof(uinttmp));
  868. argp->formatID = (int32_t)uinttmp;
  869. bp += sizeof(uinttmp);
  871. memcpy(&uinttmp, bp, sizeof(uinttmp));
  872. argp->gtrid = (u_int32_t)uinttmp;
  873. bp += sizeof(uinttmp);
  875. memcpy(&uinttmp, bp, sizeof(uinttmp));
  876. argp->bqual = (u_int32_t)uinttmp;
  877. bp += sizeof(uinttmp);
  879. memcpy(&argp->begin_lsn, bp,  sizeof(argp->begin_lsn));
  880. bp += sizeof(argp->begin_lsn);
  882. *argpp = argp;
  883. return (0);
  884. }
  886. /*
  887.  * PUBLIC: int __txn_recycle_log __P((DB_ENV *, DB_TXN *, DB_LSN *,
  888.  * PUBLIC:     u_int32_t, u_int32_t, u_int32_t));
  889.  */
  890. int
  891. __txn_recycle_log(dbenv, txnid, ret_lsnp, flags,
  892.     min, max)
  893. DB_ENV *dbenv;
  894. DB_TXN *txnid;
  895. DB_LSN *ret_lsnp;
  896. u_int32_t flags;
  897. u_int32_t min;
  898. u_int32_t max;
  899. {
  900. DBT logrec;
  901. DB_LSN *lsnp, null_lsn;
  902. u_int32_t uinttmp;
  903. u_int32_t npad, rectype, txn_num;
  904. int ret;
  905. u_int8_t *bp;
  907. rectype = DB___txn_recycle;
  908. npad = 0;
  910. if (txnid == NULL) {
  911. txn_num = 0;
  912. null_lsn.file = 0;
  913. null_lsn.offset = 0;
  914. lsnp = &null_lsn;
  915. } else {
  916. if (TAILQ_FIRST(&txnid->kids) != NULL &&
  917.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  918. return (ret);
  919. txn_num = txnid->txnid;
  920. lsnp = &txnid->last_lsn;
  921. }
  923. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  924.     + sizeof(u_int32_t)
  925.     + sizeof(u_int32_t);
  926. if (CRYPTO_ON(dbenv)) {
  927. npad =
  928.     ((DB_CIPHER *)dbenv->crypto_handle)->adj_size(logrec.size);
  929. logrec.size += npad;
  930. }
  932. if ((ret = __os_malloc(dbenv,
  933.     logrec.size, &logrec.data)) != 0)
  934. return (ret);
  936. if (npad > 0)
  937. memset((u_int8_t *)logrec.data + logrec.size - npad, 0, npad);
  939. bp = logrec.data;
  941. memcpy(bp, &rectype, sizeof(rectype));
  942. bp += sizeof(rectype);
  944. memcpy(bp, &txn_num, sizeof(txn_num));
  945. bp += sizeof(txn_num);
  947. memcpy(bp, lsnp, sizeof(DB_LSN));
  948. bp += sizeof(DB_LSN);
  950. uinttmp = (u_int32_t)min;
  951. memcpy(bp, &uinttmp, sizeof(uinttmp));
  952. bp += sizeof(uinttmp);
  954. uinttmp = (u_int32_t)max;
  955. memcpy(bp, &uinttmp, sizeof(uinttmp));
  956. bp += sizeof(uinttmp);
  958. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
  959. ret = dbenv->log_put(dbenv,
  960.    ret_lsnp, (DBT *)&logrec, flags | DB_NOCOPY);
  961. if (txnid != NULL && ret == 0)
  962. txnid->last_lsn = *ret_lsnp;
  963. #ifdef LOG_DIAGNOSTIC
  964. if (ret != 0)
  965. (void)__txn_recycle_print(dbenv,
  966.     (DBT *)&logrec, ret_lsnp, NULL, NULL);
  967. #endif
  968. __os_free(dbenv, logrec.data);
  969. return (ret);
  970. }
  972. /*
  973.  * PUBLIC: int __txn_recycle_getpgnos __P((DB_ENV *, DBT *, DB_LSN *,
  974.  * PUBLIC:     db_recops, void *));
  975.  */
  976. int
  977. __txn_recycle_getpgnos(dbenv, rec, lsnp, notused1, summary)
  978. DB_ENV *dbenv;
  979. DBT *rec;
  980. DB_LSN *lsnp;
  981. db_recops notused1;
  982. void *summary;
  983. {
  984. TXN_RECS *t;
  985. int ret;
  986. COMPQUIET(rec, NULL);
  987. COMPQUIET(notused1, DB_TXN_ABORT);
  989. t = (TXN_RECS *)summary;
  991. if ((ret = __rep_check_alloc(dbenv, t, 1)) != 0)
  992. return (ret);
  994. t->array[t->npages].flags = LSN_PAGE_NOLOCK;
  995. t->array[t->npages].lsn = *lsnp;
  996. t->array[t->npages].fid = DB_LOGFILEID_INVALID;
  997. memset(&t->array[t->npages].pgdesc, 0,
  998.     sizeof(t->array[t->npages].pgdesc));
  1000. t->npages++;
  1002. return (0);
  1003. }
  1005. /*
  1006.  * PUBLIC: int __txn_recycle_print __P((DB_ENV *, DBT *, DB_LSN *,
  1007.  * PUBLIC:     db_recops, void *));
  1008.  */
  1009. int
  1010. __txn_recycle_print(dbenv, dbtp, lsnp, notused2, notused3)
  1011. DB_ENV *dbenv;
  1012. DBT *dbtp;
  1013. DB_LSN *lsnp;
  1014. db_recops notused2;
  1015. void *notused3;
  1016. {
  1017. __txn_recycle_args *argp;
  1018. int ret;
  1020. notused2 = DB_TXN_ABORT;
  1021. notused3 = NULL;
  1023. if ((ret = __txn_recycle_read(dbenv, dbtp->data, &argp)) != 0)
  1024. return (ret);
  1025. (void)printf(
  1026.     "[%lu][%lu]__txn_recycle: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  1027.     (u_long)lsnp->file,
  1028.     (u_long)lsnp->offset,
  1029.     (u_long)argp->type,
  1030.     (u_long)argp->txnid->txnid,
  1031.     (u_long)argp->prev_lsn.file,
  1032.     (u_long)argp->prev_lsn.offset);
  1033. (void)printf("tmin: %un", argp->min);
  1034. (void)printf("tmax: %un", argp->max);
  1035. (void)printf("n");
  1036. __os_free(dbenv, argp);
  1037. return (0);
  1038. }
  1040. /*
  1041.  * PUBLIC: int __txn_recycle_read __P((DB_ENV *, void *,
  1042.  * PUBLIC:     __txn_recycle_args **));
  1043.  */
  1044. int
  1045. __txn_recycle_read(dbenv, recbuf, argpp)
  1046. DB_ENV *dbenv;
  1047. void *recbuf;
  1048. __txn_recycle_args **argpp;
  1049. {
  1050. __txn_recycle_args *argp;
  1051. u_int32_t uinttmp;
  1052. u_int8_t *bp;
  1053. int ret;
  1055. if ((ret = __os_malloc(dbenv,
  1056.     sizeof(__txn_recycle_args) + sizeof(DB_TXN), &argp)) != 0)
  1057. return (ret);
  1059. argp->txnid = (DB_TXN *)&argp[1];
  1061. bp = recbuf;
  1062. memcpy(&argp->type, bp, sizeof(argp->type));
  1063. bp += sizeof(argp->type);
  1065. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  1066. bp += sizeof(argp->txnid->txnid);
  1068. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  1069. bp += sizeof(DB_LSN);
  1071. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1072. argp->min = (u_int32_t)uinttmp;
  1073. bp += sizeof(uinttmp);
  1075. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1076. argp->max = (u_int32_t)uinttmp;
  1077. bp += sizeof(uinttmp);
  1079. *argpp = argp;
  1080. return (0);
  1081. }
  1083. /*
  1084.  * PUBLIC: int __txn_init_print __P((DB_ENV *, int (***)(DB_ENV *,
  1085.  * PUBLIC:     DBT *, DB_LSN *, db_recops, void *), size_t *));
  1086.  */
  1087. int
  1088. __txn_init_print(dbenv, dtabp, dtabsizep)
  1089. DB_ENV *dbenv;
  1090. int (***dtabp)__P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  1091. size_t *dtabsizep;
  1092. {
  1093. int ret;
  1095. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  1096.     __txn_regop_print, DB___txn_regop)) != 0)
  1097. return (ret);
  1098. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  1099.     __txn_ckp_print, DB___txn_ckp)) != 0)
  1100. return (ret);
  1101. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  1102.     __txn_child_print, DB___txn_child)) != 0)
  1103. return (ret);
  1104. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  1105.     __txn_xa_regop_print, DB___txn_xa_regop)) != 0)
  1106. return (ret);
  1107. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  1108.     __txn_recycle_print, DB___txn_recycle)) != 0)
  1109. return (ret);
  1110. return (0);
  1111. }
  1113. /*
  1114.  * PUBLIC: int __txn_init_getpgnos __P((DB_ENV *, int (***)(DB_ENV *,
  1115.  * PUBLIC:     DBT *, DB_LSN *, db_recops, void *), size_t *));
  1116.  */
  1117. int
  1118. __txn_init_getpgnos(dbenv, dtabp, dtabsizep)
  1119. DB_ENV *dbenv;
  1120. int (***dtabp)__P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  1121. size_t *dtabsizep;
  1122. {
  1123. int ret;
  1125. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  1126.     __txn_regop_getpgnos, DB___txn_regop)) != 0)
  1127. return (ret);
  1128. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  1129.     __txn_ckp_getpgnos, DB___txn_ckp)) != 0)
  1130. return (ret);
  1131. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  1132.     __txn_child_getpgnos, DB___txn_child)) != 0)
  1133. return (ret);
  1134. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  1135.     __txn_xa_regop_getpgnos, DB___txn_xa_regop)) != 0)
  1136. return (ret);
  1137. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  1138.     __txn_recycle_getpgnos, DB___txn_recycle)) != 0)
  1139. return (ret);
  1140. return (0);
  1141. }
  1143. /*
  1144.  * PUBLIC: int __txn_init_recover __P((DB_ENV *, int (***)(DB_ENV *,
  1145.  * PUBLIC:     DBT *, DB_LSN *, db_recops, void *), size_t *));
  1146.  */
  1147. int
  1148. __txn_init_recover(dbenv, dtabp, dtabsizep)
  1149. DB_ENV *dbenv;
  1150. int (***dtabp)__P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  1151. size_t *dtabsizep;
  1152. {
  1153. int ret;
  1155. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  1156.     __txn_regop_recover, DB___txn_regop)) != 0)
  1157. return (ret);
  1158. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  1159.     __txn_ckp_recover, DB___txn_ckp)) != 0)
  1160. return (ret);
  1161. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  1162.     __txn_child_recover, DB___txn_child)) != 0)
  1163. return (ret);
  1164. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  1165.     __txn_xa_regop_recover, DB___txn_xa_regop)) != 0)
  1166. return (ret);
  1167. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  1168.     __txn_recycle_recover, DB___txn_recycle)) != 0)
  1169. return (ret);
  1170. return (0);
  1171. }