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

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

MySQL数据库

开发平台：

Visual C++

qam_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/qam.h"
  18. #include "dbinc/rep.h"
  19. #include "dbinc/txn.h"
  21. /*
  22.  * PUBLIC: int __qam_incfirst_log __P((DB *, DB_TXN *, DB_LSN *,
  23.  * PUBLIC:     u_int32_t, db_recno_t, db_pgno_t));
  24.  */
  25. int
  26. __qam_incfirst_log(dbp, txnid, ret_lsnp, flags, recno, meta_pgno)
  27. DB *dbp;
  28. DB_TXN *txnid;
  29. DB_LSN *ret_lsnp;
  30. u_int32_t flags;
  31. db_recno_t recno;
  32. db_pgno_t meta_pgno;
  33. {
  34. DBT logrec;
  35. DB_ENV *dbenv;
  36. DB_LSN *lsnp, null_lsn;
  37. u_int32_t uinttmp;
  38. u_int32_t npad, rectype, txn_num;
  39. int ret;
  40. u_int8_t *bp;
  42. dbenv = dbp->dbenv;
  43. rectype = DB___qam_incfirst;
  44. npad = 0;
  46. if (txnid == NULL) {
  47. txn_num = 0;
  48. null_lsn.file = 0;
  49. null_lsn.offset = 0;
  50. lsnp = &null_lsn;
  51. } else {
  52. if (TAILQ_FIRST(&txnid->kids) != NULL &&
  53.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  54. return (ret);
  55. txn_num = txnid->txnid;
  56. lsnp = &txnid->last_lsn;
  57. }
  59. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  60.     + sizeof(u_int32_t)
  61.     + sizeof(u_int32_t)
  62.     + sizeof(u_int32_t);
  63. if (CRYPTO_ON(dbenv)) {
  64. npad =
  65.     ((DB_CIPHER *)dbenv->crypto_handle)->adj_size(logrec.size);
  66. logrec.size += npad;
  67. }
  69. if ((ret = __os_malloc(dbenv,
  70.     logrec.size, &logrec.data)) != 0)
  71. return (ret);
  73. if (npad > 0)
  74. memset((u_int8_t *)logrec.data + logrec.size - npad, 0, npad);
  76. bp = logrec.data;
  78. memcpy(bp, &rectype, sizeof(rectype));
  79. bp += sizeof(rectype);
  81. memcpy(bp, &txn_num, sizeof(txn_num));
  82. bp += sizeof(txn_num);
  84. memcpy(bp, lsnp, sizeof(DB_LSN));
  85. bp += sizeof(DB_LSN);
  87. DB_ASSERT(dbp->log_filename != NULL);
  88. if (dbp->log_filename->id == DB_LOGFILEID_INVALID &&
  89.     (ret = __dbreg_lazy_id(dbp)) != 0)
  90. return (ret);
  92. uinttmp = (u_int32_t)dbp->log_filename->id;
  93. memcpy(bp, &uinttmp, sizeof(uinttmp));
  94. bp += sizeof(uinttmp);
  96. uinttmp = (u_int32_t)recno;
  97. memcpy(bp, &uinttmp, sizeof(uinttmp));
  98. bp += sizeof(uinttmp);
  100. uinttmp = (u_int32_t)meta_pgno;
  101. memcpy(bp, &uinttmp, sizeof(uinttmp));
  102. bp += sizeof(uinttmp);
  104. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
  105. ret = dbenv->log_put(dbenv,
  106.    ret_lsnp, (DBT *)&logrec, flags | DB_NOCOPY);
  107. if (txnid != NULL && ret == 0)
  108. txnid->last_lsn = *ret_lsnp;
  109. #ifdef LOG_DIAGNOSTIC
  110. if (ret != 0)
  111. (void)__qam_incfirst_print(dbenv,
  112.     (DBT *)&logrec, ret_lsnp, NULL, NULL);
  113. #endif
  114. __os_free(dbenv, logrec.data);
  115. return (ret);
  116. }
  118. /*
  119.  * PUBLIC: int __qam_incfirst_getpgnos __P((DB_ENV *, DBT *,
  120.  * PUBLIC:     DB_LSN *, db_recops, void *));
  121.  */
  122. int
  123. __qam_incfirst_getpgnos(dbenv, rec, lsnp, notused1, summary)
  124. DB_ENV *dbenv;
  125. DBT *rec;
  126. DB_LSN *lsnp;
  127. db_recops notused1;
  128. void *summary;
  129. {
  130. DB *dbp;
  131. TXN_RECS *t;
  132. __qam_incfirst_args *argp;
  133. u_int32_t ret;
  135. COMPQUIET(notused1, DB_TXN_ABORT);
  137. argp = NULL;
  138. t = (TXN_RECS *)summary;
  140. if ((ret = __qam_incfirst_read(dbenv, rec->data, &argp)) != 0)
  141. return (ret);
  143. if ((ret = __dbreg_id_to_db(dbenv,
  144.     argp->txnid, &dbp, argp->fileid, 0)) != 0)
  145. goto err;
  147. if ((ret = __rep_check_alloc(dbenv, t, 1)) != 0)
  148. goto err;
  150. t->array[t->npages].flags = 0;
  151. t->array[t->npages].fid = argp->fileid;
  152. t->array[t->npages].lsn = *lsnp;
  153. t->array[t->npages].pgdesc.pgno = argp->meta_pgno;
  154. t->array[t->npages].pgdesc.type = DB_PAGE_LOCK;
  155. memcpy(t->array[t->npages].pgdesc.fileid, dbp->fileid,
  156.     DB_FILE_ID_LEN);
  157. t->npages++;
  159. err: if (argp != NULL)
  160. __os_free(dbenv, argp);
  161. return (ret);
  162. }
  164. /*
  165.  * PUBLIC: int __qam_incfirst_print __P((DB_ENV *, DBT *, DB_LSN *,
  166.  * PUBLIC:     db_recops, void *));
  167.  */
  168. int
  169. __qam_incfirst_print(dbenv, dbtp, lsnp, notused2, notused3)
  170. DB_ENV *dbenv;
  171. DBT *dbtp;
  172. DB_LSN *lsnp;
  173. db_recops notused2;
  174. void *notused3;
  175. {
  176. __qam_incfirst_args *argp;
  177. int ret;
  179. notused2 = DB_TXN_ABORT;
  180. notused3 = NULL;
  182. if ((ret = __qam_incfirst_read(dbenv, dbtp->data, &argp)) != 0)
  183. return (ret);
  184. (void)printf(
  185.     "[%lu][%lu]__qam_incfirst: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  186.     (u_long)lsnp->file,
  187.     (u_long)lsnp->offset,
  188.     (u_long)argp->type,
  189.     (u_long)argp->txnid->txnid,
  190.     (u_long)argp->prev_lsn.file,
  191.     (u_long)argp->prev_lsn.offset);
  192. (void)printf("tfileid: %ldn", (long)argp->fileid);
  193. (void)printf("trecno: %lun", (u_long)argp->recno);
  194. (void)printf("tmeta_pgno: %lun", (u_long)argp->meta_pgno);
  195. (void)printf("n");
  196. __os_free(dbenv, argp);
  197. return (0);
  198. }
  200. /*
  201.  * PUBLIC: int __qam_incfirst_read __P((DB_ENV *, void *,
  202.  * PUBLIC:     __qam_incfirst_args **));
  203.  */
  204. int
  205. __qam_incfirst_read(dbenv, recbuf, argpp)
  206. DB_ENV *dbenv;
  207. void *recbuf;
  208. __qam_incfirst_args **argpp;
  209. {
  210. __qam_incfirst_args *argp;
  211. u_int32_t uinttmp;
  212. u_int8_t *bp;
  213. int ret;
  215. if ((ret = __os_malloc(dbenv,
  216.     sizeof(__qam_incfirst_args) + sizeof(DB_TXN), &argp)) != 0)
  217. return (ret);
  219. argp->txnid = (DB_TXN *)&argp[1];
  221. bp = recbuf;
  222. memcpy(&argp->type, bp, sizeof(argp->type));
  223. bp += sizeof(argp->type);
  225. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  226. bp += sizeof(argp->txnid->txnid);
  228. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  229. bp += sizeof(DB_LSN);
  231. memcpy(&uinttmp, bp, sizeof(uinttmp));
  232. argp->fileid = (int32_t)uinttmp;
  233. bp += sizeof(uinttmp);
  235. memcpy(&uinttmp, bp, sizeof(uinttmp));
  236. argp->recno = (db_recno_t)uinttmp;
  237. bp += sizeof(uinttmp);
  239. memcpy(&uinttmp, bp, sizeof(uinttmp));
  240. argp->meta_pgno = (db_pgno_t)uinttmp;
  241. bp += sizeof(uinttmp);
  243. *argpp = argp;
  244. return (0);
  245. }
  247. /*
  248.  * PUBLIC: int __qam_mvptr_log __P((DB *, DB_TXN *, DB_LSN *,
  249.  * PUBLIC:     u_int32_t, u_int32_t, db_recno_t, db_recno_t, db_recno_t,
  250.  * PUBLIC:     db_recno_t, DB_LSN *, db_pgno_t));
  251.  */
  252. int
  253. __qam_mvptr_log(dbp, txnid, ret_lsnp, flags,
  254.     opcode, old_first, new_first, old_cur, new_cur,
  255.     metalsn, meta_pgno)
  256. DB *dbp;
  257. DB_TXN *txnid;
  258. DB_LSN *ret_lsnp;
  259. u_int32_t flags;
  260. u_int32_t opcode;
  261. db_recno_t old_first;
  262. db_recno_t new_first;
  263. db_recno_t old_cur;
  264. db_recno_t new_cur;
  265. DB_LSN * metalsn;
  266. db_pgno_t meta_pgno;
  267. {
  268. DBT logrec;
  269. DB_ENV *dbenv;
  270. DB_LSN *lsnp, null_lsn;
  271. u_int32_t uinttmp;
  272. u_int32_t npad, rectype, txn_num;
  273. int ret;
  274. u_int8_t *bp;
  276. dbenv = dbp->dbenv;
  277. rectype = DB___qam_mvptr;
  278. npad = 0;
  280. if (txnid == NULL) {
  281. txn_num = 0;
  282. null_lsn.file = 0;
  283. null_lsn.offset = 0;
  284. lsnp = &null_lsn;
  285. } else {
  286. if (TAILQ_FIRST(&txnid->kids) != NULL &&
  287.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  288. return (ret);
  289. txn_num = txnid->txnid;
  290. lsnp = &txnid->last_lsn;
  291. }
  293. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  294.     + sizeof(u_int32_t)
  295.     + sizeof(u_int32_t)
  296.     + sizeof(u_int32_t)
  297.     + sizeof(u_int32_t)
  298.     + sizeof(u_int32_t)
  299.     + sizeof(u_int32_t)
  300.     + sizeof(*metalsn)
  301.     + sizeof(u_int32_t);
  302. if (CRYPTO_ON(dbenv)) {
  303. npad =
  304.     ((DB_CIPHER *)dbenv->crypto_handle)->adj_size(logrec.size);
  305. logrec.size += npad;
  306. }
  308. if ((ret = __os_malloc(dbenv,
  309.     logrec.size, &logrec.data)) != 0)
  310. return (ret);
  312. if (npad > 0)
  313. memset((u_int8_t *)logrec.data + logrec.size - npad, 0, npad);
  315. bp = logrec.data;
  317. memcpy(bp, &rectype, sizeof(rectype));
  318. bp += sizeof(rectype);
  320. memcpy(bp, &txn_num, sizeof(txn_num));
  321. bp += sizeof(txn_num);
  323. memcpy(bp, lsnp, sizeof(DB_LSN));
  324. bp += sizeof(DB_LSN);
  326. uinttmp = (u_int32_t)opcode;
  327. memcpy(bp, &uinttmp, sizeof(uinttmp));
  328. bp += sizeof(uinttmp);
  330. DB_ASSERT(dbp->log_filename != NULL);
  331. if (dbp->log_filename->id == DB_LOGFILEID_INVALID &&
  332.     (ret = __dbreg_lazy_id(dbp)) != 0)
  333. return (ret);
  335. uinttmp = (u_int32_t)dbp->log_filename->id;
  336. memcpy(bp, &uinttmp, sizeof(uinttmp));
  337. bp += sizeof(uinttmp);
  339. uinttmp = (u_int32_t)old_first;
  340. memcpy(bp, &uinttmp, sizeof(uinttmp));
  341. bp += sizeof(uinttmp);
  343. uinttmp = (u_int32_t)new_first;
  344. memcpy(bp, &uinttmp, sizeof(uinttmp));
  345. bp += sizeof(uinttmp);
  347. uinttmp = (u_int32_t)old_cur;
  348. memcpy(bp, &uinttmp, sizeof(uinttmp));
  349. bp += sizeof(uinttmp);
  351. uinttmp = (u_int32_t)new_cur;
  352. memcpy(bp, &uinttmp, sizeof(uinttmp));
  353. bp += sizeof(uinttmp);
  355. if (metalsn != NULL)
  356. memcpy(bp, metalsn, sizeof(*metalsn));
  357. else
  358. memset(bp, 0, sizeof(*metalsn));
  359. bp += sizeof(*metalsn);
  361. uinttmp = (u_int32_t)meta_pgno;
  362. memcpy(bp, &uinttmp, sizeof(uinttmp));
  363. bp += sizeof(uinttmp);
  365. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
  366. ret = dbenv->log_put(dbenv,
  367.    ret_lsnp, (DBT *)&logrec, flags | DB_NOCOPY);
  368. if (txnid != NULL && ret == 0)
  369. txnid->last_lsn = *ret_lsnp;
  370. #ifdef LOG_DIAGNOSTIC
  371. if (ret != 0)
  372. (void)__qam_mvptr_print(dbenv,
  373.     (DBT *)&logrec, ret_lsnp, NULL, NULL);
  374. #endif
  375. __os_free(dbenv, logrec.data);
  376. return (ret);
  377. }
  379. /*
  380.  * PUBLIC: int __qam_mvptr_getpgnos __P((DB_ENV *, DBT *, DB_LSN *,
  381.  * PUBLIC:     db_recops, void *));
  382.  */
  383. int
  384. __qam_mvptr_getpgnos(dbenv, rec, lsnp, notused1, summary)
  385. DB_ENV *dbenv;
  386. DBT *rec;
  387. DB_LSN *lsnp;
  388. db_recops notused1;
  389. void *summary;
  390. {
  391. DB *dbp;
  392. TXN_RECS *t;
  393. __qam_mvptr_args *argp;
  394. u_int32_t ret;
  396. COMPQUIET(notused1, DB_TXN_ABORT);
  398. argp = NULL;
  399. t = (TXN_RECS *)summary;
  401. if ((ret = __qam_mvptr_read(dbenv, rec->data, &argp)) != 0)
  402. return (ret);
  404. if ((ret = __dbreg_id_to_db(dbenv,
  405.     argp->txnid, &dbp, argp->fileid, 0)) != 0)
  406. goto err;
  408. if ((ret = __rep_check_alloc(dbenv, t, 1)) != 0)
  409. goto err;
  411. t->array[t->npages].flags = 0;
  412. t->array[t->npages].fid = argp->fileid;
  413. t->array[t->npages].lsn = *lsnp;
  414. t->array[t->npages].pgdesc.pgno = argp->meta_pgno;
  415. t->array[t->npages].pgdesc.type = DB_PAGE_LOCK;
  416. memcpy(t->array[t->npages].pgdesc.fileid, dbp->fileid,
  417.     DB_FILE_ID_LEN);
  418. t->npages++;
  420. err: if (argp != NULL)
  421. __os_free(dbenv, argp);
  422. return (ret);
  423. }
  425. /*
  426.  * PUBLIC: int __qam_mvptr_print __P((DB_ENV *, DBT *, DB_LSN *,
  427.  * PUBLIC:     db_recops, void *));
  428.  */
  429. int
  430. __qam_mvptr_print(dbenv, dbtp, lsnp, notused2, notused3)
  431. DB_ENV *dbenv;
  432. DBT *dbtp;
  433. DB_LSN *lsnp;
  434. db_recops notused2;
  435. void *notused3;
  436. {
  437. __qam_mvptr_args *argp;
  438. int ret;
  440. notused2 = DB_TXN_ABORT;
  441. notused3 = NULL;
  443. if ((ret = __qam_mvptr_read(dbenv, dbtp->data, &argp)) != 0)
  444. return (ret);
  445. (void)printf(
  446.     "[%lu][%lu]__qam_mvptr: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  447.     (u_long)lsnp->file,
  448.     (u_long)lsnp->offset,
  449.     (u_long)argp->type,
  450.     (u_long)argp->txnid->txnid,
  451.     (u_long)argp->prev_lsn.file,
  452.     (u_long)argp->prev_lsn.offset);
  453. (void)printf("topcode: %lun", (u_long)argp->opcode);
  454. (void)printf("tfileid: %ldn", (long)argp->fileid);
  455. (void)printf("told_first: %lun", (u_long)argp->old_first);
  456. (void)printf("tnew_first: %lun", (u_long)argp->new_first);
  457. (void)printf("told_cur: %lun", (u_long)argp->old_cur);
  458. (void)printf("tnew_cur: %lun", (u_long)argp->new_cur);
  459. (void)printf("tmetalsn: [%lu][%lu]n",
  460.     (u_long)argp->metalsn.file, (u_long)argp->metalsn.offset);
  461. (void)printf("tmeta_pgno: %lun", (u_long)argp->meta_pgno);
  462. (void)printf("n");
  463. __os_free(dbenv, argp);
  464. return (0);
  465. }
  467. /*
  468.  * PUBLIC: int __qam_mvptr_read __P((DB_ENV *, void *, __qam_mvptr_args **));
  469.  */
  470. int
  471. __qam_mvptr_read(dbenv, recbuf, argpp)
  472. DB_ENV *dbenv;
  473. void *recbuf;
  474. __qam_mvptr_args **argpp;
  475. {
  476. __qam_mvptr_args *argp;
  477. u_int32_t uinttmp;
  478. u_int8_t *bp;
  479. int ret;
  481. if ((ret = __os_malloc(dbenv,
  482.     sizeof(__qam_mvptr_args) + sizeof(DB_TXN), &argp)) != 0)
  483. return (ret);
  485. argp->txnid = (DB_TXN *)&argp[1];
  487. bp = recbuf;
  488. memcpy(&argp->type, bp, sizeof(argp->type));
  489. bp += sizeof(argp->type);
  491. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  492. bp += sizeof(argp->txnid->txnid);
  494. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  495. bp += sizeof(DB_LSN);
  497. memcpy(&uinttmp, bp, sizeof(uinttmp));
  498. argp->opcode = (u_int32_t)uinttmp;
  499. bp += sizeof(uinttmp);
  501. memcpy(&uinttmp, bp, sizeof(uinttmp));
  502. argp->fileid = (int32_t)uinttmp;
  503. bp += sizeof(uinttmp);
  505. memcpy(&uinttmp, bp, sizeof(uinttmp));
  506. argp->old_first = (db_recno_t)uinttmp;
  507. bp += sizeof(uinttmp);
  509. memcpy(&uinttmp, bp, sizeof(uinttmp));
  510. argp->new_first = (db_recno_t)uinttmp;
  511. bp += sizeof(uinttmp);
  513. memcpy(&uinttmp, bp, sizeof(uinttmp));
  514. argp->old_cur = (db_recno_t)uinttmp;
  515. bp += sizeof(uinttmp);
  517. memcpy(&uinttmp, bp, sizeof(uinttmp));
  518. argp->new_cur = (db_recno_t)uinttmp;
  519. bp += sizeof(uinttmp);
  521. memcpy(&argp->metalsn, bp,  sizeof(argp->metalsn));
  522. bp += sizeof(argp->metalsn);
  524. memcpy(&uinttmp, bp, sizeof(uinttmp));
  525. argp->meta_pgno = (db_pgno_t)uinttmp;
  526. bp += sizeof(uinttmp);
  528. *argpp = argp;
  529. return (0);
  530. }
  532. /*
  533.  * PUBLIC: int __qam_del_log __P((DB *, DB_TXN *, DB_LSN *,
  534.  * PUBLIC:     u_int32_t, DB_LSN *, db_pgno_t, u_int32_t, db_recno_t));
  535.  */
  536. int
  537. __qam_del_log(dbp, txnid, ret_lsnp, flags, lsn, pgno, indx, recno)
  538. DB *dbp;
  539. DB_TXN *txnid;
  540. DB_LSN *ret_lsnp;
  541. u_int32_t flags;
  542. DB_LSN * lsn;
  543. db_pgno_t pgno;
  544. u_int32_t indx;
  545. db_recno_t recno;
  546. {
  547. DBT logrec;
  548. DB_ENV *dbenv;
  549. DB_LSN *lsnp, null_lsn;
  550. u_int32_t uinttmp;
  551. u_int32_t npad, rectype, txn_num;
  552. int ret;
  553. u_int8_t *bp;
  555. dbenv = dbp->dbenv;
  556. rectype = DB___qam_del;
  557. npad = 0;
  559. if (txnid == NULL) {
  560. txn_num = 0;
  561. null_lsn.file = 0;
  562. null_lsn.offset = 0;
  563. lsnp = &null_lsn;
  564. } else {
  565. if (TAILQ_FIRST(&txnid->kids) != NULL &&
  566.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  567. return (ret);
  568. txn_num = txnid->txnid;
  569. lsnp = &txnid->last_lsn;
  570. }
  572. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  573.     + sizeof(u_int32_t)
  574.     + sizeof(*lsn)
  575.     + sizeof(u_int32_t)
  576.     + sizeof(u_int32_t)
  577.     + sizeof(u_int32_t);
  578. if (CRYPTO_ON(dbenv)) {
  579. npad =
  580.     ((DB_CIPHER *)dbenv->crypto_handle)->adj_size(logrec.size);
  581. logrec.size += npad;
  582. }
  584. if ((ret = __os_malloc(dbenv,
  585.     logrec.size, &logrec.data)) != 0)
  586. return (ret);
  588. if (npad > 0)
  589. memset((u_int8_t *)logrec.data + logrec.size - npad, 0, npad);
  591. bp = logrec.data;
  593. memcpy(bp, &rectype, sizeof(rectype));
  594. bp += sizeof(rectype);
  596. memcpy(bp, &txn_num, sizeof(txn_num));
  597. bp += sizeof(txn_num);
  599. memcpy(bp, lsnp, sizeof(DB_LSN));
  600. bp += sizeof(DB_LSN);
  602. DB_ASSERT(dbp->log_filename != NULL);
  603. if (dbp->log_filename->id == DB_LOGFILEID_INVALID &&
  604.     (ret = __dbreg_lazy_id(dbp)) != 0)
  605. return (ret);
  607. uinttmp = (u_int32_t)dbp->log_filename->id;
  608. memcpy(bp, &uinttmp, sizeof(uinttmp));
  609. bp += sizeof(uinttmp);
  611. if (lsn != NULL)
  612. memcpy(bp, lsn, sizeof(*lsn));
  613. else
  614. memset(bp, 0, sizeof(*lsn));
  615. bp += sizeof(*lsn);
  617. uinttmp = (u_int32_t)pgno;
  618. memcpy(bp, &uinttmp, sizeof(uinttmp));
  619. bp += sizeof(uinttmp);
  621. uinttmp = (u_int32_t)indx;
  622. memcpy(bp, &uinttmp, sizeof(uinttmp));
  623. bp += sizeof(uinttmp);
  625. uinttmp = (u_int32_t)recno;
  626. memcpy(bp, &uinttmp, sizeof(uinttmp));
  627. bp += sizeof(uinttmp);
  629. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
  630. ret = dbenv->log_put(dbenv,
  631.    ret_lsnp, (DBT *)&logrec, flags | DB_NOCOPY);
  632. if (txnid != NULL && ret == 0)
  633. txnid->last_lsn = *ret_lsnp;
  634. #ifdef LOG_DIAGNOSTIC
  635. if (ret != 0)
  636. (void)__qam_del_print(dbenv,
  637.     (DBT *)&logrec, ret_lsnp, NULL, NULL);
  638. #endif
  639. __os_free(dbenv, logrec.data);
  640. return (ret);
  641. }
  643. /*
  644.  * PUBLIC: int __qam_del_getpgnos __P((DB_ENV *, DBT *, DB_LSN *,
  645.  * PUBLIC:     db_recops, void *));
  646.  */
  647. int
  648. __qam_del_getpgnos(dbenv, rec, lsnp, notused1, summary)
  649. DB_ENV *dbenv;
  650. DBT *rec;
  651. DB_LSN *lsnp;
  652. db_recops notused1;
  653. void *summary;
  654. {
  655. DB *dbp;
  656. TXN_RECS *t;
  657. __qam_del_args *argp;
  658. u_int32_t ret;
  660. COMPQUIET(notused1, DB_TXN_ABORT);
  662. argp = NULL;
  663. t = (TXN_RECS *)summary;
  665. if ((ret = __qam_del_read(dbenv, rec->data, &argp)) != 0)
  666. return (ret);
  668. if ((ret = __dbreg_id_to_db(dbenv,
  669.     argp->txnid, &dbp, argp->fileid, 0)) != 0)
  670. goto err;
  672. if ((ret = __rep_check_alloc(dbenv, t, 1)) != 0)
  673. goto err;
  675. t->array[t->npages].flags = 0;
  676. t->array[t->npages].fid = argp->fileid;
  677. t->array[t->npages].lsn = *lsnp;
  678. t->array[t->npages].pgdesc.pgno = argp->pgno;
  679. t->array[t->npages].pgdesc.type = DB_PAGE_LOCK;
  680. memcpy(t->array[t->npages].pgdesc.fileid, dbp->fileid,
  681.     DB_FILE_ID_LEN);
  682. t->npages++;
  684. err: if (argp != NULL)
  685. __os_free(dbenv, argp);
  686. return (ret);
  687. }
  689. /*
  690.  * PUBLIC: int __qam_del_print __P((DB_ENV *, DBT *, DB_LSN *,
  691.  * PUBLIC:     db_recops, void *));
  692.  */
  693. int
  694. __qam_del_print(dbenv, dbtp, lsnp, notused2, notused3)
  695. DB_ENV *dbenv;
  696. DBT *dbtp;
  697. DB_LSN *lsnp;
  698. db_recops notused2;
  699. void *notused3;
  700. {
  701. __qam_del_args *argp;
  702. int ret;
  704. notused2 = DB_TXN_ABORT;
  705. notused3 = NULL;
  707. if ((ret = __qam_del_read(dbenv, dbtp->data, &argp)) != 0)
  708. return (ret);
  709. (void)printf(
  710.     "[%lu][%lu]__qam_del: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  711.     (u_long)lsnp->file,
  712.     (u_long)lsnp->offset,
  713.     (u_long)argp->type,
  714.     (u_long)argp->txnid->txnid,
  715.     (u_long)argp->prev_lsn.file,
  716.     (u_long)argp->prev_lsn.offset);
  717. (void)printf("tfileid: %ldn", (long)argp->fileid);
  718. (void)printf("tlsn: [%lu][%lu]n",
  719.     (u_long)argp->lsn.file, (u_long)argp->lsn.offset);
  720. (void)printf("tpgno: %lun", (u_long)argp->pgno);
  721. (void)printf("tindx: %lun", (u_long)argp->indx);
  722. (void)printf("trecno: %lun", (u_long)argp->recno);
  723. (void)printf("n");
  724. __os_free(dbenv, argp);
  725. return (0);
  726. }
  728. /*
  729.  * PUBLIC: int __qam_del_read __P((DB_ENV *, void *, __qam_del_args **));
  730.  */
  731. int
  732. __qam_del_read(dbenv, recbuf, argpp)
  733. DB_ENV *dbenv;
  734. void *recbuf;
  735. __qam_del_args **argpp;
  736. {
  737. __qam_del_args *argp;
  738. u_int32_t uinttmp;
  739. u_int8_t *bp;
  740. int ret;
  742. if ((ret = __os_malloc(dbenv,
  743.     sizeof(__qam_del_args) + sizeof(DB_TXN), &argp)) != 0)
  744. return (ret);
  746. argp->txnid = (DB_TXN *)&argp[1];
  748. bp = recbuf;
  749. memcpy(&argp->type, bp, sizeof(argp->type));
  750. bp += sizeof(argp->type);
  752. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  753. bp += sizeof(argp->txnid->txnid);
  755. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  756. bp += sizeof(DB_LSN);
  758. memcpy(&uinttmp, bp, sizeof(uinttmp));
  759. argp->fileid = (int32_t)uinttmp;
  760. bp += sizeof(uinttmp);
  762. memcpy(&argp->lsn, bp,  sizeof(argp->lsn));
  763. bp += sizeof(argp->lsn);
  765. memcpy(&uinttmp, bp, sizeof(uinttmp));
  766. argp->pgno = (db_pgno_t)uinttmp;
  767. bp += sizeof(uinttmp);
  769. memcpy(&uinttmp, bp, sizeof(uinttmp));
  770. argp->indx = (u_int32_t)uinttmp;
  771. bp += sizeof(uinttmp);
  773. memcpy(&uinttmp, bp, sizeof(uinttmp));
  774. argp->recno = (db_recno_t)uinttmp;
  775. bp += sizeof(uinttmp);
  777. *argpp = argp;
  778. return (0);
  779. }
  781. /*
  782.  * PUBLIC: int __qam_add_log __P((DB *, DB_TXN *, DB_LSN *,
  783.  * PUBLIC:     u_int32_t, DB_LSN *, db_pgno_t, u_int32_t, db_recno_t,
  784.  * PUBLIC:     const DBT *, u_int32_t, const DBT *));
  785.  */
  786. int
  787. __qam_add_log(dbp, txnid, ret_lsnp, flags, lsn, pgno, indx, recno, data,
  788.     vflag, olddata)
  789. DB *dbp;
  790. DB_TXN *txnid;
  791. DB_LSN *ret_lsnp;
  792. u_int32_t flags;
  793. DB_LSN * lsn;
  794. db_pgno_t pgno;
  795. u_int32_t indx;
  796. db_recno_t recno;
  797. const DBT *data;
  798. u_int32_t vflag;
  799. const DBT *olddata;
  800. {
  801. DBT logrec;
  802. DB_ENV *dbenv;
  803. DB_LSN *lsnp, null_lsn;
  804. u_int32_t zero;
  805. u_int32_t uinttmp;
  806. u_int32_t npad, rectype, txn_num;
  807. int ret;
  808. u_int8_t *bp;
  810. dbenv = dbp->dbenv;
  811. rectype = DB___qam_add;
  812. npad = 0;
  814. if (txnid == NULL) {
  815. txn_num = 0;
  816. null_lsn.file = 0;
  817. null_lsn.offset = 0;
  818. lsnp = &null_lsn;
  819. } else {
  820. if (TAILQ_FIRST(&txnid->kids) != NULL &&
  821.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  822. return (ret);
  823. txn_num = txnid->txnid;
  824. lsnp = &txnid->last_lsn;
  825. }
  827. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  828.     + sizeof(u_int32_t)
  829.     + sizeof(*lsn)
  830.     + sizeof(u_int32_t)
  831.     + sizeof(u_int32_t)
  832.     + sizeof(u_int32_t)
  833.     + sizeof(u_int32_t) + (data == NULL ? 0 : data->size)
  834.     + sizeof(u_int32_t)
  835.     + sizeof(u_int32_t) + (olddata == NULL ? 0 : olddata->size);
  836. if (CRYPTO_ON(dbenv)) {
  837. npad =
  838.     ((DB_CIPHER *)dbenv->crypto_handle)->adj_size(logrec.size);
  839. logrec.size += npad;
  840. }
  842. if ((ret = __os_malloc(dbenv,
  843.     logrec.size, &logrec.data)) != 0)
  844. return (ret);
  846. if (npad > 0)
  847. memset((u_int8_t *)logrec.data + logrec.size - npad, 0, npad);
  849. bp = logrec.data;
  851. memcpy(bp, &rectype, sizeof(rectype));
  852. bp += sizeof(rectype);
  854. memcpy(bp, &txn_num, sizeof(txn_num));
  855. bp += sizeof(txn_num);
  857. memcpy(bp, lsnp, sizeof(DB_LSN));
  858. bp += sizeof(DB_LSN);
  860. DB_ASSERT(dbp->log_filename != NULL);
  861. if (dbp->log_filename->id == DB_LOGFILEID_INVALID &&
  862.     (ret = __dbreg_lazy_id(dbp)) != 0)
  863. return (ret);
  865. uinttmp = (u_int32_t)dbp->log_filename->id;
  866. memcpy(bp, &uinttmp, sizeof(uinttmp));
  867. bp += sizeof(uinttmp);
  869. if (lsn != NULL)
  870. memcpy(bp, lsn, sizeof(*lsn));
  871. else
  872. memset(bp, 0, sizeof(*lsn));
  873. bp += sizeof(*lsn);
  875. uinttmp = (u_int32_t)pgno;
  876. memcpy(bp, &uinttmp, sizeof(uinttmp));
  877. bp += sizeof(uinttmp);
  879. uinttmp = (u_int32_t)indx;
  880. memcpy(bp, &uinttmp, sizeof(uinttmp));
  881. bp += sizeof(uinttmp);
  883. uinttmp = (u_int32_t)recno;
  884. memcpy(bp, &uinttmp, sizeof(uinttmp));
  885. bp += sizeof(uinttmp);
  887. if (data == NULL) {
  888. zero = 0;
  889. memcpy(bp, &zero, sizeof(u_int32_t));
  890. bp += sizeof(u_int32_t);
  891. } else {
  892. memcpy(bp, &data->size, sizeof(data->size));
  893. bp += sizeof(data->size);
  894. memcpy(bp, data->data, data->size);
  895. bp += data->size;
  896. }
  898. uinttmp = (u_int32_t)vflag;
  899. memcpy(bp, &uinttmp, sizeof(uinttmp));
  900. bp += sizeof(uinttmp);
  902. if (olddata == NULL) {
  903. zero = 0;
  904. memcpy(bp, &zero, sizeof(u_int32_t));
  905. bp += sizeof(u_int32_t);
  906. } else {
  907. memcpy(bp, &olddata->size, sizeof(olddata->size));
  908. bp += sizeof(olddata->size);
  909. memcpy(bp, olddata->data, olddata->size);
  910. bp += olddata->size;
  911. }
  913. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
  914. ret = dbenv->log_put(dbenv,
  915.    ret_lsnp, (DBT *)&logrec, flags | DB_NOCOPY);
  916. if (txnid != NULL && ret == 0)
  917. txnid->last_lsn = *ret_lsnp;
  918. #ifdef LOG_DIAGNOSTIC
  919. if (ret != 0)
  920. (void)__qam_add_print(dbenv,
  921.     (DBT *)&logrec, ret_lsnp, NULL, NULL);
  922. #endif
  923. __os_free(dbenv, logrec.data);
  924. return (ret);
  925. }
  927. /*
  928.  * PUBLIC: int __qam_add_getpgnos __P((DB_ENV *, DBT *, DB_LSN *,
  929.  * PUBLIC:     db_recops, void *));
  930.  */
  931. int
  932. __qam_add_getpgnos(dbenv, rec, lsnp, notused1, summary)
  933. DB_ENV *dbenv;
  934. DBT *rec;
  935. DB_LSN *lsnp;
  936. db_recops notused1;
  937. void *summary;
  938. {
  939. DB *dbp;
  940. TXN_RECS *t;
  941. __qam_add_args *argp;
  942. u_int32_t ret;
  944. COMPQUIET(notused1, DB_TXN_ABORT);
  946. argp = NULL;
  947. t = (TXN_RECS *)summary;
  949. if ((ret = __qam_add_read(dbenv, rec->data, &argp)) != 0)
  950. return (ret);
  952. if ((ret = __dbreg_id_to_db(dbenv,
  953.     argp->txnid, &dbp, argp->fileid, 0)) != 0)
  954. goto err;
  956. if ((ret = __rep_check_alloc(dbenv, t, 1)) != 0)
  957. goto err;
  959. t->array[t->npages].flags = 0;
  960. t->array[t->npages].fid = argp->fileid;
  961. t->array[t->npages].lsn = *lsnp;
  962. t->array[t->npages].pgdesc.pgno = argp->pgno;
  963. t->array[t->npages].pgdesc.type = DB_PAGE_LOCK;
  964. memcpy(t->array[t->npages].pgdesc.fileid, dbp->fileid,
  965.     DB_FILE_ID_LEN);
  966. t->npages++;
  968. err: if (argp != NULL)
  969. __os_free(dbenv, argp);
  970. return (ret);
  971. }
  973. /*
  974.  * PUBLIC: int __qam_add_print __P((DB_ENV *, DBT *, DB_LSN *,
  975.  * PUBLIC:     db_recops, void *));
  976.  */
  977. int
  978. __qam_add_print(dbenv, dbtp, lsnp, notused2, notused3)
  979. DB_ENV *dbenv;
  980. DBT *dbtp;
  981. DB_LSN *lsnp;
  982. db_recops notused2;
  983. void *notused3;
  984. {
  985. __qam_add_args *argp;
  986. u_int32_t i;
  987. int ch;
  988. int ret;
  990. notused2 = DB_TXN_ABORT;
  991. notused3 = NULL;
  993. if ((ret = __qam_add_read(dbenv, dbtp->data, &argp)) != 0)
  994. return (ret);
  995. (void)printf(
  996.     "[%lu][%lu]__qam_add: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  997.     (u_long)lsnp->file,
  998.     (u_long)lsnp->offset,
  999.     (u_long)argp->type,
  1000.     (u_long)argp->txnid->txnid,
  1001.     (u_long)argp->prev_lsn.file,
  1002.     (u_long)argp->prev_lsn.offset);
  1003. (void)printf("tfileid: %ldn", (long)argp->fileid);
  1004. (void)printf("tlsn: [%lu][%lu]n",
  1005.     (u_long)argp->lsn.file, (u_long)argp->lsn.offset);
  1006. (void)printf("tpgno: %lun", (u_long)argp->pgno);
  1007. (void)printf("tindx: %lun", (u_long)argp->indx);
  1008. (void)printf("trecno: %lun", (u_long)argp->recno);
  1009. (void)printf("tdata: ");
  1010. for (i = 0; i < argp->data.size; i++) {
  1011. ch = ((u_int8_t *)argp->data.data)[i];
  1012. printf(isprint(ch) || ch == 0x0a ? "%c" : "%#x ", ch);
  1013. }
  1014. (void)printf("n");
  1015. (void)printf("tvflag: %lun", (u_long)argp->vflag);
  1016. (void)printf("tolddata: ");
  1017. for (i = 0; i < argp->olddata.size; i++) {
  1018. ch = ((u_int8_t *)argp->olddata.data)[i];
  1019. printf(isprint(ch) || ch == 0x0a ? "%c" : "%#x ", ch);
  1020. }
  1021. (void)printf("n");
  1022. (void)printf("n");
  1023. __os_free(dbenv, argp);
  1024. return (0);
  1025. }
  1027. /*
  1028.  * PUBLIC: int __qam_add_read __P((DB_ENV *, void *, __qam_add_args **));
  1029.  */
  1030. int
  1031. __qam_add_read(dbenv, recbuf, argpp)
  1032. DB_ENV *dbenv;
  1033. void *recbuf;
  1034. __qam_add_args **argpp;
  1035. {
  1036. __qam_add_args *argp;
  1037. u_int32_t uinttmp;
  1038. u_int8_t *bp;
  1039. int ret;
  1041. if ((ret = __os_malloc(dbenv,
  1042.     sizeof(__qam_add_args) + sizeof(DB_TXN), &argp)) != 0)
  1043. return (ret);
  1045. argp->txnid = (DB_TXN *)&argp[1];
  1047. bp = recbuf;
  1048. memcpy(&argp->type, bp, sizeof(argp->type));
  1049. bp += sizeof(argp->type);
  1051. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  1052. bp += sizeof(argp->txnid->txnid);
  1054. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  1055. bp += sizeof(DB_LSN);
  1057. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1058. argp->fileid = (int32_t)uinttmp;
  1059. bp += sizeof(uinttmp);
  1061. memcpy(&argp->lsn, bp,  sizeof(argp->lsn));
  1062. bp += sizeof(argp->lsn);
  1064. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1065. argp->pgno = (db_pgno_t)uinttmp;
  1066. bp += sizeof(uinttmp);
  1068. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1069. argp->indx = (u_int32_t)uinttmp;
  1070. bp += sizeof(uinttmp);
  1072. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1073. argp->recno = (db_recno_t)uinttmp;
  1074. bp += sizeof(uinttmp);
  1076. memset(&argp->data, 0, sizeof(argp->data));
  1077. memcpy(&argp->data.size, bp, sizeof(u_int32_t));
  1078. bp += sizeof(u_int32_t);
  1079. argp->data.data = bp;
  1080. bp += argp->data.size;
  1082. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1083. argp->vflag = (u_int32_t)uinttmp;
  1084. bp += sizeof(uinttmp);
  1086. memset(&argp->olddata, 0, sizeof(argp->olddata));
  1087. memcpy(&argp->olddata.size, bp, sizeof(u_int32_t));
  1088. bp += sizeof(u_int32_t);
  1089. argp->olddata.data = bp;
  1090. bp += argp->olddata.size;
  1092. *argpp = argp;
  1093. return (0);
  1094. }
  1096. /*
  1097.  * PUBLIC: int __qam_delext_log __P((DB *, DB_TXN *, DB_LSN *,
  1098.  * PUBLIC:     u_int32_t, DB_LSN *, db_pgno_t, u_int32_t, db_recno_t,
  1099.  * PUBLIC:     const DBT *));
  1100.  */
  1101. int
  1102. __qam_delext_log(dbp, txnid, ret_lsnp, flags, lsn, pgno, indx, recno, data)
  1103. DB *dbp;
  1104. DB_TXN *txnid;
  1105. DB_LSN *ret_lsnp;
  1106. u_int32_t flags;
  1107. DB_LSN * lsn;
  1108. db_pgno_t pgno;
  1109. u_int32_t indx;
  1110. db_recno_t recno;
  1111. const DBT *data;
  1112. {
  1113. DBT logrec;
  1114. DB_ENV *dbenv;
  1115. DB_LSN *lsnp, null_lsn;
  1116. u_int32_t zero;
  1117. u_int32_t uinttmp;
  1118. u_int32_t npad, rectype, txn_num;
  1119. int ret;
  1120. u_int8_t *bp;
  1122. dbenv = dbp->dbenv;
  1123. rectype = DB___qam_delext;
  1124. npad = 0;
  1126. if (txnid == NULL) {
  1127. txn_num = 0;
  1128. null_lsn.file = 0;
  1129. null_lsn.offset = 0;
  1130. lsnp = &null_lsn;
  1131. } else {
  1132. if (TAILQ_FIRST(&txnid->kids) != NULL &&
  1133.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  1134. return (ret);
  1135. txn_num = txnid->txnid;
  1136. lsnp = &txnid->last_lsn;
  1137. }
  1139. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  1140.     + sizeof(u_int32_t)
  1141.     + sizeof(*lsn)
  1142.     + sizeof(u_int32_t)
  1143.     + sizeof(u_int32_t)
  1144.     + sizeof(u_int32_t)
  1145.     + sizeof(u_int32_t) + (data == NULL ? 0 : data->size);
  1146. if (CRYPTO_ON(dbenv)) {
  1147. npad =
  1148.     ((DB_CIPHER *)dbenv->crypto_handle)->adj_size(logrec.size);
  1149. logrec.size += npad;
  1150. }
  1152. if ((ret = __os_malloc(dbenv,
  1153.     logrec.size, &logrec.data)) != 0)
  1154. return (ret);
  1156. if (npad > 0)
  1157. memset((u_int8_t *)logrec.data + logrec.size - npad, 0, npad);
  1159. bp = logrec.data;
  1161. memcpy(bp, &rectype, sizeof(rectype));
  1162. bp += sizeof(rectype);
  1164. memcpy(bp, &txn_num, sizeof(txn_num));
  1165. bp += sizeof(txn_num);
  1167. memcpy(bp, lsnp, sizeof(DB_LSN));
  1168. bp += sizeof(DB_LSN);
  1170. DB_ASSERT(dbp->log_filename != NULL);
  1171. if (dbp->log_filename->id == DB_LOGFILEID_INVALID &&
  1172.     (ret = __dbreg_lazy_id(dbp)) != 0)
  1173. return (ret);
  1175. uinttmp = (u_int32_t)dbp->log_filename->id;
  1176. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1177. bp += sizeof(uinttmp);
  1179. if (lsn != NULL)
  1180. memcpy(bp, lsn, sizeof(*lsn));
  1181. else
  1182. memset(bp, 0, sizeof(*lsn));
  1183. bp += sizeof(*lsn);
  1185. uinttmp = (u_int32_t)pgno;
  1186. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1187. bp += sizeof(uinttmp);
  1189. uinttmp = (u_int32_t)indx;
  1190. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1191. bp += sizeof(uinttmp);
  1193. uinttmp = (u_int32_t)recno;
  1194. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1195. bp += sizeof(uinttmp);
  1197. if (data == NULL) {
  1198. zero = 0;
  1199. memcpy(bp, &zero, sizeof(u_int32_t));
  1200. bp += sizeof(u_int32_t);
  1201. } else {
  1202. memcpy(bp, &data->size, sizeof(data->size));
  1203. bp += sizeof(data->size);
  1204. memcpy(bp, data->data, data->size);
  1205. bp += data->size;
  1206. }
  1208. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
  1209. ret = dbenv->log_put(dbenv,
  1210.    ret_lsnp, (DBT *)&logrec, flags | DB_NOCOPY);
  1211. if (txnid != NULL && ret == 0)
  1212. txnid->last_lsn = *ret_lsnp;
  1213. #ifdef LOG_DIAGNOSTIC
  1214. if (ret != 0)
  1215. (void)__qam_delext_print(dbenv,
  1216.     (DBT *)&logrec, ret_lsnp, NULL, NULL);
  1217. #endif
  1218. __os_free(dbenv, logrec.data);
  1219. return (ret);
  1220. }
  1222. /*
  1223.  * PUBLIC: int __qam_delext_getpgnos __P((DB_ENV *, DBT *, DB_LSN *,
  1224.  * PUBLIC:     db_recops, void *));
  1225.  */
  1226. int
  1227. __qam_delext_getpgnos(dbenv, rec, lsnp, notused1, summary)
  1228. DB_ENV *dbenv;
  1229. DBT *rec;
  1230. DB_LSN *lsnp;
  1231. db_recops notused1;
  1232. void *summary;
  1233. {
  1234. TXN_RECS *t;
  1235. int ret;
  1236. COMPQUIET(rec, NULL);
  1237. COMPQUIET(notused1, DB_TXN_ABORT);
  1239. t = (TXN_RECS *)summary;
  1241. if ((ret = __rep_check_alloc(dbenv, t, 1)) != 0)
  1242. return (ret);
  1244. t->array[t->npages].flags = LSN_PAGE_NOLOCK;
  1245. t->array[t->npages].lsn = *lsnp;
  1246. t->array[t->npages].fid = DB_LOGFILEID_INVALID;
  1247. memset(&t->array[t->npages].pgdesc, 0,
  1248.     sizeof(t->array[t->npages].pgdesc));
  1250. t->npages++;
  1252. return (0);
  1253. }
  1255. /*
  1256.  * PUBLIC: int __qam_delext_print __P((DB_ENV *, DBT *, DB_LSN *,
  1257.  * PUBLIC:     db_recops, void *));
  1258.  */
  1259. int
  1260. __qam_delext_print(dbenv, dbtp, lsnp, notused2, notused3)
  1261. DB_ENV *dbenv;
  1262. DBT *dbtp;
  1263. DB_LSN *lsnp;
  1264. db_recops notused2;
  1265. void *notused3;
  1266. {
  1267. __qam_delext_args *argp;
  1268. u_int32_t i;
  1269. int ch;
  1270. int ret;
  1272. notused2 = DB_TXN_ABORT;
  1273. notused3 = NULL;
  1275. if ((ret = __qam_delext_read(dbenv, dbtp->data, &argp)) != 0)
  1276. return (ret);
  1277. (void)printf(
  1278.     "[%lu][%lu]__qam_delext: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  1279.     (u_long)lsnp->file,
  1280.     (u_long)lsnp->offset,
  1281.     (u_long)argp->type,
  1282.     (u_long)argp->txnid->txnid,
  1283.     (u_long)argp->prev_lsn.file,
  1284.     (u_long)argp->prev_lsn.offset);
  1285. (void)printf("tfileid: %ldn", (long)argp->fileid);
  1286. (void)printf("tlsn: [%lu][%lu]n",
  1287.     (u_long)argp->lsn.file, (u_long)argp->lsn.offset);
  1288. (void)printf("tpgno: %lun", (u_long)argp->pgno);
  1289. (void)printf("tindx: %lun", (u_long)argp->indx);
  1290. (void)printf("trecno: %lun", (u_long)argp->recno);
  1291. (void)printf("tdata: ");
  1292. for (i = 0; i < argp->data.size; i++) {
  1293. ch = ((u_int8_t *)argp->data.data)[i];
  1294. printf(isprint(ch) || ch == 0x0a ? "%c" : "%#x ", ch);
  1295. }
  1296. (void)printf("n");
  1297. (void)printf("n");
  1298. __os_free(dbenv, argp);
  1299. return (0);
  1300. }
  1302. /*
  1303.  * PUBLIC: int __qam_delext_read __P((DB_ENV *, void *, __qam_delext_args **));
  1304.  */
  1305. int
  1306. __qam_delext_read(dbenv, recbuf, argpp)
  1307. DB_ENV *dbenv;
  1308. void *recbuf;
  1309. __qam_delext_args **argpp;
  1310. {
  1311. __qam_delext_args *argp;
  1312. u_int32_t uinttmp;
  1313. u_int8_t *bp;
  1314. int ret;
  1316. if ((ret = __os_malloc(dbenv,
  1317.     sizeof(__qam_delext_args) + sizeof(DB_TXN), &argp)) != 0)
  1318. return (ret);
  1320. argp->txnid = (DB_TXN *)&argp[1];
  1322. bp = recbuf;
  1323. memcpy(&argp->type, bp, sizeof(argp->type));
  1324. bp += sizeof(argp->type);
  1326. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  1327. bp += sizeof(argp->txnid->txnid);
  1329. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  1330. bp += sizeof(DB_LSN);
  1332. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1333. argp->fileid = (int32_t)uinttmp;
  1334. bp += sizeof(uinttmp);
  1336. memcpy(&argp->lsn, bp,  sizeof(argp->lsn));
  1337. bp += sizeof(argp->lsn);
  1339. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1340. argp->pgno = (db_pgno_t)uinttmp;
  1341. bp += sizeof(uinttmp);
  1343. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1344. argp->indx = (u_int32_t)uinttmp;
  1345. bp += sizeof(uinttmp);
  1347. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1348. argp->recno = (db_recno_t)uinttmp;
  1349. bp += sizeof(uinttmp);
  1351. memset(&argp->data, 0, sizeof(argp->data));
  1352. memcpy(&argp->data.size, bp, sizeof(u_int32_t));
  1353. bp += sizeof(u_int32_t);
  1354. argp->data.data = bp;
  1355. bp += argp->data.size;
  1357. *argpp = argp;
  1358. return (0);
  1359. }
  1361. /*
  1362.  * PUBLIC: int __qam_init_print __P((DB_ENV *, int (***)(DB_ENV *,
  1363.  * PUBLIC:     DBT *, DB_LSN *, db_recops, void *), size_t *));
  1364.  */
  1365. int
  1366. __qam_init_print(dbenv, dtabp, dtabsizep)
  1367. DB_ENV *dbenv;
  1368. int (***dtabp)__P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  1369. size_t *dtabsizep;
  1370. {
  1371. int ret;
  1373. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  1374.     __qam_incfirst_print, DB___qam_incfirst)) != 0)
  1375. return (ret);
  1376. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  1377.     __qam_mvptr_print, DB___qam_mvptr)) != 0)
  1378. return (ret);
  1379. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  1380.     __qam_del_print, DB___qam_del)) != 0)
  1381. return (ret);
  1382. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  1383.     __qam_add_print, DB___qam_add)) != 0)
  1384. return (ret);
  1385. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  1386.     __qam_delext_print, DB___qam_delext)) != 0)
  1387. return (ret);
  1388. return (0);
  1389. }
  1391. /*
  1392.  * PUBLIC: int __qam_init_getpgnos __P((DB_ENV *, int (***)(DB_ENV *,
  1393.  * PUBLIC:     DBT *, DB_LSN *, db_recops, void *), size_t *));
  1394.  */
  1395. int
  1396. __qam_init_getpgnos(dbenv, dtabp, dtabsizep)
  1397. DB_ENV *dbenv;
  1398. int (***dtabp)__P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  1399. size_t *dtabsizep;
  1400. {
  1401. int ret;
  1403. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  1404.     __qam_incfirst_getpgnos, DB___qam_incfirst)) != 0)
  1405. return (ret);
  1406. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  1407.     __qam_mvptr_getpgnos, DB___qam_mvptr)) != 0)
  1408. return (ret);
  1409. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  1410.     __qam_del_getpgnos, DB___qam_del)) != 0)
  1411. return (ret);
  1412. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  1413.     __qam_add_getpgnos, DB___qam_add)) != 0)
  1414. return (ret);
  1415. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  1416.     __qam_delext_getpgnos, DB___qam_delext)) != 0)
  1417. return (ret);
  1418. return (0);
  1419. }
  1421. /*
  1422.  * PUBLIC: int __qam_init_recover __P((DB_ENV *, int (***)(DB_ENV *,
  1423.  * PUBLIC:     DBT *, DB_LSN *, db_recops, void *), size_t *));
  1424.  */
  1425. int
  1426. __qam_init_recover(dbenv, dtabp, dtabsizep)
  1427. DB_ENV *dbenv;
  1428. int (***dtabp)__P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  1429. size_t *dtabsizep;
  1430. {
  1431. int ret;
  1433. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  1434.     __qam_incfirst_recover, DB___qam_incfirst)) != 0)
  1435. return (ret);
  1436. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  1437.     __qam_mvptr_recover, DB___qam_mvptr)) != 0)
  1438. return (ret);
  1439. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  1440.     __qam_del_recover, DB___qam_del)) != 0)
  1441. return (ret);
  1442. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  1443.     __qam_add_recover, DB___qam_add)) != 0)
  1444. return (ret);
  1445. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  1446.     __qam_delext_recover, DB___qam_delext)) != 0)
  1447. return (ret);
  1448. return (0);
  1449. }