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

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

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 <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 "qam.h"
  17. #include "txn.h"
  19. int
  20. __qam_inc_log(dbenv, txnid, ret_lsnp, flags,
  21. fileid, lsn)
  22. DB_ENV *dbenv;
  23. DB_TXN *txnid;
  24. DB_LSN *ret_lsnp;
  25. u_int32_t flags;
  26. int32_t fileid;
  27. DB_LSN * lsn;
  28. {
  29. DBT logrec;
  30. DB_LSN *lsnp, null_lsn;
  31. u_int32_t rectype, txn_num;
  32. int ret;
  33. u_int8_t *bp;
  35. rectype = DB_qam_inc;
  36. if (txnid != NULL &&
  37.     TAILQ_FIRST(&txnid->kids) != NULL &&
  38.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  39. return (ret);
  40. txn_num = txnid == NULL ? 0 : txnid->txnid;
  41. if (txnid == NULL) {
  42. ZERO_LSN(null_lsn);
  43. lsnp = &null_lsn;
  44. } else
  45. lsnp = &txnid->last_lsn;
  46. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  47.     + sizeof(fileid)
  48.     + sizeof(*lsn);
  49. if ((ret = __os_malloc(dbenv, logrec.size, NULL, &logrec.data)) != 0)
  50. return (ret);
  52. bp = logrec.data;
  53. memcpy(bp, &rectype, sizeof(rectype));
  54. bp += sizeof(rectype);
  55. memcpy(bp, &txn_num, sizeof(txn_num));
  56. bp += sizeof(txn_num);
  57. memcpy(bp, lsnp, sizeof(DB_LSN));
  58. bp += sizeof(DB_LSN);
  59. memcpy(bp, &fileid, sizeof(fileid));
  60. bp += sizeof(fileid);
  61. if (lsn != NULL)
  62. memcpy(bp, lsn, sizeof(*lsn));
  63. else
  64. memset(bp, 0, sizeof(*lsn));
  65. bp += sizeof(*lsn);
  66. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size);
  67. ret = log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags);
  68. if (txnid != NULL)
  69. txnid->last_lsn = *ret_lsnp;
  70. __os_free(logrec.data, logrec.size);
  71. return (ret);
  72. }
  74. int
  75. __qam_inc_print(dbenv, dbtp, lsnp, notused2, notused3)
  76. DB_ENV *dbenv;
  77. DBT *dbtp;
  78. DB_LSN *lsnp;
  79. db_recops notused2;
  80. void *notused3;
  81. {
  82. __qam_inc_args *argp;
  83. u_int32_t i;
  84. u_int ch;
  85. int ret;
  87. i = 0;
  88. ch = 0;
  89. notused2 = DB_TXN_ABORT;
  90. notused3 = NULL;
  92. if ((ret = __qam_inc_read(dbenv, dbtp->data, &argp)) != 0)
  93. return (ret);
  94. printf("[%lu][%lu]qam_inc: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  95.     (u_long)lsnp->file,
  96.     (u_long)lsnp->offset,
  97.     (u_long)argp->type,
  98.     (u_long)argp->txnid->txnid,
  99.     (u_long)argp->prev_lsn.file,
  100.     (u_long)argp->prev_lsn.offset);
  101. printf("tfileid: %ldn", (long)argp->fileid);
  102. printf("tlsn: [%lu][%lu]n",
  103.     (u_long)argp->lsn.file, (u_long)argp->lsn.offset);
  104. printf("n");
  105. __os_free(argp, 0);
  106. return (0);
  107. }
  109. int
  110. __qam_inc_read(dbenv, recbuf, argpp)
  111. DB_ENV *dbenv;
  112. void *recbuf;
  113. __qam_inc_args **argpp;
  114. {
  115. __qam_inc_args *argp;
  116. u_int8_t *bp;
  117. int ret;
  119. ret = __os_malloc(dbenv, sizeof(__qam_inc_args) +
  120.     sizeof(DB_TXN), NULL, &argp);
  121. if (ret != 0)
  122. return (ret);
  123. argp->txnid = (DB_TXN *)&argp[1];
  124. bp = recbuf;
  125. memcpy(&argp->type, bp, sizeof(argp->type));
  126. bp += sizeof(argp->type);
  127. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  128. bp += sizeof(argp->txnid->txnid);
  129. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  130. bp += sizeof(DB_LSN);
  131. memcpy(&argp->fileid, bp, sizeof(argp->fileid));
  132. bp += sizeof(argp->fileid);
  133. memcpy(&argp->lsn, bp,  sizeof(argp->lsn));
  134. bp += sizeof(argp->lsn);
  135. *argpp = argp;
  136. return (0);
  137. }
  139. int
  140. __qam_incfirst_log(dbenv, txnid, ret_lsnp, flags,
  141. fileid, recno)
  142. DB_ENV *dbenv;
  143. DB_TXN *txnid;
  144. DB_LSN *ret_lsnp;
  145. u_int32_t flags;
  146. int32_t fileid;
  147. db_recno_t recno;
  148. {
  149. DBT logrec;
  150. DB_LSN *lsnp, null_lsn;
  151. u_int32_t rectype, txn_num;
  152. int ret;
  153. u_int8_t *bp;
  155. rectype = DB_qam_incfirst;
  156. if (txnid != NULL &&
  157.     TAILQ_FIRST(&txnid->kids) != NULL &&
  158.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  159. return (ret);
  160. txn_num = txnid == NULL ? 0 : txnid->txnid;
  161. if (txnid == NULL) {
  162. ZERO_LSN(null_lsn);
  163. lsnp = &null_lsn;
  164. } else
  165. lsnp = &txnid->last_lsn;
  166. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  167.     + sizeof(fileid)
  168.     + sizeof(recno);
  169. if ((ret = __os_malloc(dbenv, logrec.size, NULL, &logrec.data)) != 0)
  170. return (ret);
  172. bp = logrec.data;
  173. memcpy(bp, &rectype, sizeof(rectype));
  174. bp += sizeof(rectype);
  175. memcpy(bp, &txn_num, sizeof(txn_num));
  176. bp += sizeof(txn_num);
  177. memcpy(bp, lsnp, sizeof(DB_LSN));
  178. bp += sizeof(DB_LSN);
  179. memcpy(bp, &fileid, sizeof(fileid));
  180. bp += sizeof(fileid);
  181. memcpy(bp, &recno, sizeof(recno));
  182. bp += sizeof(recno);
  183. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size);
  184. ret = log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags);
  185. if (txnid != NULL)
  186. txnid->last_lsn = *ret_lsnp;
  187. __os_free(logrec.data, logrec.size);
  188. return (ret);
  189. }
  191. int
  192. __qam_incfirst_print(dbenv, dbtp, lsnp, notused2, notused3)
  193. DB_ENV *dbenv;
  194. DBT *dbtp;
  195. DB_LSN *lsnp;
  196. db_recops notused2;
  197. void *notused3;
  198. {
  199. __qam_incfirst_args *argp;
  200. u_int32_t i;
  201. u_int ch;
  202. int ret;
  204. i = 0;
  205. ch = 0;
  206. notused2 = DB_TXN_ABORT;
  207. notused3 = NULL;
  209. if ((ret = __qam_incfirst_read(dbenv, dbtp->data, &argp)) != 0)
  210. return (ret);
  211. printf("[%lu][%lu]qam_incfirst: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  212.     (u_long)lsnp->file,
  213.     (u_long)lsnp->offset,
  214.     (u_long)argp->type,
  215.     (u_long)argp->txnid->txnid,
  216.     (u_long)argp->prev_lsn.file,
  217.     (u_long)argp->prev_lsn.offset);
  218. printf("tfileid: %ldn", (long)argp->fileid);
  219. printf("trecno: %lun", (u_long)argp->recno);
  220. printf("n");
  221. __os_free(argp, 0);
  222. return (0);
  223. }
  225. int
  226. __qam_incfirst_read(dbenv, recbuf, argpp)
  227. DB_ENV *dbenv;
  228. void *recbuf;
  229. __qam_incfirst_args **argpp;
  230. {
  231. __qam_incfirst_args *argp;
  232. u_int8_t *bp;
  233. int ret;
  235. ret = __os_malloc(dbenv, sizeof(__qam_incfirst_args) +
  236.     sizeof(DB_TXN), NULL, &argp);
  237. if (ret != 0)
  238. return (ret);
  239. argp->txnid = (DB_TXN *)&argp[1];
  240. bp = recbuf;
  241. memcpy(&argp->type, bp, sizeof(argp->type));
  242. bp += sizeof(argp->type);
  243. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  244. bp += sizeof(argp->txnid->txnid);
  245. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  246. bp += sizeof(DB_LSN);
  247. memcpy(&argp->fileid, bp, sizeof(argp->fileid));
  248. bp += sizeof(argp->fileid);
  249. memcpy(&argp->recno, bp, sizeof(argp->recno));
  250. bp += sizeof(argp->recno);
  251. *argpp = argp;
  252. return (0);
  253. }
  255. int
  256. __qam_mvptr_log(dbenv, txnid, ret_lsnp, flags,
  257. opcode, fileid, old_first, new_first, old_cur, new_cur,
  258. metalsn)
  259. DB_ENV *dbenv;
  260. DB_TXN *txnid;
  261. DB_LSN *ret_lsnp;
  262. u_int32_t flags;
  263. u_int32_t opcode;
  264. int32_t fileid;
  265. db_recno_t old_first;
  266. db_recno_t new_first;
  267. db_recno_t old_cur;
  268. db_recno_t new_cur;
  269. DB_LSN * metalsn;
  270. {
  271. DBT logrec;
  272. DB_LSN *lsnp, null_lsn;
  273. u_int32_t rectype, txn_num;
  274. int ret;
  275. u_int8_t *bp;
  277. rectype = DB_qam_mvptr;
  278. if (txnid != NULL &&
  279.     TAILQ_FIRST(&txnid->kids) != NULL &&
  280.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  281. return (ret);
  282. txn_num = txnid == NULL ? 0 : txnid->txnid;
  283. if (txnid == NULL) {
  284. ZERO_LSN(null_lsn);
  285. lsnp = &null_lsn;
  286. } else
  287. lsnp = &txnid->last_lsn;
  288. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  289.     + sizeof(opcode)
  290.     + sizeof(fileid)
  291.     + sizeof(old_first)
  292.     + sizeof(new_first)
  293.     + sizeof(old_cur)
  294.     + sizeof(new_cur)
  295.     + sizeof(*metalsn);
  296. if ((ret = __os_malloc(dbenv, logrec.size, NULL, &logrec.data)) != 0)
  297. return (ret);
  299. bp = logrec.data;
  300. memcpy(bp, &rectype, sizeof(rectype));
  301. bp += sizeof(rectype);
  302. memcpy(bp, &txn_num, sizeof(txn_num));
  303. bp += sizeof(txn_num);
  304. memcpy(bp, lsnp, sizeof(DB_LSN));
  305. bp += sizeof(DB_LSN);
  306. memcpy(bp, &opcode, sizeof(opcode));
  307. bp += sizeof(opcode);
  308. memcpy(bp, &fileid, sizeof(fileid));
  309. bp += sizeof(fileid);
  310. memcpy(bp, &old_first, sizeof(old_first));
  311. bp += sizeof(old_first);
  312. memcpy(bp, &new_first, sizeof(new_first));
  313. bp += sizeof(new_first);
  314. memcpy(bp, &old_cur, sizeof(old_cur));
  315. bp += sizeof(old_cur);
  316. memcpy(bp, &new_cur, sizeof(new_cur));
  317. bp += sizeof(new_cur);
  318. if (metalsn != NULL)
  319. memcpy(bp, metalsn, sizeof(*metalsn));
  320. else
  321. memset(bp, 0, sizeof(*metalsn));
  322. bp += sizeof(*metalsn);
  323. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size);
  324. ret = log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags);
  325. if (txnid != NULL)
  326. txnid->last_lsn = *ret_lsnp;
  327. __os_free(logrec.data, logrec.size);
  328. return (ret);
  329. }
  331. int
  332. __qam_mvptr_print(dbenv, dbtp, lsnp, notused2, notused3)
  333. DB_ENV *dbenv;
  334. DBT *dbtp;
  335. DB_LSN *lsnp;
  336. db_recops notused2;
  337. void *notused3;
  338. {
  339. __qam_mvptr_args *argp;
  340. u_int32_t i;
  341. u_int ch;
  342. int ret;
  344. i = 0;
  345. ch = 0;
  346. notused2 = DB_TXN_ABORT;
  347. notused3 = NULL;
  349. if ((ret = __qam_mvptr_read(dbenv, dbtp->data, &argp)) != 0)
  350. return (ret);
  351. printf("[%lu][%lu]qam_mvptr: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  352.     (u_long)lsnp->file,
  353.     (u_long)lsnp->offset,
  354.     (u_long)argp->type,
  355.     (u_long)argp->txnid->txnid,
  356.     (u_long)argp->prev_lsn.file,
  357.     (u_long)argp->prev_lsn.offset);
  358. printf("topcode: %lun", (u_long)argp->opcode);
  359. printf("tfileid: %ldn", (long)argp->fileid);
  360. printf("told_first: %lun", (u_long)argp->old_first);
  361. printf("tnew_first: %lun", (u_long)argp->new_first);
  362. printf("told_cur: %lun", (u_long)argp->old_cur);
  363. printf("tnew_cur: %lun", (u_long)argp->new_cur);
  364. printf("tmetalsn: [%lu][%lu]n",
  365.     (u_long)argp->metalsn.file, (u_long)argp->metalsn.offset);
  366. printf("n");
  367. __os_free(argp, 0);
  368. return (0);
  369. }
  371. int
  372. __qam_mvptr_read(dbenv, recbuf, argpp)
  373. DB_ENV *dbenv;
  374. void *recbuf;
  375. __qam_mvptr_args **argpp;
  376. {
  377. __qam_mvptr_args *argp;
  378. u_int8_t *bp;
  379. int ret;
  381. ret = __os_malloc(dbenv, sizeof(__qam_mvptr_args) +
  382.     sizeof(DB_TXN), NULL, &argp);
  383. if (ret != 0)
  384. return (ret);
  385. argp->txnid = (DB_TXN *)&argp[1];
  386. bp = recbuf;
  387. memcpy(&argp->type, bp, sizeof(argp->type));
  388. bp += sizeof(argp->type);
  389. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  390. bp += sizeof(argp->txnid->txnid);
  391. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  392. bp += sizeof(DB_LSN);
  393. memcpy(&argp->opcode, bp, sizeof(argp->opcode));
  394. bp += sizeof(argp->opcode);
  395. memcpy(&argp->fileid, bp, sizeof(argp->fileid));
  396. bp += sizeof(argp->fileid);
  397. memcpy(&argp->old_first, bp, sizeof(argp->old_first));
  398. bp += sizeof(argp->old_first);
  399. memcpy(&argp->new_first, bp, sizeof(argp->new_first));
  400. bp += sizeof(argp->new_first);
  401. memcpy(&argp->old_cur, bp, sizeof(argp->old_cur));
  402. bp += sizeof(argp->old_cur);
  403. memcpy(&argp->new_cur, bp, sizeof(argp->new_cur));
  404. bp += sizeof(argp->new_cur);
  405. memcpy(&argp->metalsn, bp,  sizeof(argp->metalsn));
  406. bp += sizeof(argp->metalsn);
  407. *argpp = argp;
  408. return (0);
  409. }
  411. int
  412. __qam_del_log(dbenv, txnid, ret_lsnp, flags,
  413. fileid, lsn, pgno, indx, recno)
  414. DB_ENV *dbenv;
  415. DB_TXN *txnid;
  416. DB_LSN *ret_lsnp;
  417. u_int32_t flags;
  418. int32_t fileid;
  419. DB_LSN * lsn;
  420. db_pgno_t pgno;
  421. u_int32_t indx;
  422. db_recno_t recno;
  423. {
  424. DBT logrec;
  425. DB_LSN *lsnp, null_lsn;
  426. u_int32_t rectype, txn_num;
  427. int ret;
  428. u_int8_t *bp;
  430. rectype = DB_qam_del;
  431. if (txnid != NULL &&
  432.     TAILQ_FIRST(&txnid->kids) != NULL &&
  433.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  434. return (ret);
  435. txn_num = txnid == NULL ? 0 : txnid->txnid;
  436. if (txnid == NULL) {
  437. ZERO_LSN(null_lsn);
  438. lsnp = &null_lsn;
  439. } else
  440. lsnp = &txnid->last_lsn;
  441. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  442.     + sizeof(fileid)
  443.     + sizeof(*lsn)
  444.     + sizeof(pgno)
  445.     + sizeof(indx)
  446.     + sizeof(recno);
  447. if ((ret = __os_malloc(dbenv, logrec.size, NULL, &logrec.data)) != 0)
  448. return (ret);
  450. bp = logrec.data;
  451. memcpy(bp, &rectype, sizeof(rectype));
  452. bp += sizeof(rectype);
  453. memcpy(bp, &txn_num, sizeof(txn_num));
  454. bp += sizeof(txn_num);
  455. memcpy(bp, lsnp, sizeof(DB_LSN));
  456. bp += sizeof(DB_LSN);
  457. memcpy(bp, &fileid, sizeof(fileid));
  458. bp += sizeof(fileid);
  459. if (lsn != NULL)
  460. memcpy(bp, lsn, sizeof(*lsn));
  461. else
  462. memset(bp, 0, sizeof(*lsn));
  463. bp += sizeof(*lsn);
  464. memcpy(bp, &pgno, sizeof(pgno));
  465. bp += sizeof(pgno);
  466. memcpy(bp, &indx, sizeof(indx));
  467. bp += sizeof(indx);
  468. memcpy(bp, &recno, sizeof(recno));
  469. bp += sizeof(recno);
  470. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size);
  471. ret = log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags);
  472. if (txnid != NULL)
  473. txnid->last_lsn = *ret_lsnp;
  474. __os_free(logrec.data, logrec.size);
  475. return (ret);
  476. }
  478. int
  479. __qam_del_print(dbenv, dbtp, lsnp, notused2, notused3)
  480. DB_ENV *dbenv;
  481. DBT *dbtp;
  482. DB_LSN *lsnp;
  483. db_recops notused2;
  484. void *notused3;
  485. {
  486. __qam_del_args *argp;
  487. u_int32_t i;
  488. u_int ch;
  489. int ret;
  491. i = 0;
  492. ch = 0;
  493. notused2 = DB_TXN_ABORT;
  494. notused3 = NULL;
  496. if ((ret = __qam_del_read(dbenv, dbtp->data, &argp)) != 0)
  497. return (ret);
  498. printf("[%lu][%lu]qam_del: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  499.     (u_long)lsnp->file,
  500.     (u_long)lsnp->offset,
  501.     (u_long)argp->type,
  502.     (u_long)argp->txnid->txnid,
  503.     (u_long)argp->prev_lsn.file,
  504.     (u_long)argp->prev_lsn.offset);
  505. printf("tfileid: %ldn", (long)argp->fileid);
  506. printf("tlsn: [%lu][%lu]n",
  507.     (u_long)argp->lsn.file, (u_long)argp->lsn.offset);
  508. printf("tpgno: %lun", (u_long)argp->pgno);
  509. printf("tindx: %lun", (u_long)argp->indx);
  510. printf("trecno: %lun", (u_long)argp->recno);
  511. printf("n");
  512. __os_free(argp, 0);
  513. return (0);
  514. }
  516. int
  517. __qam_del_read(dbenv, recbuf, argpp)
  518. DB_ENV *dbenv;
  519. void *recbuf;
  520. __qam_del_args **argpp;
  521. {
  522. __qam_del_args *argp;
  523. u_int8_t *bp;
  524. int ret;
  526. ret = __os_malloc(dbenv, sizeof(__qam_del_args) +
  527.     sizeof(DB_TXN), NULL, &argp);
  528. if (ret != 0)
  529. return (ret);
  530. argp->txnid = (DB_TXN *)&argp[1];
  531. bp = recbuf;
  532. memcpy(&argp->type, bp, sizeof(argp->type));
  533. bp += sizeof(argp->type);
  534. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  535. bp += sizeof(argp->txnid->txnid);
  536. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  537. bp += sizeof(DB_LSN);
  538. memcpy(&argp->fileid, bp, sizeof(argp->fileid));
  539. bp += sizeof(argp->fileid);
  540. memcpy(&argp->lsn, bp,  sizeof(argp->lsn));
  541. bp += sizeof(argp->lsn);
  542. memcpy(&argp->pgno, bp, sizeof(argp->pgno));
  543. bp += sizeof(argp->pgno);
  544. memcpy(&argp->indx, bp, sizeof(argp->indx));
  545. bp += sizeof(argp->indx);
  546. memcpy(&argp->recno, bp, sizeof(argp->recno));
  547. bp += sizeof(argp->recno);
  548. *argpp = argp;
  549. return (0);
  550. }
  552. int
  553. __qam_add_log(dbenv, txnid, ret_lsnp, flags,
  554. fileid, lsn, pgno, indx, recno, data,
  555. vflag, olddata)
  556. DB_ENV *dbenv;
  557. DB_TXN *txnid;
  558. DB_LSN *ret_lsnp;
  559. u_int32_t flags;
  560. int32_t fileid;
  561. DB_LSN * lsn;
  562. db_pgno_t pgno;
  563. u_int32_t indx;
  564. db_recno_t recno;
  565. const DBT *data;
  566. u_int32_t vflag;
  567. const DBT *olddata;
  568. {
  569. DBT logrec;
  570. DB_LSN *lsnp, null_lsn;
  571. u_int32_t zero;
  572. u_int32_t rectype, txn_num;
  573. int ret;
  574. u_int8_t *bp;
  576. rectype = DB_qam_add;
  577. if (txnid != NULL &&
  578.     TAILQ_FIRST(&txnid->kids) != NULL &&
  579.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  580. return (ret);
  581. txn_num = txnid == NULL ? 0 : txnid->txnid;
  582. if (txnid == NULL) {
  583. ZERO_LSN(null_lsn);
  584. lsnp = &null_lsn;
  585. } else
  586. lsnp = &txnid->last_lsn;
  587. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  588.     + sizeof(fileid)
  589.     + sizeof(*lsn)
  590.     + sizeof(pgno)
  591.     + sizeof(indx)
  592.     + sizeof(recno)
  593.     + sizeof(u_int32_t) + (data == NULL ? 0 : data->size)
  594.     + sizeof(vflag)
  595.     + sizeof(u_int32_t) + (olddata == NULL ? 0 : olddata->size);
  596. if ((ret = __os_malloc(dbenv, logrec.size, NULL, &logrec.data)) != 0)
  597. return (ret);
  599. bp = logrec.data;
  600. memcpy(bp, &rectype, sizeof(rectype));
  601. bp += sizeof(rectype);
  602. memcpy(bp, &txn_num, sizeof(txn_num));
  603. bp += sizeof(txn_num);
  604. memcpy(bp, lsnp, sizeof(DB_LSN));
  605. bp += sizeof(DB_LSN);
  606. memcpy(bp, &fileid, sizeof(fileid));
  607. bp += sizeof(fileid);
  608. if (lsn != NULL)
  609. memcpy(bp, lsn, sizeof(*lsn));
  610. else
  611. memset(bp, 0, sizeof(*lsn));
  612. bp += sizeof(*lsn);
  613. memcpy(bp, &pgno, sizeof(pgno));
  614. bp += sizeof(pgno);
  615. memcpy(bp, &indx, sizeof(indx));
  616. bp += sizeof(indx);
  617. memcpy(bp, &recno, sizeof(recno));
  618. bp += sizeof(recno);
  619. if (data == NULL) {
  620. zero = 0;
  621. memcpy(bp, &zero, sizeof(u_int32_t));
  622. bp += sizeof(u_int32_t);
  623. } else {
  624. memcpy(bp, &data->size, sizeof(data->size));
  625. bp += sizeof(data->size);
  626. memcpy(bp, data->data, data->size);
  627. bp += data->size;
  628. }
  629. memcpy(bp, &vflag, sizeof(vflag));
  630. bp += sizeof(vflag);
  631. if (olddata == NULL) {
  632. zero = 0;
  633. memcpy(bp, &zero, sizeof(u_int32_t));
  634. bp += sizeof(u_int32_t);
  635. } else {
  636. memcpy(bp, &olddata->size, sizeof(olddata->size));
  637. bp += sizeof(olddata->size);
  638. memcpy(bp, olddata->data, olddata->size);
  639. bp += olddata->size;
  640. }
  641. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size);
  642. ret = log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags);
  643. if (txnid != NULL)
  644. txnid->last_lsn = *ret_lsnp;
  645. __os_free(logrec.data, logrec.size);
  646. return (ret);
  647. }
  649. int
  650. __qam_add_print(dbenv, dbtp, lsnp, notused2, notused3)
  651. DB_ENV *dbenv;
  652. DBT *dbtp;
  653. DB_LSN *lsnp;
  654. db_recops notused2;
  655. void *notused3;
  656. {
  657. __qam_add_args *argp;
  658. u_int32_t i;
  659. u_int ch;
  660. int ret;
  662. i = 0;
  663. ch = 0;
  664. notused2 = DB_TXN_ABORT;
  665. notused3 = NULL;
  667. if ((ret = __qam_add_read(dbenv, dbtp->data, &argp)) != 0)
  668. return (ret);
  669. printf("[%lu][%lu]qam_add: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  670.     (u_long)lsnp->file,
  671.     (u_long)lsnp->offset,
  672.     (u_long)argp->type,
  673.     (u_long)argp->txnid->txnid,
  674.     (u_long)argp->prev_lsn.file,
  675.     (u_long)argp->prev_lsn.offset);
  676. printf("tfileid: %ldn", (long)argp->fileid);
  677. printf("tlsn: [%lu][%lu]n",
  678.     (u_long)argp->lsn.file, (u_long)argp->lsn.offset);
  679. printf("tpgno: %lun", (u_long)argp->pgno);
  680. printf("tindx: %lun", (u_long)argp->indx);
  681. printf("trecno: %lun", (u_long)argp->recno);
  682. printf("tdata: ");
  683. for (i = 0; i < argp->data.size; i++) {
  684. ch = ((u_int8_t *)argp->data.data)[i];
  685. if (isprint(ch) || ch == 0xa)
  686. putchar(ch);
  687. else
  688. printf("%#x ", ch);
  689. }
  690. printf("n");
  691. printf("tvflag: %lun", (u_long)argp->vflag);
  692. printf("tolddata: ");
  693. for (i = 0; i < argp->olddata.size; i++) {
  694. ch = ((u_int8_t *)argp->olddata.data)[i];
  695. if (isprint(ch) || ch == 0xa)
  696. putchar(ch);
  697. else
  698. printf("%#x ", ch);
  699. }
  700. printf("n");
  701. printf("n");
  702. __os_free(argp, 0);
  703. return (0);
  704. }
  706. int
  707. __qam_add_read(dbenv, recbuf, argpp)
  708. DB_ENV *dbenv;
  709. void *recbuf;
  710. __qam_add_args **argpp;
  711. {
  712. __qam_add_args *argp;
  713. u_int8_t *bp;
  714. int ret;
  716. ret = __os_malloc(dbenv, sizeof(__qam_add_args) +
  717.     sizeof(DB_TXN), NULL, &argp);
  718. if (ret != 0)
  719. return (ret);
  720. argp->txnid = (DB_TXN *)&argp[1];
  721. bp = recbuf;
  722. memcpy(&argp->type, bp, sizeof(argp->type));
  723. bp += sizeof(argp->type);
  724. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  725. bp += sizeof(argp->txnid->txnid);
  726. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  727. bp += sizeof(DB_LSN);
  728. memcpy(&argp->fileid, bp, sizeof(argp->fileid));
  729. bp += sizeof(argp->fileid);
  730. memcpy(&argp->lsn, bp,  sizeof(argp->lsn));
  731. bp += sizeof(argp->lsn);
  732. memcpy(&argp->pgno, bp, sizeof(argp->pgno));
  733. bp += sizeof(argp->pgno);
  734. memcpy(&argp->indx, bp, sizeof(argp->indx));
  735. bp += sizeof(argp->indx);
  736. memcpy(&argp->recno, bp, sizeof(argp->recno));
  737. bp += sizeof(argp->recno);
  738. memset(&argp->data, 0, sizeof(argp->data));
  739. memcpy(&argp->data.size, bp, sizeof(u_int32_t));
  740. bp += sizeof(u_int32_t);
  741. argp->data.data = bp;
  742. bp += argp->data.size;
  743. memcpy(&argp->vflag, bp, sizeof(argp->vflag));
  744. bp += sizeof(argp->vflag);
  745. memset(&argp->olddata, 0, sizeof(argp->olddata));
  746. memcpy(&argp->olddata.size, bp, sizeof(u_int32_t));
  747. bp += sizeof(u_int32_t);
  748. argp->olddata.data = bp;
  749. bp += argp->olddata.size;
  750. *argpp = argp;
  751. return (0);
  752. }
  754. int
  755. __qam_delete_log(dbenv, txnid, ret_lsnp, flags,
  756. name, lsn)
  757. DB_ENV *dbenv;
  758. DB_TXN *txnid;
  759. DB_LSN *ret_lsnp;
  760. u_int32_t flags;
  761. const DBT *name;
  762. DB_LSN * lsn;
  763. {
  764. DBT logrec;
  765. DB_LSN *lsnp, null_lsn;
  766. u_int32_t zero;
  767. u_int32_t rectype, txn_num;
  768. int ret;
  769. u_int8_t *bp;
  771. rectype = DB_qam_delete;
  772. if (txnid != NULL &&
  773.     TAILQ_FIRST(&txnid->kids) != NULL &&
  774.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  775. return (ret);
  776. txn_num = txnid == NULL ? 0 : txnid->txnid;
  777. if (txnid == NULL) {
  778. ZERO_LSN(null_lsn);
  779. lsnp = &null_lsn;
  780. } else
  781. lsnp = &txnid->last_lsn;
  782. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  783.     + sizeof(u_int32_t) + (name == NULL ? 0 : name->size)
  784.     + sizeof(*lsn);
  785. if ((ret = __os_malloc(dbenv, logrec.size, NULL, &logrec.data)) != 0)
  786. return (ret);
  788. bp = logrec.data;
  789. memcpy(bp, &rectype, sizeof(rectype));
  790. bp += sizeof(rectype);
  791. memcpy(bp, &txn_num, sizeof(txn_num));
  792. bp += sizeof(txn_num);
  793. memcpy(bp, lsnp, sizeof(DB_LSN));
  794. bp += sizeof(DB_LSN);
  795. if (name == NULL) {
  796. zero = 0;
  797. memcpy(bp, &zero, sizeof(u_int32_t));
  798. bp += sizeof(u_int32_t);
  799. } else {
  800. memcpy(bp, &name->size, sizeof(name->size));
  801. bp += sizeof(name->size);
  802. memcpy(bp, name->data, name->size);
  803. bp += name->size;
  804. }
  805. if (lsn != NULL)
  806. memcpy(bp, lsn, sizeof(*lsn));
  807. else
  808. memset(bp, 0, sizeof(*lsn));
  809. bp += sizeof(*lsn);
  810. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size);
  811. ret = log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags);
  812. if (txnid != NULL)
  813. txnid->last_lsn = *ret_lsnp;
  814. __os_free(logrec.data, logrec.size);
  815. return (ret);
  816. }
  818. int
  819. __qam_delete_print(dbenv, dbtp, lsnp, notused2, notused3)
  820. DB_ENV *dbenv;
  821. DBT *dbtp;
  822. DB_LSN *lsnp;
  823. db_recops notused2;
  824. void *notused3;
  825. {
  826. __qam_delete_args *argp;
  827. u_int32_t i;
  828. u_int ch;
  829. int ret;
  831. i = 0;
  832. ch = 0;
  833. notused2 = DB_TXN_ABORT;
  834. notused3 = NULL;
  836. if ((ret = __qam_delete_read(dbenv, dbtp->data, &argp)) != 0)
  837. return (ret);
  838. printf("[%lu][%lu]qam_delete: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  839.     (u_long)lsnp->file,
  840.     (u_long)lsnp->offset,
  841.     (u_long)argp->type,
  842.     (u_long)argp->txnid->txnid,
  843.     (u_long)argp->prev_lsn.file,
  844.     (u_long)argp->prev_lsn.offset);
  845. printf("tname: ");
  846. for (i = 0; i < argp->name.size; i++) {
  847. ch = ((u_int8_t *)argp->name.data)[i];
  848. if (isprint(ch) || ch == 0xa)
  849. putchar(ch);
  850. else
  851. printf("%#x ", ch);
  852. }
  853. printf("n");
  854. printf("tlsn: [%lu][%lu]n",
  855.     (u_long)argp->lsn.file, (u_long)argp->lsn.offset);
  856. printf("n");
  857. __os_free(argp, 0);
  858. return (0);
  859. }
  861. int
  862. __qam_delete_read(dbenv, recbuf, argpp)
  863. DB_ENV *dbenv;
  864. void *recbuf;
  865. __qam_delete_args **argpp;
  866. {
  867. __qam_delete_args *argp;
  868. u_int8_t *bp;
  869. int ret;
  871. ret = __os_malloc(dbenv, sizeof(__qam_delete_args) +
  872.     sizeof(DB_TXN), NULL, &argp);
  873. if (ret != 0)
  874. return (ret);
  875. argp->txnid = (DB_TXN *)&argp[1];
  876. bp = recbuf;
  877. memcpy(&argp->type, bp, sizeof(argp->type));
  878. bp += sizeof(argp->type);
  879. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  880. bp += sizeof(argp->txnid->txnid);
  881. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  882. bp += sizeof(DB_LSN);
  883. memset(&argp->name, 0, sizeof(argp->name));
  884. memcpy(&argp->name.size, bp, sizeof(u_int32_t));
  885. bp += sizeof(u_int32_t);
  886. argp->name.data = bp;
  887. bp += argp->name.size;
  888. memcpy(&argp->lsn, bp,  sizeof(argp->lsn));
  889. bp += sizeof(argp->lsn);
  890. *argpp = argp;
  891. return (0);
  892. }
  894. int
  895. __qam_rename_log(dbenv, txnid, ret_lsnp, flags,
  896. name, newname)
  897. DB_ENV *dbenv;
  898. DB_TXN *txnid;
  899. DB_LSN *ret_lsnp;
  900. u_int32_t flags;
  901. const DBT *name;
  902. const DBT *newname;
  903. {
  904. DBT logrec;
  905. DB_LSN *lsnp, null_lsn;
  906. u_int32_t zero;
  907. u_int32_t rectype, txn_num;
  908. int ret;
  909. u_int8_t *bp;
  911. rectype = DB_qam_rename;
  912. if (txnid != NULL &&
  913.     TAILQ_FIRST(&txnid->kids) != NULL &&
  914.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  915. return (ret);
  916. txn_num = txnid == NULL ? 0 : txnid->txnid;
  917. if (txnid == NULL) {
  918. ZERO_LSN(null_lsn);
  919. lsnp = &null_lsn;
  920. } else
  921. lsnp = &txnid->last_lsn;
  922. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  923.     + sizeof(u_int32_t) + (name == NULL ? 0 : name->size)
  924.     + sizeof(u_int32_t) + (newname == NULL ? 0 : newname->size);
  925. if ((ret = __os_malloc(dbenv, logrec.size, NULL, &logrec.data)) != 0)
  926. return (ret);
  928. bp = logrec.data;
  929. memcpy(bp, &rectype, sizeof(rectype));
  930. bp += sizeof(rectype);
  931. memcpy(bp, &txn_num, sizeof(txn_num));
  932. bp += sizeof(txn_num);
  933. memcpy(bp, lsnp, sizeof(DB_LSN));
  934. bp += sizeof(DB_LSN);
  935. if (name == NULL) {
  936. zero = 0;
  937. memcpy(bp, &zero, sizeof(u_int32_t));
  938. bp += sizeof(u_int32_t);
  939. } else {
  940. memcpy(bp, &name->size, sizeof(name->size));
  941. bp += sizeof(name->size);
  942. memcpy(bp, name->data, name->size);
  943. bp += name->size;
  944. }
  945. if (newname == NULL) {
  946. zero = 0;
  947. memcpy(bp, &zero, sizeof(u_int32_t));
  948. bp += sizeof(u_int32_t);
  949. } else {
  950. memcpy(bp, &newname->size, sizeof(newname->size));
  951. bp += sizeof(newname->size);
  952. memcpy(bp, newname->data, newname->size);
  953. bp += newname->size;
  954. }
  955. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size);
  956. ret = log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags);
  957. if (txnid != NULL)
  958. txnid->last_lsn = *ret_lsnp;
  959. __os_free(logrec.data, logrec.size);
  960. return (ret);
  961. }
  963. int
  964. __qam_rename_print(dbenv, dbtp, lsnp, notused2, notused3)
  965. DB_ENV *dbenv;
  966. DBT *dbtp;
  967. DB_LSN *lsnp;
  968. db_recops notused2;
  969. void *notused3;
  970. {
  971. __qam_rename_args *argp;
  972. u_int32_t i;
  973. u_int ch;
  974. int ret;
  976. i = 0;
  977. ch = 0;
  978. notused2 = DB_TXN_ABORT;
  979. notused3 = NULL;
  981. if ((ret = __qam_rename_read(dbenv, dbtp->data, &argp)) != 0)
  982. return (ret);
  983. printf("[%lu][%lu]qam_rename: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  984.     (u_long)lsnp->file,
  985.     (u_long)lsnp->offset,
  986.     (u_long)argp->type,
  987.     (u_long)argp->txnid->txnid,
  988.     (u_long)argp->prev_lsn.file,
  989.     (u_long)argp->prev_lsn.offset);
  990. printf("tname: ");
  991. for (i = 0; i < argp->name.size; i++) {
  992. ch = ((u_int8_t *)argp->name.data)[i];
  993. if (isprint(ch) || ch == 0xa)
  994. putchar(ch);
  995. else
  996. printf("%#x ", ch);
  997. }
  998. printf("n");
  999. printf("tnewname: ");
  1000. for (i = 0; i < argp->newname.size; i++) {
  1001. ch = ((u_int8_t *)argp->newname.data)[i];
  1002. if (isprint(ch) || ch == 0xa)
  1003. putchar(ch);
  1004. else
  1005. printf("%#x ", ch);
  1006. }
  1007. printf("n");
  1008. printf("n");
  1009. __os_free(argp, 0);
  1010. return (0);
  1011. }
  1013. int
  1014. __qam_rename_read(dbenv, recbuf, argpp)
  1015. DB_ENV *dbenv;
  1016. void *recbuf;
  1017. __qam_rename_args **argpp;
  1018. {
  1019. __qam_rename_args *argp;
  1020. u_int8_t *bp;
  1021. int ret;
  1023. ret = __os_malloc(dbenv, sizeof(__qam_rename_args) +
  1024.     sizeof(DB_TXN), NULL, &argp);
  1025. if (ret != 0)
  1026. return (ret);
  1027. argp->txnid = (DB_TXN *)&argp[1];
  1028. bp = recbuf;
  1029. memcpy(&argp->type, bp, sizeof(argp->type));
  1030. bp += sizeof(argp->type);
  1031. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  1032. bp += sizeof(argp->txnid->txnid);
  1033. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  1034. bp += sizeof(DB_LSN);
  1035. memset(&argp->name, 0, sizeof(argp->name));
  1036. memcpy(&argp->name.size, bp, sizeof(u_int32_t));
  1037. bp += sizeof(u_int32_t);
  1038. argp->name.data = bp;
  1039. bp += argp->name.size;
  1040. memset(&argp->newname, 0, sizeof(argp->newname));
  1041. memcpy(&argp->newname.size, bp, sizeof(u_int32_t));
  1042. bp += sizeof(u_int32_t);
  1043. argp->newname.data = bp;
  1044. bp += argp->newname.size;
  1045. *argpp = argp;
  1046. return (0);
  1047. }
  1049. int
  1050. __qam_delext_log(dbenv, txnid, ret_lsnp, flags,
  1051. fileid, lsn, pgno, indx, recno, data)
  1052. DB_ENV *dbenv;
  1053. DB_TXN *txnid;
  1054. DB_LSN *ret_lsnp;
  1055. u_int32_t flags;
  1056. int32_t fileid;
  1057. DB_LSN * lsn;
  1058. db_pgno_t pgno;
  1059. u_int32_t indx;
  1060. db_recno_t recno;
  1061. const DBT *data;
  1062. {
  1063. DBT logrec;
  1064. DB_LSN *lsnp, null_lsn;
  1065. u_int32_t zero;
  1066. u_int32_t rectype, txn_num;
  1067. int ret;
  1068. u_int8_t *bp;
  1070. rectype = DB_qam_delext;
  1071. if (txnid != NULL &&
  1072.     TAILQ_FIRST(&txnid->kids) != NULL &&
  1073.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  1074. return (ret);
  1075. txn_num = txnid == NULL ? 0 : txnid->txnid;
  1076. if (txnid == NULL) {
  1077. ZERO_LSN(null_lsn);
  1078. lsnp = &null_lsn;
  1079. } else
  1080. lsnp = &txnid->last_lsn;
  1081. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  1082.     + sizeof(fileid)
  1083.     + sizeof(*lsn)
  1084.     + sizeof(pgno)
  1085.     + sizeof(indx)
  1086.     + sizeof(recno)
  1087.     + sizeof(u_int32_t) + (data == NULL ? 0 : data->size);
  1088. if ((ret = __os_malloc(dbenv, logrec.size, NULL, &logrec.data)) != 0)
  1089. return (ret);
  1091. bp = logrec.data;
  1092. memcpy(bp, &rectype, sizeof(rectype));
  1093. bp += sizeof(rectype);
  1094. memcpy(bp, &txn_num, sizeof(txn_num));
  1095. bp += sizeof(txn_num);
  1096. memcpy(bp, lsnp, sizeof(DB_LSN));
  1097. bp += sizeof(DB_LSN);
  1098. memcpy(bp, &fileid, sizeof(fileid));
  1099. bp += sizeof(fileid);
  1100. if (lsn != NULL)
  1101. memcpy(bp, lsn, sizeof(*lsn));
  1102. else
  1103. memset(bp, 0, sizeof(*lsn));
  1104. bp += sizeof(*lsn);
  1105. memcpy(bp, &pgno, sizeof(pgno));
  1106. bp += sizeof(pgno);
  1107. memcpy(bp, &indx, sizeof(indx));
  1108. bp += sizeof(indx);
  1109. memcpy(bp, &recno, sizeof(recno));
  1110. bp += sizeof(recno);
  1111. if (data == NULL) {
  1112. zero = 0;
  1113. memcpy(bp, &zero, sizeof(u_int32_t));
  1114. bp += sizeof(u_int32_t);
  1115. } else {
  1116. memcpy(bp, &data->size, sizeof(data->size));
  1117. bp += sizeof(data->size);
  1118. memcpy(bp, data->data, data->size);
  1119. bp += data->size;
  1120. }
  1121. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size);
  1122. ret = log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags);
  1123. if (txnid != NULL)
  1124. txnid->last_lsn = *ret_lsnp;
  1125. __os_free(logrec.data, logrec.size);
  1126. return (ret);
  1127. }
  1129. int
  1130. __qam_delext_print(dbenv, dbtp, lsnp, notused2, notused3)
  1131. DB_ENV *dbenv;
  1132. DBT *dbtp;
  1133. DB_LSN *lsnp;
  1134. db_recops notused2;
  1135. void *notused3;
  1136. {
  1137. __qam_delext_args *argp;
  1138. u_int32_t i;
  1139. u_int ch;
  1140. int ret;
  1142. i = 0;
  1143. ch = 0;
  1144. notused2 = DB_TXN_ABORT;
  1145. notused3 = NULL;
  1147. if ((ret = __qam_delext_read(dbenv, dbtp->data, &argp)) != 0)
  1148. return (ret);
  1149. printf("[%lu][%lu]qam_delext: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  1150.     (u_long)lsnp->file,
  1151.     (u_long)lsnp->offset,
  1152.     (u_long)argp->type,
  1153.     (u_long)argp->txnid->txnid,
  1154.     (u_long)argp->prev_lsn.file,
  1155.     (u_long)argp->prev_lsn.offset);
  1156. printf("tfileid: %ldn", (long)argp->fileid);
  1157. printf("tlsn: [%lu][%lu]n",
  1158.     (u_long)argp->lsn.file, (u_long)argp->lsn.offset);
  1159. printf("tpgno: %lun", (u_long)argp->pgno);
  1160. printf("tindx: %lun", (u_long)argp->indx);
  1161. printf("trecno: %lun", (u_long)argp->recno);
  1162. printf("tdata: ");
  1163. for (i = 0; i < argp->data.size; i++) {
  1164. ch = ((u_int8_t *)argp->data.data)[i];
  1165. if (isprint(ch) || ch == 0xa)
  1166. putchar(ch);
  1167. else
  1168. printf("%#x ", ch);
  1169. }
  1170. printf("n");
  1171. printf("n");
  1172. __os_free(argp, 0);
  1173. return (0);
  1174. }
  1176. int
  1177. __qam_delext_read(dbenv, recbuf, argpp)
  1178. DB_ENV *dbenv;
  1179. void *recbuf;
  1180. __qam_delext_args **argpp;
  1181. {
  1182. __qam_delext_args *argp;
  1183. u_int8_t *bp;
  1184. int ret;
  1186. ret = __os_malloc(dbenv, sizeof(__qam_delext_args) +
  1187.     sizeof(DB_TXN), NULL, &argp);
  1188. if (ret != 0)
  1189. return (ret);
  1190. argp->txnid = (DB_TXN *)&argp[1];
  1191. bp = recbuf;
  1192. memcpy(&argp->type, bp, sizeof(argp->type));
  1193. bp += sizeof(argp->type);
  1194. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  1195. bp += sizeof(argp->txnid->txnid);
  1196. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  1197. bp += sizeof(DB_LSN);
  1198. memcpy(&argp->fileid, bp, sizeof(argp->fileid));
  1199. bp += sizeof(argp->fileid);
  1200. memcpy(&argp->lsn, bp,  sizeof(argp->lsn));
  1201. bp += sizeof(argp->lsn);
  1202. memcpy(&argp->pgno, bp, sizeof(argp->pgno));
  1203. bp += sizeof(argp->pgno);
  1204. memcpy(&argp->indx, bp, sizeof(argp->indx));
  1205. bp += sizeof(argp->indx);
  1206. memcpy(&argp->recno, bp, sizeof(argp->recno));
  1207. bp += sizeof(argp->recno);
  1208. memset(&argp->data, 0, sizeof(argp->data));
  1209. memcpy(&argp->data.size, bp, sizeof(u_int32_t));
  1210. bp += sizeof(u_int32_t);
  1211. argp->data.data = bp;
  1212. bp += argp->data.size;
  1213. *argpp = argp;
  1214. return (0);
  1215. }
  1217. int
  1218. __qam_init_print(dbenv)
  1219. DB_ENV *dbenv;
  1220. {
  1221. int ret;
  1223. if ((ret = __db_add_recovery(dbenv,
  1224.     __qam_inc_print, DB_qam_inc)) != 0)
  1225. return (ret);
  1226. if ((ret = __db_add_recovery(dbenv,
  1227.     __qam_incfirst_print, DB_qam_incfirst)) != 0)
  1228. return (ret);
  1229. if ((ret = __db_add_recovery(dbenv,
  1230.     __qam_mvptr_print, DB_qam_mvptr)) != 0)
  1231. return (ret);
  1232. if ((ret = __db_add_recovery(dbenv,
  1233.     __qam_del_print, DB_qam_del)) != 0)
  1234. return (ret);
  1235. if ((ret = __db_add_recovery(dbenv,
  1236.     __qam_add_print, DB_qam_add)) != 0)
  1237. return (ret);
  1238. if ((ret = __db_add_recovery(dbenv,
  1239.     __qam_delete_print, DB_qam_delete)) != 0)
  1240. return (ret);
  1241. if ((ret = __db_add_recovery(dbenv,
  1242.     __qam_rename_print, DB_qam_rename)) != 0)
  1243. return (ret);
  1244. if ((ret = __db_add_recovery(dbenv,
  1245.     __qam_delext_print, DB_qam_delext)) != 0)
  1246. return (ret);
  1247. return (0);
  1248. }
  1250. int
  1251. __qam_init_recover(dbenv)
  1252. DB_ENV *dbenv;
  1253. {
  1254. int ret;
  1256. if ((ret = __db_add_recovery(dbenv,
  1257.     __qam_inc_recover, DB_qam_inc)) != 0)
  1258. return (ret);
  1259. if ((ret = __db_add_recovery(dbenv,
  1260.     __qam_incfirst_recover, DB_qam_incfirst)) != 0)
  1261. return (ret);
  1262. if ((ret = __db_add_recovery(dbenv,
  1263.     __qam_mvptr_recover, DB_qam_mvptr)) != 0)
  1264. return (ret);
  1265. if ((ret = __db_add_recovery(dbenv,
  1266.     __qam_del_recover, DB_qam_del)) != 0)
  1267. return (ret);
  1268. if ((ret = __db_add_recovery(dbenv,
  1269.     __qam_add_recover, DB_qam_add)) != 0)
  1270. return (ret);
  1271. if ((ret = __db_add_recovery(dbenv,
  1272.     __qam_delete_recover, DB_qam_delete)) != 0)
  1273. return (ret);
  1274. if ((ret = __db_add_recovery(dbenv,
  1275.     __qam_rename_recover, DB_qam_rename)) != 0)
  1276. return (ret);
  1277. if ((ret = __db_add_recovery(dbenv,
  1278.     __qam_delext_recover, DB_qam_delext)) != 0)
  1279. return (ret);
  1280. return (0);
  1281. }