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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
txn_auto.c
资源名称：mysql-3.23.35.tar.gz　[点击查看]
上传用户：tsgydb
上传日期：2007-04-14
资源大小：10674k
文件大小：22k
源码类别：

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 <errno.h>
  9. #include <string.h>
  10. #endif
  12. #include "db_int.h"
  13. #include "db_page.h"
  14. #include "db_dispatch.h"
  15. #include "db_am.h"
  16. #include "txn.h"
  18. int
  19. __txn_old_regop_print(dbenv, dbtp, lsnp, notused2, notused3)
  20. DB_ENV *dbenv;
  21. DBT *dbtp;
  22. DB_LSN *lsnp;
  23. db_recops notused2;
  24. void *notused3;
  25. {
  26. __txn_old_regop_args *argp;
  27. u_int32_t i;
  28. u_int ch;
  29. int ret;
  31. i = 0;
  32. ch = 0;
  33. notused2 = DB_TXN_ABORT;
  34. notused3 = NULL;
  36. if ((ret = __txn_old_regop_read(dbenv, dbtp->data, &argp)) != 0)
  37. return (ret);
  38. printf("[%lu][%lu]txn_old_regop: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  39.     (u_long)lsnp->file,
  40.     (u_long)lsnp->offset,
  41.     (u_long)argp->type,
  42.     (u_long)argp->txnid->txnid,
  43.     (u_long)argp->prev_lsn.file,
  44.     (u_long)argp->prev_lsn.offset);
  45. printf("topcode: %lun", (u_long)argp->opcode);
  46. printf("n");
  47. __os_free(argp, 0);
  48. return (0);
  49. }
  51. int
  52. __txn_old_regop_read(dbenv, recbuf, argpp)
  53. DB_ENV *dbenv;
  54. void *recbuf;
  55. __txn_old_regop_args **argpp;
  56. {
  57. __txn_old_regop_args *argp;
  58. u_int8_t *bp;
  59. int ret;
  61. ret = __os_malloc(dbenv, sizeof(__txn_old_regop_args) +
  62.     sizeof(DB_TXN), NULL, &argp);
  63. if (ret != 0)
  64. return (ret);
  65. argp->txnid = (DB_TXN *)&argp[1];
  66. bp = recbuf;
  67. memcpy(&argp->type, bp, sizeof(argp->type));
  68. bp += sizeof(argp->type);
  69. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  70. bp += sizeof(argp->txnid->txnid);
  71. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  72. bp += sizeof(DB_LSN);
  73. memcpy(&argp->opcode, bp, sizeof(argp->opcode));
  74. bp += sizeof(argp->opcode);
  75. *argpp = argp;
  76. return (0);
  77. }
  79. int
  80. __txn_regop_log(dbenv, txnid, ret_lsnp, flags,
  81. opcode, timestamp)
  82. DB_ENV *dbenv;
  83. DB_TXN *txnid;
  84. DB_LSN *ret_lsnp;
  85. u_int32_t flags;
  86. u_int32_t opcode;
  87. int32_t timestamp;
  88. {
  89. DBT logrec;
  90. DB_LSN *lsnp, null_lsn;
  91. u_int32_t rectype, txn_num;
  92. int ret;
  93. u_int8_t *bp;
  95. rectype = DB_txn_regop;
  96. if (txnid != NULL &&
  97.     TAILQ_FIRST(&txnid->kids) != NULL &&
  98.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  99. return (ret);
  100. txn_num = txnid == NULL ? 0 : txnid->txnid;
  101. if (txnid == NULL) {
  102. ZERO_LSN(null_lsn);
  103. lsnp = &null_lsn;
  104. } else
  105. lsnp = &txnid->last_lsn;
  106. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  107.     + sizeof(opcode)
  108.     + sizeof(timestamp);
  109. if ((ret = __os_malloc(dbenv, logrec.size, NULL, &logrec.data)) != 0)
  110. return (ret);
  112. bp = logrec.data;
  113. memcpy(bp, &rectype, sizeof(rectype));
  114. bp += sizeof(rectype);
  115. memcpy(bp, &txn_num, sizeof(txn_num));
  116. bp += sizeof(txn_num);
  117. memcpy(bp, lsnp, sizeof(DB_LSN));
  118. bp += sizeof(DB_LSN);
  119. memcpy(bp, &opcode, sizeof(opcode));
  120. bp += sizeof(opcode);
  121. memcpy(bp, &timestamp, sizeof(timestamp));
  122. bp += sizeof(timestamp);
  123. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size);
  124. ret = log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags);
  125. if (txnid != NULL)
  126. txnid->last_lsn = *ret_lsnp;
  127. __os_free(logrec.data, logrec.size);
  128. return (ret);
  129. }
  131. int
  132. __txn_regop_print(dbenv, dbtp, lsnp, notused2, notused3)
  133. DB_ENV *dbenv;
  134. DBT *dbtp;
  135. DB_LSN *lsnp;
  136. db_recops notused2;
  137. void *notused3;
  138. {
  139. __txn_regop_args *argp;
  140. u_int32_t i;
  141. u_int ch;
  142. int ret;
  144. i = 0;
  145. ch = 0;
  146. notused2 = DB_TXN_ABORT;
  147. notused3 = NULL;
  149. if ((ret = __txn_regop_read(dbenv, dbtp->data, &argp)) != 0)
  150. return (ret);
  151. printf("[%lu][%lu]txn_regop: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  152.     (u_long)lsnp->file,
  153.     (u_long)lsnp->offset,
  154.     (u_long)argp->type,
  155.     (u_long)argp->txnid->txnid,
  156.     (u_long)argp->prev_lsn.file,
  157.     (u_long)argp->prev_lsn.offset);
  158. printf("topcode: %lun", (u_long)argp->opcode);
  159. printf("ttimestamp: %ldn", (long)argp->timestamp);
  160. printf("n");
  161. __os_free(argp, 0);
  162. return (0);
  163. }
  165. int
  166. __txn_regop_read(dbenv, recbuf, argpp)
  167. DB_ENV *dbenv;
  168. void *recbuf;
  169. __txn_regop_args **argpp;
  170. {
  171. __txn_regop_args *argp;
  172. u_int8_t *bp;
  173. int ret;
  175. ret = __os_malloc(dbenv, sizeof(__txn_regop_args) +
  176.     sizeof(DB_TXN), NULL, &argp);
  177. if (ret != 0)
  178. return (ret);
  179. argp->txnid = (DB_TXN *)&argp[1];
  180. bp = recbuf;
  181. memcpy(&argp->type, bp, sizeof(argp->type));
  182. bp += sizeof(argp->type);
  183. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  184. bp += sizeof(argp->txnid->txnid);
  185. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  186. bp += sizeof(DB_LSN);
  187. memcpy(&argp->opcode, bp, sizeof(argp->opcode));
  188. bp += sizeof(argp->opcode);
  189. memcpy(&argp->timestamp, bp, sizeof(argp->timestamp));
  190. bp += sizeof(argp->timestamp);
  191. *argpp = argp;
  192. return (0);
  193. }
  195. int
  196. __txn_old_ckp_print(dbenv, dbtp, lsnp, notused2, notused3)
  197. DB_ENV *dbenv;
  198. DBT *dbtp;
  199. DB_LSN *lsnp;
  200. db_recops notused2;
  201. void *notused3;
  202. {
  203. __txn_old_ckp_args *argp;
  204. u_int32_t i;
  205. u_int ch;
  206. int ret;
  208. i = 0;
  209. ch = 0;
  210. notused2 = DB_TXN_ABORT;
  211. notused3 = NULL;
  213. if ((ret = __txn_old_ckp_read(dbenv, dbtp->data, &argp)) != 0)
  214. return (ret);
  215. printf("[%lu][%lu]txn_old_ckp: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  216.     (u_long)lsnp->file,
  217.     (u_long)lsnp->offset,
  218.     (u_long)argp->type,
  219.     (u_long)argp->txnid->txnid,
  220.     (u_long)argp->prev_lsn.file,
  221.     (u_long)argp->prev_lsn.offset);
  222. printf("tckp_lsn: [%lu][%lu]n",
  223.     (u_long)argp->ckp_lsn.file, (u_long)argp->ckp_lsn.offset);
  224. printf("tlast_ckp: [%lu][%lu]n",
  225.     (u_long)argp->last_ckp.file, (u_long)argp->last_ckp.offset);
  226. printf("n");
  227. __os_free(argp, 0);
  228. return (0);
  229. }
  231. int
  232. __txn_old_ckp_read(dbenv, recbuf, argpp)
  233. DB_ENV *dbenv;
  234. void *recbuf;
  235. __txn_old_ckp_args **argpp;
  236. {
  237. __txn_old_ckp_args *argp;
  238. u_int8_t *bp;
  239. int ret;
  241. ret = __os_malloc(dbenv, sizeof(__txn_old_ckp_args) +
  242.     sizeof(DB_TXN), NULL, &argp);
  243. if (ret != 0)
  244. return (ret);
  245. argp->txnid = (DB_TXN *)&argp[1];
  246. bp = recbuf;
  247. memcpy(&argp->type, bp, sizeof(argp->type));
  248. bp += sizeof(argp->type);
  249. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  250. bp += sizeof(argp->txnid->txnid);
  251. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  252. bp += sizeof(DB_LSN);
  253. memcpy(&argp->ckp_lsn, bp,  sizeof(argp->ckp_lsn));
  254. bp += sizeof(argp->ckp_lsn);
  255. memcpy(&argp->last_ckp, bp,  sizeof(argp->last_ckp));
  256. bp += sizeof(argp->last_ckp);
  257. *argpp = argp;
  258. return (0);
  259. }
  261. int
  262. __txn_ckp_log(dbenv, txnid, ret_lsnp, flags,
  263. ckp_lsn, last_ckp, timestamp)
  264. DB_ENV *dbenv;
  265. DB_TXN *txnid;
  266. DB_LSN *ret_lsnp;
  267. u_int32_t flags;
  268. DB_LSN * ckp_lsn;
  269. DB_LSN * last_ckp;
  270. int32_t timestamp;
  271. {
  272. DBT logrec;
  273. DB_LSN *lsnp, null_lsn;
  274. u_int32_t rectype, txn_num;
  275. int ret;
  276. u_int8_t *bp;
  278. rectype = DB_txn_ckp;
  279. if (txnid != NULL &&
  280.     TAILQ_FIRST(&txnid->kids) != NULL &&
  281.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  282. return (ret);
  283. txn_num = txnid == NULL ? 0 : txnid->txnid;
  284. if (txnid == NULL) {
  285. ZERO_LSN(null_lsn);
  286. lsnp = &null_lsn;
  287. } else
  288. lsnp = &txnid->last_lsn;
  289. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  290.     + sizeof(*ckp_lsn)
  291.     + sizeof(*last_ckp)
  292.     + sizeof(timestamp);
  293. if ((ret = __os_malloc(dbenv, logrec.size, NULL, &logrec.data)) != 0)
  294. return (ret);
  296. bp = logrec.data;
  297. memcpy(bp, &rectype, sizeof(rectype));
  298. bp += sizeof(rectype);
  299. memcpy(bp, &txn_num, sizeof(txn_num));
  300. bp += sizeof(txn_num);
  301. memcpy(bp, lsnp, sizeof(DB_LSN));
  302. bp += sizeof(DB_LSN);
  303. if (ckp_lsn != NULL)
  304. memcpy(bp, ckp_lsn, sizeof(*ckp_lsn));
  305. else
  306. memset(bp, 0, sizeof(*ckp_lsn));
  307. bp += sizeof(*ckp_lsn);
  308. if (last_ckp != NULL)
  309. memcpy(bp, last_ckp, sizeof(*last_ckp));
  310. else
  311. memset(bp, 0, sizeof(*last_ckp));
  312. bp += sizeof(*last_ckp);
  313. memcpy(bp, &timestamp, sizeof(timestamp));
  314. bp += sizeof(timestamp);
  315. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size);
  316. ret = log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags);
  317. if (txnid != NULL)
  318. txnid->last_lsn = *ret_lsnp;
  319. __os_free(logrec.data, logrec.size);
  320. return (ret);
  321. }
  323. int
  324. __txn_ckp_print(dbenv, dbtp, lsnp, notused2, notused3)
  325. DB_ENV *dbenv;
  326. DBT *dbtp;
  327. DB_LSN *lsnp;
  328. db_recops notused2;
  329. void *notused3;
  330. {
  331. __txn_ckp_args *argp;
  332. u_int32_t i;
  333. u_int ch;
  334. int ret;
  336. i = 0;
  337. ch = 0;
  338. notused2 = DB_TXN_ABORT;
  339. notused3 = NULL;
  341. if ((ret = __txn_ckp_read(dbenv, dbtp->data, &argp)) != 0)
  342. return (ret);
  343. printf("[%lu][%lu]txn_ckp: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  344.     (u_long)lsnp->file,
  345.     (u_long)lsnp->offset,
  346.     (u_long)argp->type,
  347.     (u_long)argp->txnid->txnid,
  348.     (u_long)argp->prev_lsn.file,
  349.     (u_long)argp->prev_lsn.offset);
  350. printf("tckp_lsn: [%lu][%lu]n",
  351.     (u_long)argp->ckp_lsn.file, (u_long)argp->ckp_lsn.offset);
  352. printf("tlast_ckp: [%lu][%lu]n",
  353.     (u_long)argp->last_ckp.file, (u_long)argp->last_ckp.offset);
  354. printf("ttimestamp: %ldn", (long)argp->timestamp);
  355. printf("n");
  356. __os_free(argp, 0);
  357. return (0);
  358. }
  360. int
  361. __txn_ckp_read(dbenv, recbuf, argpp)
  362. DB_ENV *dbenv;
  363. void *recbuf;
  364. __txn_ckp_args **argpp;
  365. {
  366. __txn_ckp_args *argp;
  367. u_int8_t *bp;
  368. int ret;
  370. ret = __os_malloc(dbenv, sizeof(__txn_ckp_args) +
  371.     sizeof(DB_TXN), NULL, &argp);
  372. if (ret != 0)
  373. return (ret);
  374. argp->txnid = (DB_TXN *)&argp[1];
  375. bp = recbuf;
  376. memcpy(&argp->type, bp, sizeof(argp->type));
  377. bp += sizeof(argp->type);
  378. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  379. bp += sizeof(argp->txnid->txnid);
  380. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  381. bp += sizeof(DB_LSN);
  382. memcpy(&argp->ckp_lsn, bp,  sizeof(argp->ckp_lsn));
  383. bp += sizeof(argp->ckp_lsn);
  384. memcpy(&argp->last_ckp, bp,  sizeof(argp->last_ckp));
  385. bp += sizeof(argp->last_ckp);
  386. memcpy(&argp->timestamp, bp, sizeof(argp->timestamp));
  387. bp += sizeof(argp->timestamp);
  388. *argpp = argp;
  389. return (0);
  390. }
  392. int
  393. __txn_xa_regop_old_print(dbenv, dbtp, lsnp, notused2, notused3)
  394. DB_ENV *dbenv;
  395. DBT *dbtp;
  396. DB_LSN *lsnp;
  397. db_recops notused2;
  398. void *notused3;
  399. {
  400. __txn_xa_regop_old_args *argp;
  401. u_int32_t i;
  402. u_int ch;
  403. int ret;
  405. i = 0;
  406. ch = 0;
  407. notused2 = DB_TXN_ABORT;
  408. notused3 = NULL;
  410. if ((ret = __txn_xa_regop_old_read(dbenv, dbtp->data, &argp)) != 0)
  411. return (ret);
  412. printf("[%lu][%lu]txn_xa_regop_old: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  413.     (u_long)lsnp->file,
  414.     (u_long)lsnp->offset,
  415.     (u_long)argp->type,
  416.     (u_long)argp->txnid->txnid,
  417.     (u_long)argp->prev_lsn.file,
  418.     (u_long)argp->prev_lsn.offset);
  419. printf("topcode: %lun", (u_long)argp->opcode);
  420. printf("txid: ");
  421. for (i = 0; i < argp->xid.size; i++) {
  422. ch = ((u_int8_t *)argp->xid.data)[i];
  423. if (isprint(ch) || ch == 0xa)
  424. putchar(ch);
  425. else
  426. printf("%#x ", ch);
  427. }
  428. printf("n");
  429. printf("tformatID: %ldn", (long)argp->formatID);
  430. printf("tgtrid: %un", argp->gtrid);
  431. printf("tbqual: %un", argp->bqual);
  432. printf("n");
  433. __os_free(argp, 0);
  434. return (0);
  435. }
  437. int
  438. __txn_xa_regop_old_read(dbenv, recbuf, argpp)
  439. DB_ENV *dbenv;
  440. void *recbuf;
  441. __txn_xa_regop_old_args **argpp;
  442. {
  443. __txn_xa_regop_old_args *argp;
  444. u_int8_t *bp;
  445. int ret;
  447. ret = __os_malloc(dbenv, sizeof(__txn_xa_regop_old_args) +
  448.     sizeof(DB_TXN), NULL, &argp);
  449. if (ret != 0)
  450. return (ret);
  451. argp->txnid = (DB_TXN *)&argp[1];
  452. bp = recbuf;
  453. memcpy(&argp->type, bp, sizeof(argp->type));
  454. bp += sizeof(argp->type);
  455. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  456. bp += sizeof(argp->txnid->txnid);
  457. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  458. bp += sizeof(DB_LSN);
  459. memcpy(&argp->opcode, bp, sizeof(argp->opcode));
  460. bp += sizeof(argp->opcode);
  461. memset(&argp->xid, 0, sizeof(argp->xid));
  462. memcpy(&argp->xid.size, bp, sizeof(u_int32_t));
  463. bp += sizeof(u_int32_t);
  464. argp->xid.data = bp;
  465. bp += argp->xid.size;
  466. memcpy(&argp->formatID, bp, sizeof(argp->formatID));
  467. bp += sizeof(argp->formatID);
  468. memcpy(&argp->gtrid, bp, sizeof(argp->gtrid));
  469. bp += sizeof(argp->gtrid);
  470. memcpy(&argp->bqual, bp, sizeof(argp->bqual));
  471. bp += sizeof(argp->bqual);
  472. *argpp = argp;
  473. return (0);
  474. }
  476. int
  477. __txn_xa_regop_log(dbenv, txnid, ret_lsnp, flags,
  478. opcode, xid, formatID, gtrid, bqual, begin_lsn)
  479. DB_ENV *dbenv;
  480. DB_TXN *txnid;
  481. DB_LSN *ret_lsnp;
  482. u_int32_t flags;
  483. u_int32_t opcode;
  484. const DBT *xid;
  485. int32_t formatID;
  486. u_int32_t gtrid;
  487. u_int32_t bqual;
  488. DB_LSN * begin_lsn;
  489. {
  490. DBT logrec;
  491. DB_LSN *lsnp, null_lsn;
  492. u_int32_t zero;
  493. u_int32_t rectype, txn_num;
  494. int ret;
  495. u_int8_t *bp;
  497. rectype = DB_txn_xa_regop;
  498. if (txnid != NULL &&
  499.     TAILQ_FIRST(&txnid->kids) != NULL &&
  500.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  501. return (ret);
  502. txn_num = txnid == NULL ? 0 : txnid->txnid;
  503. if (txnid == NULL) {
  504. ZERO_LSN(null_lsn);
  505. lsnp = &null_lsn;
  506. } else
  507. lsnp = &txnid->last_lsn;
  508. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  509.     + sizeof(opcode)
  510.     + sizeof(u_int32_t) + (xid == NULL ? 0 : xid->size)
  511.     + sizeof(formatID)
  512.     + sizeof(gtrid)
  513.     + sizeof(bqual)
  514.     + sizeof(*begin_lsn);
  515. if ((ret = __os_malloc(dbenv, logrec.size, NULL, &logrec.data)) != 0)
  516. return (ret);
  518. bp = logrec.data;
  519. memcpy(bp, &rectype, sizeof(rectype));
  520. bp += sizeof(rectype);
  521. memcpy(bp, &txn_num, sizeof(txn_num));
  522. bp += sizeof(txn_num);
  523. memcpy(bp, lsnp, sizeof(DB_LSN));
  524. bp += sizeof(DB_LSN);
  525. memcpy(bp, &opcode, sizeof(opcode));
  526. bp += sizeof(opcode);
  527. if (xid == NULL) {
  528. zero = 0;
  529. memcpy(bp, &zero, sizeof(u_int32_t));
  530. bp += sizeof(u_int32_t);
  531. } else {
  532. memcpy(bp, &xid->size, sizeof(xid->size));
  533. bp += sizeof(xid->size);
  534. memcpy(bp, xid->data, xid->size);
  535. bp += xid->size;
  536. }
  537. memcpy(bp, &formatID, sizeof(formatID));
  538. bp += sizeof(formatID);
  539. memcpy(bp, &gtrid, sizeof(gtrid));
  540. bp += sizeof(gtrid);
  541. memcpy(bp, &bqual, sizeof(bqual));
  542. bp += sizeof(bqual);
  543. if (begin_lsn != NULL)
  544. memcpy(bp, begin_lsn, sizeof(*begin_lsn));
  545. else
  546. memset(bp, 0, sizeof(*begin_lsn));
  547. bp += sizeof(*begin_lsn);
  548. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size);
  549. ret = log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags);
  550. if (txnid != NULL)
  551. txnid->last_lsn = *ret_lsnp;
  552. __os_free(logrec.data, logrec.size);
  553. return (ret);
  554. }
  556. int
  557. __txn_xa_regop_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. __txn_xa_regop_args *argp;
  565. u_int32_t i;
  566. u_int ch;
  567. int ret;
  569. i = 0;
  570. ch = 0;
  571. notused2 = DB_TXN_ABORT;
  572. notused3 = NULL;
  574. if ((ret = __txn_xa_regop_read(dbenv, dbtp->data, &argp)) != 0)
  575. return (ret);
  576. printf("[%lu][%lu]txn_xa_regop: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  577.     (u_long)lsnp->file,
  578.     (u_long)lsnp->offset,
  579.     (u_long)argp->type,
  580.     (u_long)argp->txnid->txnid,
  581.     (u_long)argp->prev_lsn.file,
  582.     (u_long)argp->prev_lsn.offset);
  583. printf("topcode: %lun", (u_long)argp->opcode);
  584. printf("txid: ");
  585. for (i = 0; i < argp->xid.size; i++) {
  586. ch = ((u_int8_t *)argp->xid.data)[i];
  587. if (isprint(ch) || ch == 0xa)
  588. putchar(ch);
  589. else
  590. printf("%#x ", ch);
  591. }
  592. printf("n");
  593. printf("tformatID: %ldn", (long)argp->formatID);
  594. printf("tgtrid: %un", argp->gtrid);
  595. printf("tbqual: %un", argp->bqual);
  596. printf("tbegin_lsn: [%lu][%lu]n",
  597.     (u_long)argp->begin_lsn.file, (u_long)argp->begin_lsn.offset);
  598. printf("n");
  599. __os_free(argp, 0);
  600. return (0);
  601. }
  603. int
  604. __txn_xa_regop_read(dbenv, recbuf, argpp)
  605. DB_ENV *dbenv;
  606. void *recbuf;
  607. __txn_xa_regop_args **argpp;
  608. {
  609. __txn_xa_regop_args *argp;
  610. u_int8_t *bp;
  611. int ret;
  613. ret = __os_malloc(dbenv, sizeof(__txn_xa_regop_args) +
  614.     sizeof(DB_TXN), NULL, &argp);
  615. if (ret != 0)
  616. return (ret);
  617. argp->txnid = (DB_TXN *)&argp[1];
  618. bp = recbuf;
  619. memcpy(&argp->type, bp, sizeof(argp->type));
  620. bp += sizeof(argp->type);
  621. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  622. bp += sizeof(argp->txnid->txnid);
  623. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  624. bp += sizeof(DB_LSN);
  625. memcpy(&argp->opcode, bp, sizeof(argp->opcode));
  626. bp += sizeof(argp->opcode);
  627. memset(&argp->xid, 0, sizeof(argp->xid));
  628. memcpy(&argp->xid.size, bp, sizeof(u_int32_t));
  629. bp += sizeof(u_int32_t);
  630. argp->xid.data = bp;
  631. bp += argp->xid.size;
  632. memcpy(&argp->formatID, bp, sizeof(argp->formatID));
  633. bp += sizeof(argp->formatID);
  634. memcpy(&argp->gtrid, bp, sizeof(argp->gtrid));
  635. bp += sizeof(argp->gtrid);
  636. memcpy(&argp->bqual, bp, sizeof(argp->bqual));
  637. bp += sizeof(argp->bqual);
  638. memcpy(&argp->begin_lsn, bp,  sizeof(argp->begin_lsn));
  639. bp += sizeof(argp->begin_lsn);
  640. *argpp = argp;
  641. return (0);
  642. }
  644. int
  645. __txn_child_old_print(dbenv, dbtp, lsnp, notused2, notused3)
  646. DB_ENV *dbenv;
  647. DBT *dbtp;
  648. DB_LSN *lsnp;
  649. db_recops notused2;
  650. void *notused3;
  651. {
  652. __txn_child_old_args *argp;
  653. u_int32_t i;
  654. u_int ch;
  655. int ret;
  657. i = 0;
  658. ch = 0;
  659. notused2 = DB_TXN_ABORT;
  660. notused3 = NULL;
  662. if ((ret = __txn_child_old_read(dbenv, dbtp->data, &argp)) != 0)
  663. return (ret);
  664. printf("[%lu][%lu]txn_child_old: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  665.     (u_long)lsnp->file,
  666.     (u_long)lsnp->offset,
  667.     (u_long)argp->type,
  668.     (u_long)argp->txnid->txnid,
  669.     (u_long)argp->prev_lsn.file,
  670.     (u_long)argp->prev_lsn.offset);
  671. printf("topcode: %lun", (u_long)argp->opcode);
  672. printf("tparent: 0x%lxn", (u_long)argp->parent);
  673. printf("n");
  674. __os_free(argp, 0);
  675. return (0);
  676. }
  678. int
  679. __txn_child_old_read(dbenv, recbuf, argpp)
  680. DB_ENV *dbenv;
  681. void *recbuf;
  682. __txn_child_old_args **argpp;
  683. {
  684. __txn_child_old_args *argp;
  685. u_int8_t *bp;
  686. int ret;
  688. ret = __os_malloc(dbenv, sizeof(__txn_child_old_args) +
  689.     sizeof(DB_TXN), NULL, &argp);
  690. if (ret != 0)
  691. return (ret);
  692. argp->txnid = (DB_TXN *)&argp[1];
  693. bp = recbuf;
  694. memcpy(&argp->type, bp, sizeof(argp->type));
  695. bp += sizeof(argp->type);
  696. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  697. bp += sizeof(argp->txnid->txnid);
  698. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  699. bp += sizeof(DB_LSN);
  700. memcpy(&argp->opcode, bp, sizeof(argp->opcode));
  701. bp += sizeof(argp->opcode);
  702. memcpy(&argp->parent, bp, sizeof(argp->parent));
  703. bp += sizeof(argp->parent);
  704. *argpp = argp;
  705. return (0);
  706. }
  708. int
  709. __txn_child_log(dbenv, txnid, ret_lsnp, flags,
  710. child, c_lsn)
  711. DB_ENV *dbenv;
  712. DB_TXN *txnid;
  713. DB_LSN *ret_lsnp;
  714. u_int32_t flags;
  715. u_int32_t child;
  716. DB_LSN * c_lsn;
  717. {
  718. DBT logrec;
  719. DB_LSN *lsnp, null_lsn;
  720. u_int32_t rectype, txn_num;
  721. int ret;
  722. u_int8_t *bp;
  724. rectype = DB_txn_child;
  725. if (txnid != NULL &&
  726.     TAILQ_FIRST(&txnid->kids) != NULL &&
  727.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  728. return (ret);
  729. txn_num = txnid == NULL ? 0 : txnid->txnid;
  730. if (txnid == NULL) {
  731. ZERO_LSN(null_lsn);
  732. lsnp = &null_lsn;
  733. } else
  734. lsnp = &txnid->last_lsn;
  735. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  736.     + sizeof(child)
  737.     + sizeof(*c_lsn);
  738. if ((ret = __os_malloc(dbenv, logrec.size, NULL, &logrec.data)) != 0)
  739. return (ret);
  741. bp = logrec.data;
  742. memcpy(bp, &rectype, sizeof(rectype));
  743. bp += sizeof(rectype);
  744. memcpy(bp, &txn_num, sizeof(txn_num));
  745. bp += sizeof(txn_num);
  746. memcpy(bp, lsnp, sizeof(DB_LSN));
  747. bp += sizeof(DB_LSN);
  748. memcpy(bp, &child, sizeof(child));
  749. bp += sizeof(child);
  750. if (c_lsn != NULL)
  751. memcpy(bp, c_lsn, sizeof(*c_lsn));
  752. else
  753. memset(bp, 0, sizeof(*c_lsn));
  754. bp += sizeof(*c_lsn);
  755. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size);
  756. ret = log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags);
  757. if (txnid != NULL)
  758. txnid->last_lsn = *ret_lsnp;
  759. __os_free(logrec.data, logrec.size);
  760. return (ret);
  761. }
  763. int
  764. __txn_child_print(dbenv, dbtp, lsnp, notused2, notused3)
  765. DB_ENV *dbenv;
  766. DBT *dbtp;
  767. DB_LSN *lsnp;
  768. db_recops notused2;
  769. void *notused3;
  770. {
  771. __txn_child_args *argp;
  772. u_int32_t i;
  773. u_int ch;
  774. int ret;
  776. i = 0;
  777. ch = 0;
  778. notused2 = DB_TXN_ABORT;
  779. notused3 = NULL;
  781. if ((ret = __txn_child_read(dbenv, dbtp->data, &argp)) != 0)
  782. return (ret);
  783. printf("[%lu][%lu]txn_child: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  784.     (u_long)lsnp->file,
  785.     (u_long)lsnp->offset,
  786.     (u_long)argp->type,
  787.     (u_long)argp->txnid->txnid,
  788.     (u_long)argp->prev_lsn.file,
  789.     (u_long)argp->prev_lsn.offset);
  790. printf("tchild: 0x%lxn", (u_long)argp->child);
  791. printf("tc_lsn: [%lu][%lu]n",
  792.     (u_long)argp->c_lsn.file, (u_long)argp->c_lsn.offset);
  793. printf("n");
  794. __os_free(argp, 0);
  795. return (0);
  796. }
  798. int
  799. __txn_child_read(dbenv, recbuf, argpp)
  800. DB_ENV *dbenv;
  801. void *recbuf;
  802. __txn_child_args **argpp;
  803. {
  804. __txn_child_args *argp;
  805. u_int8_t *bp;
  806. int ret;
  808. ret = __os_malloc(dbenv, sizeof(__txn_child_args) +
  809.     sizeof(DB_TXN), NULL, &argp);
  810. if (ret != 0)
  811. return (ret);
  812. argp->txnid = (DB_TXN *)&argp[1];
  813. bp = recbuf;
  814. memcpy(&argp->type, bp, sizeof(argp->type));
  815. bp += sizeof(argp->type);
  816. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  817. bp += sizeof(argp->txnid->txnid);
  818. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  819. bp += sizeof(DB_LSN);
  820. memcpy(&argp->child, bp, sizeof(argp->child));
  821. bp += sizeof(argp->child);
  822. memcpy(&argp->c_lsn, bp,  sizeof(argp->c_lsn));
  823. bp += sizeof(argp->c_lsn);
  824. *argpp = argp;
  825. return (0);
  826. }
  828. int
  829. __txn_init_print(dbenv)
  830. DB_ENV *dbenv;
  831. {
  832. int ret;
  834. if ((ret = __db_add_recovery(dbenv,
  835.     __txn_old_regop_print, DB_txn_old_regop)) != 0)
  836. return (ret);
  837. if ((ret = __db_add_recovery(dbenv,
  838.     __txn_regop_print, DB_txn_regop)) != 0)
  839. return (ret);
  840. if ((ret = __db_add_recovery(dbenv,
  841.     __txn_old_ckp_print, DB_txn_old_ckp)) != 0)
  842. return (ret);
  843. if ((ret = __db_add_recovery(dbenv,
  844.     __txn_ckp_print, DB_txn_ckp)) != 0)
  845. return (ret);
  846. if ((ret = __db_add_recovery(dbenv,
  847.     __txn_xa_regop_old_print, DB_txn_xa_regop_old)) != 0)
  848. return (ret);
  849. if ((ret = __db_add_recovery(dbenv,
  850.     __txn_xa_regop_print, DB_txn_xa_regop)) != 0)
  851. return (ret);
  852. if ((ret = __db_add_recovery(dbenv,
  853.     __txn_child_old_print, DB_txn_child_old)) != 0)
  854. return (ret);
  855. if ((ret = __db_add_recovery(dbenv,
  856.     __txn_child_print, DB_txn_child)) != 0)
  857. return (ret);
  858. return (0);
  859. }
  861. int
  862. __txn_init_recover(dbenv)
  863. DB_ENV *dbenv;
  864. {
  865. int ret;
  867. if ((ret = __db_add_recovery(dbenv,
  868.     __deprecated_recover, DB_txn_old_regop)) != 0)
  869. return (ret);
  870. if ((ret = __db_add_recovery(dbenv,
  871.     __txn_regop_recover, DB_txn_regop)) != 0)
  872. return (ret);
  873. if ((ret = __db_add_recovery(dbenv,
  874.     __deprecated_recover, DB_txn_old_ckp)) != 0)
  875. return (ret);
  876. if ((ret = __db_add_recovery(dbenv,
  877.     __txn_ckp_recover, DB_txn_ckp)) != 0)
  878. return (ret);
  879. if ((ret = __db_add_recovery(dbenv,
  880.     __deprecated_recover, DB_txn_xa_regop_old)) != 0)
  881. return (ret);
  882. if ((ret = __db_add_recovery(dbenv,
  883.     __txn_xa_regop_recover, DB_txn_xa_regop)) != 0)
  884. return (ret);
  885. if ((ret = __db_add_recovery(dbenv,
  886.     __deprecated_recover, DB_txn_child_old)) != 0)
  887. return (ret);
  888. if ((ret = __db_add_recovery(dbenv,
  889.     __txn_child_recover, DB_txn_child)) != 0)
  890. return (ret);
  891. return (0);
  892. }