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

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

MySQL数据库

开发平台：

Visual C++

db_auto.c：源码内容
  1. /* Do not edit: automatically built by gen_rec.awk. */
  2. #include "db_config.h"
  4. #ifndef NO_SYSTEM_INCLUDES
  5. #include <sys/types.h>
  7. #include <ctype.h>
  8. #include <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. __db_addrem_log(dbenv, txnid, ret_lsnp, flags,
  20. opcode, fileid, pgno, indx, nbytes, hdr,
  21. dbt, pagelsn)
  22. DB_ENV *dbenv;
  23. DB_TXN *txnid;
  24. DB_LSN *ret_lsnp;
  25. u_int32_t flags;
  26. u_int32_t opcode;
  27. int32_t fileid;
  28. db_pgno_t pgno;
  29. u_int32_t indx;
  30. size_t nbytes;
  31. const DBT *hdr;
  32. const DBT *dbt;
  33. DB_LSN * pagelsn;
  34. {
  35. DBT logrec;
  36. DB_LSN *lsnp, null_lsn;
  37. u_int32_t zero;
  38. u_int32_t rectype, txn_num;
  39. int ret;
  40. u_int8_t *bp;
  42. rectype = DB_db_addrem;
  43. if (txnid != NULL &&
  44.     TAILQ_FIRST(&txnid->kids) != NULL &&
  45.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  46. return (ret);
  47. txn_num = txnid == NULL ? 0 : txnid->txnid;
  48. if (txnid == NULL) {
  49. ZERO_LSN(null_lsn);
  50. lsnp = &null_lsn;
  51. } else
  52. lsnp = &txnid->last_lsn;
  53. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  54.     + sizeof(opcode)
  55.     + sizeof(fileid)
  56.     + sizeof(pgno)
  57.     + sizeof(indx)
  58.     + sizeof(nbytes)
  59.     + sizeof(u_int32_t) + (hdr == NULL ? 0 : hdr->size)
  60.     + sizeof(u_int32_t) + (dbt == NULL ? 0 : dbt->size)
  61.     + sizeof(*pagelsn);
  62. if ((ret = __os_malloc(dbenv, logrec.size, NULL, &logrec.data)) != 0)
  63. return (ret);
  65. bp = logrec.data;
  66. memcpy(bp, &rectype, sizeof(rectype));
  67. bp += sizeof(rectype);
  68. memcpy(bp, &txn_num, sizeof(txn_num));
  69. bp += sizeof(txn_num);
  70. memcpy(bp, lsnp, sizeof(DB_LSN));
  71. bp += sizeof(DB_LSN);
  72. memcpy(bp, &opcode, sizeof(opcode));
  73. bp += sizeof(opcode);
  74. memcpy(bp, &fileid, sizeof(fileid));
  75. bp += sizeof(fileid);
  76. memcpy(bp, &pgno, sizeof(pgno));
  77. bp += sizeof(pgno);
  78. memcpy(bp, &indx, sizeof(indx));
  79. bp += sizeof(indx);
  80. memcpy(bp, &nbytes, sizeof(nbytes));
  81. bp += sizeof(nbytes);
  82. if (hdr == NULL) {
  83. zero = 0;
  84. memcpy(bp, &zero, sizeof(u_int32_t));
  85. bp += sizeof(u_int32_t);
  86. } else {
  87. memcpy(bp, &hdr->size, sizeof(hdr->size));
  88. bp += sizeof(hdr->size);
  89. memcpy(bp, hdr->data, hdr->size);
  90. bp += hdr->size;
  91. }
  92. if (dbt == NULL) {
  93. zero = 0;
  94. memcpy(bp, &zero, sizeof(u_int32_t));
  95. bp += sizeof(u_int32_t);
  96. } else {
  97. memcpy(bp, &dbt->size, sizeof(dbt->size));
  98. bp += sizeof(dbt->size);
  99. memcpy(bp, dbt->data, dbt->size);
  100. bp += dbt->size;
  101. }
  102. if (pagelsn != NULL)
  103. memcpy(bp, pagelsn, sizeof(*pagelsn));
  104. else
  105. memset(bp, 0, sizeof(*pagelsn));
  106. bp += sizeof(*pagelsn);
  107. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size);
  108. ret = log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags);
  109. if (txnid != NULL)
  110. txnid->last_lsn = *ret_lsnp;
  111. __os_free(logrec.data, logrec.size);
  112. return (ret);
  113. }
  115. int
  116. __db_addrem_print(dbenv, dbtp, lsnp, notused2, notused3)
  117. DB_ENV *dbenv;
  118. DBT *dbtp;
  119. DB_LSN *lsnp;
  120. db_recops notused2;
  121. void *notused3;
  122. {
  123. __db_addrem_args *argp;
  124. u_int32_t i;
  125. u_int ch;
  126. int ret;
  128. i = 0;
  129. ch = 0;
  130. notused2 = DB_TXN_ABORT;
  131. notused3 = NULL;
  133. if ((ret = __db_addrem_read(dbenv, dbtp->data, &argp)) != 0)
  134. return (ret);
  135. printf("[%lu][%lu]db_addrem: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  136.     (u_long)lsnp->file,
  137.     (u_long)lsnp->offset,
  138.     (u_long)argp->type,
  139.     (u_long)argp->txnid->txnid,
  140.     (u_long)argp->prev_lsn.file,
  141.     (u_long)argp->prev_lsn.offset);
  142. printf("topcode: %lun", (u_long)argp->opcode);
  143. printf("tfileid: %ldn", (long)argp->fileid);
  144. printf("tpgno: %lun", (u_long)argp->pgno);
  145. printf("tindx: %lun", (u_long)argp->indx);
  146. printf("tnbytes: %lun", (u_long)argp->nbytes);
  147. printf("thdr: ");
  148. for (i = 0; i < argp->hdr.size; i++) {
  149. ch = ((u_int8_t *)argp->hdr.data)[i];
  150. if (isprint(ch) || ch == 0xa)
  151. putchar(ch);
  152. else
  153. printf("%#x ", ch);
  154. }
  155. printf("n");
  156. printf("tdbt: ");
  157. for (i = 0; i < argp->dbt.size; i++) {
  158. ch = ((u_int8_t *)argp->dbt.data)[i];
  159. if (isprint(ch) || ch == 0xa)
  160. putchar(ch);
  161. else
  162. printf("%#x ", ch);
  163. }
  164. printf("n");
  165. printf("tpagelsn: [%lu][%lu]n",
  166.     (u_long)argp->pagelsn.file, (u_long)argp->pagelsn.offset);
  167. printf("n");
  168. __os_free(argp, 0);
  169. return (0);
  170. }
  172. int
  173. __db_addrem_read(dbenv, recbuf, argpp)
  174. DB_ENV *dbenv;
  175. void *recbuf;
  176. __db_addrem_args **argpp;
  177. {
  178. __db_addrem_args *argp;
  179. u_int8_t *bp;
  180. int ret;
  182. ret = __os_malloc(dbenv, sizeof(__db_addrem_args) +
  183.     sizeof(DB_TXN), NULL, &argp);
  184. if (ret != 0)
  185. return (ret);
  186. argp->txnid = (DB_TXN *)&argp[1];
  187. bp = recbuf;
  188. memcpy(&argp->type, bp, sizeof(argp->type));
  189. bp += sizeof(argp->type);
  190. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  191. bp += sizeof(argp->txnid->txnid);
  192. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  193. bp += sizeof(DB_LSN);
  194. memcpy(&argp->opcode, bp, sizeof(argp->opcode));
  195. bp += sizeof(argp->opcode);
  196. memcpy(&argp->fileid, bp, sizeof(argp->fileid));
  197. bp += sizeof(argp->fileid);
  198. memcpy(&argp->pgno, bp, sizeof(argp->pgno));
  199. bp += sizeof(argp->pgno);
  200. memcpy(&argp->indx, bp, sizeof(argp->indx));
  201. bp += sizeof(argp->indx);
  202. memcpy(&argp->nbytes, bp, sizeof(argp->nbytes));
  203. bp += sizeof(argp->nbytes);
  204. memset(&argp->hdr, 0, sizeof(argp->hdr));
  205. memcpy(&argp->hdr.size, bp, sizeof(u_int32_t));
  206. bp += sizeof(u_int32_t);
  207. argp->hdr.data = bp;
  208. bp += argp->hdr.size;
  209. memset(&argp->dbt, 0, sizeof(argp->dbt));
  210. memcpy(&argp->dbt.size, bp, sizeof(u_int32_t));
  211. bp += sizeof(u_int32_t);
  212. argp->dbt.data = bp;
  213. bp += argp->dbt.size;
  214. memcpy(&argp->pagelsn, bp,  sizeof(argp->pagelsn));
  215. bp += sizeof(argp->pagelsn);
  216. *argpp = argp;
  217. return (0);
  218. }
  220. int
  221. __db_split_print(dbenv, dbtp, lsnp, notused2, notused3)
  222. DB_ENV *dbenv;
  223. DBT *dbtp;
  224. DB_LSN *lsnp;
  225. db_recops notused2;
  226. void *notused3;
  227. {
  228. __db_split_args *argp;
  229. u_int32_t i;
  230. u_int ch;
  231. int ret;
  233. i = 0;
  234. ch = 0;
  235. notused2 = DB_TXN_ABORT;
  236. notused3 = NULL;
  238. if ((ret = __db_split_read(dbenv, dbtp->data, &argp)) != 0)
  239. return (ret);
  240. printf("[%lu][%lu]db_split: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  241.     (u_long)lsnp->file,
  242.     (u_long)lsnp->offset,
  243.     (u_long)argp->type,
  244.     (u_long)argp->txnid->txnid,
  245.     (u_long)argp->prev_lsn.file,
  246.     (u_long)argp->prev_lsn.offset);
  247. printf("topcode: %lun", (u_long)argp->opcode);
  248. printf("tfileid: %ldn", (long)argp->fileid);
  249. printf("tpgno: %lun", (u_long)argp->pgno);
  250. printf("tpageimage: ");
  251. for (i = 0; i < argp->pageimage.size; i++) {
  252. ch = ((u_int8_t *)argp->pageimage.data)[i];
  253. if (isprint(ch) || ch == 0xa)
  254. putchar(ch);
  255. else
  256. printf("%#x ", ch);
  257. }
  258. printf("n");
  259. printf("tpagelsn: [%lu][%lu]n",
  260.     (u_long)argp->pagelsn.file, (u_long)argp->pagelsn.offset);
  261. printf("n");
  262. __os_free(argp, 0);
  263. return (0);
  264. }
  266. int
  267. __db_split_read(dbenv, recbuf, argpp)
  268. DB_ENV *dbenv;
  269. void *recbuf;
  270. __db_split_args **argpp;
  271. {
  272. __db_split_args *argp;
  273. u_int8_t *bp;
  274. int ret;
  276. ret = __os_malloc(dbenv, sizeof(__db_split_args) +
  277.     sizeof(DB_TXN), NULL, &argp);
  278. if (ret != 0)
  279. return (ret);
  280. argp->txnid = (DB_TXN *)&argp[1];
  281. bp = recbuf;
  282. memcpy(&argp->type, bp, sizeof(argp->type));
  283. bp += sizeof(argp->type);
  284. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  285. bp += sizeof(argp->txnid->txnid);
  286. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  287. bp += sizeof(DB_LSN);
  288. memcpy(&argp->opcode, bp, sizeof(argp->opcode));
  289. bp += sizeof(argp->opcode);
  290. memcpy(&argp->fileid, bp, sizeof(argp->fileid));
  291. bp += sizeof(argp->fileid);
  292. memcpy(&argp->pgno, bp, sizeof(argp->pgno));
  293. bp += sizeof(argp->pgno);
  294. memset(&argp->pageimage, 0, sizeof(argp->pageimage));
  295. memcpy(&argp->pageimage.size, bp, sizeof(u_int32_t));
  296. bp += sizeof(u_int32_t);
  297. argp->pageimage.data = bp;
  298. bp += argp->pageimage.size;
  299. memcpy(&argp->pagelsn, bp,  sizeof(argp->pagelsn));
  300. bp += sizeof(argp->pagelsn);
  301. *argpp = argp;
  302. return (0);
  303. }
  305. int
  306. __db_big_log(dbenv, txnid, ret_lsnp, flags,
  307. opcode, fileid, pgno, prev_pgno, next_pgno, dbt,
  308. pagelsn, prevlsn, nextlsn)
  309. DB_ENV *dbenv;
  310. DB_TXN *txnid;
  311. DB_LSN *ret_lsnp;
  312. u_int32_t flags;
  313. u_int32_t opcode;
  314. int32_t fileid;
  315. db_pgno_t pgno;
  316. db_pgno_t prev_pgno;
  317. db_pgno_t next_pgno;
  318. const DBT *dbt;
  319. DB_LSN * pagelsn;
  320. DB_LSN * prevlsn;
  321. DB_LSN * nextlsn;
  322. {
  323. DBT logrec;
  324. DB_LSN *lsnp, null_lsn;
  325. u_int32_t zero;
  326. u_int32_t rectype, txn_num;
  327. int ret;
  328. u_int8_t *bp;
  330. rectype = DB_db_big;
  331. if (txnid != NULL &&
  332.     TAILQ_FIRST(&txnid->kids) != NULL &&
  333.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  334. return (ret);
  335. txn_num = txnid == NULL ? 0 : txnid->txnid;
  336. if (txnid == NULL) {
  337. ZERO_LSN(null_lsn);
  338. lsnp = &null_lsn;
  339. } else
  340. lsnp = &txnid->last_lsn;
  341. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  342.     + sizeof(opcode)
  343.     + sizeof(fileid)
  344.     + sizeof(pgno)
  345.     + sizeof(prev_pgno)
  346.     + sizeof(next_pgno)
  347.     + sizeof(u_int32_t) + (dbt == NULL ? 0 : dbt->size)
  348.     + sizeof(*pagelsn)
  349.     + sizeof(*prevlsn)
  350.     + sizeof(*nextlsn);
  351. if ((ret = __os_malloc(dbenv, logrec.size, NULL, &logrec.data)) != 0)
  352. return (ret);
  354. bp = logrec.data;
  355. memcpy(bp, &rectype, sizeof(rectype));
  356. bp += sizeof(rectype);
  357. memcpy(bp, &txn_num, sizeof(txn_num));
  358. bp += sizeof(txn_num);
  359. memcpy(bp, lsnp, sizeof(DB_LSN));
  360. bp += sizeof(DB_LSN);
  361. memcpy(bp, &opcode, sizeof(opcode));
  362. bp += sizeof(opcode);
  363. memcpy(bp, &fileid, sizeof(fileid));
  364. bp += sizeof(fileid);
  365. memcpy(bp, &pgno, sizeof(pgno));
  366. bp += sizeof(pgno);
  367. memcpy(bp, &prev_pgno, sizeof(prev_pgno));
  368. bp += sizeof(prev_pgno);
  369. memcpy(bp, &next_pgno, sizeof(next_pgno));
  370. bp += sizeof(next_pgno);
  371. if (dbt == NULL) {
  372. zero = 0;
  373. memcpy(bp, &zero, sizeof(u_int32_t));
  374. bp += sizeof(u_int32_t);
  375. } else {
  376. memcpy(bp, &dbt->size, sizeof(dbt->size));
  377. bp += sizeof(dbt->size);
  378. memcpy(bp, dbt->data, dbt->size);
  379. bp += dbt->size;
  380. }
  381. if (pagelsn != NULL)
  382. memcpy(bp, pagelsn, sizeof(*pagelsn));
  383. else
  384. memset(bp, 0, sizeof(*pagelsn));
  385. bp += sizeof(*pagelsn);
  386. if (prevlsn != NULL)
  387. memcpy(bp, prevlsn, sizeof(*prevlsn));
  388. else
  389. memset(bp, 0, sizeof(*prevlsn));
  390. bp += sizeof(*prevlsn);
  391. if (nextlsn != NULL)
  392. memcpy(bp, nextlsn, sizeof(*nextlsn));
  393. else
  394. memset(bp, 0, sizeof(*nextlsn));
  395. bp += sizeof(*nextlsn);
  396. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size);
  397. ret = log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags);
  398. if (txnid != NULL)
  399. txnid->last_lsn = *ret_lsnp;
  400. __os_free(logrec.data, logrec.size);
  401. return (ret);
  402. }
  404. int
  405. __db_big_print(dbenv, dbtp, lsnp, notused2, notused3)
  406. DB_ENV *dbenv;
  407. DBT *dbtp;
  408. DB_LSN *lsnp;
  409. db_recops notused2;
  410. void *notused3;
  411. {
  412. __db_big_args *argp;
  413. u_int32_t i;
  414. u_int ch;
  415. int ret;
  417. i = 0;
  418. ch = 0;
  419. notused2 = DB_TXN_ABORT;
  420. notused3 = NULL;
  422. if ((ret = __db_big_read(dbenv, dbtp->data, &argp)) != 0)
  423. return (ret);
  424. printf("[%lu][%lu]db_big: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  425.     (u_long)lsnp->file,
  426.     (u_long)lsnp->offset,
  427.     (u_long)argp->type,
  428.     (u_long)argp->txnid->txnid,
  429.     (u_long)argp->prev_lsn.file,
  430.     (u_long)argp->prev_lsn.offset);
  431. printf("topcode: %lun", (u_long)argp->opcode);
  432. printf("tfileid: %ldn", (long)argp->fileid);
  433. printf("tpgno: %lun", (u_long)argp->pgno);
  434. printf("tprev_pgno: %lun", (u_long)argp->prev_pgno);
  435. printf("tnext_pgno: %lun", (u_long)argp->next_pgno);
  436. printf("tdbt: ");
  437. for (i = 0; i < argp->dbt.size; i++) {
  438. ch = ((u_int8_t *)argp->dbt.data)[i];
  439. if (isprint(ch) || ch == 0xa)
  440. putchar(ch);
  441. else
  442. printf("%#x ", ch);
  443. }
  444. printf("n");
  445. printf("tpagelsn: [%lu][%lu]n",
  446.     (u_long)argp->pagelsn.file, (u_long)argp->pagelsn.offset);
  447. printf("tprevlsn: [%lu][%lu]n",
  448.     (u_long)argp->prevlsn.file, (u_long)argp->prevlsn.offset);
  449. printf("tnextlsn: [%lu][%lu]n",
  450.     (u_long)argp->nextlsn.file, (u_long)argp->nextlsn.offset);
  451. printf("n");
  452. __os_free(argp, 0);
  453. return (0);
  454. }
  456. int
  457. __db_big_read(dbenv, recbuf, argpp)
  458. DB_ENV *dbenv;
  459. void *recbuf;
  460. __db_big_args **argpp;
  461. {
  462. __db_big_args *argp;
  463. u_int8_t *bp;
  464. int ret;
  466. ret = __os_malloc(dbenv, sizeof(__db_big_args) +
  467.     sizeof(DB_TXN), NULL, &argp);
  468. if (ret != 0)
  469. return (ret);
  470. argp->txnid = (DB_TXN *)&argp[1];
  471. bp = recbuf;
  472. memcpy(&argp->type, bp, sizeof(argp->type));
  473. bp += sizeof(argp->type);
  474. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  475. bp += sizeof(argp->txnid->txnid);
  476. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  477. bp += sizeof(DB_LSN);
  478. memcpy(&argp->opcode, bp, sizeof(argp->opcode));
  479. bp += sizeof(argp->opcode);
  480. memcpy(&argp->fileid, bp, sizeof(argp->fileid));
  481. bp += sizeof(argp->fileid);
  482. memcpy(&argp->pgno, bp, sizeof(argp->pgno));
  483. bp += sizeof(argp->pgno);
  484. memcpy(&argp->prev_pgno, bp, sizeof(argp->prev_pgno));
  485. bp += sizeof(argp->prev_pgno);
  486. memcpy(&argp->next_pgno, bp, sizeof(argp->next_pgno));
  487. bp += sizeof(argp->next_pgno);
  488. memset(&argp->dbt, 0, sizeof(argp->dbt));
  489. memcpy(&argp->dbt.size, bp, sizeof(u_int32_t));
  490. bp += sizeof(u_int32_t);
  491. argp->dbt.data = bp;
  492. bp += argp->dbt.size;
  493. memcpy(&argp->pagelsn, bp,  sizeof(argp->pagelsn));
  494. bp += sizeof(argp->pagelsn);
  495. memcpy(&argp->prevlsn, bp,  sizeof(argp->prevlsn));
  496. bp += sizeof(argp->prevlsn);
  497. memcpy(&argp->nextlsn, bp,  sizeof(argp->nextlsn));
  498. bp += sizeof(argp->nextlsn);
  499. *argpp = argp;
  500. return (0);
  501. }
  503. int
  504. __db_ovref_log(dbenv, txnid, ret_lsnp, flags,
  505. fileid, pgno, adjust, lsn)
  506. DB_ENV *dbenv;
  507. DB_TXN *txnid;
  508. DB_LSN *ret_lsnp;
  509. u_int32_t flags;
  510. int32_t fileid;
  511. db_pgno_t pgno;
  512. int32_t adjust;
  513. DB_LSN * lsn;
  514. {
  515. DBT logrec;
  516. DB_LSN *lsnp, null_lsn;
  517. u_int32_t rectype, txn_num;
  518. int ret;
  519. u_int8_t *bp;
  521. rectype = DB_db_ovref;
  522. if (txnid != NULL &&
  523.     TAILQ_FIRST(&txnid->kids) != NULL &&
  524.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  525. return (ret);
  526. txn_num = txnid == NULL ? 0 : txnid->txnid;
  527. if (txnid == NULL) {
  528. ZERO_LSN(null_lsn);
  529. lsnp = &null_lsn;
  530. } else
  531. lsnp = &txnid->last_lsn;
  532. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  533.     + sizeof(fileid)
  534.     + sizeof(pgno)
  535.     + sizeof(adjust)
  536.     + sizeof(*lsn);
  537. if ((ret = __os_malloc(dbenv, logrec.size, NULL, &logrec.data)) != 0)
  538. return (ret);
  540. bp = logrec.data;
  541. memcpy(bp, &rectype, sizeof(rectype));
  542. bp += sizeof(rectype);
  543. memcpy(bp, &txn_num, sizeof(txn_num));
  544. bp += sizeof(txn_num);
  545. memcpy(bp, lsnp, sizeof(DB_LSN));
  546. bp += sizeof(DB_LSN);
  547. memcpy(bp, &fileid, sizeof(fileid));
  548. bp += sizeof(fileid);
  549. memcpy(bp, &pgno, sizeof(pgno));
  550. bp += sizeof(pgno);
  551. memcpy(bp, &adjust, sizeof(adjust));
  552. bp += sizeof(adjust);
  553. if (lsn != NULL)
  554. memcpy(bp, lsn, sizeof(*lsn));
  555. else
  556. memset(bp, 0, sizeof(*lsn));
  557. bp += sizeof(*lsn);
  558. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size);
  559. ret = log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags);
  560. if (txnid != NULL)
  561. txnid->last_lsn = *ret_lsnp;
  562. __os_free(logrec.data, logrec.size);
  563. return (ret);
  564. }
  566. int
  567. __db_ovref_print(dbenv, dbtp, lsnp, notused2, notused3)
  568. DB_ENV *dbenv;
  569. DBT *dbtp;
  570. DB_LSN *lsnp;
  571. db_recops notused2;
  572. void *notused3;
  573. {
  574. __db_ovref_args *argp;
  575. u_int32_t i;
  576. u_int ch;
  577. int ret;
  579. i = 0;
  580. ch = 0;
  581. notused2 = DB_TXN_ABORT;
  582. notused3 = NULL;
  584. if ((ret = __db_ovref_read(dbenv, dbtp->data, &argp)) != 0)
  585. return (ret);
  586. printf("[%lu][%lu]db_ovref: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  587.     (u_long)lsnp->file,
  588.     (u_long)lsnp->offset,
  589.     (u_long)argp->type,
  590.     (u_long)argp->txnid->txnid,
  591.     (u_long)argp->prev_lsn.file,
  592.     (u_long)argp->prev_lsn.offset);
  593. printf("tfileid: %ldn", (long)argp->fileid);
  594. printf("tpgno: %lun", (u_long)argp->pgno);
  595. printf("tadjust: %ldn", (long)argp->adjust);
  596. printf("tlsn: [%lu][%lu]n",
  597.     (u_long)argp->lsn.file, (u_long)argp->lsn.offset);
  598. printf("n");
  599. __os_free(argp, 0);
  600. return (0);
  601. }
  603. int
  604. __db_ovref_read(dbenv, recbuf, argpp)
  605. DB_ENV *dbenv;
  606. void *recbuf;
  607. __db_ovref_args **argpp;
  608. {
  609. __db_ovref_args *argp;
  610. u_int8_t *bp;
  611. int ret;
  613. ret = __os_malloc(dbenv, sizeof(__db_ovref_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->fileid, bp, sizeof(argp->fileid));
  626. bp += sizeof(argp->fileid);
  627. memcpy(&argp->pgno, bp, sizeof(argp->pgno));
  628. bp += sizeof(argp->pgno);
  629. memcpy(&argp->adjust, bp, sizeof(argp->adjust));
  630. bp += sizeof(argp->adjust);
  631. memcpy(&argp->lsn, bp,  sizeof(argp->lsn));
  632. bp += sizeof(argp->lsn);
  633. *argpp = argp;
  634. return (0);
  635. }
  637. int
  638. __db_relink_log(dbenv, txnid, ret_lsnp, flags,
  639. opcode, fileid, pgno, lsn, prev, lsn_prev,
  640. next, lsn_next)
  641. DB_ENV *dbenv;
  642. DB_TXN *txnid;
  643. DB_LSN *ret_lsnp;
  644. u_int32_t flags;
  645. u_int32_t opcode;
  646. int32_t fileid;
  647. db_pgno_t pgno;
  648. DB_LSN * lsn;
  649. db_pgno_t prev;
  650. DB_LSN * lsn_prev;
  651. db_pgno_t next;
  652. DB_LSN * lsn_next;
  653. {
  654. DBT logrec;
  655. DB_LSN *lsnp, null_lsn;
  656. u_int32_t rectype, txn_num;
  657. int ret;
  658. u_int8_t *bp;
  660. rectype = DB_db_relink;
  661. if (txnid != NULL &&
  662.     TAILQ_FIRST(&txnid->kids) != NULL &&
  663.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  664. return (ret);
  665. txn_num = txnid == NULL ? 0 : txnid->txnid;
  666. if (txnid == NULL) {
  667. ZERO_LSN(null_lsn);
  668. lsnp = &null_lsn;
  669. } else
  670. lsnp = &txnid->last_lsn;
  671. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  672.     + sizeof(opcode)
  673.     + sizeof(fileid)
  674.     + sizeof(pgno)
  675.     + sizeof(*lsn)
  676.     + sizeof(prev)
  677.     + sizeof(*lsn_prev)
  678.     + sizeof(next)
  679.     + sizeof(*lsn_next);
  680. if ((ret = __os_malloc(dbenv, logrec.size, NULL, &logrec.data)) != 0)
  681. return (ret);
  683. bp = logrec.data;
  684. memcpy(bp, &rectype, sizeof(rectype));
  685. bp += sizeof(rectype);
  686. memcpy(bp, &txn_num, sizeof(txn_num));
  687. bp += sizeof(txn_num);
  688. memcpy(bp, lsnp, sizeof(DB_LSN));
  689. bp += sizeof(DB_LSN);
  690. memcpy(bp, &opcode, sizeof(opcode));
  691. bp += sizeof(opcode);
  692. memcpy(bp, &fileid, sizeof(fileid));
  693. bp += sizeof(fileid);
  694. memcpy(bp, &pgno, sizeof(pgno));
  695. bp += sizeof(pgno);
  696. if (lsn != NULL)
  697. memcpy(bp, lsn, sizeof(*lsn));
  698. else
  699. memset(bp, 0, sizeof(*lsn));
  700. bp += sizeof(*lsn);
  701. memcpy(bp, &prev, sizeof(prev));
  702. bp += sizeof(prev);
  703. if (lsn_prev != NULL)
  704. memcpy(bp, lsn_prev, sizeof(*lsn_prev));
  705. else
  706. memset(bp, 0, sizeof(*lsn_prev));
  707. bp += sizeof(*lsn_prev);
  708. memcpy(bp, &next, sizeof(next));
  709. bp += sizeof(next);
  710. if (lsn_next != NULL)
  711. memcpy(bp, lsn_next, sizeof(*lsn_next));
  712. else
  713. memset(bp, 0, sizeof(*lsn_next));
  714. bp += sizeof(*lsn_next);
  715. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size);
  716. ret = log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags);
  717. if (txnid != NULL)
  718. txnid->last_lsn = *ret_lsnp;
  719. __os_free(logrec.data, logrec.size);
  720. return (ret);
  721. }
  723. int
  724. __db_relink_print(dbenv, dbtp, lsnp, notused2, notused3)
  725. DB_ENV *dbenv;
  726. DBT *dbtp;
  727. DB_LSN *lsnp;
  728. db_recops notused2;
  729. void *notused3;
  730. {
  731. __db_relink_args *argp;
  732. u_int32_t i;
  733. u_int ch;
  734. int ret;
  736. i = 0;
  737. ch = 0;
  738. notused2 = DB_TXN_ABORT;
  739. notused3 = NULL;
  741. if ((ret = __db_relink_read(dbenv, dbtp->data, &argp)) != 0)
  742. return (ret);
  743. printf("[%lu][%lu]db_relink: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  744.     (u_long)lsnp->file,
  745.     (u_long)lsnp->offset,
  746.     (u_long)argp->type,
  747.     (u_long)argp->txnid->txnid,
  748.     (u_long)argp->prev_lsn.file,
  749.     (u_long)argp->prev_lsn.offset);
  750. printf("topcode: %lun", (u_long)argp->opcode);
  751. printf("tfileid: %ldn", (long)argp->fileid);
  752. printf("tpgno: %lun", (u_long)argp->pgno);
  753. printf("tlsn: [%lu][%lu]n",
  754.     (u_long)argp->lsn.file, (u_long)argp->lsn.offset);
  755. printf("tprev: %lun", (u_long)argp->prev);
  756. printf("tlsn_prev: [%lu][%lu]n",
  757.     (u_long)argp->lsn_prev.file, (u_long)argp->lsn_prev.offset);
  758. printf("tnext: %lun", (u_long)argp->next);
  759. printf("tlsn_next: [%lu][%lu]n",
  760.     (u_long)argp->lsn_next.file, (u_long)argp->lsn_next.offset);
  761. printf("n");
  762. __os_free(argp, 0);
  763. return (0);
  764. }
  766. int
  767. __db_relink_read(dbenv, recbuf, argpp)
  768. DB_ENV *dbenv;
  769. void *recbuf;
  770. __db_relink_args **argpp;
  771. {
  772. __db_relink_args *argp;
  773. u_int8_t *bp;
  774. int ret;
  776. ret = __os_malloc(dbenv, sizeof(__db_relink_args) +
  777.     sizeof(DB_TXN), NULL, &argp);
  778. if (ret != 0)
  779. return (ret);
  780. argp->txnid = (DB_TXN *)&argp[1];
  781. bp = recbuf;
  782. memcpy(&argp->type, bp, sizeof(argp->type));
  783. bp += sizeof(argp->type);
  784. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  785. bp += sizeof(argp->txnid->txnid);
  786. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  787. bp += sizeof(DB_LSN);
  788. memcpy(&argp->opcode, bp, sizeof(argp->opcode));
  789. bp += sizeof(argp->opcode);
  790. memcpy(&argp->fileid, bp, sizeof(argp->fileid));
  791. bp += sizeof(argp->fileid);
  792. memcpy(&argp->pgno, bp, sizeof(argp->pgno));
  793. bp += sizeof(argp->pgno);
  794. memcpy(&argp->lsn, bp,  sizeof(argp->lsn));
  795. bp += sizeof(argp->lsn);
  796. memcpy(&argp->prev, bp, sizeof(argp->prev));
  797. bp += sizeof(argp->prev);
  798. memcpy(&argp->lsn_prev, bp,  sizeof(argp->lsn_prev));
  799. bp += sizeof(argp->lsn_prev);
  800. memcpy(&argp->next, bp, sizeof(argp->next));
  801. bp += sizeof(argp->next);
  802. memcpy(&argp->lsn_next, bp,  sizeof(argp->lsn_next));
  803. bp += sizeof(argp->lsn_next);
  804. *argpp = argp;
  805. return (0);
  806. }
  808. int
  809. __db_addpage_print(dbenv, dbtp, lsnp, notused2, notused3)
  810. DB_ENV *dbenv;
  811. DBT *dbtp;
  812. DB_LSN *lsnp;
  813. db_recops notused2;
  814. void *notused3;
  815. {
  816. __db_addpage_args *argp;
  817. u_int32_t i;
  818. u_int ch;
  819. int ret;
  821. i = 0;
  822. ch = 0;
  823. notused2 = DB_TXN_ABORT;
  824. notused3 = NULL;
  826. if ((ret = __db_addpage_read(dbenv, dbtp->data, &argp)) != 0)
  827. return (ret);
  828. printf("[%lu][%lu]db_addpage: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  829.     (u_long)lsnp->file,
  830.     (u_long)lsnp->offset,
  831.     (u_long)argp->type,
  832.     (u_long)argp->txnid->txnid,
  833.     (u_long)argp->prev_lsn.file,
  834.     (u_long)argp->prev_lsn.offset);
  835. printf("tfileid: %ldn", (long)argp->fileid);
  836. printf("tpgno: %lun", (u_long)argp->pgno);
  837. printf("tlsn: [%lu][%lu]n",
  838.     (u_long)argp->lsn.file, (u_long)argp->lsn.offset);
  839. printf("tnextpgno: %lun", (u_long)argp->nextpgno);
  840. printf("tnextlsn: [%lu][%lu]n",
  841.     (u_long)argp->nextlsn.file, (u_long)argp->nextlsn.offset);
  842. printf("n");
  843. __os_free(argp, 0);
  844. return (0);
  845. }
  847. int
  848. __db_addpage_read(dbenv, recbuf, argpp)
  849. DB_ENV *dbenv;
  850. void *recbuf;
  851. __db_addpage_args **argpp;
  852. {
  853. __db_addpage_args *argp;
  854. u_int8_t *bp;
  855. int ret;
  857. ret = __os_malloc(dbenv, sizeof(__db_addpage_args) +
  858.     sizeof(DB_TXN), NULL, &argp);
  859. if (ret != 0)
  860. return (ret);
  861. argp->txnid = (DB_TXN *)&argp[1];
  862. bp = recbuf;
  863. memcpy(&argp->type, bp, sizeof(argp->type));
  864. bp += sizeof(argp->type);
  865. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  866. bp += sizeof(argp->txnid->txnid);
  867. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  868. bp += sizeof(DB_LSN);
  869. memcpy(&argp->fileid, bp, sizeof(argp->fileid));
  870. bp += sizeof(argp->fileid);
  871. memcpy(&argp->pgno, bp, sizeof(argp->pgno));
  872. bp += sizeof(argp->pgno);
  873. memcpy(&argp->lsn, bp,  sizeof(argp->lsn));
  874. bp += sizeof(argp->lsn);
  875. memcpy(&argp->nextpgno, bp, sizeof(argp->nextpgno));
  876. bp += sizeof(argp->nextpgno);
  877. memcpy(&argp->nextlsn, bp,  sizeof(argp->nextlsn));
  878. bp += sizeof(argp->nextlsn);
  879. *argpp = argp;
  880. return (0);
  881. }
  883. int
  884. __db_debug_log(dbenv, txnid, ret_lsnp, flags,
  885. op, fileid, key, data, arg_flags)
  886. DB_ENV *dbenv;
  887. DB_TXN *txnid;
  888. DB_LSN *ret_lsnp;
  889. u_int32_t flags;
  890. const DBT *op;
  891. int32_t fileid;
  892. const DBT *key;
  893. const DBT *data;
  894. u_int32_t arg_flags;
  895. {
  896. DBT logrec;
  897. DB_LSN *lsnp, null_lsn;
  898. u_int32_t zero;
  899. u_int32_t rectype, txn_num;
  900. int ret;
  901. u_int8_t *bp;
  903. rectype = DB_db_debug;
  904. if (txnid != NULL &&
  905.     TAILQ_FIRST(&txnid->kids) != NULL &&
  906.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  907. return (ret);
  908. txn_num = txnid == NULL ? 0 : txnid->txnid;
  909. if (txnid == NULL) {
  910. ZERO_LSN(null_lsn);
  911. lsnp = &null_lsn;
  912. } else
  913. lsnp = &txnid->last_lsn;
  914. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  915.     + sizeof(u_int32_t) + (op == NULL ? 0 : op->size)
  916.     + sizeof(fileid)
  917.     + sizeof(u_int32_t) + (key == NULL ? 0 : key->size)
  918.     + sizeof(u_int32_t) + (data == NULL ? 0 : data->size)
  919.     + sizeof(arg_flags);
  920. if ((ret = __os_malloc(dbenv, logrec.size, NULL, &logrec.data)) != 0)
  921. return (ret);
  923. bp = logrec.data;
  924. memcpy(bp, &rectype, sizeof(rectype));
  925. bp += sizeof(rectype);
  926. memcpy(bp, &txn_num, sizeof(txn_num));
  927. bp += sizeof(txn_num);
  928. memcpy(bp, lsnp, sizeof(DB_LSN));
  929. bp += sizeof(DB_LSN);
  930. if (op == NULL) {
  931. zero = 0;
  932. memcpy(bp, &zero, sizeof(u_int32_t));
  933. bp += sizeof(u_int32_t);
  934. } else {
  935. memcpy(bp, &op->size, sizeof(op->size));
  936. bp += sizeof(op->size);
  937. memcpy(bp, op->data, op->size);
  938. bp += op->size;
  939. }
  940. memcpy(bp, &fileid, sizeof(fileid));
  941. bp += sizeof(fileid);
  942. if (key == NULL) {
  943. zero = 0;
  944. memcpy(bp, &zero, sizeof(u_int32_t));
  945. bp += sizeof(u_int32_t);
  946. } else {
  947. memcpy(bp, &key->size, sizeof(key->size));
  948. bp += sizeof(key->size);
  949. memcpy(bp, key->data, key->size);
  950. bp += key->size;
  951. }
  952. if (data == NULL) {
  953. zero = 0;
  954. memcpy(bp, &zero, sizeof(u_int32_t));
  955. bp += sizeof(u_int32_t);
  956. } else {
  957. memcpy(bp, &data->size, sizeof(data->size));
  958. bp += sizeof(data->size);
  959. memcpy(bp, data->data, data->size);
  960. bp += data->size;
  961. }
  962. memcpy(bp, &arg_flags, sizeof(arg_flags));
  963. bp += sizeof(arg_flags);
  964. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size);
  965. ret = log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags);
  966. if (txnid != NULL)
  967. txnid->last_lsn = *ret_lsnp;
  968. __os_free(logrec.data, logrec.size);
  969. return (ret);
  970. }
  972. int
  973. __db_debug_print(dbenv, dbtp, lsnp, notused2, notused3)
  974. DB_ENV *dbenv;
  975. DBT *dbtp;
  976. DB_LSN *lsnp;
  977. db_recops notused2;
  978. void *notused3;
  979. {
  980. __db_debug_args *argp;
  981. u_int32_t i;
  982. u_int ch;
  983. int ret;
  985. i = 0;
  986. ch = 0;
  987. notused2 = DB_TXN_ABORT;
  988. notused3 = NULL;
  990. if ((ret = __db_debug_read(dbenv, dbtp->data, &argp)) != 0)
  991. return (ret);
  992. printf("[%lu][%lu]db_debug: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  993.     (u_long)lsnp->file,
  994.     (u_long)lsnp->offset,
  995.     (u_long)argp->type,
  996.     (u_long)argp->txnid->txnid,
  997.     (u_long)argp->prev_lsn.file,
  998.     (u_long)argp->prev_lsn.offset);
  999. printf("top: ");
  1000. for (i = 0; i < argp->op.size; i++) {
  1001. ch = ((u_int8_t *)argp->op.data)[i];
  1002. if (isprint(ch) || ch == 0xa)
  1003. putchar(ch);
  1004. else
  1005. printf("%#x ", ch);
  1006. }
  1007. printf("n");
  1008. printf("tfileid: %ldn", (long)argp->fileid);
  1009. printf("tkey: ");
  1010. for (i = 0; i < argp->key.size; i++) {
  1011. ch = ((u_int8_t *)argp->key.data)[i];
  1012. if (isprint(ch) || ch == 0xa)
  1013. putchar(ch);
  1014. else
  1015. printf("%#x ", ch);
  1016. }
  1017. printf("n");
  1018. printf("tdata: ");
  1019. for (i = 0; i < argp->data.size; i++) {
  1020. ch = ((u_int8_t *)argp->data.data)[i];
  1021. if (isprint(ch) || ch == 0xa)
  1022. putchar(ch);
  1023. else
  1024. printf("%#x ", ch);
  1025. }
  1026. printf("n");
  1027. printf("targ_flags: %lun", (u_long)argp->arg_flags);
  1028. printf("n");
  1029. __os_free(argp, 0);
  1030. return (0);
  1031. }
  1033. int
  1034. __db_debug_read(dbenv, recbuf, argpp)
  1035. DB_ENV *dbenv;
  1036. void *recbuf;
  1037. __db_debug_args **argpp;
  1038. {
  1039. __db_debug_args *argp;
  1040. u_int8_t *bp;
  1041. int ret;
  1043. ret = __os_malloc(dbenv, sizeof(__db_debug_args) +
  1044.     sizeof(DB_TXN), NULL, &argp);
  1045. if (ret != 0)
  1046. return (ret);
  1047. argp->txnid = (DB_TXN *)&argp[1];
  1048. bp = recbuf;
  1049. memcpy(&argp->type, bp, sizeof(argp->type));
  1050. bp += sizeof(argp->type);
  1051. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  1052. bp += sizeof(argp->txnid->txnid);
  1053. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  1054. bp += sizeof(DB_LSN);
  1055. memset(&argp->op, 0, sizeof(argp->op));
  1056. memcpy(&argp->op.size, bp, sizeof(u_int32_t));
  1057. bp += sizeof(u_int32_t);
  1058. argp->op.data = bp;
  1059. bp += argp->op.size;
  1060. memcpy(&argp->fileid, bp, sizeof(argp->fileid));
  1061. bp += sizeof(argp->fileid);
  1062. memset(&argp->key, 0, sizeof(argp->key));
  1063. memcpy(&argp->key.size, bp, sizeof(u_int32_t));
  1064. bp += sizeof(u_int32_t);
  1065. argp->key.data = bp;
  1066. bp += argp->key.size;
  1067. memset(&argp->data, 0, sizeof(argp->data));
  1068. memcpy(&argp->data.size, bp, sizeof(u_int32_t));
  1069. bp += sizeof(u_int32_t);
  1070. argp->data.data = bp;
  1071. bp += argp->data.size;
  1072. memcpy(&argp->arg_flags, bp, sizeof(argp->arg_flags));
  1073. bp += sizeof(argp->arg_flags);
  1074. *argpp = argp;
  1075. return (0);
  1076. }
  1078. int
  1079. __db_noop_log(dbenv, txnid, ret_lsnp, flags,
  1080. fileid, pgno, prevlsn)
  1081. DB_ENV *dbenv;
  1082. DB_TXN *txnid;
  1083. DB_LSN *ret_lsnp;
  1084. u_int32_t flags;
  1085. int32_t fileid;
  1086. db_pgno_t pgno;
  1087. DB_LSN * prevlsn;
  1088. {
  1089. DBT logrec;
  1090. DB_LSN *lsnp, null_lsn;
  1091. u_int32_t rectype, txn_num;
  1092. int ret;
  1093. u_int8_t *bp;
  1095. rectype = DB_db_noop;
  1096. if (txnid != NULL &&
  1097.     TAILQ_FIRST(&txnid->kids) != NULL &&
  1098.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  1099. return (ret);
  1100. txn_num = txnid == NULL ? 0 : txnid->txnid;
  1101. if (txnid == NULL) {
  1102. ZERO_LSN(null_lsn);
  1103. lsnp = &null_lsn;
  1104. } else
  1105. lsnp = &txnid->last_lsn;
  1106. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  1107.     + sizeof(fileid)
  1108.     + sizeof(pgno)
  1109.     + sizeof(*prevlsn);
  1110. if ((ret = __os_malloc(dbenv, logrec.size, NULL, &logrec.data)) != 0)
  1111. return (ret);
  1113. bp = logrec.data;
  1114. memcpy(bp, &rectype, sizeof(rectype));
  1115. bp += sizeof(rectype);
  1116. memcpy(bp, &txn_num, sizeof(txn_num));
  1117. bp += sizeof(txn_num);
  1118. memcpy(bp, lsnp, sizeof(DB_LSN));
  1119. bp += sizeof(DB_LSN);
  1120. memcpy(bp, &fileid, sizeof(fileid));
  1121. bp += sizeof(fileid);
  1122. memcpy(bp, &pgno, sizeof(pgno));
  1123. bp += sizeof(pgno);
  1124. if (prevlsn != NULL)
  1125. memcpy(bp, prevlsn, sizeof(*prevlsn));
  1126. else
  1127. memset(bp, 0, sizeof(*prevlsn));
  1128. bp += sizeof(*prevlsn);
  1129. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size);
  1130. ret = log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags);
  1131. if (txnid != NULL)
  1132. txnid->last_lsn = *ret_lsnp;
  1133. __os_free(logrec.data, logrec.size);
  1134. return (ret);
  1135. }
  1137. int
  1138. __db_noop_print(dbenv, dbtp, lsnp, notused2, notused3)
  1139. DB_ENV *dbenv;
  1140. DBT *dbtp;
  1141. DB_LSN *lsnp;
  1142. db_recops notused2;
  1143. void *notused3;
  1144. {
  1145. __db_noop_args *argp;
  1146. u_int32_t i;
  1147. u_int ch;
  1148. int ret;
  1150. i = 0;
  1151. ch = 0;
  1152. notused2 = DB_TXN_ABORT;
  1153. notused3 = NULL;
  1155. if ((ret = __db_noop_read(dbenv, dbtp->data, &argp)) != 0)
  1156. return (ret);
  1157. printf("[%lu][%lu]db_noop: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  1158.     (u_long)lsnp->file,
  1159.     (u_long)lsnp->offset,
  1160.     (u_long)argp->type,
  1161.     (u_long)argp->txnid->txnid,
  1162.     (u_long)argp->prev_lsn.file,
  1163.     (u_long)argp->prev_lsn.offset);
  1164. printf("tfileid: %ldn", (long)argp->fileid);
  1165. printf("tpgno: %lun", (u_long)argp->pgno);
  1166. printf("tprevlsn: [%lu][%lu]n",
  1167.     (u_long)argp->prevlsn.file, (u_long)argp->prevlsn.offset);
  1168. printf("n");
  1169. __os_free(argp, 0);
  1170. return (0);
  1171. }
  1173. int
  1174. __db_noop_read(dbenv, recbuf, argpp)
  1175. DB_ENV *dbenv;
  1176. void *recbuf;
  1177. __db_noop_args **argpp;
  1178. {
  1179. __db_noop_args *argp;
  1180. u_int8_t *bp;
  1181. int ret;
  1183. ret = __os_malloc(dbenv, sizeof(__db_noop_args) +
  1184.     sizeof(DB_TXN), NULL, &argp);
  1185. if (ret != 0)
  1186. return (ret);
  1187. argp->txnid = (DB_TXN *)&argp[1];
  1188. bp = recbuf;
  1189. memcpy(&argp->type, bp, sizeof(argp->type));
  1190. bp += sizeof(argp->type);
  1191. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  1192. bp += sizeof(argp->txnid->txnid);
  1193. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  1194. bp += sizeof(DB_LSN);
  1195. memcpy(&argp->fileid, bp, sizeof(argp->fileid));
  1196. bp += sizeof(argp->fileid);
  1197. memcpy(&argp->pgno, bp, sizeof(argp->pgno));
  1198. bp += sizeof(argp->pgno);
  1199. memcpy(&argp->prevlsn, bp,  sizeof(argp->prevlsn));
  1200. bp += sizeof(argp->prevlsn);
  1201. *argpp = argp;
  1202. return (0);
  1203. }
  1205. int
  1206. __db_init_print(dbenv)
  1207. DB_ENV *dbenv;
  1208. {
  1209. int ret;
  1211. if ((ret = __db_add_recovery(dbenv,
  1212.     __db_addrem_print, DB_db_addrem)) != 0)
  1213. return (ret);
  1214. if ((ret = __db_add_recovery(dbenv,
  1215.     __db_split_print, DB_db_split)) != 0)
  1216. return (ret);
  1217. if ((ret = __db_add_recovery(dbenv,
  1218.     __db_big_print, DB_db_big)) != 0)
  1219. return (ret);
  1220. if ((ret = __db_add_recovery(dbenv,
  1221.     __db_ovref_print, DB_db_ovref)) != 0)
  1222. return (ret);
  1223. if ((ret = __db_add_recovery(dbenv,
  1224.     __db_relink_print, DB_db_relink)) != 0)
  1225. return (ret);
  1226. if ((ret = __db_add_recovery(dbenv,
  1227.     __db_addpage_print, DB_db_addpage)) != 0)
  1228. return (ret);
  1229. if ((ret = __db_add_recovery(dbenv,
  1230.     __db_debug_print, DB_db_debug)) != 0)
  1231. return (ret);
  1232. if ((ret = __db_add_recovery(dbenv,
  1233.     __db_noop_print, DB_db_noop)) != 0)
  1234. return (ret);
  1235. return (0);
  1236. }
  1238. int
  1239. __db_init_recover(dbenv)
  1240. DB_ENV *dbenv;
  1241. {
  1242. int ret;
  1244. if ((ret = __db_add_recovery(dbenv,
  1245.     __db_addrem_recover, DB_db_addrem)) != 0)
  1246. return (ret);
  1247. if ((ret = __db_add_recovery(dbenv,
  1248.     __deprecated_recover, DB_db_split)) != 0)
  1249. return (ret);
  1250. if ((ret = __db_add_recovery(dbenv,
  1251.     __db_big_recover, DB_db_big)) != 0)
  1252. return (ret);
  1253. if ((ret = __db_add_recovery(dbenv,
  1254.     __db_ovref_recover, DB_db_ovref)) != 0)
  1255. return (ret);
  1256. if ((ret = __db_add_recovery(dbenv,
  1257.     __db_relink_recover, DB_db_relink)) != 0)
  1258. return (ret);
  1259. if ((ret = __db_add_recovery(dbenv,
  1260.     __deprecated_recover, DB_db_addpage)) != 0)
  1261. return (ret);
  1262. if ((ret = __db_add_recovery(dbenv,
  1263.     __db_debug_recover, DB_db_debug)) != 0)
  1264. return (ret);
  1265. if ((ret = __db_add_recovery(dbenv,
  1266.     __db_noop_recover, DB_db_noop)) != 0)
  1267. return (ret);
  1268. return (0);
  1269. }