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

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

MySQL数据库

开发平台：

Visual C++

hash_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 "hash.h"
  17. #include "txn.h"
  19. int
  20. __ham_insdel_log(dbenv, txnid, ret_lsnp, flags,
  21. opcode, fileid, pgno, ndx, pagelsn, key,
  22. data)
  23. DB_ENV *dbenv;
  24. DB_TXN *txnid;
  25. DB_LSN *ret_lsnp;
  26. u_int32_t flags;
  27. u_int32_t opcode;
  28. int32_t fileid;
  29. db_pgno_t pgno;
  30. u_int32_t ndx;
  31. DB_LSN * pagelsn;
  32. const DBT *key;
  33. const DBT *data;
  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_ham_insdel;
  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(ndx)
  58.     + sizeof(*pagelsn)
  59.     + sizeof(u_int32_t) + (key == NULL ? 0 : key->size)
  60.     + sizeof(u_int32_t) + (data == NULL ? 0 : data->size);
  61. if ((ret = __os_malloc(dbenv, logrec.size, NULL, &logrec.data)) != 0)
  62. return (ret);
  64. bp = logrec.data;
  65. memcpy(bp, &rectype, sizeof(rectype));
  66. bp += sizeof(rectype);
  67. memcpy(bp, &txn_num, sizeof(txn_num));
  68. bp += sizeof(txn_num);
  69. memcpy(bp, lsnp, sizeof(DB_LSN));
  70. bp += sizeof(DB_LSN);
  71. memcpy(bp, &opcode, sizeof(opcode));
  72. bp += sizeof(opcode);
  73. memcpy(bp, &fileid, sizeof(fileid));
  74. bp += sizeof(fileid);
  75. memcpy(bp, &pgno, sizeof(pgno));
  76. bp += sizeof(pgno);
  77. memcpy(bp, &ndx, sizeof(ndx));
  78. bp += sizeof(ndx);
  79. if (pagelsn != NULL)
  80. memcpy(bp, pagelsn, sizeof(*pagelsn));
  81. else
  82. memset(bp, 0, sizeof(*pagelsn));
  83. bp += sizeof(*pagelsn);
  84. if (key == NULL) {
  85. zero = 0;
  86. memcpy(bp, &zero, sizeof(u_int32_t));
  87. bp += sizeof(u_int32_t);
  88. } else {
  89. memcpy(bp, &key->size, sizeof(key->size));
  90. bp += sizeof(key->size);
  91. memcpy(bp, key->data, key->size);
  92. bp += key->size;
  93. }
  94. if (data == NULL) {
  95. zero = 0;
  96. memcpy(bp, &zero, sizeof(u_int32_t));
  97. bp += sizeof(u_int32_t);
  98. } else {
  99. memcpy(bp, &data->size, sizeof(data->size));
  100. bp += sizeof(data->size);
  101. memcpy(bp, data->data, data->size);
  102. bp += data->size;
  103. }
  104. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size);
  105. ret = log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags);
  106. if (txnid != NULL)
  107. txnid->last_lsn = *ret_lsnp;
  108. __os_free(logrec.data, logrec.size);
  109. return (ret);
  110. }
  112. int
  113. __ham_insdel_print(dbenv, dbtp, lsnp, notused2, notused3)
  114. DB_ENV *dbenv;
  115. DBT *dbtp;
  116. DB_LSN *lsnp;
  117. db_recops notused2;
  118. void *notused3;
  119. {
  120. __ham_insdel_args *argp;
  121. u_int32_t i;
  122. u_int ch;
  123. int ret;
  125. i = 0;
  126. ch = 0;
  127. notused2 = DB_TXN_ABORT;
  128. notused3 = NULL;
  130. if ((ret = __ham_insdel_read(dbenv, dbtp->data, &argp)) != 0)
  131. return (ret);
  132. printf("[%lu][%lu]ham_insdel: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  133.     (u_long)lsnp->file,
  134.     (u_long)lsnp->offset,
  135.     (u_long)argp->type,
  136.     (u_long)argp->txnid->txnid,
  137.     (u_long)argp->prev_lsn.file,
  138.     (u_long)argp->prev_lsn.offset);
  139. printf("topcode: %lun", (u_long)argp->opcode);
  140. printf("tfileid: %ldn", (long)argp->fileid);
  141. printf("tpgno: %lun", (u_long)argp->pgno);
  142. printf("tndx: %lun", (u_long)argp->ndx);
  143. printf("tpagelsn: [%lu][%lu]n",
  144.     (u_long)argp->pagelsn.file, (u_long)argp->pagelsn.offset);
  145. printf("tkey: ");
  146. for (i = 0; i < argp->key.size; i++) {
  147. ch = ((u_int8_t *)argp->key.data)[i];
  148. if (isprint(ch) || ch == 0xa)
  149. putchar(ch);
  150. else
  151. printf("%#x ", ch);
  152. }
  153. printf("n");
  154. printf("tdata: ");
  155. for (i = 0; i < argp->data.size; i++) {
  156. ch = ((u_int8_t *)argp->data.data)[i];
  157. if (isprint(ch) || ch == 0xa)
  158. putchar(ch);
  159. else
  160. printf("%#x ", ch);
  161. }
  162. printf("n");
  163. printf("n");
  164. __os_free(argp, 0);
  165. return (0);
  166. }
  168. int
  169. __ham_insdel_read(dbenv, recbuf, argpp)
  170. DB_ENV *dbenv;
  171. void *recbuf;
  172. __ham_insdel_args **argpp;
  173. {
  174. __ham_insdel_args *argp;
  175. u_int8_t *bp;
  176. int ret;
  178. ret = __os_malloc(dbenv, sizeof(__ham_insdel_args) +
  179.     sizeof(DB_TXN), NULL, &argp);
  180. if (ret != 0)
  181. return (ret);
  182. argp->txnid = (DB_TXN *)&argp[1];
  183. bp = recbuf;
  184. memcpy(&argp->type, bp, sizeof(argp->type));
  185. bp += sizeof(argp->type);
  186. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  187. bp += sizeof(argp->txnid->txnid);
  188. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  189. bp += sizeof(DB_LSN);
  190. memcpy(&argp->opcode, bp, sizeof(argp->opcode));
  191. bp += sizeof(argp->opcode);
  192. memcpy(&argp->fileid, bp, sizeof(argp->fileid));
  193. bp += sizeof(argp->fileid);
  194. memcpy(&argp->pgno, bp, sizeof(argp->pgno));
  195. bp += sizeof(argp->pgno);
  196. memcpy(&argp->ndx, bp, sizeof(argp->ndx));
  197. bp += sizeof(argp->ndx);
  198. memcpy(&argp->pagelsn, bp,  sizeof(argp->pagelsn));
  199. bp += sizeof(argp->pagelsn);
  200. memset(&argp->key, 0, sizeof(argp->key));
  201. memcpy(&argp->key.size, bp, sizeof(u_int32_t));
  202. bp += sizeof(u_int32_t);
  203. argp->key.data = bp;
  204. bp += argp->key.size;
  205. memset(&argp->data, 0, sizeof(argp->data));
  206. memcpy(&argp->data.size, bp, sizeof(u_int32_t));
  207. bp += sizeof(u_int32_t);
  208. argp->data.data = bp;
  209. bp += argp->data.size;
  210. *argpp = argp;
  211. return (0);
  212. }
  214. int
  215. __ham_newpage_log(dbenv, txnid, ret_lsnp, flags,
  216. opcode, fileid, prev_pgno, prevlsn, new_pgno, pagelsn,
  217. next_pgno, nextlsn)
  218. DB_ENV *dbenv;
  219. DB_TXN *txnid;
  220. DB_LSN *ret_lsnp;
  221. u_int32_t flags;
  222. u_int32_t opcode;
  223. int32_t fileid;
  224. db_pgno_t prev_pgno;
  225. DB_LSN * prevlsn;
  226. db_pgno_t new_pgno;
  227. DB_LSN * pagelsn;
  228. db_pgno_t next_pgno;
  229. DB_LSN * nextlsn;
  230. {
  231. DBT logrec;
  232. DB_LSN *lsnp, null_lsn;
  233. u_int32_t rectype, txn_num;
  234. int ret;
  235. u_int8_t *bp;
  237. rectype = DB_ham_newpage;
  238. if (txnid != NULL &&
  239.     TAILQ_FIRST(&txnid->kids) != NULL &&
  240.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  241. return (ret);
  242. txn_num = txnid == NULL ? 0 : txnid->txnid;
  243. if (txnid == NULL) {
  244. ZERO_LSN(null_lsn);
  245. lsnp = &null_lsn;
  246. } else
  247. lsnp = &txnid->last_lsn;
  248. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  249.     + sizeof(opcode)
  250.     + sizeof(fileid)
  251.     + sizeof(prev_pgno)
  252.     + sizeof(*prevlsn)
  253.     + sizeof(new_pgno)
  254.     + sizeof(*pagelsn)
  255.     + sizeof(next_pgno)
  256.     + sizeof(*nextlsn);
  257. if ((ret = __os_malloc(dbenv, logrec.size, NULL, &logrec.data)) != 0)
  258. return (ret);
  260. bp = logrec.data;
  261. memcpy(bp, &rectype, sizeof(rectype));
  262. bp += sizeof(rectype);
  263. memcpy(bp, &txn_num, sizeof(txn_num));
  264. bp += sizeof(txn_num);
  265. memcpy(bp, lsnp, sizeof(DB_LSN));
  266. bp += sizeof(DB_LSN);
  267. memcpy(bp, &opcode, sizeof(opcode));
  268. bp += sizeof(opcode);
  269. memcpy(bp, &fileid, sizeof(fileid));
  270. bp += sizeof(fileid);
  271. memcpy(bp, &prev_pgno, sizeof(prev_pgno));
  272. bp += sizeof(prev_pgno);
  273. if (prevlsn != NULL)
  274. memcpy(bp, prevlsn, sizeof(*prevlsn));
  275. else
  276. memset(bp, 0, sizeof(*prevlsn));
  277. bp += sizeof(*prevlsn);
  278. memcpy(bp, &new_pgno, sizeof(new_pgno));
  279. bp += sizeof(new_pgno);
  280. if (pagelsn != NULL)
  281. memcpy(bp, pagelsn, sizeof(*pagelsn));
  282. else
  283. memset(bp, 0, sizeof(*pagelsn));
  284. bp += sizeof(*pagelsn);
  285. memcpy(bp, &next_pgno, sizeof(next_pgno));
  286. bp += sizeof(next_pgno);
  287. if (nextlsn != NULL)
  288. memcpy(bp, nextlsn, sizeof(*nextlsn));
  289. else
  290. memset(bp, 0, sizeof(*nextlsn));
  291. bp += sizeof(*nextlsn);
  292. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size);
  293. ret = log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags);
  294. if (txnid != NULL)
  295. txnid->last_lsn = *ret_lsnp;
  296. __os_free(logrec.data, logrec.size);
  297. return (ret);
  298. }
  300. int
  301. __ham_newpage_print(dbenv, dbtp, lsnp, notused2, notused3)
  302. DB_ENV *dbenv;
  303. DBT *dbtp;
  304. DB_LSN *lsnp;
  305. db_recops notused2;
  306. void *notused3;
  307. {
  308. __ham_newpage_args *argp;
  309. u_int32_t i;
  310. u_int ch;
  311. int ret;
  313. i = 0;
  314. ch = 0;
  315. notused2 = DB_TXN_ABORT;
  316. notused3 = NULL;
  318. if ((ret = __ham_newpage_read(dbenv, dbtp->data, &argp)) != 0)
  319. return (ret);
  320. printf("[%lu][%lu]ham_newpage: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  321.     (u_long)lsnp->file,
  322.     (u_long)lsnp->offset,
  323.     (u_long)argp->type,
  324.     (u_long)argp->txnid->txnid,
  325.     (u_long)argp->prev_lsn.file,
  326.     (u_long)argp->prev_lsn.offset);
  327. printf("topcode: %lun", (u_long)argp->opcode);
  328. printf("tfileid: %ldn", (long)argp->fileid);
  329. printf("tprev_pgno: %lun", (u_long)argp->prev_pgno);
  330. printf("tprevlsn: [%lu][%lu]n",
  331.     (u_long)argp->prevlsn.file, (u_long)argp->prevlsn.offset);
  332. printf("tnew_pgno: %lun", (u_long)argp->new_pgno);
  333. printf("tpagelsn: [%lu][%lu]n",
  334.     (u_long)argp->pagelsn.file, (u_long)argp->pagelsn.offset);
  335. printf("tnext_pgno: %lun", (u_long)argp->next_pgno);
  336. printf("tnextlsn: [%lu][%lu]n",
  337.     (u_long)argp->nextlsn.file, (u_long)argp->nextlsn.offset);
  338. printf("n");
  339. __os_free(argp, 0);
  340. return (0);
  341. }
  343. int
  344. __ham_newpage_read(dbenv, recbuf, argpp)
  345. DB_ENV *dbenv;
  346. void *recbuf;
  347. __ham_newpage_args **argpp;
  348. {
  349. __ham_newpage_args *argp;
  350. u_int8_t *bp;
  351. int ret;
  353. ret = __os_malloc(dbenv, sizeof(__ham_newpage_args) +
  354.     sizeof(DB_TXN), NULL, &argp);
  355. if (ret != 0)
  356. return (ret);
  357. argp->txnid = (DB_TXN *)&argp[1];
  358. bp = recbuf;
  359. memcpy(&argp->type, bp, sizeof(argp->type));
  360. bp += sizeof(argp->type);
  361. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  362. bp += sizeof(argp->txnid->txnid);
  363. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  364. bp += sizeof(DB_LSN);
  365. memcpy(&argp->opcode, bp, sizeof(argp->opcode));
  366. bp += sizeof(argp->opcode);
  367. memcpy(&argp->fileid, bp, sizeof(argp->fileid));
  368. bp += sizeof(argp->fileid);
  369. memcpy(&argp->prev_pgno, bp, sizeof(argp->prev_pgno));
  370. bp += sizeof(argp->prev_pgno);
  371. memcpy(&argp->prevlsn, bp,  sizeof(argp->prevlsn));
  372. bp += sizeof(argp->prevlsn);
  373. memcpy(&argp->new_pgno, bp, sizeof(argp->new_pgno));
  374. bp += sizeof(argp->new_pgno);
  375. memcpy(&argp->pagelsn, bp,  sizeof(argp->pagelsn));
  376. bp += sizeof(argp->pagelsn);
  377. memcpy(&argp->next_pgno, bp, sizeof(argp->next_pgno));
  378. bp += sizeof(argp->next_pgno);
  379. memcpy(&argp->nextlsn, bp,  sizeof(argp->nextlsn));
  380. bp += sizeof(argp->nextlsn);
  381. *argpp = argp;
  382. return (0);
  383. }
  385. int
  386. __ham_splitmeta_print(dbenv, dbtp, lsnp, notused2, notused3)
  387. DB_ENV *dbenv;
  388. DBT *dbtp;
  389. DB_LSN *lsnp;
  390. db_recops notused2;
  391. void *notused3;
  392. {
  393. __ham_splitmeta_args *argp;
  394. u_int32_t i;
  395. u_int ch;
  396. int ret;
  398. i = 0;
  399. ch = 0;
  400. notused2 = DB_TXN_ABORT;
  401. notused3 = NULL;
  403. if ((ret = __ham_splitmeta_read(dbenv, dbtp->data, &argp)) != 0)
  404. return (ret);
  405. printf("[%lu][%lu]ham_splitmeta: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  406.     (u_long)lsnp->file,
  407.     (u_long)lsnp->offset,
  408.     (u_long)argp->type,
  409.     (u_long)argp->txnid->txnid,
  410.     (u_long)argp->prev_lsn.file,
  411.     (u_long)argp->prev_lsn.offset);
  412. printf("tfileid: %ldn", (long)argp->fileid);
  413. printf("tbucket: %lun", (u_long)argp->bucket);
  414. printf("tovflpoint: %lun", (u_long)argp->ovflpoint);
  415. printf("tspares: %lun", (u_long)argp->spares);
  416. printf("tmetalsn: [%lu][%lu]n",
  417.     (u_long)argp->metalsn.file, (u_long)argp->metalsn.offset);
  418. printf("n");
  419. __os_free(argp, 0);
  420. return (0);
  421. }
  423. int
  424. __ham_splitmeta_read(dbenv, recbuf, argpp)
  425. DB_ENV *dbenv;
  426. void *recbuf;
  427. __ham_splitmeta_args **argpp;
  428. {
  429. __ham_splitmeta_args *argp;
  430. u_int8_t *bp;
  431. int ret;
  433. ret = __os_malloc(dbenv, sizeof(__ham_splitmeta_args) +
  434.     sizeof(DB_TXN), NULL, &argp);
  435. if (ret != 0)
  436. return (ret);
  437. argp->txnid = (DB_TXN *)&argp[1];
  438. bp = recbuf;
  439. memcpy(&argp->type, bp, sizeof(argp->type));
  440. bp += sizeof(argp->type);
  441. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  442. bp += sizeof(argp->txnid->txnid);
  443. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  444. bp += sizeof(DB_LSN);
  445. memcpy(&argp->fileid, bp, sizeof(argp->fileid));
  446. bp += sizeof(argp->fileid);
  447. memcpy(&argp->bucket, bp, sizeof(argp->bucket));
  448. bp += sizeof(argp->bucket);
  449. memcpy(&argp->ovflpoint, bp, sizeof(argp->ovflpoint));
  450. bp += sizeof(argp->ovflpoint);
  451. memcpy(&argp->spares, bp, sizeof(argp->spares));
  452. bp += sizeof(argp->spares);
  453. memcpy(&argp->metalsn, bp,  sizeof(argp->metalsn));
  454. bp += sizeof(argp->metalsn);
  455. *argpp = argp;
  456. return (0);
  457. }
  459. int
  460. __ham_splitdata_log(dbenv, txnid, ret_lsnp, flags,
  461. fileid, opcode, pgno, pageimage, pagelsn)
  462. DB_ENV *dbenv;
  463. DB_TXN *txnid;
  464. DB_LSN *ret_lsnp;
  465. u_int32_t flags;
  466. int32_t fileid;
  467. u_int32_t opcode;
  468. db_pgno_t pgno;
  469. const DBT *pageimage;
  470. DB_LSN * pagelsn;
  471. {
  472. DBT logrec;
  473. DB_LSN *lsnp, null_lsn;
  474. u_int32_t zero;
  475. u_int32_t rectype, txn_num;
  476. int ret;
  477. u_int8_t *bp;
  479. rectype = DB_ham_splitdata;
  480. if (txnid != NULL &&
  481.     TAILQ_FIRST(&txnid->kids) != NULL &&
  482.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  483. return (ret);
  484. txn_num = txnid == NULL ? 0 : txnid->txnid;
  485. if (txnid == NULL) {
  486. ZERO_LSN(null_lsn);
  487. lsnp = &null_lsn;
  488. } else
  489. lsnp = &txnid->last_lsn;
  490. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  491.     + sizeof(fileid)
  492.     + sizeof(opcode)
  493.     + sizeof(pgno)
  494.     + sizeof(u_int32_t) + (pageimage == NULL ? 0 : pageimage->size)
  495.     + sizeof(*pagelsn);
  496. if ((ret = __os_malloc(dbenv, logrec.size, NULL, &logrec.data)) != 0)
  497. return (ret);
  499. bp = logrec.data;
  500. memcpy(bp, &rectype, sizeof(rectype));
  501. bp += sizeof(rectype);
  502. memcpy(bp, &txn_num, sizeof(txn_num));
  503. bp += sizeof(txn_num);
  504. memcpy(bp, lsnp, sizeof(DB_LSN));
  505. bp += sizeof(DB_LSN);
  506. memcpy(bp, &fileid, sizeof(fileid));
  507. bp += sizeof(fileid);
  508. memcpy(bp, &opcode, sizeof(opcode));
  509. bp += sizeof(opcode);
  510. memcpy(bp, &pgno, sizeof(pgno));
  511. bp += sizeof(pgno);
  512. if (pageimage == NULL) {
  513. zero = 0;
  514. memcpy(bp, &zero, sizeof(u_int32_t));
  515. bp += sizeof(u_int32_t);
  516. } else {
  517. memcpy(bp, &pageimage->size, sizeof(pageimage->size));
  518. bp += sizeof(pageimage->size);
  519. memcpy(bp, pageimage->data, pageimage->size);
  520. bp += pageimage->size;
  521. }
  522. if (pagelsn != NULL)
  523. memcpy(bp, pagelsn, sizeof(*pagelsn));
  524. else
  525. memset(bp, 0, sizeof(*pagelsn));
  526. bp += sizeof(*pagelsn);
  527. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size);
  528. ret = log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags);
  529. if (txnid != NULL)
  530. txnid->last_lsn = *ret_lsnp;
  531. __os_free(logrec.data, logrec.size);
  532. return (ret);
  533. }
  535. int
  536. __ham_splitdata_print(dbenv, dbtp, lsnp, notused2, notused3)
  537. DB_ENV *dbenv;
  538. DBT *dbtp;
  539. DB_LSN *lsnp;
  540. db_recops notused2;
  541. void *notused3;
  542. {
  543. __ham_splitdata_args *argp;
  544. u_int32_t i;
  545. u_int ch;
  546. int ret;
  548. i = 0;
  549. ch = 0;
  550. notused2 = DB_TXN_ABORT;
  551. notused3 = NULL;
  553. if ((ret = __ham_splitdata_read(dbenv, dbtp->data, &argp)) != 0)
  554. return (ret);
  555. printf("[%lu][%lu]ham_splitdata: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  556.     (u_long)lsnp->file,
  557.     (u_long)lsnp->offset,
  558.     (u_long)argp->type,
  559.     (u_long)argp->txnid->txnid,
  560.     (u_long)argp->prev_lsn.file,
  561.     (u_long)argp->prev_lsn.offset);
  562. printf("tfileid: %ldn", (long)argp->fileid);
  563. printf("topcode: %lun", (u_long)argp->opcode);
  564. printf("tpgno: %lun", (u_long)argp->pgno);
  565. printf("tpageimage: ");
  566. for (i = 0; i < argp->pageimage.size; i++) {
  567. ch = ((u_int8_t *)argp->pageimage.data)[i];
  568. if (isprint(ch) || ch == 0xa)
  569. putchar(ch);
  570. else
  571. printf("%#x ", ch);
  572. }
  573. printf("n");
  574. printf("tpagelsn: [%lu][%lu]n",
  575.     (u_long)argp->pagelsn.file, (u_long)argp->pagelsn.offset);
  576. printf("n");
  577. __os_free(argp, 0);
  578. return (0);
  579. }
  581. int
  582. __ham_splitdata_read(dbenv, recbuf, argpp)
  583. DB_ENV *dbenv;
  584. void *recbuf;
  585. __ham_splitdata_args **argpp;
  586. {
  587. __ham_splitdata_args *argp;
  588. u_int8_t *bp;
  589. int ret;
  591. ret = __os_malloc(dbenv, sizeof(__ham_splitdata_args) +
  592.     sizeof(DB_TXN), NULL, &argp);
  593. if (ret != 0)
  594. return (ret);
  595. argp->txnid = (DB_TXN *)&argp[1];
  596. bp = recbuf;
  597. memcpy(&argp->type, bp, sizeof(argp->type));
  598. bp += sizeof(argp->type);
  599. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  600. bp += sizeof(argp->txnid->txnid);
  601. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  602. bp += sizeof(DB_LSN);
  603. memcpy(&argp->fileid, bp, sizeof(argp->fileid));
  604. bp += sizeof(argp->fileid);
  605. memcpy(&argp->opcode, bp, sizeof(argp->opcode));
  606. bp += sizeof(argp->opcode);
  607. memcpy(&argp->pgno, bp, sizeof(argp->pgno));
  608. bp += sizeof(argp->pgno);
  609. memset(&argp->pageimage, 0, sizeof(argp->pageimage));
  610. memcpy(&argp->pageimage.size, bp, sizeof(u_int32_t));
  611. bp += sizeof(u_int32_t);
  612. argp->pageimage.data = bp;
  613. bp += argp->pageimage.size;
  614. memcpy(&argp->pagelsn, bp,  sizeof(argp->pagelsn));
  615. bp += sizeof(argp->pagelsn);
  616. *argpp = argp;
  617. return (0);
  618. }
  620. int
  621. __ham_replace_log(dbenv, txnid, ret_lsnp, flags,
  622. fileid, pgno, ndx, pagelsn, off, olditem,
  623. newitem, makedup)
  624. DB_ENV *dbenv;
  625. DB_TXN *txnid;
  626. DB_LSN *ret_lsnp;
  627. u_int32_t flags;
  628. int32_t fileid;
  629. db_pgno_t pgno;
  630. u_int32_t ndx;
  631. DB_LSN * pagelsn;
  632. int32_t off;
  633. const DBT *olditem;
  634. const DBT *newitem;
  635. u_int32_t makedup;
  636. {
  637. DBT logrec;
  638. DB_LSN *lsnp, null_lsn;
  639. u_int32_t zero;
  640. u_int32_t rectype, txn_num;
  641. int ret;
  642. u_int8_t *bp;
  644. rectype = DB_ham_replace;
  645. if (txnid != NULL &&
  646.     TAILQ_FIRST(&txnid->kids) != NULL &&
  647.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  648. return (ret);
  649. txn_num = txnid == NULL ? 0 : txnid->txnid;
  650. if (txnid == NULL) {
  651. ZERO_LSN(null_lsn);
  652. lsnp = &null_lsn;
  653. } else
  654. lsnp = &txnid->last_lsn;
  655. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  656.     + sizeof(fileid)
  657.     + sizeof(pgno)
  658.     + sizeof(ndx)
  659.     + sizeof(*pagelsn)
  660.     + sizeof(off)
  661.     + sizeof(u_int32_t) + (olditem == NULL ? 0 : olditem->size)
  662.     + sizeof(u_int32_t) + (newitem == NULL ? 0 : newitem->size)
  663.     + sizeof(makedup);
  664. if ((ret = __os_malloc(dbenv, logrec.size, NULL, &logrec.data)) != 0)
  665. return (ret);
  667. bp = logrec.data;
  668. memcpy(bp, &rectype, sizeof(rectype));
  669. bp += sizeof(rectype);
  670. memcpy(bp, &txn_num, sizeof(txn_num));
  671. bp += sizeof(txn_num);
  672. memcpy(bp, lsnp, sizeof(DB_LSN));
  673. bp += sizeof(DB_LSN);
  674. memcpy(bp, &fileid, sizeof(fileid));
  675. bp += sizeof(fileid);
  676. memcpy(bp, &pgno, sizeof(pgno));
  677. bp += sizeof(pgno);
  678. memcpy(bp, &ndx, sizeof(ndx));
  679. bp += sizeof(ndx);
  680. if (pagelsn != NULL)
  681. memcpy(bp, pagelsn, sizeof(*pagelsn));
  682. else
  683. memset(bp, 0, sizeof(*pagelsn));
  684. bp += sizeof(*pagelsn);
  685. memcpy(bp, &off, sizeof(off));
  686. bp += sizeof(off);
  687. if (olditem == NULL) {
  688. zero = 0;
  689. memcpy(bp, &zero, sizeof(u_int32_t));
  690. bp += sizeof(u_int32_t);
  691. } else {
  692. memcpy(bp, &olditem->size, sizeof(olditem->size));
  693. bp += sizeof(olditem->size);
  694. memcpy(bp, olditem->data, olditem->size);
  695. bp += olditem->size;
  696. }
  697. if (newitem == NULL) {
  698. zero = 0;
  699. memcpy(bp, &zero, sizeof(u_int32_t));
  700. bp += sizeof(u_int32_t);
  701. } else {
  702. memcpy(bp, &newitem->size, sizeof(newitem->size));
  703. bp += sizeof(newitem->size);
  704. memcpy(bp, newitem->data, newitem->size);
  705. bp += newitem->size;
  706. }
  707. memcpy(bp, &makedup, sizeof(makedup));
  708. bp += sizeof(makedup);
  709. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size);
  710. ret = log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags);
  711. if (txnid != NULL)
  712. txnid->last_lsn = *ret_lsnp;
  713. __os_free(logrec.data, logrec.size);
  714. return (ret);
  715. }
  717. int
  718. __ham_replace_print(dbenv, dbtp, lsnp, notused2, notused3)
  719. DB_ENV *dbenv;
  720. DBT *dbtp;
  721. DB_LSN *lsnp;
  722. db_recops notused2;
  723. void *notused3;
  724. {
  725. __ham_replace_args *argp;
  726. u_int32_t i;
  727. u_int ch;
  728. int ret;
  730. i = 0;
  731. ch = 0;
  732. notused2 = DB_TXN_ABORT;
  733. notused3 = NULL;
  735. if ((ret = __ham_replace_read(dbenv, dbtp->data, &argp)) != 0)
  736. return (ret);
  737. printf("[%lu][%lu]ham_replace: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  738.     (u_long)lsnp->file,
  739.     (u_long)lsnp->offset,
  740.     (u_long)argp->type,
  741.     (u_long)argp->txnid->txnid,
  742.     (u_long)argp->prev_lsn.file,
  743.     (u_long)argp->prev_lsn.offset);
  744. printf("tfileid: %ldn", (long)argp->fileid);
  745. printf("tpgno: %lun", (u_long)argp->pgno);
  746. printf("tndx: %lun", (u_long)argp->ndx);
  747. printf("tpagelsn: [%lu][%lu]n",
  748.     (u_long)argp->pagelsn.file, (u_long)argp->pagelsn.offset);
  749. printf("toff: %ldn", (long)argp->off);
  750. printf("tolditem: ");
  751. for (i = 0; i < argp->olditem.size; i++) {
  752. ch = ((u_int8_t *)argp->olditem.data)[i];
  753. if (isprint(ch) || ch == 0xa)
  754. putchar(ch);
  755. else
  756. printf("%#x ", ch);
  757. }
  758. printf("n");
  759. printf("tnewitem: ");
  760. for (i = 0; i < argp->newitem.size; i++) {
  761. ch = ((u_int8_t *)argp->newitem.data)[i];
  762. if (isprint(ch) || ch == 0xa)
  763. putchar(ch);
  764. else
  765. printf("%#x ", ch);
  766. }
  767. printf("n");
  768. printf("tmakedup: %lun", (u_long)argp->makedup);
  769. printf("n");
  770. __os_free(argp, 0);
  771. return (0);
  772. }
  774. int
  775. __ham_replace_read(dbenv, recbuf, argpp)
  776. DB_ENV *dbenv;
  777. void *recbuf;
  778. __ham_replace_args **argpp;
  779. {
  780. __ham_replace_args *argp;
  781. u_int8_t *bp;
  782. int ret;
  784. ret = __os_malloc(dbenv, sizeof(__ham_replace_args) +
  785.     sizeof(DB_TXN), NULL, &argp);
  786. if (ret != 0)
  787. return (ret);
  788. argp->txnid = (DB_TXN *)&argp[1];
  789. bp = recbuf;
  790. memcpy(&argp->type, bp, sizeof(argp->type));
  791. bp += sizeof(argp->type);
  792. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  793. bp += sizeof(argp->txnid->txnid);
  794. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  795. bp += sizeof(DB_LSN);
  796. memcpy(&argp->fileid, bp, sizeof(argp->fileid));
  797. bp += sizeof(argp->fileid);
  798. memcpy(&argp->pgno, bp, sizeof(argp->pgno));
  799. bp += sizeof(argp->pgno);
  800. memcpy(&argp->ndx, bp, sizeof(argp->ndx));
  801. bp += sizeof(argp->ndx);
  802. memcpy(&argp->pagelsn, bp,  sizeof(argp->pagelsn));
  803. bp += sizeof(argp->pagelsn);
  804. memcpy(&argp->off, bp, sizeof(argp->off));
  805. bp += sizeof(argp->off);
  806. memset(&argp->olditem, 0, sizeof(argp->olditem));
  807. memcpy(&argp->olditem.size, bp, sizeof(u_int32_t));
  808. bp += sizeof(u_int32_t);
  809. argp->olditem.data = bp;
  810. bp += argp->olditem.size;
  811. memset(&argp->newitem, 0, sizeof(argp->newitem));
  812. memcpy(&argp->newitem.size, bp, sizeof(u_int32_t));
  813. bp += sizeof(u_int32_t);
  814. argp->newitem.data = bp;
  815. bp += argp->newitem.size;
  816. memcpy(&argp->makedup, bp, sizeof(argp->makedup));
  817. bp += sizeof(argp->makedup);
  818. *argpp = argp;
  819. return (0);
  820. }
  822. int
  823. __ham_newpgno_print(dbenv, dbtp, lsnp, notused2, notused3)
  824. DB_ENV *dbenv;
  825. DBT *dbtp;
  826. DB_LSN *lsnp;
  827. db_recops notused2;
  828. void *notused3;
  829. {
  830. __ham_newpgno_args *argp;
  831. u_int32_t i;
  832. u_int ch;
  833. int ret;
  835. i = 0;
  836. ch = 0;
  837. notused2 = DB_TXN_ABORT;
  838. notused3 = NULL;
  840. if ((ret = __ham_newpgno_read(dbenv, dbtp->data, &argp)) != 0)
  841. return (ret);
  842. printf("[%lu][%lu]ham_newpgno: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  843.     (u_long)lsnp->file,
  844.     (u_long)lsnp->offset,
  845.     (u_long)argp->type,
  846.     (u_long)argp->txnid->txnid,
  847.     (u_long)argp->prev_lsn.file,
  848.     (u_long)argp->prev_lsn.offset);
  849. printf("topcode: %lun", (u_long)argp->opcode);
  850. printf("tfileid: %ldn", (long)argp->fileid);
  851. printf("tpgno: %lun", (u_long)argp->pgno);
  852. printf("tfree_pgno: %lun", (u_long)argp->free_pgno);
  853. printf("told_type: %lun", (u_long)argp->old_type);
  854. printf("told_pgno: %lun", (u_long)argp->old_pgno);
  855. printf("tnew_type: %lun", (u_long)argp->new_type);
  856. printf("tpagelsn: [%lu][%lu]n",
  857.     (u_long)argp->pagelsn.file, (u_long)argp->pagelsn.offset);
  858. printf("tmetalsn: [%lu][%lu]n",
  859.     (u_long)argp->metalsn.file, (u_long)argp->metalsn.offset);
  860. printf("n");
  861. __os_free(argp, 0);
  862. return (0);
  863. }
  865. int
  866. __ham_newpgno_read(dbenv, recbuf, argpp)
  867. DB_ENV *dbenv;
  868. void *recbuf;
  869. __ham_newpgno_args **argpp;
  870. {
  871. __ham_newpgno_args *argp;
  872. u_int8_t *bp;
  873. int ret;
  875. ret = __os_malloc(dbenv, sizeof(__ham_newpgno_args) +
  876.     sizeof(DB_TXN), NULL, &argp);
  877. if (ret != 0)
  878. return (ret);
  879. argp->txnid = (DB_TXN *)&argp[1];
  880. bp = recbuf;
  881. memcpy(&argp->type, bp, sizeof(argp->type));
  882. bp += sizeof(argp->type);
  883. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  884. bp += sizeof(argp->txnid->txnid);
  885. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  886. bp += sizeof(DB_LSN);
  887. memcpy(&argp->opcode, bp, sizeof(argp->opcode));
  888. bp += sizeof(argp->opcode);
  889. memcpy(&argp->fileid, bp, sizeof(argp->fileid));
  890. bp += sizeof(argp->fileid);
  891. memcpy(&argp->pgno, bp, sizeof(argp->pgno));
  892. bp += sizeof(argp->pgno);
  893. memcpy(&argp->free_pgno, bp, sizeof(argp->free_pgno));
  894. bp += sizeof(argp->free_pgno);
  895. memcpy(&argp->old_type, bp, sizeof(argp->old_type));
  896. bp += sizeof(argp->old_type);
  897. memcpy(&argp->old_pgno, bp, sizeof(argp->old_pgno));
  898. bp += sizeof(argp->old_pgno);
  899. memcpy(&argp->new_type, bp, sizeof(argp->new_type));
  900. bp += sizeof(argp->new_type);
  901. memcpy(&argp->pagelsn, bp,  sizeof(argp->pagelsn));
  902. bp += sizeof(argp->pagelsn);
  903. memcpy(&argp->metalsn, bp,  sizeof(argp->metalsn));
  904. bp += sizeof(argp->metalsn);
  905. *argpp = argp;
  906. return (0);
  907. }
  909. int
  910. __ham_ovfl_print(dbenv, dbtp, lsnp, notused2, notused3)
  911. DB_ENV *dbenv;
  912. DBT *dbtp;
  913. DB_LSN *lsnp;
  914. db_recops notused2;
  915. void *notused3;
  916. {
  917. __ham_ovfl_args *argp;
  918. u_int32_t i;
  919. u_int ch;
  920. int ret;
  922. i = 0;
  923. ch = 0;
  924. notused2 = DB_TXN_ABORT;
  925. notused3 = NULL;
  927. if ((ret = __ham_ovfl_read(dbenv, dbtp->data, &argp)) != 0)
  928. return (ret);
  929. printf("[%lu][%lu]ham_ovfl: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  930.     (u_long)lsnp->file,
  931.     (u_long)lsnp->offset,
  932.     (u_long)argp->type,
  933.     (u_long)argp->txnid->txnid,
  934.     (u_long)argp->prev_lsn.file,
  935.     (u_long)argp->prev_lsn.offset);
  936. printf("tfileid: %ldn", (long)argp->fileid);
  937. printf("tstart_pgno: %lun", (u_long)argp->start_pgno);
  938. printf("tnpages: %lun", (u_long)argp->npages);
  939. printf("tfree_pgno: %lun", (u_long)argp->free_pgno);
  940. printf("tovflpoint: %lun", (u_long)argp->ovflpoint);
  941. printf("tmetalsn: [%lu][%lu]n",
  942.     (u_long)argp->metalsn.file, (u_long)argp->metalsn.offset);
  943. printf("n");
  944. __os_free(argp, 0);
  945. return (0);
  946. }
  948. int
  949. __ham_ovfl_read(dbenv, recbuf, argpp)
  950. DB_ENV *dbenv;
  951. void *recbuf;
  952. __ham_ovfl_args **argpp;
  953. {
  954. __ham_ovfl_args *argp;
  955. u_int8_t *bp;
  956. int ret;
  958. ret = __os_malloc(dbenv, sizeof(__ham_ovfl_args) +
  959.     sizeof(DB_TXN), NULL, &argp);
  960. if (ret != 0)
  961. return (ret);
  962. argp->txnid = (DB_TXN *)&argp[1];
  963. bp = recbuf;
  964. memcpy(&argp->type, bp, sizeof(argp->type));
  965. bp += sizeof(argp->type);
  966. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  967. bp += sizeof(argp->txnid->txnid);
  968. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  969. bp += sizeof(DB_LSN);
  970. memcpy(&argp->fileid, bp, sizeof(argp->fileid));
  971. bp += sizeof(argp->fileid);
  972. memcpy(&argp->start_pgno, bp, sizeof(argp->start_pgno));
  973. bp += sizeof(argp->start_pgno);
  974. memcpy(&argp->npages, bp, sizeof(argp->npages));
  975. bp += sizeof(argp->npages);
  976. memcpy(&argp->free_pgno, bp, sizeof(argp->free_pgno));
  977. bp += sizeof(argp->free_pgno);
  978. memcpy(&argp->ovflpoint, bp, sizeof(argp->ovflpoint));
  979. bp += sizeof(argp->ovflpoint);
  980. memcpy(&argp->metalsn, bp,  sizeof(argp->metalsn));
  981. bp += sizeof(argp->metalsn);
  982. *argpp = argp;
  983. return (0);
  984. }
  986. int
  987. __ham_copypage_log(dbenv, txnid, ret_lsnp, flags,
  988. fileid, pgno, pagelsn, next_pgno, nextlsn, nnext_pgno,
  989. nnextlsn, page)
  990. DB_ENV *dbenv;
  991. DB_TXN *txnid;
  992. DB_LSN *ret_lsnp;
  993. u_int32_t flags;
  994. int32_t fileid;
  995. db_pgno_t pgno;
  996. DB_LSN * pagelsn;
  997. db_pgno_t next_pgno;
  998. DB_LSN * nextlsn;
  999. db_pgno_t nnext_pgno;
  1000. DB_LSN * nnextlsn;
  1001. const DBT *page;
  1002. {
  1003. DBT logrec;
  1004. DB_LSN *lsnp, null_lsn;
  1005. u_int32_t zero;
  1006. u_int32_t rectype, txn_num;
  1007. int ret;
  1008. u_int8_t *bp;
  1010. rectype = DB_ham_copypage;
  1011. if (txnid != NULL &&
  1012.     TAILQ_FIRST(&txnid->kids) != NULL &&
  1013.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  1014. return (ret);
  1015. txn_num = txnid == NULL ? 0 : txnid->txnid;
  1016. if (txnid == NULL) {
  1017. ZERO_LSN(null_lsn);
  1018. lsnp = &null_lsn;
  1019. } else
  1020. lsnp = &txnid->last_lsn;
  1021. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  1022.     + sizeof(fileid)
  1023.     + sizeof(pgno)
  1024.     + sizeof(*pagelsn)
  1025.     + sizeof(next_pgno)
  1026.     + sizeof(*nextlsn)
  1027.     + sizeof(nnext_pgno)
  1028.     + sizeof(*nnextlsn)
  1029.     + sizeof(u_int32_t) + (page == NULL ? 0 : page->size);
  1030. if ((ret = __os_malloc(dbenv, logrec.size, NULL, &logrec.data)) != 0)
  1031. return (ret);
  1033. bp = logrec.data;
  1034. memcpy(bp, &rectype, sizeof(rectype));
  1035. bp += sizeof(rectype);
  1036. memcpy(bp, &txn_num, sizeof(txn_num));
  1037. bp += sizeof(txn_num);
  1038. memcpy(bp, lsnp, sizeof(DB_LSN));
  1039. bp += sizeof(DB_LSN);
  1040. memcpy(bp, &fileid, sizeof(fileid));
  1041. bp += sizeof(fileid);
  1042. memcpy(bp, &pgno, sizeof(pgno));
  1043. bp += sizeof(pgno);
  1044. if (pagelsn != NULL)
  1045. memcpy(bp, pagelsn, sizeof(*pagelsn));
  1046. else
  1047. memset(bp, 0, sizeof(*pagelsn));
  1048. bp += sizeof(*pagelsn);
  1049. memcpy(bp, &next_pgno, sizeof(next_pgno));
  1050. bp += sizeof(next_pgno);
  1051. if (nextlsn != NULL)
  1052. memcpy(bp, nextlsn, sizeof(*nextlsn));
  1053. else
  1054. memset(bp, 0, sizeof(*nextlsn));
  1055. bp += sizeof(*nextlsn);
  1056. memcpy(bp, &nnext_pgno, sizeof(nnext_pgno));
  1057. bp += sizeof(nnext_pgno);
  1058. if (nnextlsn != NULL)
  1059. memcpy(bp, nnextlsn, sizeof(*nnextlsn));
  1060. else
  1061. memset(bp, 0, sizeof(*nnextlsn));
  1062. bp += sizeof(*nnextlsn);
  1063. if (page == NULL) {
  1064. zero = 0;
  1065. memcpy(bp, &zero, sizeof(u_int32_t));
  1066. bp += sizeof(u_int32_t);
  1067. } else {
  1068. memcpy(bp, &page->size, sizeof(page->size));
  1069. bp += sizeof(page->size);
  1070. memcpy(bp, page->data, page->size);
  1071. bp += page->size;
  1072. }
  1073. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size);
  1074. ret = log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags);
  1075. if (txnid != NULL)
  1076. txnid->last_lsn = *ret_lsnp;
  1077. __os_free(logrec.data, logrec.size);
  1078. return (ret);
  1079. }
  1081. int
  1082. __ham_copypage_print(dbenv, dbtp, lsnp, notused2, notused3)
  1083. DB_ENV *dbenv;
  1084. DBT *dbtp;
  1085. DB_LSN *lsnp;
  1086. db_recops notused2;
  1087. void *notused3;
  1088. {
  1089. __ham_copypage_args *argp;
  1090. u_int32_t i;
  1091. u_int ch;
  1092. int ret;
  1094. i = 0;
  1095. ch = 0;
  1096. notused2 = DB_TXN_ABORT;
  1097. notused3 = NULL;
  1099. if ((ret = __ham_copypage_read(dbenv, dbtp->data, &argp)) != 0)
  1100. return (ret);
  1101. printf("[%lu][%lu]ham_copypage: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  1102.     (u_long)lsnp->file,
  1103.     (u_long)lsnp->offset,
  1104.     (u_long)argp->type,
  1105.     (u_long)argp->txnid->txnid,
  1106.     (u_long)argp->prev_lsn.file,
  1107.     (u_long)argp->prev_lsn.offset);
  1108. printf("tfileid: %ldn", (long)argp->fileid);
  1109. printf("tpgno: %lun", (u_long)argp->pgno);
  1110. printf("tpagelsn: [%lu][%lu]n",
  1111.     (u_long)argp->pagelsn.file, (u_long)argp->pagelsn.offset);
  1112. printf("tnext_pgno: %lun", (u_long)argp->next_pgno);
  1113. printf("tnextlsn: [%lu][%lu]n",
  1114.     (u_long)argp->nextlsn.file, (u_long)argp->nextlsn.offset);
  1115. printf("tnnext_pgno: %lun", (u_long)argp->nnext_pgno);
  1116. printf("tnnextlsn: [%lu][%lu]n",
  1117.     (u_long)argp->nnextlsn.file, (u_long)argp->nnextlsn.offset);
  1118. printf("tpage: ");
  1119. for (i = 0; i < argp->page.size; i++) {
  1120. ch = ((u_int8_t *)argp->page.data)[i];
  1121. if (isprint(ch) || ch == 0xa)
  1122. putchar(ch);
  1123. else
  1124. printf("%#x ", ch);
  1125. }
  1126. printf("n");
  1127. printf("n");
  1128. __os_free(argp, 0);
  1129. return (0);
  1130. }
  1132. int
  1133. __ham_copypage_read(dbenv, recbuf, argpp)
  1134. DB_ENV *dbenv;
  1135. void *recbuf;
  1136. __ham_copypage_args **argpp;
  1137. {
  1138. __ham_copypage_args *argp;
  1139. u_int8_t *bp;
  1140. int ret;
  1142. ret = __os_malloc(dbenv, sizeof(__ham_copypage_args) +
  1143.     sizeof(DB_TXN), NULL, &argp);
  1144. if (ret != 0)
  1145. return (ret);
  1146. argp->txnid = (DB_TXN *)&argp[1];
  1147. bp = recbuf;
  1148. memcpy(&argp->type, bp, sizeof(argp->type));
  1149. bp += sizeof(argp->type);
  1150. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  1151. bp += sizeof(argp->txnid->txnid);
  1152. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  1153. bp += sizeof(DB_LSN);
  1154. memcpy(&argp->fileid, bp, sizeof(argp->fileid));
  1155. bp += sizeof(argp->fileid);
  1156. memcpy(&argp->pgno, bp, sizeof(argp->pgno));
  1157. bp += sizeof(argp->pgno);
  1158. memcpy(&argp->pagelsn, bp,  sizeof(argp->pagelsn));
  1159. bp += sizeof(argp->pagelsn);
  1160. memcpy(&argp->next_pgno, bp, sizeof(argp->next_pgno));
  1161. bp += sizeof(argp->next_pgno);
  1162. memcpy(&argp->nextlsn, bp,  sizeof(argp->nextlsn));
  1163. bp += sizeof(argp->nextlsn);
  1164. memcpy(&argp->nnext_pgno, bp, sizeof(argp->nnext_pgno));
  1165. bp += sizeof(argp->nnext_pgno);
  1166. memcpy(&argp->nnextlsn, bp,  sizeof(argp->nnextlsn));
  1167. bp += sizeof(argp->nnextlsn);
  1168. memset(&argp->page, 0, sizeof(argp->page));
  1169. memcpy(&argp->page.size, bp, sizeof(u_int32_t));
  1170. bp += sizeof(u_int32_t);
  1171. argp->page.data = bp;
  1172. bp += argp->page.size;
  1173. *argpp = argp;
  1174. return (0);
  1175. }
  1177. int
  1178. __ham_metagroup_log(dbenv, txnid, ret_lsnp, flags,
  1179. fileid, bucket, pgno, metalsn, pagelsn)
  1180. DB_ENV *dbenv;
  1181. DB_TXN *txnid;
  1182. DB_LSN *ret_lsnp;
  1183. u_int32_t flags;
  1184. int32_t fileid;
  1185. u_int32_t bucket;
  1186. db_pgno_t pgno;
  1187. DB_LSN * metalsn;
  1188. DB_LSN * pagelsn;
  1189. {
  1190. DBT logrec;
  1191. DB_LSN *lsnp, null_lsn;
  1192. u_int32_t rectype, txn_num;
  1193. int ret;
  1194. u_int8_t *bp;
  1196. rectype = DB_ham_metagroup;
  1197. if (txnid != NULL &&
  1198.     TAILQ_FIRST(&txnid->kids) != NULL &&
  1199.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  1200. return (ret);
  1201. txn_num = txnid == NULL ? 0 : txnid->txnid;
  1202. if (txnid == NULL) {
  1203. ZERO_LSN(null_lsn);
  1204. lsnp = &null_lsn;
  1205. } else
  1206. lsnp = &txnid->last_lsn;
  1207. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  1208.     + sizeof(fileid)
  1209.     + sizeof(bucket)
  1210.     + sizeof(pgno)
  1211.     + sizeof(*metalsn)
  1212.     + sizeof(*pagelsn);
  1213. if ((ret = __os_malloc(dbenv, logrec.size, NULL, &logrec.data)) != 0)
  1214. return (ret);
  1216. bp = logrec.data;
  1217. memcpy(bp, &rectype, sizeof(rectype));
  1218. bp += sizeof(rectype);
  1219. memcpy(bp, &txn_num, sizeof(txn_num));
  1220. bp += sizeof(txn_num);
  1221. memcpy(bp, lsnp, sizeof(DB_LSN));
  1222. bp += sizeof(DB_LSN);
  1223. memcpy(bp, &fileid, sizeof(fileid));
  1224. bp += sizeof(fileid);
  1225. memcpy(bp, &bucket, sizeof(bucket));
  1226. bp += sizeof(bucket);
  1227. memcpy(bp, &pgno, sizeof(pgno));
  1228. bp += sizeof(pgno);
  1229. if (metalsn != NULL)
  1230. memcpy(bp, metalsn, sizeof(*metalsn));
  1231. else
  1232. memset(bp, 0, sizeof(*metalsn));
  1233. bp += sizeof(*metalsn);
  1234. if (pagelsn != NULL)
  1235. memcpy(bp, pagelsn, sizeof(*pagelsn));
  1236. else
  1237. memset(bp, 0, sizeof(*pagelsn));
  1238. bp += sizeof(*pagelsn);
  1239. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size);
  1240. ret = log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags);
  1241. if (txnid != NULL)
  1242. txnid->last_lsn = *ret_lsnp;
  1243. __os_free(logrec.data, logrec.size);
  1244. return (ret);
  1245. }
  1247. int
  1248. __ham_metagroup_print(dbenv, dbtp, lsnp, notused2, notused3)
  1249. DB_ENV *dbenv;
  1250. DBT *dbtp;
  1251. DB_LSN *lsnp;
  1252. db_recops notused2;
  1253. void *notused3;
  1254. {
  1255. __ham_metagroup_args *argp;
  1256. u_int32_t i;
  1257. u_int ch;
  1258. int ret;
  1260. i = 0;
  1261. ch = 0;
  1262. notused2 = DB_TXN_ABORT;
  1263. notused3 = NULL;
  1265. if ((ret = __ham_metagroup_read(dbenv, dbtp->data, &argp)) != 0)
  1266. return (ret);
  1267. printf("[%lu][%lu]ham_metagroup: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  1268.     (u_long)lsnp->file,
  1269.     (u_long)lsnp->offset,
  1270.     (u_long)argp->type,
  1271.     (u_long)argp->txnid->txnid,
  1272.     (u_long)argp->prev_lsn.file,
  1273.     (u_long)argp->prev_lsn.offset);
  1274. printf("tfileid: %ldn", (long)argp->fileid);
  1275. printf("tbucket: %lun", (u_long)argp->bucket);
  1276. printf("tpgno: %lun", (u_long)argp->pgno);
  1277. printf("tmetalsn: [%lu][%lu]n",
  1278.     (u_long)argp->metalsn.file, (u_long)argp->metalsn.offset);
  1279. printf("tpagelsn: [%lu][%lu]n",
  1280.     (u_long)argp->pagelsn.file, (u_long)argp->pagelsn.offset);
  1281. printf("n");
  1282. __os_free(argp, 0);
  1283. return (0);
  1284. }
  1286. int
  1287. __ham_metagroup_read(dbenv, recbuf, argpp)
  1288. DB_ENV *dbenv;
  1289. void *recbuf;
  1290. __ham_metagroup_args **argpp;
  1291. {
  1292. __ham_metagroup_args *argp;
  1293. u_int8_t *bp;
  1294. int ret;
  1296. ret = __os_malloc(dbenv, sizeof(__ham_metagroup_args) +
  1297.     sizeof(DB_TXN), NULL, &argp);
  1298. if (ret != 0)
  1299. return (ret);
  1300. argp->txnid = (DB_TXN *)&argp[1];
  1301. bp = recbuf;
  1302. memcpy(&argp->type, bp, sizeof(argp->type));
  1303. bp += sizeof(argp->type);
  1304. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  1305. bp += sizeof(argp->txnid->txnid);
  1306. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  1307. bp += sizeof(DB_LSN);
  1308. memcpy(&argp->fileid, bp, sizeof(argp->fileid));
  1309. bp += sizeof(argp->fileid);
  1310. memcpy(&argp->bucket, bp, sizeof(argp->bucket));
  1311. bp += sizeof(argp->bucket);
  1312. memcpy(&argp->pgno, bp, sizeof(argp->pgno));
  1313. bp += sizeof(argp->pgno);
  1314. memcpy(&argp->metalsn, bp,  sizeof(argp->metalsn));
  1315. bp += sizeof(argp->metalsn);
  1316. memcpy(&argp->pagelsn, bp,  sizeof(argp->pagelsn));
  1317. bp += sizeof(argp->pagelsn);
  1318. *argpp = argp;
  1319. return (0);
  1320. }
  1322. int
  1323. __ham_groupalloc1_print(dbenv, dbtp, lsnp, notused2, notused3)
  1324. DB_ENV *dbenv;
  1325. DBT *dbtp;
  1326. DB_LSN *lsnp;
  1327. db_recops notused2;
  1328. void *notused3;
  1329. {
  1330. __ham_groupalloc1_args *argp;
  1331. u_int32_t i;
  1332. u_int ch;
  1333. int ret;
  1335. i = 0;
  1336. ch = 0;
  1337. notused2 = DB_TXN_ABORT;
  1338. notused3 = NULL;
  1340. if ((ret = __ham_groupalloc1_read(dbenv, dbtp->data, &argp)) != 0)
  1341. return (ret);
  1342. printf("[%lu][%lu]ham_groupalloc1: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  1343.     (u_long)lsnp->file,
  1344.     (u_long)lsnp->offset,
  1345.     (u_long)argp->type,
  1346.     (u_long)argp->txnid->txnid,
  1347.     (u_long)argp->prev_lsn.file,
  1348.     (u_long)argp->prev_lsn.offset);
  1349. printf("tfileid: %ldn", (long)argp->fileid);
  1350. printf("tpgno: %lun", (u_long)argp->pgno);
  1351. printf("tmetalsn: [%lu][%lu]n",
  1352.     (u_long)argp->metalsn.file, (u_long)argp->metalsn.offset);
  1353. printf("tmmetalsn: [%lu][%lu]n",
  1354.     (u_long)argp->mmetalsn.file, (u_long)argp->mmetalsn.offset);
  1355. printf("tstart_pgno: %lun", (u_long)argp->start_pgno);
  1356. printf("tnum: %lun", (u_long)argp->num);
  1357. printf("n");
  1358. __os_free(argp, 0);
  1359. return (0);
  1360. }
  1362. int
  1363. __ham_groupalloc1_read(dbenv, recbuf, argpp)
  1364. DB_ENV *dbenv;
  1365. void *recbuf;
  1366. __ham_groupalloc1_args **argpp;
  1367. {
  1368. __ham_groupalloc1_args *argp;
  1369. u_int8_t *bp;
  1370. int ret;
  1372. ret = __os_malloc(dbenv, sizeof(__ham_groupalloc1_args) +
  1373.     sizeof(DB_TXN), NULL, &argp);
  1374. if (ret != 0)
  1375. return (ret);
  1376. argp->txnid = (DB_TXN *)&argp[1];
  1377. bp = recbuf;
  1378. memcpy(&argp->type, bp, sizeof(argp->type));
  1379. bp += sizeof(argp->type);
  1380. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  1381. bp += sizeof(argp->txnid->txnid);
  1382. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  1383. bp += sizeof(DB_LSN);
  1384. memcpy(&argp->fileid, bp, sizeof(argp->fileid));
  1385. bp += sizeof(argp->fileid);
  1386. memcpy(&argp->pgno, bp, sizeof(argp->pgno));
  1387. bp += sizeof(argp->pgno);
  1388. memcpy(&argp->metalsn, bp,  sizeof(argp->metalsn));
  1389. bp += sizeof(argp->metalsn);
  1390. memcpy(&argp->mmetalsn, bp,  sizeof(argp->mmetalsn));
  1391. bp += sizeof(argp->mmetalsn);
  1392. memcpy(&argp->start_pgno, bp, sizeof(argp->start_pgno));
  1393. bp += sizeof(argp->start_pgno);
  1394. memcpy(&argp->num, bp, sizeof(argp->num));
  1395. bp += sizeof(argp->num);
  1396. *argpp = argp;
  1397. return (0);
  1398. }
  1400. int
  1401. __ham_groupalloc2_print(dbenv, dbtp, lsnp, notused2, notused3)
  1402. DB_ENV *dbenv;
  1403. DBT *dbtp;
  1404. DB_LSN *lsnp;
  1405. db_recops notused2;
  1406. void *notused3;
  1407. {
  1408. __ham_groupalloc2_args *argp;
  1409. u_int32_t i;
  1410. u_int ch;
  1411. int ret;
  1413. i = 0;
  1414. ch = 0;
  1415. notused2 = DB_TXN_ABORT;
  1416. notused3 = NULL;
  1418. if ((ret = __ham_groupalloc2_read(dbenv, dbtp->data, &argp)) != 0)
  1419. return (ret);
  1420. printf("[%lu][%lu]ham_groupalloc2: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  1421.     (u_long)lsnp->file,
  1422.     (u_long)lsnp->offset,
  1423.     (u_long)argp->type,
  1424.     (u_long)argp->txnid->txnid,
  1425.     (u_long)argp->prev_lsn.file,
  1426.     (u_long)argp->prev_lsn.offset);
  1427. printf("tfileid: %ldn", (long)argp->fileid);
  1428. printf("tmeta_lsn: [%lu][%lu]n",
  1429.     (u_long)argp->meta_lsn.file, (u_long)argp->meta_lsn.offset);
  1430. printf("talloc_lsn: [%lu][%lu]n",
  1431.     (u_long)argp->alloc_lsn.file, (u_long)argp->alloc_lsn.offset);
  1432. printf("tstart_pgno: %lun", (u_long)argp->start_pgno);
  1433. printf("tnum: %lun", (u_long)argp->num);
  1434. printf("tfree: %lun", (u_long)argp->free);
  1435. printf("n");
  1436. __os_free(argp, 0);
  1437. return (0);
  1438. }
  1440. int
  1441. __ham_groupalloc2_read(dbenv, recbuf, argpp)
  1442. DB_ENV *dbenv;
  1443. void *recbuf;
  1444. __ham_groupalloc2_args **argpp;
  1445. {
  1446. __ham_groupalloc2_args *argp;
  1447. u_int8_t *bp;
  1448. int ret;
  1450. ret = __os_malloc(dbenv, sizeof(__ham_groupalloc2_args) +
  1451.     sizeof(DB_TXN), NULL, &argp);
  1452. if (ret != 0)
  1453. return (ret);
  1454. argp->txnid = (DB_TXN *)&argp[1];
  1455. bp = recbuf;
  1456. memcpy(&argp->type, bp, sizeof(argp->type));
  1457. bp += sizeof(argp->type);
  1458. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  1459. bp += sizeof(argp->txnid->txnid);
  1460. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  1461. bp += sizeof(DB_LSN);
  1462. memcpy(&argp->fileid, bp, sizeof(argp->fileid));
  1463. bp += sizeof(argp->fileid);
  1464. memcpy(&argp->meta_lsn, bp,  sizeof(argp->meta_lsn));
  1465. bp += sizeof(argp->meta_lsn);
  1466. memcpy(&argp->alloc_lsn, bp,  sizeof(argp->alloc_lsn));
  1467. bp += sizeof(argp->alloc_lsn);
  1468. memcpy(&argp->start_pgno, bp, sizeof(argp->start_pgno));
  1469. bp += sizeof(argp->start_pgno);
  1470. memcpy(&argp->num, bp, sizeof(argp->num));
  1471. bp += sizeof(argp->num);
  1472. memcpy(&argp->free, bp, sizeof(argp->free));
  1473. bp += sizeof(argp->free);
  1474. *argpp = argp;
  1475. return (0);
  1476. }
  1478. int
  1479. __ham_groupalloc_log(dbenv, txnid, ret_lsnp, flags,
  1480. fileid, meta_lsn, start_pgno, num, free)
  1481. DB_ENV *dbenv;
  1482. DB_TXN *txnid;
  1483. DB_LSN *ret_lsnp;
  1484. u_int32_t flags;
  1485. int32_t fileid;
  1486. DB_LSN * meta_lsn;
  1487. db_pgno_t start_pgno;
  1488. u_int32_t num;
  1489. db_pgno_t free;
  1490. {
  1491. DBT logrec;
  1492. DB_LSN *lsnp, null_lsn;
  1493. u_int32_t rectype, txn_num;
  1494. int ret;
  1495. u_int8_t *bp;
  1497. rectype = DB_ham_groupalloc;
  1498. if (txnid != NULL &&
  1499.     TAILQ_FIRST(&txnid->kids) != NULL &&
  1500.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  1501. return (ret);
  1502. txn_num = txnid == NULL ? 0 : txnid->txnid;
  1503. if (txnid == NULL) {
  1504. ZERO_LSN(null_lsn);
  1505. lsnp = &null_lsn;
  1506. } else
  1507. lsnp = &txnid->last_lsn;
  1508. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  1509.     + sizeof(fileid)
  1510.     + sizeof(*meta_lsn)
  1511.     + sizeof(start_pgno)
  1512.     + sizeof(num)
  1513.     + sizeof(free);
  1514. if ((ret = __os_malloc(dbenv, logrec.size, NULL, &logrec.data)) != 0)
  1515. return (ret);
  1517. bp = logrec.data;
  1518. memcpy(bp, &rectype, sizeof(rectype));
  1519. bp += sizeof(rectype);
  1520. memcpy(bp, &txn_num, sizeof(txn_num));
  1521. bp += sizeof(txn_num);
  1522. memcpy(bp, lsnp, sizeof(DB_LSN));
  1523. bp += sizeof(DB_LSN);
  1524. memcpy(bp, &fileid, sizeof(fileid));
  1525. bp += sizeof(fileid);
  1526. if (meta_lsn != NULL)
  1527. memcpy(bp, meta_lsn, sizeof(*meta_lsn));
  1528. else
  1529. memset(bp, 0, sizeof(*meta_lsn));
  1530. bp += sizeof(*meta_lsn);
  1531. memcpy(bp, &start_pgno, sizeof(start_pgno));
  1532. bp += sizeof(start_pgno);
  1533. memcpy(bp, &num, sizeof(num));
  1534. bp += sizeof(num);
  1535. memcpy(bp, &free, sizeof(free));
  1536. bp += sizeof(free);
  1537. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size);
  1538. ret = log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags);
  1539. if (txnid != NULL)
  1540. txnid->last_lsn = *ret_lsnp;
  1541. __os_free(logrec.data, logrec.size);
  1542. return (ret);
  1543. }
  1545. int
  1546. __ham_groupalloc_print(dbenv, dbtp, lsnp, notused2, notused3)
  1547. DB_ENV *dbenv;
  1548. DBT *dbtp;
  1549. DB_LSN *lsnp;
  1550. db_recops notused2;
  1551. void *notused3;
  1552. {
  1553. __ham_groupalloc_args *argp;
  1554. u_int32_t i;
  1555. u_int ch;
  1556. int ret;
  1558. i = 0;
  1559. ch = 0;
  1560. notused2 = DB_TXN_ABORT;
  1561. notused3 = NULL;
  1563. if ((ret = __ham_groupalloc_read(dbenv, dbtp->data, &argp)) != 0)
  1564. return (ret);
  1565. printf("[%lu][%lu]ham_groupalloc: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  1566.     (u_long)lsnp->file,
  1567.     (u_long)lsnp->offset,
  1568.     (u_long)argp->type,
  1569.     (u_long)argp->txnid->txnid,
  1570.     (u_long)argp->prev_lsn.file,
  1571.     (u_long)argp->prev_lsn.offset);
  1572. printf("tfileid: %ldn", (long)argp->fileid);
  1573. printf("tmeta_lsn: [%lu][%lu]n",
  1574.     (u_long)argp->meta_lsn.file, (u_long)argp->meta_lsn.offset);
  1575. printf("tstart_pgno: %lun", (u_long)argp->start_pgno);
  1576. printf("tnum: %lun", (u_long)argp->num);
  1577. printf("tfree: %lun", (u_long)argp->free);
  1578. printf("n");
  1579. __os_free(argp, 0);
  1580. return (0);
  1581. }
  1583. int
  1584. __ham_groupalloc_read(dbenv, recbuf, argpp)
  1585. DB_ENV *dbenv;
  1586. void *recbuf;
  1587. __ham_groupalloc_args **argpp;
  1588. {
  1589. __ham_groupalloc_args *argp;
  1590. u_int8_t *bp;
  1591. int ret;
  1593. ret = __os_malloc(dbenv, sizeof(__ham_groupalloc_args) +
  1594.     sizeof(DB_TXN), NULL, &argp);
  1595. if (ret != 0)
  1596. return (ret);
  1597. argp->txnid = (DB_TXN *)&argp[1];
  1598. bp = recbuf;
  1599. memcpy(&argp->type, bp, sizeof(argp->type));
  1600. bp += sizeof(argp->type);
  1601. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  1602. bp += sizeof(argp->txnid->txnid);
  1603. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  1604. bp += sizeof(DB_LSN);
  1605. memcpy(&argp->fileid, bp, sizeof(argp->fileid));
  1606. bp += sizeof(argp->fileid);
  1607. memcpy(&argp->meta_lsn, bp,  sizeof(argp->meta_lsn));
  1608. bp += sizeof(argp->meta_lsn);
  1609. memcpy(&argp->start_pgno, bp, sizeof(argp->start_pgno));
  1610. bp += sizeof(argp->start_pgno);
  1611. memcpy(&argp->num, bp, sizeof(argp->num));
  1612. bp += sizeof(argp->num);
  1613. memcpy(&argp->free, bp, sizeof(argp->free));
  1614. bp += sizeof(argp->free);
  1615. *argpp = argp;
  1616. return (0);
  1617. }
  1619. int
  1620. __ham_curadj_log(dbenv, txnid, ret_lsnp, flags,
  1621. fileid, pgno, indx, len, dup_off, add,
  1622. is_dup, order)
  1623. DB_ENV *dbenv;
  1624. DB_TXN *txnid;
  1625. DB_LSN *ret_lsnp;
  1626. u_int32_t flags;
  1627. int32_t fileid;
  1628. db_pgno_t pgno;
  1629. u_int32_t indx;
  1630. u_int32_t len;
  1631. u_int32_t dup_off;
  1632. int add;
  1633. int is_dup;
  1634. u_int32_t order;
  1635. {
  1636. DBT logrec;
  1637. DB_LSN *lsnp, null_lsn;
  1638. u_int32_t rectype, txn_num;
  1639. int ret;
  1640. u_int8_t *bp;
  1642. rectype = DB_ham_curadj;
  1643. if (txnid != NULL &&
  1644.     TAILQ_FIRST(&txnid->kids) != NULL &&
  1645.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  1646. return (ret);
  1647. txn_num = txnid == NULL ? 0 : txnid->txnid;
  1648. if (txnid == NULL) {
  1649. ZERO_LSN(null_lsn);
  1650. lsnp = &null_lsn;
  1651. } else
  1652. lsnp = &txnid->last_lsn;
  1653. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  1654.     + sizeof(fileid)
  1655.     + sizeof(pgno)
  1656.     + sizeof(indx)
  1657.     + sizeof(len)
  1658.     + sizeof(dup_off)
  1659.     + sizeof(add)
  1660.     + sizeof(is_dup)
  1661.     + sizeof(order);
  1662. if ((ret = __os_malloc(dbenv, logrec.size, NULL, &logrec.data)) != 0)
  1663. return (ret);
  1665. bp = logrec.data;
  1666. memcpy(bp, &rectype, sizeof(rectype));
  1667. bp += sizeof(rectype);
  1668. memcpy(bp, &txn_num, sizeof(txn_num));
  1669. bp += sizeof(txn_num);
  1670. memcpy(bp, lsnp, sizeof(DB_LSN));
  1671. bp += sizeof(DB_LSN);
  1672. memcpy(bp, &fileid, sizeof(fileid));
  1673. bp += sizeof(fileid);
  1674. memcpy(bp, &pgno, sizeof(pgno));
  1675. bp += sizeof(pgno);
  1676. memcpy(bp, &indx, sizeof(indx));
  1677. bp += sizeof(indx);
  1678. memcpy(bp, &len, sizeof(len));
  1679. bp += sizeof(len);
  1680. memcpy(bp, &dup_off, sizeof(dup_off));
  1681. bp += sizeof(dup_off);
  1682. memcpy(bp, &add, sizeof(add));
  1683. bp += sizeof(add);
  1684. memcpy(bp, &is_dup, sizeof(is_dup));
  1685. bp += sizeof(is_dup);
  1686. memcpy(bp, &order, sizeof(order));
  1687. bp += sizeof(order);
  1688. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size);
  1689. ret = log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags);
  1690. if (txnid != NULL)
  1691. txnid->last_lsn = *ret_lsnp;
  1692. __os_free(logrec.data, logrec.size);
  1693. return (ret);
  1694. }
  1696. int
  1697. __ham_curadj_print(dbenv, dbtp, lsnp, notused2, notused3)
  1698. DB_ENV *dbenv;
  1699. DBT *dbtp;
  1700. DB_LSN *lsnp;
  1701. db_recops notused2;
  1702. void *notused3;
  1703. {
  1704. __ham_curadj_args *argp;
  1705. u_int32_t i;
  1706. u_int ch;
  1707. int ret;
  1709. i = 0;
  1710. ch = 0;
  1711. notused2 = DB_TXN_ABORT;
  1712. notused3 = NULL;
  1714. if ((ret = __ham_curadj_read(dbenv, dbtp->data, &argp)) != 0)
  1715. return (ret);
  1716. printf("[%lu][%lu]ham_curadj: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  1717.     (u_long)lsnp->file,
  1718.     (u_long)lsnp->offset,
  1719.     (u_long)argp->type,
  1720.     (u_long)argp->txnid->txnid,
  1721.     (u_long)argp->prev_lsn.file,
  1722.     (u_long)argp->prev_lsn.offset);
  1723. printf("tfileid: %ldn", (long)argp->fileid);
  1724. printf("tpgno: %lun", (u_long)argp->pgno);
  1725. printf("tindx: %lun", (u_long)argp->indx);
  1726. printf("tlen: %lun", (u_long)argp->len);
  1727. printf("tdup_off: %lun", (u_long)argp->dup_off);
  1728. printf("tadd: %ldn", (long)argp->add);
  1729. printf("tis_dup: %ldn", (long)argp->is_dup);
  1730. printf("torder: %lun", (u_long)argp->order);
  1731. printf("n");
  1732. __os_free(argp, 0);
  1733. return (0);
  1734. }
  1736. int
  1737. __ham_curadj_read(dbenv, recbuf, argpp)
  1738. DB_ENV *dbenv;
  1739. void *recbuf;
  1740. __ham_curadj_args **argpp;
  1741. {
  1742. __ham_curadj_args *argp;
  1743. u_int8_t *bp;
  1744. int ret;
  1746. ret = __os_malloc(dbenv, sizeof(__ham_curadj_args) +
  1747.     sizeof(DB_TXN), NULL, &argp);
  1748. if (ret != 0)
  1749. return (ret);
  1750. argp->txnid = (DB_TXN *)&argp[1];
  1751. bp = recbuf;
  1752. memcpy(&argp->type, bp, sizeof(argp->type));
  1753. bp += sizeof(argp->type);
  1754. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  1755. bp += sizeof(argp->txnid->txnid);
  1756. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  1757. bp += sizeof(DB_LSN);
  1758. memcpy(&argp->fileid, bp, sizeof(argp->fileid));
  1759. bp += sizeof(argp->fileid);
  1760. memcpy(&argp->pgno, bp, sizeof(argp->pgno));
  1761. bp += sizeof(argp->pgno);
  1762. memcpy(&argp->indx, bp, sizeof(argp->indx));
  1763. bp += sizeof(argp->indx);
  1764. memcpy(&argp->len, bp, sizeof(argp->len));
  1765. bp += sizeof(argp->len);
  1766. memcpy(&argp->dup_off, bp, sizeof(argp->dup_off));
  1767. bp += sizeof(argp->dup_off);
  1768. memcpy(&argp->add, bp, sizeof(argp->add));
  1769. bp += sizeof(argp->add);
  1770. memcpy(&argp->is_dup, bp, sizeof(argp->is_dup));
  1771. bp += sizeof(argp->is_dup);
  1772. memcpy(&argp->order, bp, sizeof(argp->order));
  1773. bp += sizeof(argp->order);
  1774. *argpp = argp;
  1775. return (0);
  1776. }
  1778. int
  1779. __ham_chgpg_log(dbenv, txnid, ret_lsnp, flags,
  1780. fileid, mode, old_pgno, new_pgno, old_indx, new_indx)
  1781. DB_ENV *dbenv;
  1782. DB_TXN *txnid;
  1783. DB_LSN *ret_lsnp;
  1784. u_int32_t flags;
  1785. int32_t fileid;
  1786. db_ham_mode mode;
  1787. db_pgno_t old_pgno;
  1788. db_pgno_t new_pgno;
  1789. u_int32_t old_indx;
  1790. u_int32_t new_indx;
  1791. {
  1792. DBT logrec;
  1793. DB_LSN *lsnp, null_lsn;
  1794. u_int32_t rectype, txn_num;
  1795. int ret;
  1796. u_int8_t *bp;
  1798. rectype = DB_ham_chgpg;
  1799. if (txnid != NULL &&
  1800.     TAILQ_FIRST(&txnid->kids) != NULL &&
  1801.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  1802. return (ret);
  1803. txn_num = txnid == NULL ? 0 : txnid->txnid;
  1804. if (txnid == NULL) {
  1805. ZERO_LSN(null_lsn);
  1806. lsnp = &null_lsn;
  1807. } else
  1808. lsnp = &txnid->last_lsn;
  1809. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  1810.     + sizeof(fileid)
  1811.     + sizeof(mode)
  1812.     + sizeof(old_pgno)
  1813.     + sizeof(new_pgno)
  1814.     + sizeof(old_indx)
  1815.     + sizeof(new_indx);
  1816. if ((ret = __os_malloc(dbenv, logrec.size, NULL, &logrec.data)) != 0)
  1817. return (ret);
  1819. bp = logrec.data;
  1820. memcpy(bp, &rectype, sizeof(rectype));
  1821. bp += sizeof(rectype);
  1822. memcpy(bp, &txn_num, sizeof(txn_num));
  1823. bp += sizeof(txn_num);
  1824. memcpy(bp, lsnp, sizeof(DB_LSN));
  1825. bp += sizeof(DB_LSN);
  1826. memcpy(bp, &fileid, sizeof(fileid));
  1827. bp += sizeof(fileid);
  1828. memcpy(bp, &mode, sizeof(mode));
  1829. bp += sizeof(mode);
  1830. memcpy(bp, &old_pgno, sizeof(old_pgno));
  1831. bp += sizeof(old_pgno);
  1832. memcpy(bp, &new_pgno, sizeof(new_pgno));
  1833. bp += sizeof(new_pgno);
  1834. memcpy(bp, &old_indx, sizeof(old_indx));
  1835. bp += sizeof(old_indx);
  1836. memcpy(bp, &new_indx, sizeof(new_indx));
  1837. bp += sizeof(new_indx);
  1838. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size);
  1839. ret = log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags);
  1840. if (txnid != NULL)
  1841. txnid->last_lsn = *ret_lsnp;
  1842. __os_free(logrec.data, logrec.size);
  1843. return (ret);
  1844. }
  1846. int
  1847. __ham_chgpg_print(dbenv, dbtp, lsnp, notused2, notused3)
  1848. DB_ENV *dbenv;
  1849. DBT *dbtp;
  1850. DB_LSN *lsnp;
  1851. db_recops notused2;
  1852. void *notused3;
  1853. {
  1854. __ham_chgpg_args *argp;
  1855. u_int32_t i;
  1856. u_int ch;
  1857. int ret;
  1859. i = 0;
  1860. ch = 0;
  1861. notused2 = DB_TXN_ABORT;
  1862. notused3 = NULL;
  1864. if ((ret = __ham_chgpg_read(dbenv, dbtp->data, &argp)) != 0)
  1865. return (ret);
  1866. printf("[%lu][%lu]ham_chgpg: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  1867.     (u_long)lsnp->file,
  1868.     (u_long)lsnp->offset,
  1869.     (u_long)argp->type,
  1870.     (u_long)argp->txnid->txnid,
  1871.     (u_long)argp->prev_lsn.file,
  1872.     (u_long)argp->prev_lsn.offset);
  1873. printf("tfileid: %ldn", (long)argp->fileid);
  1874. printf("tmode: %ldn", (long)argp->mode);
  1875. printf("told_pgno: %lun", (u_long)argp->old_pgno);
  1876. printf("tnew_pgno: %lun", (u_long)argp->new_pgno);
  1877. printf("told_indx: %lun", (u_long)argp->old_indx);
  1878. printf("tnew_indx: %lun", (u_long)argp->new_indx);
  1879. printf("n");
  1880. __os_free(argp, 0);
  1881. return (0);
  1882. }
  1884. int
  1885. __ham_chgpg_read(dbenv, recbuf, argpp)
  1886. DB_ENV *dbenv;
  1887. void *recbuf;
  1888. __ham_chgpg_args **argpp;
  1889. {
  1890. __ham_chgpg_args *argp;
  1891. u_int8_t *bp;
  1892. int ret;
  1894. ret = __os_malloc(dbenv, sizeof(__ham_chgpg_args) +
  1895.     sizeof(DB_TXN), NULL, &argp);
  1896. if (ret != 0)
  1897. return (ret);
  1898. argp->txnid = (DB_TXN *)&argp[1];
  1899. bp = recbuf;
  1900. memcpy(&argp->type, bp, sizeof(argp->type));
  1901. bp += sizeof(argp->type);
  1902. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  1903. bp += sizeof(argp->txnid->txnid);
  1904. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  1905. bp += sizeof(DB_LSN);
  1906. memcpy(&argp->fileid, bp, sizeof(argp->fileid));
  1907. bp += sizeof(argp->fileid);
  1908. memcpy(&argp->mode, bp, sizeof(argp->mode));
  1909. bp += sizeof(argp->mode);
  1910. memcpy(&argp->old_pgno, bp, sizeof(argp->old_pgno));
  1911. bp += sizeof(argp->old_pgno);
  1912. memcpy(&argp->new_pgno, bp, sizeof(argp->new_pgno));
  1913. bp += sizeof(argp->new_pgno);
  1914. memcpy(&argp->old_indx, bp, sizeof(argp->old_indx));
  1915. bp += sizeof(argp->old_indx);
  1916. memcpy(&argp->new_indx, bp, sizeof(argp->new_indx));
  1917. bp += sizeof(argp->new_indx);
  1918. *argpp = argp;
  1919. return (0);
  1920. }
  1922. int
  1923. __ham_init_print(dbenv)
  1924. DB_ENV *dbenv;
  1925. {
  1926. int ret;
  1928. if ((ret = __db_add_recovery(dbenv,
  1929.     __ham_insdel_print, DB_ham_insdel)) != 0)
  1930. return (ret);
  1931. if ((ret = __db_add_recovery(dbenv,
  1932.     __ham_newpage_print, DB_ham_newpage)) != 0)
  1933. return (ret);
  1934. if ((ret = __db_add_recovery(dbenv,
  1935.     __ham_splitmeta_print, DB_ham_splitmeta)) != 0)
  1936. return (ret);
  1937. if ((ret = __db_add_recovery(dbenv,
  1938.     __ham_splitdata_print, DB_ham_splitdata)) != 0)
  1939. return (ret);
  1940. if ((ret = __db_add_recovery(dbenv,
  1941.     __ham_replace_print, DB_ham_replace)) != 0)
  1942. return (ret);
  1943. if ((ret = __db_add_recovery(dbenv,
  1944.     __ham_newpgno_print, DB_ham_newpgno)) != 0)
  1945. return (ret);
  1946. if ((ret = __db_add_recovery(dbenv,
  1947.     __ham_ovfl_print, DB_ham_ovfl)) != 0)
  1948. return (ret);
  1949. if ((ret = __db_add_recovery(dbenv,
  1950.     __ham_copypage_print, DB_ham_copypage)) != 0)
  1951. return (ret);
  1952. if ((ret = __db_add_recovery(dbenv,
  1953.     __ham_metagroup_print, DB_ham_metagroup)) != 0)
  1954. return (ret);
  1955. if ((ret = __db_add_recovery(dbenv,
  1956.     __ham_groupalloc1_print, DB_ham_groupalloc1)) != 0)
  1957. return (ret);
  1958. if ((ret = __db_add_recovery(dbenv,
  1959.     __ham_groupalloc2_print, DB_ham_groupalloc2)) != 0)
  1960. return (ret);
  1961. if ((ret = __db_add_recovery(dbenv,
  1962.     __ham_groupalloc_print, DB_ham_groupalloc)) != 0)
  1963. return (ret);
  1964. if ((ret = __db_add_recovery(dbenv,
  1965.     __ham_curadj_print, DB_ham_curadj)) != 0)
  1966. return (ret);
  1967. if ((ret = __db_add_recovery(dbenv,
  1968.     __ham_chgpg_print, DB_ham_chgpg)) != 0)
  1969. return (ret);
  1970. return (0);
  1971. }
  1973. int
  1974. __ham_init_recover(dbenv)
  1975. DB_ENV *dbenv;
  1976. {
  1977. int ret;
  1979. if ((ret = __db_add_recovery(dbenv,
  1980.     __ham_insdel_recover, DB_ham_insdel)) != 0)
  1981. return (ret);
  1982. if ((ret = __db_add_recovery(dbenv,
  1983.     __ham_newpage_recover, DB_ham_newpage)) != 0)
  1984. return (ret);
  1985. if ((ret = __db_add_recovery(dbenv,
  1986.     __deprecated_recover, DB_ham_splitmeta)) != 0)
  1987. return (ret);
  1988. if ((ret = __db_add_recovery(dbenv,
  1989.     __ham_splitdata_recover, DB_ham_splitdata)) != 0)
  1990. return (ret);
  1991. if ((ret = __db_add_recovery(dbenv,
  1992.     __ham_replace_recover, DB_ham_replace)) != 0)
  1993. return (ret);
  1994. if ((ret = __db_add_recovery(dbenv,
  1995.     __deprecated_recover, DB_ham_newpgno)) != 0)
  1996. return (ret);
  1997. if ((ret = __db_add_recovery(dbenv,
  1998.     __deprecated_recover, DB_ham_ovfl)) != 0)
  1999. return (ret);
  2000. if ((ret = __db_add_recovery(dbenv,
  2001.     __ham_copypage_recover, DB_ham_copypage)) != 0)
  2002. return (ret);
  2003. if ((ret = __db_add_recovery(dbenv,
  2004.     __ham_metagroup_recover, DB_ham_metagroup)) != 0)
  2005. return (ret);
  2006. if ((ret = __db_add_recovery(dbenv,
  2007.     __deprecated_recover, DB_ham_groupalloc1)) != 0)
  2008. return (ret);
  2009. if ((ret = __db_add_recovery(dbenv,
  2010.     __deprecated_recover, DB_ham_groupalloc2)) != 0)
  2011. return (ret);
  2012. if ((ret = __db_add_recovery(dbenv,
  2013.     __ham_groupalloc_recover, DB_ham_groupalloc)) != 0)
  2014. return (ret);
  2015. if ((ret = __db_add_recovery(dbenv,
  2016.     __ham_curadj_recover, DB_ham_curadj)) != 0)
  2017. return (ret);
  2018. if ((ret = __db_add_recovery(dbenv,
  2019.     __ham_chgpg_recover, DB_ham_chgpg)) != 0)
  2020. return (ret);
  2021. return (0);
  2022. }