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

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

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 <string.h>
  9. #endif
  11. #include "db_int.h"
  12. #include "dbinc/crypto.h"
  13. #include "dbinc/db_page.h"
  14. #include "dbinc/db_dispatch.h"
  15. #include "dbinc/db_am.h"
  16. #include "dbinc/hash.h"
  17. #include "dbinc/rep.h"
  18. #include "dbinc/log.h"
  19. #include "dbinc/txn.h"
  21. /*
  22.  * PUBLIC: int __ham_insdel_log __P((DB *, DB_TXN *, DB_LSN *,
  23.  * PUBLIC:     u_int32_t, u_int32_t, db_pgno_t, u_int32_t, DB_LSN *,
  24.  * PUBLIC:     const DBT *, const DBT *));
  25.  */
  26. int
  27. __ham_insdel_log(dbp, txnid, ret_lsnp, flags,
  28.     opcode, pgno, ndx, pagelsn, key,
  29.     data)
  30. DB *dbp;
  31. DB_TXN *txnid;
  32. DB_LSN *ret_lsnp;
  33. u_int32_t flags;
  34. u_int32_t opcode;
  35. db_pgno_t pgno;
  36. u_int32_t ndx;
  37. DB_LSN * pagelsn;
  38. const DBT *key;
  39. const DBT *data;
  40. {
  41. DBT logrec;
  42. DB_ENV *dbenv;
  43. DB_LSN *lsnp, null_lsn;
  44. u_int32_t zero;
  45. u_int32_t uinttmp;
  46. u_int32_t npad, rectype, txn_num;
  47. int ret;
  48. u_int8_t *bp;
  50. dbenv = dbp->dbenv;
  51. rectype = DB___ham_insdel;
  52. npad = 0;
  54. if (txnid == NULL) {
  55. txn_num = 0;
  56. null_lsn.file = 0;
  57. null_lsn.offset = 0;
  58. lsnp = &null_lsn;
  59. } else {
  60. if (TAILQ_FIRST(&txnid->kids) != NULL &&
  61.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  62. return (ret);
  63. txn_num = txnid->txnid;
  64. lsnp = &txnid->last_lsn;
  65. }
  67. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  68.     + sizeof(u_int32_t)
  69.     + sizeof(u_int32_t)
  70.     + sizeof(u_int32_t)
  71.     + sizeof(u_int32_t)
  72.     + sizeof(*pagelsn)
  73.     + sizeof(u_int32_t) + (key == NULL ? 0 : key->size)
  74.     + sizeof(u_int32_t) + (data == NULL ? 0 : data->size);
  75. if (CRYPTO_ON(dbenv)) {
  76. npad =
  77.     ((DB_CIPHER *)dbenv->crypto_handle)->adj_size(logrec.size);
  78. logrec.size += npad;
  79. }
  81. if ((ret = __os_malloc(dbenv,
  82.     logrec.size, &logrec.data)) != 0)
  83. return (ret);
  85. if (npad > 0)
  86. memset((u_int8_t *)logrec.data + logrec.size - npad, 0, npad);
  88. bp = logrec.data;
  90. memcpy(bp, &rectype, sizeof(rectype));
  91. bp += sizeof(rectype);
  93. memcpy(bp, &txn_num, sizeof(txn_num));
  94. bp += sizeof(txn_num);
  96. memcpy(bp, lsnp, sizeof(DB_LSN));
  97. bp += sizeof(DB_LSN);
  99. uinttmp = (u_int32_t)opcode;
  100. memcpy(bp, &uinttmp, sizeof(uinttmp));
  101. bp += sizeof(uinttmp);
  103. DB_ASSERT(dbp->log_filename != NULL);
  104. if (dbp->log_filename->id == DB_LOGFILEID_INVALID &&
  105.     (ret = __dbreg_lazy_id(dbp)) != 0)
  106. return (ret);
  108. uinttmp = (u_int32_t)dbp->log_filename->id;
  109. memcpy(bp, &uinttmp, sizeof(uinttmp));
  110. bp += sizeof(uinttmp);
  112. uinttmp = (u_int32_t)pgno;
  113. memcpy(bp, &uinttmp, sizeof(uinttmp));
  114. bp += sizeof(uinttmp);
  116. uinttmp = (u_int32_t)ndx;
  117. memcpy(bp, &uinttmp, sizeof(uinttmp));
  118. bp += sizeof(uinttmp);
  120. if (pagelsn != NULL)
  121. memcpy(bp, pagelsn, sizeof(*pagelsn));
  122. else
  123. memset(bp, 0, sizeof(*pagelsn));
  124. bp += sizeof(*pagelsn);
  126. if (key == NULL) {
  127. zero = 0;
  128. memcpy(bp, &zero, sizeof(u_int32_t));
  129. bp += sizeof(u_int32_t);
  130. } else {
  131. memcpy(bp, &key->size, sizeof(key->size));
  132. bp += sizeof(key->size);
  133. memcpy(bp, key->data, key->size);
  134. bp += key->size;
  135. }
  137. if (data == NULL) {
  138. zero = 0;
  139. memcpy(bp, &zero, sizeof(u_int32_t));
  140. bp += sizeof(u_int32_t);
  141. } else {
  142. memcpy(bp, &data->size, sizeof(data->size));
  143. bp += sizeof(data->size);
  144. memcpy(bp, data->data, data->size);
  145. bp += data->size;
  146. }
  148. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
  149. ret = dbenv->log_put(dbenv,
  150.    ret_lsnp, (DBT *)&logrec, flags | DB_NOCOPY);
  151. if (txnid != NULL && ret == 0)
  152. txnid->last_lsn = *ret_lsnp;
  153. #ifdef LOG_DIAGNOSTIC
  154. if (ret != 0)
  155. (void)__ham_insdel_print(dbenv,
  156.     (DBT *)&logrec, ret_lsnp, NULL, NULL);
  157. #endif
  158. __os_free(dbenv, logrec.data);
  159. return (ret);
  160. }
  162. /*
  163.  * PUBLIC: int __ham_insdel_getpgnos __P((DB_ENV *, DBT *, DB_LSN *,
  164.  * PUBLIC:     db_recops, void *));
  165.  */
  166. int
  167. __ham_insdel_getpgnos(dbenv, rec, lsnp, notused1, summary)
  168. DB_ENV *dbenv;
  169. DBT *rec;
  170. DB_LSN *lsnp;
  171. db_recops notused1;
  172. void *summary;
  173. {
  174. DB *dbp;
  175. TXN_RECS *t;
  176. __ham_insdel_args *argp;
  177. u_int32_t ret;
  179. COMPQUIET(notused1, DB_TXN_ABORT);
  181. argp = NULL;
  182. t = (TXN_RECS *)summary;
  184. if ((ret = __ham_insdel_read(dbenv, rec->data, &argp)) != 0)
  185. return (ret);
  187. if ((ret = __dbreg_id_to_db(dbenv,
  188.     argp->txnid, &dbp, argp->fileid, 0)) != 0)
  189. goto err;
  191. if ((ret = __rep_check_alloc(dbenv, t, 1)) != 0)
  192. goto err;
  194. t->array[t->npages].flags = 0;
  195. t->array[t->npages].fid = argp->fileid;
  196. t->array[t->npages].lsn = *lsnp;
  197. t->array[t->npages].pgdesc.pgno = argp->pgno;
  198. t->array[t->npages].pgdesc.type = DB_PAGE_LOCK;
  199. memcpy(t->array[t->npages].pgdesc.fileid, dbp->fileid,
  200.     DB_FILE_ID_LEN);
  201. t->npages++;
  203. err: if (argp != NULL)
  204. __os_free(dbenv, argp);
  205. return (ret);
  206. }
  208. /*
  209.  * PUBLIC: int __ham_insdel_print __P((DB_ENV *, DBT *, DB_LSN *,
  210.  * PUBLIC:     db_recops, void *));
  211.  */
  212. int
  213. __ham_insdel_print(dbenv, dbtp, lsnp, notused2, notused3)
  214. DB_ENV *dbenv;
  215. DBT *dbtp;
  216. DB_LSN *lsnp;
  217. db_recops notused2;
  218. void *notused3;
  219. {
  220. __ham_insdel_args *argp;
  221. u_int32_t i;
  222. int ch;
  223. int ret;
  225. notused2 = DB_TXN_ABORT;
  226. notused3 = NULL;
  228. if ((ret = __ham_insdel_read(dbenv, dbtp->data, &argp)) != 0)
  229. return (ret);
  230. (void)printf(
  231.     "[%lu][%lu]__ham_insdel: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  232.     (u_long)lsnp->file,
  233.     (u_long)lsnp->offset,
  234.     (u_long)argp->type,
  235.     (u_long)argp->txnid->txnid,
  236.     (u_long)argp->prev_lsn.file,
  237.     (u_long)argp->prev_lsn.offset);
  238. (void)printf("topcode: %lun", (u_long)argp->opcode);
  239. (void)printf("tfileid: %ldn", (long)argp->fileid);
  240. (void)printf("tpgno: %lun", (u_long)argp->pgno);
  241. (void)printf("tndx: %lun", (u_long)argp->ndx);
  242. (void)printf("tpagelsn: [%lu][%lu]n",
  243.     (u_long)argp->pagelsn.file, (u_long)argp->pagelsn.offset);
  244. (void)printf("tkey: ");
  245. for (i = 0; i < argp->key.size; i++) {
  246. ch = ((u_int8_t *)argp->key.data)[i];
  247. printf(isprint(ch) || ch == 0x0a ? "%c" : "%#x ", ch);
  248. }
  249. (void)printf("n");
  250. (void)printf("tdata: ");
  251. for (i = 0; i < argp->data.size; i++) {
  252. ch = ((u_int8_t *)argp->data.data)[i];
  253. printf(isprint(ch) || ch == 0x0a ? "%c" : "%#x ", ch);
  254. }
  255. (void)printf("n");
  256. (void)printf("n");
  257. __os_free(dbenv, argp);
  258. return (0);
  259. }
  261. /*
  262.  * PUBLIC: int __ham_insdel_read __P((DB_ENV *, void *, __ham_insdel_args **));
  263.  */
  264. int
  265. __ham_insdel_read(dbenv, recbuf, argpp)
  266. DB_ENV *dbenv;
  267. void *recbuf;
  268. __ham_insdel_args **argpp;
  269. {
  270. __ham_insdel_args *argp;
  271. u_int32_t uinttmp;
  272. u_int8_t *bp;
  273. int ret;
  275. if ((ret = __os_malloc(dbenv,
  276.     sizeof(__ham_insdel_args) + sizeof(DB_TXN), &argp)) != 0)
  277. return (ret);
  279. argp->txnid = (DB_TXN *)&argp[1];
  281. bp = recbuf;
  282. memcpy(&argp->type, bp, sizeof(argp->type));
  283. bp += sizeof(argp->type);
  285. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  286. bp += sizeof(argp->txnid->txnid);
  288. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  289. bp += sizeof(DB_LSN);
  291. memcpy(&uinttmp, bp, sizeof(uinttmp));
  292. argp->opcode = (u_int32_t)uinttmp;
  293. bp += sizeof(uinttmp);
  295. memcpy(&uinttmp, bp, sizeof(uinttmp));
  296. argp->fileid = (int32_t)uinttmp;
  297. bp += sizeof(uinttmp);
  299. memcpy(&uinttmp, bp, sizeof(uinttmp));
  300. argp->pgno = (db_pgno_t)uinttmp;
  301. bp += sizeof(uinttmp);
  303. memcpy(&uinttmp, bp, sizeof(uinttmp));
  304. argp->ndx = (u_int32_t)uinttmp;
  305. bp += sizeof(uinttmp);
  307. memcpy(&argp->pagelsn, bp,  sizeof(argp->pagelsn));
  308. bp += sizeof(argp->pagelsn);
  310. memset(&argp->key, 0, sizeof(argp->key));
  311. memcpy(&argp->key.size, bp, sizeof(u_int32_t));
  312. bp += sizeof(u_int32_t);
  313. argp->key.data = bp;
  314. bp += argp->key.size;
  316. memset(&argp->data, 0, sizeof(argp->data));
  317. memcpy(&argp->data.size, bp, sizeof(u_int32_t));
  318. bp += sizeof(u_int32_t);
  319. argp->data.data = bp;
  320. bp += argp->data.size;
  322. *argpp = argp;
  323. return (0);
  324. }
  326. /*
  327.  * PUBLIC: int __ham_newpage_log __P((DB *, DB_TXN *, DB_LSN *,
  328.  * PUBLIC:     u_int32_t, u_int32_t, db_pgno_t, DB_LSN *, db_pgno_t, DB_LSN *,
  329.  * PUBLIC:     db_pgno_t, DB_LSN *));
  330.  */
  331. int
  332. __ham_newpage_log(dbp, txnid, ret_lsnp, flags,
  333.     opcode, prev_pgno, prevlsn, new_pgno, pagelsn,
  334.     next_pgno, nextlsn)
  335. DB *dbp;
  336. DB_TXN *txnid;
  337. DB_LSN *ret_lsnp;
  338. u_int32_t flags;
  339. u_int32_t opcode;
  340. db_pgno_t prev_pgno;
  341. DB_LSN * prevlsn;
  342. db_pgno_t new_pgno;
  343. DB_LSN * pagelsn;
  344. db_pgno_t next_pgno;
  345. DB_LSN * nextlsn;
  346. {
  347. DBT logrec;
  348. DB_ENV *dbenv;
  349. DB_LSN *lsnp, null_lsn;
  350. u_int32_t uinttmp;
  351. u_int32_t npad, rectype, txn_num;
  352. int ret;
  353. u_int8_t *bp;
  355. dbenv = dbp->dbenv;
  356. rectype = DB___ham_newpage;
  357. npad = 0;
  359. if (txnid == NULL) {
  360. txn_num = 0;
  361. null_lsn.file = 0;
  362. null_lsn.offset = 0;
  363. lsnp = &null_lsn;
  364. } else {
  365. if (TAILQ_FIRST(&txnid->kids) != NULL &&
  366.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  367. return (ret);
  368. txn_num = txnid->txnid;
  369. lsnp = &txnid->last_lsn;
  370. }
  372. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  373.     + sizeof(u_int32_t)
  374.     + sizeof(u_int32_t)
  375.     + sizeof(u_int32_t)
  376.     + sizeof(*prevlsn)
  377.     + sizeof(u_int32_t)
  378.     + sizeof(*pagelsn)
  379.     + sizeof(u_int32_t)
  380.     + sizeof(*nextlsn);
  381. if (CRYPTO_ON(dbenv)) {
  382. npad =
  383.     ((DB_CIPHER *)dbenv->crypto_handle)->adj_size(logrec.size);
  384. logrec.size += npad;
  385. }
  387. if ((ret = __os_malloc(dbenv,
  388.     logrec.size, &logrec.data)) != 0)
  389. return (ret);
  391. if (npad > 0)
  392. memset((u_int8_t *)logrec.data + logrec.size - npad, 0, npad);
  394. bp = logrec.data;
  396. memcpy(bp, &rectype, sizeof(rectype));
  397. bp += sizeof(rectype);
  399. memcpy(bp, &txn_num, sizeof(txn_num));
  400. bp += sizeof(txn_num);
  402. memcpy(bp, lsnp, sizeof(DB_LSN));
  403. bp += sizeof(DB_LSN);
  405. uinttmp = (u_int32_t)opcode;
  406. memcpy(bp, &uinttmp, sizeof(uinttmp));
  407. bp += sizeof(uinttmp);
  409. DB_ASSERT(dbp->log_filename != NULL);
  410. if (dbp->log_filename->id == DB_LOGFILEID_INVALID &&
  411.     (ret = __dbreg_lazy_id(dbp)) != 0)
  412. return (ret);
  414. uinttmp = (u_int32_t)dbp->log_filename->id;
  415. memcpy(bp, &uinttmp, sizeof(uinttmp));
  416. bp += sizeof(uinttmp);
  418. uinttmp = (u_int32_t)prev_pgno;
  419. memcpy(bp, &uinttmp, sizeof(uinttmp));
  420. bp += sizeof(uinttmp);
  422. if (prevlsn != NULL)
  423. memcpy(bp, prevlsn, sizeof(*prevlsn));
  424. else
  425. memset(bp, 0, sizeof(*prevlsn));
  426. bp += sizeof(*prevlsn);
  428. uinttmp = (u_int32_t)new_pgno;
  429. memcpy(bp, &uinttmp, sizeof(uinttmp));
  430. bp += sizeof(uinttmp);
  432. if (pagelsn != NULL)
  433. memcpy(bp, pagelsn, sizeof(*pagelsn));
  434. else
  435. memset(bp, 0, sizeof(*pagelsn));
  436. bp += sizeof(*pagelsn);
  438. uinttmp = (u_int32_t)next_pgno;
  439. memcpy(bp, &uinttmp, sizeof(uinttmp));
  440. bp += sizeof(uinttmp);
  442. if (nextlsn != NULL)
  443. memcpy(bp, nextlsn, sizeof(*nextlsn));
  444. else
  445. memset(bp, 0, sizeof(*nextlsn));
  446. bp += sizeof(*nextlsn);
  448. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
  449. ret = dbenv->log_put(dbenv,
  450.    ret_lsnp, (DBT *)&logrec, flags | DB_NOCOPY);
  451. if (txnid != NULL && ret == 0)
  452. txnid->last_lsn = *ret_lsnp;
  453. #ifdef LOG_DIAGNOSTIC
  454. if (ret != 0)
  455. (void)__ham_newpage_print(dbenv,
  456.     (DBT *)&logrec, ret_lsnp, NULL, NULL);
  457. #endif
  458. __os_free(dbenv, logrec.data);
  459. return (ret);
  460. }
  462. /*
  463.  * PUBLIC: int __ham_newpage_getpgnos __P((DB_ENV *, DBT *, DB_LSN *,
  464.  * PUBLIC:     db_recops, void *));
  465.  */
  466. int
  467. __ham_newpage_getpgnos(dbenv, rec, lsnp, notused1, summary)
  468. DB_ENV *dbenv;
  469. DBT *rec;
  470. DB_LSN *lsnp;
  471. db_recops notused1;
  472. void *summary;
  473. {
  474. DB *dbp;
  475. TXN_RECS *t;
  476. __ham_newpage_args *argp;
  477. u_int32_t ret;
  479. COMPQUIET(notused1, DB_TXN_ABORT);
  481. argp = NULL;
  482. t = (TXN_RECS *)summary;
  484. if ((ret = __ham_newpage_read(dbenv, rec->data, &argp)) != 0)
  485. return (ret);
  487. if ((ret = __dbreg_id_to_db(dbenv,
  488.     argp->txnid, &dbp, argp->fileid, 0)) != 0)
  489. goto err;
  491. if ((ret = __rep_check_alloc(dbenv, t, 3)) != 0)
  492. goto err;
  494. if (argp->prev_pgno != PGNO_INVALID) {
  495. t->array[t->npages].flags = 0;
  496. t->array[t->npages].fid = argp->fileid;
  497. t->array[t->npages].lsn = *lsnp;
  498. t->array[t->npages].pgdesc.pgno = argp->prev_pgno;
  499. t->array[t->npages].pgdesc.type = DB_PAGE_LOCK;
  500. memcpy(t->array[t->npages].pgdesc.fileid, dbp->fileid,
  501.     DB_FILE_ID_LEN);
  502. t->npages++;
  503. }
  504. if (argp->new_pgno != PGNO_INVALID) {
  505. t->array[t->npages].flags = 0;
  506. t->array[t->npages].fid = argp->fileid;
  507. t->array[t->npages].lsn = *lsnp;
  508. t->array[t->npages].pgdesc.pgno = argp->new_pgno;
  509. t->array[t->npages].pgdesc.type = DB_PAGE_LOCK;
  510. memcpy(t->array[t->npages].pgdesc.fileid, dbp->fileid,
  511.     DB_FILE_ID_LEN);
  512. t->npages++;
  513. }
  514. if (argp->next_pgno != PGNO_INVALID) {
  515. t->array[t->npages].flags = 0;
  516. t->array[t->npages].fid = argp->fileid;
  517. t->array[t->npages].lsn = *lsnp;
  518. t->array[t->npages].pgdesc.pgno = argp->next_pgno;
  519. t->array[t->npages].pgdesc.type = DB_PAGE_LOCK;
  520. memcpy(t->array[t->npages].pgdesc.fileid, dbp->fileid,
  521.     DB_FILE_ID_LEN);
  522. t->npages++;
  523. }
  525. err: if (argp != NULL)
  526. __os_free(dbenv, argp);
  527. return (ret);
  528. }
  530. /*
  531.  * PUBLIC: int __ham_newpage_print __P((DB_ENV *, DBT *, DB_LSN *,
  532.  * PUBLIC:     db_recops, void *));
  533.  */
  534. int
  535. __ham_newpage_print(dbenv, dbtp, lsnp, notused2, notused3)
  536. DB_ENV *dbenv;
  537. DBT *dbtp;
  538. DB_LSN *lsnp;
  539. db_recops notused2;
  540. void *notused3;
  541. {
  542. __ham_newpage_args *argp;
  543. int ret;
  545. notused2 = DB_TXN_ABORT;
  546. notused3 = NULL;
  548. if ((ret = __ham_newpage_read(dbenv, dbtp->data, &argp)) != 0)
  549. return (ret);
  550. (void)printf(
  551.     "[%lu][%lu]__ham_newpage: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  552.     (u_long)lsnp->file,
  553.     (u_long)lsnp->offset,
  554.     (u_long)argp->type,
  555.     (u_long)argp->txnid->txnid,
  556.     (u_long)argp->prev_lsn.file,
  557.     (u_long)argp->prev_lsn.offset);
  558. (void)printf("topcode: %lun", (u_long)argp->opcode);
  559. (void)printf("tfileid: %ldn", (long)argp->fileid);
  560. (void)printf("tprev_pgno: %lun", (u_long)argp->prev_pgno);
  561. (void)printf("tprevlsn: [%lu][%lu]n",
  562.     (u_long)argp->prevlsn.file, (u_long)argp->prevlsn.offset);
  563. (void)printf("tnew_pgno: %lun", (u_long)argp->new_pgno);
  564. (void)printf("tpagelsn: [%lu][%lu]n",
  565.     (u_long)argp->pagelsn.file, (u_long)argp->pagelsn.offset);
  566. (void)printf("tnext_pgno: %lun", (u_long)argp->next_pgno);
  567. (void)printf("tnextlsn: [%lu][%lu]n",
  568.     (u_long)argp->nextlsn.file, (u_long)argp->nextlsn.offset);
  569. (void)printf("n");
  570. __os_free(dbenv, argp);
  571. return (0);
  572. }
  574. /*
  575.  * PUBLIC: int __ham_newpage_read __P((DB_ENV *, void *,
  576.  * PUBLIC:     __ham_newpage_args **));
  577.  */
  578. int
  579. __ham_newpage_read(dbenv, recbuf, argpp)
  580. DB_ENV *dbenv;
  581. void *recbuf;
  582. __ham_newpage_args **argpp;
  583. {
  584. __ham_newpage_args *argp;
  585. u_int32_t uinttmp;
  586. u_int8_t *bp;
  587. int ret;
  589. if ((ret = __os_malloc(dbenv,
  590.     sizeof(__ham_newpage_args) + sizeof(DB_TXN), &argp)) != 0)
  591. return (ret);
  593. argp->txnid = (DB_TXN *)&argp[1];
  595. bp = recbuf;
  596. memcpy(&argp->type, bp, sizeof(argp->type));
  597. bp += sizeof(argp->type);
  599. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  600. bp += sizeof(argp->txnid->txnid);
  602. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  603. bp += sizeof(DB_LSN);
  605. memcpy(&uinttmp, bp, sizeof(uinttmp));
  606. argp->opcode = (u_int32_t)uinttmp;
  607. bp += sizeof(uinttmp);
  609. memcpy(&uinttmp, bp, sizeof(uinttmp));
  610. argp->fileid = (int32_t)uinttmp;
  611. bp += sizeof(uinttmp);
  613. memcpy(&uinttmp, bp, sizeof(uinttmp));
  614. argp->prev_pgno = (db_pgno_t)uinttmp;
  615. bp += sizeof(uinttmp);
  617. memcpy(&argp->prevlsn, bp,  sizeof(argp->prevlsn));
  618. bp += sizeof(argp->prevlsn);
  620. memcpy(&uinttmp, bp, sizeof(uinttmp));
  621. argp->new_pgno = (db_pgno_t)uinttmp;
  622. bp += sizeof(uinttmp);
  624. memcpy(&argp->pagelsn, bp,  sizeof(argp->pagelsn));
  625. bp += sizeof(argp->pagelsn);
  627. memcpy(&uinttmp, bp, sizeof(uinttmp));
  628. argp->next_pgno = (db_pgno_t)uinttmp;
  629. bp += sizeof(uinttmp);
  631. memcpy(&argp->nextlsn, bp,  sizeof(argp->nextlsn));
  632. bp += sizeof(argp->nextlsn);
  634. *argpp = argp;
  635. return (0);
  636. }
  638. /*
  639.  * PUBLIC: int __ham_splitdata_log __P((DB *, DB_TXN *, DB_LSN *,
  640.  * PUBLIC:     u_int32_t, u_int32_t, db_pgno_t, const DBT *, DB_LSN *));
  641.  */
  642. int
  643. __ham_splitdata_log(dbp, txnid, ret_lsnp, flags, opcode, pgno, pageimage, pagelsn)
  644. DB *dbp;
  645. DB_TXN *txnid;
  646. DB_LSN *ret_lsnp;
  647. u_int32_t flags;
  648. u_int32_t opcode;
  649. db_pgno_t pgno;
  650. const DBT *pageimage;
  651. DB_LSN * pagelsn;
  652. {
  653. DBT logrec;
  654. DB_ENV *dbenv;
  655. DB_LSN *lsnp, null_lsn;
  656. u_int32_t zero;
  657. u_int32_t uinttmp;
  658. u_int32_t npad, rectype, txn_num;
  659. int ret;
  660. u_int8_t *bp;
  662. dbenv = dbp->dbenv;
  663. rectype = DB___ham_splitdata;
  664. npad = 0;
  666. if (txnid == NULL) {
  667. txn_num = 0;
  668. null_lsn.file = 0;
  669. null_lsn.offset = 0;
  670. lsnp = &null_lsn;
  671. } else {
  672. if (TAILQ_FIRST(&txnid->kids) != NULL &&
  673.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  674. return (ret);
  675. txn_num = txnid->txnid;
  676. lsnp = &txnid->last_lsn;
  677. }
  679. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  680.     + sizeof(u_int32_t)
  681.     + sizeof(u_int32_t)
  682.     + sizeof(u_int32_t)
  683.     + sizeof(u_int32_t) + (pageimage == NULL ? 0 : pageimage->size)
  684.     + sizeof(*pagelsn);
  685. if (CRYPTO_ON(dbenv)) {
  686. npad =
  687.     ((DB_CIPHER *)dbenv->crypto_handle)->adj_size(logrec.size);
  688. logrec.size += npad;
  689. }
  691. if ((ret = __os_malloc(dbenv,
  692.     logrec.size, &logrec.data)) != 0)
  693. return (ret);
  695. if (npad > 0)
  696. memset((u_int8_t *)logrec.data + logrec.size - npad, 0, npad);
  698. bp = logrec.data;
  700. memcpy(bp, &rectype, sizeof(rectype));
  701. bp += sizeof(rectype);
  703. memcpy(bp, &txn_num, sizeof(txn_num));
  704. bp += sizeof(txn_num);
  706. memcpy(bp, lsnp, sizeof(DB_LSN));
  707. bp += sizeof(DB_LSN);
  709. DB_ASSERT(dbp->log_filename != NULL);
  710. if (dbp->log_filename->id == DB_LOGFILEID_INVALID &&
  711.     (ret = __dbreg_lazy_id(dbp)) != 0)
  712. return (ret);
  714. uinttmp = (u_int32_t)dbp->log_filename->id;
  715. memcpy(bp, &uinttmp, sizeof(uinttmp));
  716. bp += sizeof(uinttmp);
  718. uinttmp = (u_int32_t)opcode;
  719. memcpy(bp, &uinttmp, sizeof(uinttmp));
  720. bp += sizeof(uinttmp);
  722. uinttmp = (u_int32_t)pgno;
  723. memcpy(bp, &uinttmp, sizeof(uinttmp));
  724. bp += sizeof(uinttmp);
  726. if (pageimage == NULL) {
  727. zero = 0;
  728. memcpy(bp, &zero, sizeof(u_int32_t));
  729. bp += sizeof(u_int32_t);
  730. } else {
  731. memcpy(bp, &pageimage->size, sizeof(pageimage->size));
  732. bp += sizeof(pageimage->size);
  733. memcpy(bp, pageimage->data, pageimage->size);
  734. bp += pageimage->size;
  735. }
  737. if (pagelsn != NULL)
  738. memcpy(bp, pagelsn, sizeof(*pagelsn));
  739. else
  740. memset(bp, 0, sizeof(*pagelsn));
  741. bp += sizeof(*pagelsn);
  743. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
  744. ret = dbenv->log_put(dbenv,
  745.    ret_lsnp, (DBT *)&logrec, flags | DB_NOCOPY);
  746. if (txnid != NULL && ret == 0)
  747. txnid->last_lsn = *ret_lsnp;
  748. #ifdef LOG_DIAGNOSTIC
  749. if (ret != 0)
  750. (void)__ham_splitdata_print(dbenv,
  751.     (DBT *)&logrec, ret_lsnp, NULL, NULL);
  752. #endif
  753. __os_free(dbenv, logrec.data);
  754. return (ret);
  755. }
  757. /*
  758.  * PUBLIC: int __ham_splitdata_getpgnos __P((DB_ENV *, DBT *,
  759.  * PUBLIC:     DB_LSN *, db_recops, void *));
  760.  */
  761. int
  762. __ham_splitdata_getpgnos(dbenv, rec, lsnp, notused1, summary)
  763. DB_ENV *dbenv;
  764. DBT *rec;
  765. DB_LSN *lsnp;
  766. db_recops notused1;
  767. void *summary;
  768. {
  769. DB *dbp;
  770. TXN_RECS *t;
  771. __ham_splitdata_args *argp;
  772. u_int32_t ret;
  774. COMPQUIET(notused1, DB_TXN_ABORT);
  776. argp = NULL;
  777. t = (TXN_RECS *)summary;
  779. if ((ret = __ham_splitdata_read(dbenv, rec->data, &argp)) != 0)
  780. return (ret);
  782. if ((ret = __dbreg_id_to_db(dbenv,
  783.     argp->txnid, &dbp, argp->fileid, 0)) != 0)
  784. goto err;
  786. if ((ret = __rep_check_alloc(dbenv, t, 1)) != 0)
  787. goto err;
  789. t->array[t->npages].flags = 0;
  790. t->array[t->npages].fid = argp->fileid;
  791. t->array[t->npages].lsn = *lsnp;
  792. t->array[t->npages].pgdesc.pgno = argp->pgno;
  793. t->array[t->npages].pgdesc.type = DB_PAGE_LOCK;
  794. memcpy(t->array[t->npages].pgdesc.fileid, dbp->fileid,
  795.     DB_FILE_ID_LEN);
  796. t->npages++;
  798. err: if (argp != NULL)
  799. __os_free(dbenv, argp);
  800. return (ret);
  801. }
  803. /*
  804.  * PUBLIC: int __ham_splitdata_print __P((DB_ENV *, DBT *, DB_LSN *,
  805.  * PUBLIC:     db_recops, void *));
  806.  */
  807. int
  808. __ham_splitdata_print(dbenv, dbtp, lsnp, notused2, notused3)
  809. DB_ENV *dbenv;
  810. DBT *dbtp;
  811. DB_LSN *lsnp;
  812. db_recops notused2;
  813. void *notused3;
  814. {
  815. __ham_splitdata_args *argp;
  816. u_int32_t i;
  817. int ch;
  818. int ret;
  820. notused2 = DB_TXN_ABORT;
  821. notused3 = NULL;
  823. if ((ret = __ham_splitdata_read(dbenv, dbtp->data, &argp)) != 0)
  824. return (ret);
  825. (void)printf(
  826.     "[%lu][%lu]__ham_splitdata: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  827.     (u_long)lsnp->file,
  828.     (u_long)lsnp->offset,
  829.     (u_long)argp->type,
  830.     (u_long)argp->txnid->txnid,
  831.     (u_long)argp->prev_lsn.file,
  832.     (u_long)argp->prev_lsn.offset);
  833. (void)printf("tfileid: %ldn", (long)argp->fileid);
  834. (void)printf("topcode: %lun", (u_long)argp->opcode);
  835. (void)printf("tpgno: %lun", (u_long)argp->pgno);
  836. (void)printf("tpageimage: ");
  837. for (i = 0; i < argp->pageimage.size; i++) {
  838. ch = ((u_int8_t *)argp->pageimage.data)[i];
  839. printf(isprint(ch) || ch == 0x0a ? "%c" : "%#x ", ch);
  840. }
  841. (void)printf("n");
  842. (void)printf("tpagelsn: [%lu][%lu]n",
  843.     (u_long)argp->pagelsn.file, (u_long)argp->pagelsn.offset);
  844. (void)printf("n");
  845. __os_free(dbenv, argp);
  846. return (0);
  847. }
  849. /*
  850.  * PUBLIC: int __ham_splitdata_read __P((DB_ENV *, void *,
  851.  * PUBLIC:     __ham_splitdata_args **));
  852.  */
  853. int
  854. __ham_splitdata_read(dbenv, recbuf, argpp)
  855. DB_ENV *dbenv;
  856. void *recbuf;
  857. __ham_splitdata_args **argpp;
  858. {
  859. __ham_splitdata_args *argp;
  860. u_int32_t uinttmp;
  861. u_int8_t *bp;
  862. int ret;
  864. if ((ret = __os_malloc(dbenv,
  865.     sizeof(__ham_splitdata_args) + sizeof(DB_TXN), &argp)) != 0)
  866. return (ret);
  868. argp->txnid = (DB_TXN *)&argp[1];
  870. bp = recbuf;
  871. memcpy(&argp->type, bp, sizeof(argp->type));
  872. bp += sizeof(argp->type);
  874. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  875. bp += sizeof(argp->txnid->txnid);
  877. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  878. bp += sizeof(DB_LSN);
  880. memcpy(&uinttmp, bp, sizeof(uinttmp));
  881. argp->fileid = (int32_t)uinttmp;
  882. bp += sizeof(uinttmp);
  884. memcpy(&uinttmp, bp, sizeof(uinttmp));
  885. argp->opcode = (u_int32_t)uinttmp;
  886. bp += sizeof(uinttmp);
  888. memcpy(&uinttmp, bp, sizeof(uinttmp));
  889. argp->pgno = (db_pgno_t)uinttmp;
  890. bp += sizeof(uinttmp);
  892. memset(&argp->pageimage, 0, sizeof(argp->pageimage));
  893. memcpy(&argp->pageimage.size, bp, sizeof(u_int32_t));
  894. bp += sizeof(u_int32_t);
  895. argp->pageimage.data = bp;
  896. bp += argp->pageimage.size;
  898. memcpy(&argp->pagelsn, bp,  sizeof(argp->pagelsn));
  899. bp += sizeof(argp->pagelsn);
  901. *argpp = argp;
  902. return (0);
  903. }
  905. /*
  906.  * PUBLIC: int __ham_replace_log __P((DB *, DB_TXN *, DB_LSN *,
  907.  * PUBLIC:     u_int32_t, db_pgno_t, u_int32_t, DB_LSN *, int32_t, const DBT *,
  908.  * PUBLIC:     const DBT *, u_int32_t));
  909.  */
  910. int
  911. __ham_replace_log(dbp, txnid, ret_lsnp, flags, pgno, ndx, pagelsn, off, olditem,
  912.     newitem, makedup)
  913. DB *dbp;
  914. DB_TXN *txnid;
  915. DB_LSN *ret_lsnp;
  916. u_int32_t flags;
  917. db_pgno_t pgno;
  918. u_int32_t ndx;
  919. DB_LSN * pagelsn;
  920. int32_t off;
  921. const DBT *olditem;
  922. const DBT *newitem;
  923. u_int32_t makedup;
  924. {
  925. DBT logrec;
  926. DB_ENV *dbenv;
  927. DB_LSN *lsnp, null_lsn;
  928. u_int32_t zero;
  929. u_int32_t uinttmp;
  930. u_int32_t npad, rectype, txn_num;
  931. int ret;
  932. u_int8_t *bp;
  934. dbenv = dbp->dbenv;
  935. rectype = DB___ham_replace;
  936. npad = 0;
  938. if (txnid == NULL) {
  939. txn_num = 0;
  940. null_lsn.file = 0;
  941. null_lsn.offset = 0;
  942. lsnp = &null_lsn;
  943. } else {
  944. if (TAILQ_FIRST(&txnid->kids) != NULL &&
  945.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  946. return (ret);
  947. txn_num = txnid->txnid;
  948. lsnp = &txnid->last_lsn;
  949. }
  951. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  952.     + sizeof(u_int32_t)
  953.     + sizeof(u_int32_t)
  954.     + sizeof(u_int32_t)
  955.     + sizeof(*pagelsn)
  956.     + sizeof(u_int32_t)
  957.     + sizeof(u_int32_t) + (olditem == NULL ? 0 : olditem->size)
  958.     + sizeof(u_int32_t) + (newitem == NULL ? 0 : newitem->size)
  959.     + sizeof(u_int32_t);
  960. if (CRYPTO_ON(dbenv)) {
  961. npad =
  962.     ((DB_CIPHER *)dbenv->crypto_handle)->adj_size(logrec.size);
  963. logrec.size += npad;
  964. }
  966. if ((ret = __os_malloc(dbenv,
  967.     logrec.size, &logrec.data)) != 0)
  968. return (ret);
  970. if (npad > 0)
  971. memset((u_int8_t *)logrec.data + logrec.size - npad, 0, npad);
  973. bp = logrec.data;
  975. memcpy(bp, &rectype, sizeof(rectype));
  976. bp += sizeof(rectype);
  978. memcpy(bp, &txn_num, sizeof(txn_num));
  979. bp += sizeof(txn_num);
  981. memcpy(bp, lsnp, sizeof(DB_LSN));
  982. bp += sizeof(DB_LSN);
  984. DB_ASSERT(dbp->log_filename != NULL);
  985. if (dbp->log_filename->id == DB_LOGFILEID_INVALID &&
  986.     (ret = __dbreg_lazy_id(dbp)) != 0)
  987. return (ret);
  989. uinttmp = (u_int32_t)dbp->log_filename->id;
  990. memcpy(bp, &uinttmp, sizeof(uinttmp));
  991. bp += sizeof(uinttmp);
  993. uinttmp = (u_int32_t)pgno;
  994. memcpy(bp, &uinttmp, sizeof(uinttmp));
  995. bp += sizeof(uinttmp);
  997. uinttmp = (u_int32_t)ndx;
  998. memcpy(bp, &uinttmp, sizeof(uinttmp));
  999. bp += sizeof(uinttmp);
  1001. if (pagelsn != NULL)
  1002. memcpy(bp, pagelsn, sizeof(*pagelsn));
  1003. else
  1004. memset(bp, 0, sizeof(*pagelsn));
  1005. bp += sizeof(*pagelsn);
  1007. uinttmp = (u_int32_t)off;
  1008. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1009. bp += sizeof(uinttmp);
  1011. if (olditem == NULL) {
  1012. zero = 0;
  1013. memcpy(bp, &zero, sizeof(u_int32_t));
  1014. bp += sizeof(u_int32_t);
  1015. } else {
  1016. memcpy(bp, &olditem->size, sizeof(olditem->size));
  1017. bp += sizeof(olditem->size);
  1018. memcpy(bp, olditem->data, olditem->size);
  1019. bp += olditem->size;
  1020. }
  1022. if (newitem == NULL) {
  1023. zero = 0;
  1024. memcpy(bp, &zero, sizeof(u_int32_t));
  1025. bp += sizeof(u_int32_t);
  1026. } else {
  1027. memcpy(bp, &newitem->size, sizeof(newitem->size));
  1028. bp += sizeof(newitem->size);
  1029. memcpy(bp, newitem->data, newitem->size);
  1030. bp += newitem->size;
  1031. }
  1033. uinttmp = (u_int32_t)makedup;
  1034. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1035. bp += sizeof(uinttmp);
  1037. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
  1038. ret = dbenv->log_put(dbenv,
  1039.    ret_lsnp, (DBT *)&logrec, flags | DB_NOCOPY);
  1040. if (txnid != NULL && ret == 0)
  1041. txnid->last_lsn = *ret_lsnp;
  1042. #ifdef LOG_DIAGNOSTIC
  1043. if (ret != 0)
  1044. (void)__ham_replace_print(dbenv,
  1045.     (DBT *)&logrec, ret_lsnp, NULL, NULL);
  1046. #endif
  1047. __os_free(dbenv, logrec.data);
  1048. return (ret);
  1049. }
  1051. /*
  1052.  * PUBLIC: int __ham_replace_getpgnos __P((DB_ENV *, DBT *, DB_LSN *,
  1053.  * PUBLIC:     db_recops, void *));
  1054.  */
  1055. int
  1056. __ham_replace_getpgnos(dbenv, rec, lsnp, notused1, summary)
  1057. DB_ENV *dbenv;
  1058. DBT *rec;
  1059. DB_LSN *lsnp;
  1060. db_recops notused1;
  1061. void *summary;
  1062. {
  1063. DB *dbp;
  1064. TXN_RECS *t;
  1065. __ham_replace_args *argp;
  1066. u_int32_t ret;
  1068. COMPQUIET(notused1, DB_TXN_ABORT);
  1070. argp = NULL;
  1071. t = (TXN_RECS *)summary;
  1073. if ((ret = __ham_replace_read(dbenv, rec->data, &argp)) != 0)
  1074. return (ret);
  1076. if ((ret = __dbreg_id_to_db(dbenv,
  1077.     argp->txnid, &dbp, argp->fileid, 0)) != 0)
  1078. goto err;
  1080. if ((ret = __rep_check_alloc(dbenv, t, 1)) != 0)
  1081. goto err;
  1083. t->array[t->npages].flags = 0;
  1084. t->array[t->npages].fid = argp->fileid;
  1085. t->array[t->npages].lsn = *lsnp;
  1086. t->array[t->npages].pgdesc.pgno = argp->pgno;
  1087. t->array[t->npages].pgdesc.type = DB_PAGE_LOCK;
  1088. memcpy(t->array[t->npages].pgdesc.fileid, dbp->fileid,
  1089.     DB_FILE_ID_LEN);
  1090. t->npages++;
  1092. err: if (argp != NULL)
  1093. __os_free(dbenv, argp);
  1094. return (ret);
  1095. }
  1097. /*
  1098.  * PUBLIC: int __ham_replace_print __P((DB_ENV *, DBT *, DB_LSN *,
  1099.  * PUBLIC:     db_recops, void *));
  1100.  */
  1101. int
  1102. __ham_replace_print(dbenv, dbtp, lsnp, notused2, notused3)
  1103. DB_ENV *dbenv;
  1104. DBT *dbtp;
  1105. DB_LSN *lsnp;
  1106. db_recops notused2;
  1107. void *notused3;
  1108. {
  1109. __ham_replace_args *argp;
  1110. u_int32_t i;
  1111. int ch;
  1112. int ret;
  1114. notused2 = DB_TXN_ABORT;
  1115. notused3 = NULL;
  1117. if ((ret = __ham_replace_read(dbenv, dbtp->data, &argp)) != 0)
  1118. return (ret);
  1119. (void)printf(
  1120.     "[%lu][%lu]__ham_replace: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  1121.     (u_long)lsnp->file,
  1122.     (u_long)lsnp->offset,
  1123.     (u_long)argp->type,
  1124.     (u_long)argp->txnid->txnid,
  1125.     (u_long)argp->prev_lsn.file,
  1126.     (u_long)argp->prev_lsn.offset);
  1127. (void)printf("tfileid: %ldn", (long)argp->fileid);
  1128. (void)printf("tpgno: %lun", (u_long)argp->pgno);
  1129. (void)printf("tndx: %lun", (u_long)argp->ndx);
  1130. (void)printf("tpagelsn: [%lu][%lu]n",
  1131.     (u_long)argp->pagelsn.file, (u_long)argp->pagelsn.offset);
  1132. (void)printf("toff: %ldn", (long)argp->off);
  1133. (void)printf("tolditem: ");
  1134. for (i = 0; i < argp->olditem.size; i++) {
  1135. ch = ((u_int8_t *)argp->olditem.data)[i];
  1136. printf(isprint(ch) || ch == 0x0a ? "%c" : "%#x ", ch);
  1137. }
  1138. (void)printf("n");
  1139. (void)printf("tnewitem: ");
  1140. for (i = 0; i < argp->newitem.size; i++) {
  1141. ch = ((u_int8_t *)argp->newitem.data)[i];
  1142. printf(isprint(ch) || ch == 0x0a ? "%c" : "%#x ", ch);
  1143. }
  1144. (void)printf("n");
  1145. (void)printf("tmakedup: %lun", (u_long)argp->makedup);
  1146. (void)printf("n");
  1147. __os_free(dbenv, argp);
  1148. return (0);
  1149. }
  1151. /*
  1152.  * PUBLIC: int __ham_replace_read __P((DB_ENV *, void *,
  1153.  * PUBLIC:     __ham_replace_args **));
  1154.  */
  1155. int
  1156. __ham_replace_read(dbenv, recbuf, argpp)
  1157. DB_ENV *dbenv;
  1158. void *recbuf;
  1159. __ham_replace_args **argpp;
  1160. {
  1161. __ham_replace_args *argp;
  1162. u_int32_t uinttmp;
  1163. u_int8_t *bp;
  1164. int ret;
  1166. if ((ret = __os_malloc(dbenv,
  1167.     sizeof(__ham_replace_args) + sizeof(DB_TXN), &argp)) != 0)
  1168. return (ret);
  1170. argp->txnid = (DB_TXN *)&argp[1];
  1172. bp = recbuf;
  1173. memcpy(&argp->type, bp, sizeof(argp->type));
  1174. bp += sizeof(argp->type);
  1176. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  1177. bp += sizeof(argp->txnid->txnid);
  1179. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  1180. bp += sizeof(DB_LSN);
  1182. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1183. argp->fileid = (int32_t)uinttmp;
  1184. bp += sizeof(uinttmp);
  1186. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1187. argp->pgno = (db_pgno_t)uinttmp;
  1188. bp += sizeof(uinttmp);
  1190. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1191. argp->ndx = (u_int32_t)uinttmp;
  1192. bp += sizeof(uinttmp);
  1194. memcpy(&argp->pagelsn, bp,  sizeof(argp->pagelsn));
  1195. bp += sizeof(argp->pagelsn);
  1197. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1198. argp->off = (int32_t)uinttmp;
  1199. bp += sizeof(uinttmp);
  1201. memset(&argp->olditem, 0, sizeof(argp->olditem));
  1202. memcpy(&argp->olditem.size, bp, sizeof(u_int32_t));
  1203. bp += sizeof(u_int32_t);
  1204. argp->olditem.data = bp;
  1205. bp += argp->olditem.size;
  1207. memset(&argp->newitem, 0, sizeof(argp->newitem));
  1208. memcpy(&argp->newitem.size, bp, sizeof(u_int32_t));
  1209. bp += sizeof(u_int32_t);
  1210. argp->newitem.data = bp;
  1211. bp += argp->newitem.size;
  1213. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1214. argp->makedup = (u_int32_t)uinttmp;
  1215. bp += sizeof(uinttmp);
  1217. *argpp = argp;
  1218. return (0);
  1219. }
  1221. /*
  1222.  * PUBLIC: int __ham_copypage_log __P((DB *, DB_TXN *, DB_LSN *,
  1223.  * PUBLIC:     u_int32_t, db_pgno_t, DB_LSN *, db_pgno_t, DB_LSN *, db_pgno_t,
  1224.  * PUBLIC:     DB_LSN *, const DBT *));
  1225.  */
  1226. int
  1227. __ham_copypage_log(dbp, txnid, ret_lsnp, flags, pgno, pagelsn, next_pgno, nextlsn, nnext_pgno,
  1228.     nnextlsn, page)
  1229. DB *dbp;
  1230. DB_TXN *txnid;
  1231. DB_LSN *ret_lsnp;
  1232. u_int32_t flags;
  1233. db_pgno_t pgno;
  1234. DB_LSN * pagelsn;
  1235. db_pgno_t next_pgno;
  1236. DB_LSN * nextlsn;
  1237. db_pgno_t nnext_pgno;
  1238. DB_LSN * nnextlsn;
  1239. const DBT *page;
  1240. {
  1241. DBT logrec;
  1242. DB_ENV *dbenv;
  1243. DB_LSN *lsnp, null_lsn;
  1244. u_int32_t zero;
  1245. u_int32_t uinttmp;
  1246. u_int32_t npad, rectype, txn_num;
  1247. int ret;
  1248. u_int8_t *bp;
  1250. dbenv = dbp->dbenv;
  1251. rectype = DB___ham_copypage;
  1252. npad = 0;
  1254. if (txnid == NULL) {
  1255. txn_num = 0;
  1256. null_lsn.file = 0;
  1257. null_lsn.offset = 0;
  1258. lsnp = &null_lsn;
  1259. } else {
  1260. if (TAILQ_FIRST(&txnid->kids) != NULL &&
  1261.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  1262. return (ret);
  1263. txn_num = txnid->txnid;
  1264. lsnp = &txnid->last_lsn;
  1265. }
  1267. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  1268.     + sizeof(u_int32_t)
  1269.     + sizeof(u_int32_t)
  1270.     + sizeof(*pagelsn)
  1271.     + sizeof(u_int32_t)
  1272.     + sizeof(*nextlsn)
  1273.     + sizeof(u_int32_t)
  1274.     + sizeof(*nnextlsn)
  1275.     + sizeof(u_int32_t) + (page == NULL ? 0 : page->size);
  1276. if (CRYPTO_ON(dbenv)) {
  1277. npad =
  1278.     ((DB_CIPHER *)dbenv->crypto_handle)->adj_size(logrec.size);
  1279. logrec.size += npad;
  1280. }
  1282. if ((ret = __os_malloc(dbenv,
  1283.     logrec.size, &logrec.data)) != 0)
  1284. return (ret);
  1286. if (npad > 0)
  1287. memset((u_int8_t *)logrec.data + logrec.size - npad, 0, npad);
  1289. bp = logrec.data;
  1291. memcpy(bp, &rectype, sizeof(rectype));
  1292. bp += sizeof(rectype);
  1294. memcpy(bp, &txn_num, sizeof(txn_num));
  1295. bp += sizeof(txn_num);
  1297. memcpy(bp, lsnp, sizeof(DB_LSN));
  1298. bp += sizeof(DB_LSN);
  1300. DB_ASSERT(dbp->log_filename != NULL);
  1301. if (dbp->log_filename->id == DB_LOGFILEID_INVALID &&
  1302.     (ret = __dbreg_lazy_id(dbp)) != 0)
  1303. return (ret);
  1305. uinttmp = (u_int32_t)dbp->log_filename->id;
  1306. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1307. bp += sizeof(uinttmp);
  1309. uinttmp = (u_int32_t)pgno;
  1310. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1311. bp += sizeof(uinttmp);
  1313. if (pagelsn != NULL)
  1314. memcpy(bp, pagelsn, sizeof(*pagelsn));
  1315. else
  1316. memset(bp, 0, sizeof(*pagelsn));
  1317. bp += sizeof(*pagelsn);
  1319. uinttmp = (u_int32_t)next_pgno;
  1320. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1321. bp += sizeof(uinttmp);
  1323. if (nextlsn != NULL)
  1324. memcpy(bp, nextlsn, sizeof(*nextlsn));
  1325. else
  1326. memset(bp, 0, sizeof(*nextlsn));
  1327. bp += sizeof(*nextlsn);
  1329. uinttmp = (u_int32_t)nnext_pgno;
  1330. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1331. bp += sizeof(uinttmp);
  1333. if (nnextlsn != NULL)
  1334. memcpy(bp, nnextlsn, sizeof(*nnextlsn));
  1335. else
  1336. memset(bp, 0, sizeof(*nnextlsn));
  1337. bp += sizeof(*nnextlsn);
  1339. if (page == NULL) {
  1340. zero = 0;
  1341. memcpy(bp, &zero, sizeof(u_int32_t));
  1342. bp += sizeof(u_int32_t);
  1343. } else {
  1344. memcpy(bp, &page->size, sizeof(page->size));
  1345. bp += sizeof(page->size);
  1346. memcpy(bp, page->data, page->size);
  1347. bp += page->size;
  1348. }
  1350. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
  1351. ret = dbenv->log_put(dbenv,
  1352.    ret_lsnp, (DBT *)&logrec, flags | DB_NOCOPY);
  1353. if (txnid != NULL && ret == 0)
  1354. txnid->last_lsn = *ret_lsnp;
  1355. #ifdef LOG_DIAGNOSTIC
  1356. if (ret != 0)
  1357. (void)__ham_copypage_print(dbenv,
  1358.     (DBT *)&logrec, ret_lsnp, NULL, NULL);
  1359. #endif
  1360. __os_free(dbenv, logrec.data);
  1361. return (ret);
  1362. }
  1364. /*
  1365.  * PUBLIC: int __ham_copypage_getpgnos __P((DB_ENV *, DBT *,
  1366.  * PUBLIC:     DB_LSN *, db_recops, void *));
  1367.  */
  1368. int
  1369. __ham_copypage_getpgnos(dbenv, rec, lsnp, notused1, summary)
  1370. DB_ENV *dbenv;
  1371. DBT *rec;
  1372. DB_LSN *lsnp;
  1373. db_recops notused1;
  1374. void *summary;
  1375. {
  1376. DB *dbp;
  1377. TXN_RECS *t;
  1378. __ham_copypage_args *argp;
  1379. u_int32_t ret;
  1381. COMPQUIET(notused1, DB_TXN_ABORT);
  1383. argp = NULL;
  1384. t = (TXN_RECS *)summary;
  1386. if ((ret = __ham_copypage_read(dbenv, rec->data, &argp)) != 0)
  1387. return (ret);
  1389. if ((ret = __dbreg_id_to_db(dbenv,
  1390.     argp->txnid, &dbp, argp->fileid, 0)) != 0)
  1391. goto err;
  1393. if ((ret = __rep_check_alloc(dbenv, t, 3)) != 0)
  1394. goto err;
  1396. t->array[t->npages].flags = 0;
  1397. t->array[t->npages].fid = argp->fileid;
  1398. t->array[t->npages].lsn = *lsnp;
  1399. t->array[t->npages].pgdesc.pgno = argp->pgno;
  1400. t->array[t->npages].pgdesc.type = DB_PAGE_LOCK;
  1401. memcpy(t->array[t->npages].pgdesc.fileid, dbp->fileid,
  1402.     DB_FILE_ID_LEN);
  1403. t->npages++;
  1404. t->array[t->npages].flags = 0;
  1405. t->array[t->npages].fid = argp->fileid;
  1406. t->array[t->npages].lsn = *lsnp;
  1407. t->array[t->npages].pgdesc.pgno = argp->next_pgno;
  1408. t->array[t->npages].pgdesc.type = DB_PAGE_LOCK;
  1409. memcpy(t->array[t->npages].pgdesc.fileid, dbp->fileid,
  1410.     DB_FILE_ID_LEN);
  1411. t->npages++;
  1412. if (argp->nnext_pgno != PGNO_INVALID) {
  1413. t->array[t->npages].flags = 0;
  1414. t->array[t->npages].fid = argp->fileid;
  1415. t->array[t->npages].lsn = *lsnp;
  1416. t->array[t->npages].pgdesc.pgno = argp->nnext_pgno;
  1417. t->array[t->npages].pgdesc.type = DB_PAGE_LOCK;
  1418. memcpy(t->array[t->npages].pgdesc.fileid, dbp->fileid,
  1419.     DB_FILE_ID_LEN);
  1420. t->npages++;
  1421. }
  1423. err: if (argp != NULL)
  1424. __os_free(dbenv, argp);
  1425. return (ret);
  1426. }
  1428. /*
  1429.  * PUBLIC: int __ham_copypage_print __P((DB_ENV *, DBT *, DB_LSN *,
  1430.  * PUBLIC:     db_recops, void *));
  1431.  */
  1432. int
  1433. __ham_copypage_print(dbenv, dbtp, lsnp, notused2, notused3)
  1434. DB_ENV *dbenv;
  1435. DBT *dbtp;
  1436. DB_LSN *lsnp;
  1437. db_recops notused2;
  1438. void *notused3;
  1439. {
  1440. __ham_copypage_args *argp;
  1441. u_int32_t i;
  1442. int ch;
  1443. int ret;
  1445. notused2 = DB_TXN_ABORT;
  1446. notused3 = NULL;
  1448. if ((ret = __ham_copypage_read(dbenv, dbtp->data, &argp)) != 0)
  1449. return (ret);
  1450. (void)printf(
  1451.     "[%lu][%lu]__ham_copypage: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  1452.     (u_long)lsnp->file,
  1453.     (u_long)lsnp->offset,
  1454.     (u_long)argp->type,
  1455.     (u_long)argp->txnid->txnid,
  1456.     (u_long)argp->prev_lsn.file,
  1457.     (u_long)argp->prev_lsn.offset);
  1458. (void)printf("tfileid: %ldn", (long)argp->fileid);
  1459. (void)printf("tpgno: %lun", (u_long)argp->pgno);
  1460. (void)printf("tpagelsn: [%lu][%lu]n",
  1461.     (u_long)argp->pagelsn.file, (u_long)argp->pagelsn.offset);
  1462. (void)printf("tnext_pgno: %lun", (u_long)argp->next_pgno);
  1463. (void)printf("tnextlsn: [%lu][%lu]n",
  1464.     (u_long)argp->nextlsn.file, (u_long)argp->nextlsn.offset);
  1465. (void)printf("tnnext_pgno: %lun", (u_long)argp->nnext_pgno);
  1466. (void)printf("tnnextlsn: [%lu][%lu]n",
  1467.     (u_long)argp->nnextlsn.file, (u_long)argp->nnextlsn.offset);
  1468. (void)printf("tpage: ");
  1469. for (i = 0; i < argp->page.size; i++) {
  1470. ch = ((u_int8_t *)argp->page.data)[i];
  1471. printf(isprint(ch) || ch == 0x0a ? "%c" : "%#x ", ch);
  1472. }
  1473. (void)printf("n");
  1474. (void)printf("n");
  1475. __os_free(dbenv, argp);
  1476. return (0);
  1477. }
  1479. /*
  1480.  * PUBLIC: int __ham_copypage_read __P((DB_ENV *, void *,
  1481.  * PUBLIC:     __ham_copypage_args **));
  1482.  */
  1483. int
  1484. __ham_copypage_read(dbenv, recbuf, argpp)
  1485. DB_ENV *dbenv;
  1486. void *recbuf;
  1487. __ham_copypage_args **argpp;
  1488. {
  1489. __ham_copypage_args *argp;
  1490. u_int32_t uinttmp;
  1491. u_int8_t *bp;
  1492. int ret;
  1494. if ((ret = __os_malloc(dbenv,
  1495.     sizeof(__ham_copypage_args) + sizeof(DB_TXN), &argp)) != 0)
  1496. return (ret);
  1498. argp->txnid = (DB_TXN *)&argp[1];
  1500. bp = recbuf;
  1501. memcpy(&argp->type, bp, sizeof(argp->type));
  1502. bp += sizeof(argp->type);
  1504. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  1505. bp += sizeof(argp->txnid->txnid);
  1507. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  1508. bp += sizeof(DB_LSN);
  1510. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1511. argp->fileid = (int32_t)uinttmp;
  1512. bp += sizeof(uinttmp);
  1514. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1515. argp->pgno = (db_pgno_t)uinttmp;
  1516. bp += sizeof(uinttmp);
  1518. memcpy(&argp->pagelsn, bp,  sizeof(argp->pagelsn));
  1519. bp += sizeof(argp->pagelsn);
  1521. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1522. argp->next_pgno = (db_pgno_t)uinttmp;
  1523. bp += sizeof(uinttmp);
  1525. memcpy(&argp->nextlsn, bp,  sizeof(argp->nextlsn));
  1526. bp += sizeof(argp->nextlsn);
  1528. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1529. argp->nnext_pgno = (db_pgno_t)uinttmp;
  1530. bp += sizeof(uinttmp);
  1532. memcpy(&argp->nnextlsn, bp,  sizeof(argp->nnextlsn));
  1533. bp += sizeof(argp->nnextlsn);
  1535. memset(&argp->page, 0, sizeof(argp->page));
  1536. memcpy(&argp->page.size, bp, sizeof(u_int32_t));
  1537. bp += sizeof(u_int32_t);
  1538. argp->page.data = bp;
  1539. bp += argp->page.size;
  1541. *argpp = argp;
  1542. return (0);
  1543. }
  1545. /*
  1546.  * PUBLIC: int __ham_metagroup_log __P((DB *, DB_TXN *, DB_LSN *,
  1547.  * PUBLIC:     u_int32_t, u_int32_t, db_pgno_t, DB_LSN *, db_pgno_t, DB_LSN *,
  1548.  * PUBLIC:     db_pgno_t, DB_LSN *, u_int32_t));
  1549.  */
  1550. int
  1551. __ham_metagroup_log(dbp, txnid, ret_lsnp, flags, bucket, mmpgno, mmetalsn, mpgno, metalsn,
  1552.     pgno, pagelsn, newalloc)
  1553. DB *dbp;
  1554. DB_TXN *txnid;
  1555. DB_LSN *ret_lsnp;
  1556. u_int32_t flags;
  1557. u_int32_t bucket;
  1558. db_pgno_t mmpgno;
  1559. DB_LSN * mmetalsn;
  1560. db_pgno_t mpgno;
  1561. DB_LSN * metalsn;
  1562. db_pgno_t pgno;
  1563. DB_LSN * pagelsn;
  1564. u_int32_t newalloc;
  1565. {
  1566. DBT logrec;
  1567. DB_ENV *dbenv;
  1568. DB_LSN *lsnp, null_lsn;
  1569. u_int32_t uinttmp;
  1570. u_int32_t npad, rectype, txn_num;
  1571. int ret;
  1572. u_int8_t *bp;
  1574. dbenv = dbp->dbenv;
  1575. rectype = DB___ham_metagroup;
  1576. npad = 0;
  1578. if (txnid == NULL) {
  1579. txn_num = 0;
  1580. null_lsn.file = 0;
  1581. null_lsn.offset = 0;
  1582. lsnp = &null_lsn;
  1583. } else {
  1584. if (TAILQ_FIRST(&txnid->kids) != NULL &&
  1585.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  1586. return (ret);
  1587. txn_num = txnid->txnid;
  1588. lsnp = &txnid->last_lsn;
  1589. }
  1591. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  1592.     + sizeof(u_int32_t)
  1593.     + sizeof(u_int32_t)
  1594.     + sizeof(u_int32_t)
  1595.     + sizeof(*mmetalsn)
  1596.     + sizeof(u_int32_t)
  1597.     + sizeof(*metalsn)
  1598.     + sizeof(u_int32_t)
  1599.     + sizeof(*pagelsn)
  1600.     + sizeof(u_int32_t);
  1601. if (CRYPTO_ON(dbenv)) {
  1602. npad =
  1603.     ((DB_CIPHER *)dbenv->crypto_handle)->adj_size(logrec.size);
  1604. logrec.size += npad;
  1605. }
  1607. if ((ret = __os_malloc(dbenv,
  1608.     logrec.size, &logrec.data)) != 0)
  1609. return (ret);
  1611. if (npad > 0)
  1612. memset((u_int8_t *)logrec.data + logrec.size - npad, 0, npad);
  1614. bp = logrec.data;
  1616. memcpy(bp, &rectype, sizeof(rectype));
  1617. bp += sizeof(rectype);
  1619. memcpy(bp, &txn_num, sizeof(txn_num));
  1620. bp += sizeof(txn_num);
  1622. memcpy(bp, lsnp, sizeof(DB_LSN));
  1623. bp += sizeof(DB_LSN);
  1625. DB_ASSERT(dbp->log_filename != NULL);
  1626. if (dbp->log_filename->id == DB_LOGFILEID_INVALID &&
  1627.     (ret = __dbreg_lazy_id(dbp)) != 0)
  1628. return (ret);
  1630. uinttmp = (u_int32_t)dbp->log_filename->id;
  1631. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1632. bp += sizeof(uinttmp);
  1634. uinttmp = (u_int32_t)bucket;
  1635. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1636. bp += sizeof(uinttmp);
  1638. uinttmp = (u_int32_t)mmpgno;
  1639. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1640. bp += sizeof(uinttmp);
  1642. if (mmetalsn != NULL)
  1643. memcpy(bp, mmetalsn, sizeof(*mmetalsn));
  1644. else
  1645. memset(bp, 0, sizeof(*mmetalsn));
  1646. bp += sizeof(*mmetalsn);
  1648. uinttmp = (u_int32_t)mpgno;
  1649. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1650. bp += sizeof(uinttmp);
  1652. if (metalsn != NULL)
  1653. memcpy(bp, metalsn, sizeof(*metalsn));
  1654. else
  1655. memset(bp, 0, sizeof(*metalsn));
  1656. bp += sizeof(*metalsn);
  1658. uinttmp = (u_int32_t)pgno;
  1659. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1660. bp += sizeof(uinttmp);
  1662. if (pagelsn != NULL)
  1663. memcpy(bp, pagelsn, sizeof(*pagelsn));
  1664. else
  1665. memset(bp, 0, sizeof(*pagelsn));
  1666. bp += sizeof(*pagelsn);
  1668. uinttmp = (u_int32_t)newalloc;
  1669. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1670. bp += sizeof(uinttmp);
  1672. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
  1673. ret = dbenv->log_put(dbenv,
  1674.    ret_lsnp, (DBT *)&logrec, flags | DB_NOCOPY);
  1675. if (txnid != NULL && ret == 0)
  1676. txnid->last_lsn = *ret_lsnp;
  1677. #ifdef LOG_DIAGNOSTIC
  1678. if (ret != 0)
  1679. (void)__ham_metagroup_print(dbenv,
  1680.     (DBT *)&logrec, ret_lsnp, NULL, NULL);
  1681. #endif
  1682. __os_free(dbenv, logrec.data);
  1683. return (ret);
  1684. }
  1686. /*
  1687.  * PUBLIC: int __ham_metagroup_getpgnos __P((DB_ENV *, DBT *,
  1688.  * PUBLIC:     DB_LSN *, db_recops, void *));
  1689.  */
  1690. int
  1691. __ham_metagroup_getpgnos(dbenv, rec, lsnp, notused1, summary)
  1692. DB_ENV *dbenv;
  1693. DBT *rec;
  1694. DB_LSN *lsnp;
  1695. db_recops notused1;
  1696. void *summary;
  1697. {
  1698. DB *dbp;
  1699. TXN_RECS *t;
  1700. __ham_metagroup_args *argp;
  1701. u_int32_t ret;
  1703. COMPQUIET(notused1, DB_TXN_ABORT);
  1705. argp = NULL;
  1706. t = (TXN_RECS *)summary;
  1708. if ((ret = __ham_metagroup_read(dbenv, rec->data, &argp)) != 0)
  1709. return (ret);
  1711. if ((ret = __dbreg_id_to_db(dbenv,
  1712.     argp->txnid, &dbp, argp->fileid, 0)) != 0)
  1713. goto err;
  1715. if ((ret = __rep_check_alloc(dbenv, t, 3)) != 0)
  1716. goto err;
  1718. t->array[t->npages].flags = 0;
  1719. t->array[t->npages].fid = argp->fileid;
  1720. t->array[t->npages].lsn = *lsnp;
  1721. t->array[t->npages].pgdesc.pgno = argp->mmpgno;
  1722. t->array[t->npages].pgdesc.type = DB_PAGE_LOCK;
  1723. memcpy(t->array[t->npages].pgdesc.fileid, dbp->fileid,
  1724.     DB_FILE_ID_LEN);
  1725. t->npages++;
  1726. if (argp->mpgno != PGNO_INVALID) {
  1727. t->array[t->npages].flags = 0;
  1728. t->array[t->npages].fid = argp->fileid;
  1729. t->array[t->npages].lsn = *lsnp;
  1730. t->array[t->npages].pgdesc.pgno = argp->mpgno;
  1731. t->array[t->npages].pgdesc.type = DB_PAGE_LOCK;
  1732. memcpy(t->array[t->npages].pgdesc.fileid, dbp->fileid,
  1733.     DB_FILE_ID_LEN);
  1734. t->npages++;
  1735. }
  1736. t->array[t->npages].flags = 0;
  1737. t->array[t->npages].fid = argp->fileid;
  1738. t->array[t->npages].lsn = *lsnp;
  1739. t->array[t->npages].pgdesc.pgno = argp->pgno;
  1740. t->array[t->npages].pgdesc.type = DB_PAGE_LOCK;
  1741. memcpy(t->array[t->npages].pgdesc.fileid, dbp->fileid,
  1742.     DB_FILE_ID_LEN);
  1743. t->npages++;
  1745. err: if (argp != NULL)
  1746. __os_free(dbenv, argp);
  1747. return (ret);
  1748. }
  1750. /*
  1751.  * PUBLIC: int __ham_metagroup_print __P((DB_ENV *, DBT *, DB_LSN *,
  1752.  * PUBLIC:     db_recops, void *));
  1753.  */
  1754. int
  1755. __ham_metagroup_print(dbenv, dbtp, lsnp, notused2, notused3)
  1756. DB_ENV *dbenv;
  1757. DBT *dbtp;
  1758. DB_LSN *lsnp;
  1759. db_recops notused2;
  1760. void *notused3;
  1761. {
  1762. __ham_metagroup_args *argp;
  1763. int ret;
  1765. notused2 = DB_TXN_ABORT;
  1766. notused3 = NULL;
  1768. if ((ret = __ham_metagroup_read(dbenv, dbtp->data, &argp)) != 0)
  1769. return (ret);
  1770. (void)printf(
  1771.     "[%lu][%lu]__ham_metagroup: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  1772.     (u_long)lsnp->file,
  1773.     (u_long)lsnp->offset,
  1774.     (u_long)argp->type,
  1775.     (u_long)argp->txnid->txnid,
  1776.     (u_long)argp->prev_lsn.file,
  1777.     (u_long)argp->prev_lsn.offset);
  1778. (void)printf("tfileid: %ldn", (long)argp->fileid);
  1779. (void)printf("tbucket: %lun", (u_long)argp->bucket);
  1780. (void)printf("tmmpgno: %lun", (u_long)argp->mmpgno);
  1781. (void)printf("tmmetalsn: [%lu][%lu]n",
  1782.     (u_long)argp->mmetalsn.file, (u_long)argp->mmetalsn.offset);
  1783. (void)printf("tmpgno: %lun", (u_long)argp->mpgno);
  1784. (void)printf("tmetalsn: [%lu][%lu]n",
  1785.     (u_long)argp->metalsn.file, (u_long)argp->metalsn.offset);
  1786. (void)printf("tpgno: %lun", (u_long)argp->pgno);
  1787. (void)printf("tpagelsn: [%lu][%lu]n",
  1788.     (u_long)argp->pagelsn.file, (u_long)argp->pagelsn.offset);
  1789. (void)printf("tnewalloc: %lun", (u_long)argp->newalloc);
  1790. (void)printf("n");
  1791. __os_free(dbenv, argp);
  1792. return (0);
  1793. }
  1795. /*
  1796.  * PUBLIC: int __ham_metagroup_read __P((DB_ENV *, void *,
  1797.  * PUBLIC:     __ham_metagroup_args **));
  1798.  */
  1799. int
  1800. __ham_metagroup_read(dbenv, recbuf, argpp)
  1801. DB_ENV *dbenv;
  1802. void *recbuf;
  1803. __ham_metagroup_args **argpp;
  1804. {
  1805. __ham_metagroup_args *argp;
  1806. u_int32_t uinttmp;
  1807. u_int8_t *bp;
  1808. int ret;
  1810. if ((ret = __os_malloc(dbenv,
  1811.     sizeof(__ham_metagroup_args) + sizeof(DB_TXN), &argp)) != 0)
  1812. return (ret);
  1814. argp->txnid = (DB_TXN *)&argp[1];
  1816. bp = recbuf;
  1817. memcpy(&argp->type, bp, sizeof(argp->type));
  1818. bp += sizeof(argp->type);
  1820. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  1821. bp += sizeof(argp->txnid->txnid);
  1823. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  1824. bp += sizeof(DB_LSN);
  1826. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1827. argp->fileid = (int32_t)uinttmp;
  1828. bp += sizeof(uinttmp);
  1830. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1831. argp->bucket = (u_int32_t)uinttmp;
  1832. bp += sizeof(uinttmp);
  1834. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1835. argp->mmpgno = (db_pgno_t)uinttmp;
  1836. bp += sizeof(uinttmp);
  1838. memcpy(&argp->mmetalsn, bp,  sizeof(argp->mmetalsn));
  1839. bp += sizeof(argp->mmetalsn);
  1841. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1842. argp->mpgno = (db_pgno_t)uinttmp;
  1843. bp += sizeof(uinttmp);
  1845. memcpy(&argp->metalsn, bp,  sizeof(argp->metalsn));
  1846. bp += sizeof(argp->metalsn);
  1848. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1849. argp->pgno = (db_pgno_t)uinttmp;
  1850. bp += sizeof(uinttmp);
  1852. memcpy(&argp->pagelsn, bp,  sizeof(argp->pagelsn));
  1853. bp += sizeof(argp->pagelsn);
  1855. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1856. argp->newalloc = (u_int32_t)uinttmp;
  1857. bp += sizeof(uinttmp);
  1859. *argpp = argp;
  1860. return (0);
  1861. }
  1863. /*
  1864.  * PUBLIC: int __ham_groupalloc_log __P((DB *, DB_TXN *, DB_LSN *,
  1865.  * PUBLIC:     u_int32_t, DB_LSN *, db_pgno_t, u_int32_t, db_pgno_t));
  1866.  */
  1867. int
  1868. __ham_groupalloc_log(dbp, txnid, ret_lsnp, flags, meta_lsn, start_pgno, num, free)
  1869. DB *dbp;
  1870. DB_TXN *txnid;
  1871. DB_LSN *ret_lsnp;
  1872. u_int32_t flags;
  1873. DB_LSN * meta_lsn;
  1874. db_pgno_t start_pgno;
  1875. u_int32_t num;
  1876. db_pgno_t free;
  1877. {
  1878. DBT logrec;
  1879. DB_ENV *dbenv;
  1880. DB_LSN *lsnp, null_lsn;
  1881. u_int32_t uinttmp;
  1882. u_int32_t npad, rectype, txn_num;
  1883. int ret;
  1884. u_int8_t *bp;
  1886. dbenv = dbp->dbenv;
  1887. rectype = DB___ham_groupalloc;
  1888. npad = 0;
  1890. if (txnid == NULL) {
  1891. txn_num = 0;
  1892. null_lsn.file = 0;
  1893. null_lsn.offset = 0;
  1894. lsnp = &null_lsn;
  1895. } else {
  1896. if (TAILQ_FIRST(&txnid->kids) != NULL &&
  1897.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  1898. return (ret);
  1899. txn_num = txnid->txnid;
  1900. lsnp = &txnid->last_lsn;
  1901. }
  1903. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  1904.     + sizeof(u_int32_t)
  1905.     + sizeof(*meta_lsn)
  1906.     + sizeof(u_int32_t)
  1907.     + sizeof(u_int32_t)
  1908.     + sizeof(u_int32_t);
  1909. if (CRYPTO_ON(dbenv)) {
  1910. npad =
  1911.     ((DB_CIPHER *)dbenv->crypto_handle)->adj_size(logrec.size);
  1912. logrec.size += npad;
  1913. }
  1915. if ((ret = __os_malloc(dbenv,
  1916.     logrec.size, &logrec.data)) != 0)
  1917. return (ret);
  1919. if (npad > 0)
  1920. memset((u_int8_t *)logrec.data + logrec.size - npad, 0, npad);
  1922. bp = logrec.data;
  1924. memcpy(bp, &rectype, sizeof(rectype));
  1925. bp += sizeof(rectype);
  1927. memcpy(bp, &txn_num, sizeof(txn_num));
  1928. bp += sizeof(txn_num);
  1930. memcpy(bp, lsnp, sizeof(DB_LSN));
  1931. bp += sizeof(DB_LSN);
  1933. DB_ASSERT(dbp->log_filename != NULL);
  1934. if (dbp->log_filename->id == DB_LOGFILEID_INVALID &&
  1935.     (ret = __dbreg_lazy_id(dbp)) != 0)
  1936. return (ret);
  1938. uinttmp = (u_int32_t)dbp->log_filename->id;
  1939. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1940. bp += sizeof(uinttmp);
  1942. if (meta_lsn != NULL)
  1943. memcpy(bp, meta_lsn, sizeof(*meta_lsn));
  1944. else
  1945. memset(bp, 0, sizeof(*meta_lsn));
  1946. bp += sizeof(*meta_lsn);
  1948. uinttmp = (u_int32_t)start_pgno;
  1949. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1950. bp += sizeof(uinttmp);
  1952. uinttmp = (u_int32_t)num;
  1953. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1954. bp += sizeof(uinttmp);
  1956. uinttmp = (u_int32_t)free;
  1957. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1958. bp += sizeof(uinttmp);
  1960. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
  1961. ret = dbenv->log_put(dbenv,
  1962.    ret_lsnp, (DBT *)&logrec, flags | DB_NOCOPY);
  1963. if (txnid != NULL && ret == 0)
  1964. txnid->last_lsn = *ret_lsnp;
  1965. #ifdef LOG_DIAGNOSTIC
  1966. if (ret != 0)
  1967. (void)__ham_groupalloc_print(dbenv,
  1968.     (DBT *)&logrec, ret_lsnp, NULL, NULL);
  1969. #endif
  1970. __os_free(dbenv, logrec.data);
  1971. return (ret);
  1972. }
  1974. /*
  1975.  * PUBLIC: int __ham_groupalloc_getpgnos __P((DB_ENV *, DBT *,
  1976.  * PUBLIC:     DB_LSN *, db_recops, void *));
  1977.  */
  1978. int
  1979. __ham_groupalloc_getpgnos(dbenv, rec, lsnp, notused1, summary)
  1980. DB_ENV *dbenv;
  1981. DBT *rec;
  1982. DB_LSN *lsnp;
  1983. db_recops notused1;
  1984. void *summary;
  1985. {
  1986. DB *dbp;
  1987. TXN_RECS *t;
  1988. __ham_groupalloc_args *argp;
  1989. u_int32_t ret;
  1991. COMPQUIET(notused1, DB_TXN_ABORT);
  1993. argp = NULL;
  1994. t = (TXN_RECS *)summary;
  1996. if ((ret = __ham_groupalloc_read(dbenv, rec->data, &argp)) != 0)
  1997. return (ret);
  1999. if ((ret = __dbreg_id_to_db(dbenv,
  2000.     argp->txnid, &dbp, argp->fileid, 0)) != 0)
  2001. goto err;
  2003. if ((ret = __rep_check_alloc(dbenv, t, 1)) != 0)
  2004. goto err;
  2006. t->array[t->npages].flags = 0;
  2007. t->array[t->npages].fid = argp->fileid;
  2008. t->array[t->npages].lsn = *lsnp;
  2009. t->array[t->npages].pgdesc.pgno = argp->start_pgno;
  2010. t->array[t->npages].pgdesc.type = DB_PAGE_LOCK;
  2011. memcpy(t->array[t->npages].pgdesc.fileid, dbp->fileid,
  2012.     DB_FILE_ID_LEN);
  2013. t->npages++;
  2015. err: if (argp != NULL)
  2016. __os_free(dbenv, argp);
  2017. return (ret);
  2018. }
  2020. /*
  2021.  * PUBLIC: int __ham_groupalloc_print __P((DB_ENV *, DBT *, DB_LSN *,
  2022.  * PUBLIC:     db_recops, void *));
  2023.  */
  2024. int
  2025. __ham_groupalloc_print(dbenv, dbtp, lsnp, notused2, notused3)
  2026. DB_ENV *dbenv;
  2027. DBT *dbtp;
  2028. DB_LSN *lsnp;
  2029. db_recops notused2;
  2030. void *notused3;
  2031. {
  2032. __ham_groupalloc_args *argp;
  2033. int ret;
  2035. notused2 = DB_TXN_ABORT;
  2036. notused3 = NULL;
  2038. if ((ret = __ham_groupalloc_read(dbenv, dbtp->data, &argp)) != 0)
  2039. return (ret);
  2040. (void)printf(
  2041.     "[%lu][%lu]__ham_groupalloc: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  2042.     (u_long)lsnp->file,
  2043.     (u_long)lsnp->offset,
  2044.     (u_long)argp->type,
  2045.     (u_long)argp->txnid->txnid,
  2046.     (u_long)argp->prev_lsn.file,
  2047.     (u_long)argp->prev_lsn.offset);
  2048. (void)printf("tfileid: %ldn", (long)argp->fileid);
  2049. (void)printf("tmeta_lsn: [%lu][%lu]n",
  2050.     (u_long)argp->meta_lsn.file, (u_long)argp->meta_lsn.offset);
  2051. (void)printf("tstart_pgno: %lun", (u_long)argp->start_pgno);
  2052. (void)printf("tnum: %lun", (u_long)argp->num);
  2053. (void)printf("tfree: %lun", (u_long)argp->free);
  2054. (void)printf("n");
  2055. __os_free(dbenv, argp);
  2056. return (0);
  2057. }
  2059. /*
  2060.  * PUBLIC: int __ham_groupalloc_read __P((DB_ENV *, void *,
  2061.  * PUBLIC:     __ham_groupalloc_args **));
  2062.  */
  2063. int
  2064. __ham_groupalloc_read(dbenv, recbuf, argpp)
  2065. DB_ENV *dbenv;
  2066. void *recbuf;
  2067. __ham_groupalloc_args **argpp;
  2068. {
  2069. __ham_groupalloc_args *argp;
  2070. u_int32_t uinttmp;
  2071. u_int8_t *bp;
  2072. int ret;
  2074. if ((ret = __os_malloc(dbenv,
  2075.     sizeof(__ham_groupalloc_args) + sizeof(DB_TXN), &argp)) != 0)
  2076. return (ret);
  2078. argp->txnid = (DB_TXN *)&argp[1];
  2080. bp = recbuf;
  2081. memcpy(&argp->type, bp, sizeof(argp->type));
  2082. bp += sizeof(argp->type);
  2084. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  2085. bp += sizeof(argp->txnid->txnid);
  2087. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  2088. bp += sizeof(DB_LSN);
  2090. memcpy(&uinttmp, bp, sizeof(uinttmp));
  2091. argp->fileid = (int32_t)uinttmp;
  2092. bp += sizeof(uinttmp);
  2094. memcpy(&argp->meta_lsn, bp,  sizeof(argp->meta_lsn));
  2095. bp += sizeof(argp->meta_lsn);
  2097. memcpy(&uinttmp, bp, sizeof(uinttmp));
  2098. argp->start_pgno = (db_pgno_t)uinttmp;
  2099. bp += sizeof(uinttmp);
  2101. memcpy(&uinttmp, bp, sizeof(uinttmp));
  2102. argp->num = (u_int32_t)uinttmp;
  2103. bp += sizeof(uinttmp);
  2105. memcpy(&uinttmp, bp, sizeof(uinttmp));
  2106. argp->free = (db_pgno_t)uinttmp;
  2107. bp += sizeof(uinttmp);
  2109. *argpp = argp;
  2110. return (0);
  2111. }
  2113. /*
  2114.  * PUBLIC: int __ham_curadj_log __P((DB *, DB_TXN *, DB_LSN *,
  2115.  * PUBLIC:     u_int32_t, db_pgno_t, u_int32_t, u_int32_t, u_int32_t, int, int,
  2116.  * PUBLIC:     u_int32_t));
  2117.  */
  2118. int
  2119. __ham_curadj_log(dbp, txnid, ret_lsnp, flags, pgno, indx, len, dup_off, add,
  2120.     is_dup, order)
  2121. DB *dbp;
  2122. DB_TXN *txnid;
  2123. DB_LSN *ret_lsnp;
  2124. u_int32_t flags;
  2125. db_pgno_t pgno;
  2126. u_int32_t indx;
  2127. u_int32_t len;
  2128. u_int32_t dup_off;
  2129. int add;
  2130. int is_dup;
  2131. u_int32_t order;
  2132. {
  2133. DBT logrec;
  2134. DB_ENV *dbenv;
  2135. DB_LSN *lsnp, null_lsn;
  2136. u_int32_t uinttmp;
  2137. u_int32_t npad, rectype, txn_num;
  2138. int ret;
  2139. u_int8_t *bp;
  2141. dbenv = dbp->dbenv;
  2142. rectype = DB___ham_curadj;
  2143. npad = 0;
  2145. if (txnid == NULL) {
  2146. txn_num = 0;
  2147. null_lsn.file = 0;
  2148. null_lsn.offset = 0;
  2149. lsnp = &null_lsn;
  2150. } else {
  2151. if (TAILQ_FIRST(&txnid->kids) != NULL &&
  2152.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  2153. return (ret);
  2154. txn_num = txnid->txnid;
  2155. lsnp = &txnid->last_lsn;
  2156. }
  2158. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  2159.     + sizeof(u_int32_t)
  2160.     + sizeof(u_int32_t)
  2161.     + sizeof(u_int32_t)
  2162.     + sizeof(u_int32_t)
  2163.     + sizeof(u_int32_t)
  2164.     + sizeof(u_int32_t)
  2165.     + sizeof(u_int32_t)
  2166.     + sizeof(u_int32_t);
  2167. if (CRYPTO_ON(dbenv)) {
  2168. npad =
  2169.     ((DB_CIPHER *)dbenv->crypto_handle)->adj_size(logrec.size);
  2170. logrec.size += npad;
  2171. }
  2173. if ((ret = __os_malloc(dbenv,
  2174.     logrec.size, &logrec.data)) != 0)
  2175. return (ret);
  2177. if (npad > 0)
  2178. memset((u_int8_t *)logrec.data + logrec.size - npad, 0, npad);
  2180. bp = logrec.data;
  2182. memcpy(bp, &rectype, sizeof(rectype));
  2183. bp += sizeof(rectype);
  2185. memcpy(bp, &txn_num, sizeof(txn_num));
  2186. bp += sizeof(txn_num);
  2188. memcpy(bp, lsnp, sizeof(DB_LSN));
  2189. bp += sizeof(DB_LSN);
  2191. DB_ASSERT(dbp->log_filename != NULL);
  2192. if (dbp->log_filename->id == DB_LOGFILEID_INVALID &&
  2193.     (ret = __dbreg_lazy_id(dbp)) != 0)
  2194. return (ret);
  2196. uinttmp = (u_int32_t)dbp->log_filename->id;
  2197. memcpy(bp, &uinttmp, sizeof(uinttmp));
  2198. bp += sizeof(uinttmp);
  2200. uinttmp = (u_int32_t)pgno;
  2201. memcpy(bp, &uinttmp, sizeof(uinttmp));
  2202. bp += sizeof(uinttmp);
  2204. uinttmp = (u_int32_t)indx;
  2205. memcpy(bp, &uinttmp, sizeof(uinttmp));
  2206. bp += sizeof(uinttmp);
  2208. uinttmp = (u_int32_t)len;
  2209. memcpy(bp, &uinttmp, sizeof(uinttmp));
  2210. bp += sizeof(uinttmp);
  2212. uinttmp = (u_int32_t)dup_off;
  2213. memcpy(bp, &uinttmp, sizeof(uinttmp));
  2214. bp += sizeof(uinttmp);
  2216. uinttmp = (u_int32_t)add;
  2217. memcpy(bp, &uinttmp, sizeof(uinttmp));
  2218. bp += sizeof(uinttmp);
  2220. uinttmp = (u_int32_t)is_dup;
  2221. memcpy(bp, &uinttmp, sizeof(uinttmp));
  2222. bp += sizeof(uinttmp);
  2224. uinttmp = (u_int32_t)order;
  2225. memcpy(bp, &uinttmp, sizeof(uinttmp));
  2226. bp += sizeof(uinttmp);
  2228. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
  2229. ret = dbenv->log_put(dbenv,
  2230.    ret_lsnp, (DBT *)&logrec, flags | DB_NOCOPY);
  2231. if (txnid != NULL && ret == 0)
  2232. txnid->last_lsn = *ret_lsnp;
  2233. #ifdef LOG_DIAGNOSTIC
  2234. if (ret != 0)
  2235. (void)__ham_curadj_print(dbenv,
  2236.     (DBT *)&logrec, ret_lsnp, NULL, NULL);
  2237. #endif
  2238. __os_free(dbenv, logrec.data);
  2239. return (ret);
  2240. }
  2242. /*
  2243.  * PUBLIC: int __ham_curadj_getpgnos __P((DB_ENV *, DBT *, DB_LSN *,
  2244.  * PUBLIC:     db_recops, void *));
  2245.  */
  2246. int
  2247. __ham_curadj_getpgnos(dbenv, rec, lsnp, notused1, summary)
  2248. DB_ENV *dbenv;
  2249. DBT *rec;
  2250. DB_LSN *lsnp;
  2251. db_recops notused1;
  2252. void *summary;
  2253. {
  2254. TXN_RECS *t;
  2255. int ret;
  2256. COMPQUIET(rec, NULL);
  2257. COMPQUIET(notused1, DB_TXN_ABORT);
  2259. t = (TXN_RECS *)summary;
  2261. if ((ret = __rep_check_alloc(dbenv, t, 1)) != 0)
  2262. return (ret);
  2264. t->array[t->npages].flags = LSN_PAGE_NOLOCK;
  2265. t->array[t->npages].lsn = *lsnp;
  2266. t->array[t->npages].fid = DB_LOGFILEID_INVALID;
  2267. memset(&t->array[t->npages].pgdesc, 0,
  2268.     sizeof(t->array[t->npages].pgdesc));
  2270. t->npages++;
  2272. return (0);
  2273. }
  2275. /*
  2276.  * PUBLIC: int __ham_curadj_print __P((DB_ENV *, DBT *, DB_LSN *,
  2277.  * PUBLIC:     db_recops, void *));
  2278.  */
  2279. int
  2280. __ham_curadj_print(dbenv, dbtp, lsnp, notused2, notused3)
  2281. DB_ENV *dbenv;
  2282. DBT *dbtp;
  2283. DB_LSN *lsnp;
  2284. db_recops notused2;
  2285. void *notused3;
  2286. {
  2287. __ham_curadj_args *argp;
  2288. int ret;
  2290. notused2 = DB_TXN_ABORT;
  2291. notused3 = NULL;
  2293. if ((ret = __ham_curadj_read(dbenv, dbtp->data, &argp)) != 0)
  2294. return (ret);
  2295. (void)printf(
  2296.     "[%lu][%lu]__ham_curadj: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  2297.     (u_long)lsnp->file,
  2298.     (u_long)lsnp->offset,
  2299.     (u_long)argp->type,
  2300.     (u_long)argp->txnid->txnid,
  2301.     (u_long)argp->prev_lsn.file,
  2302.     (u_long)argp->prev_lsn.offset);
  2303. (void)printf("tfileid: %ldn", (long)argp->fileid);
  2304. (void)printf("tpgno: %lun", (u_long)argp->pgno);
  2305. (void)printf("tindx: %lun", (u_long)argp->indx);
  2306. (void)printf("tlen: %lun", (u_long)argp->len);
  2307. (void)printf("tdup_off: %lun", (u_long)argp->dup_off);
  2308. (void)printf("tadd: %ldn", (long)argp->add);
  2309. (void)printf("tis_dup: %ldn", (long)argp->is_dup);
  2310. (void)printf("torder: %lun", (u_long)argp->order);
  2311. (void)printf("n");
  2312. __os_free(dbenv, argp);
  2313. return (0);
  2314. }
  2316. /*
  2317.  * PUBLIC: int __ham_curadj_read __P((DB_ENV *, void *, __ham_curadj_args **));
  2318.  */
  2319. int
  2320. __ham_curadj_read(dbenv, recbuf, argpp)
  2321. DB_ENV *dbenv;
  2322. void *recbuf;
  2323. __ham_curadj_args **argpp;
  2324. {
  2325. __ham_curadj_args *argp;
  2326. u_int32_t uinttmp;
  2327. u_int8_t *bp;
  2328. int ret;
  2330. if ((ret = __os_malloc(dbenv,
  2331.     sizeof(__ham_curadj_args) + sizeof(DB_TXN), &argp)) != 0)
  2332. return (ret);
  2334. argp->txnid = (DB_TXN *)&argp[1];
  2336. bp = recbuf;
  2337. memcpy(&argp->type, bp, sizeof(argp->type));
  2338. bp += sizeof(argp->type);
  2340. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  2341. bp += sizeof(argp->txnid->txnid);
  2343. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  2344. bp += sizeof(DB_LSN);
  2346. memcpy(&uinttmp, bp, sizeof(uinttmp));
  2347. argp->fileid = (int32_t)uinttmp;
  2348. bp += sizeof(uinttmp);
  2350. memcpy(&uinttmp, bp, sizeof(uinttmp));
  2351. argp->pgno = (db_pgno_t)uinttmp;
  2352. bp += sizeof(uinttmp);
  2354. memcpy(&uinttmp, bp, sizeof(uinttmp));
  2355. argp->indx = (u_int32_t)uinttmp;
  2356. bp += sizeof(uinttmp);
  2358. memcpy(&uinttmp, bp, sizeof(uinttmp));
  2359. argp->len = (u_int32_t)uinttmp;
  2360. bp += sizeof(uinttmp);
  2362. memcpy(&uinttmp, bp, sizeof(uinttmp));
  2363. argp->dup_off = (u_int32_t)uinttmp;
  2364. bp += sizeof(uinttmp);
  2366. memcpy(&uinttmp, bp, sizeof(uinttmp));
  2367. argp->add = (int)uinttmp;
  2368. bp += sizeof(uinttmp);
  2370. memcpy(&uinttmp, bp, sizeof(uinttmp));
  2371. argp->is_dup = (int)uinttmp;
  2372. bp += sizeof(uinttmp);
  2374. memcpy(&uinttmp, bp, sizeof(uinttmp));
  2375. argp->order = (u_int32_t)uinttmp;
  2376. bp += sizeof(uinttmp);
  2378. *argpp = argp;
  2379. return (0);
  2380. }
  2382. /*
  2383.  * PUBLIC: int __ham_chgpg_log __P((DB *, DB_TXN *, DB_LSN *,
  2384.  * PUBLIC:     u_int32_t, db_ham_mode, db_pgno_t, db_pgno_t, u_int32_t,
  2385.  * PUBLIC:     u_int32_t));
  2386.  */
  2387. int
  2388. __ham_chgpg_log(dbp, txnid, ret_lsnp, flags, mode, old_pgno, new_pgno, old_indx, new_indx)
  2389. DB *dbp;
  2390. DB_TXN *txnid;
  2391. DB_LSN *ret_lsnp;
  2392. u_int32_t flags;
  2393. db_ham_mode mode;
  2394. db_pgno_t old_pgno;
  2395. db_pgno_t new_pgno;
  2396. u_int32_t old_indx;
  2397. u_int32_t new_indx;
  2398. {
  2399. DBT logrec;
  2400. DB_ENV *dbenv;
  2401. DB_LSN *lsnp, null_lsn;
  2402. u_int32_t uinttmp;
  2403. u_int32_t npad, rectype, txn_num;
  2404. int ret;
  2405. u_int8_t *bp;
  2407. dbenv = dbp->dbenv;
  2408. rectype = DB___ham_chgpg;
  2409. npad = 0;
  2411. if (txnid == NULL) {
  2412. txn_num = 0;
  2413. null_lsn.file = 0;
  2414. null_lsn.offset = 0;
  2415. lsnp = &null_lsn;
  2416. } else {
  2417. if (TAILQ_FIRST(&txnid->kids) != NULL &&
  2418.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  2419. return (ret);
  2420. txn_num = txnid->txnid;
  2421. lsnp = &txnid->last_lsn;
  2422. }
  2424. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  2425.     + sizeof(u_int32_t)
  2426.     + sizeof(u_int32_t)
  2427.     + sizeof(u_int32_t)
  2428.     + sizeof(u_int32_t)
  2429.     + sizeof(u_int32_t)
  2430.     + sizeof(u_int32_t);
  2431. if (CRYPTO_ON(dbenv)) {
  2432. npad =
  2433.     ((DB_CIPHER *)dbenv->crypto_handle)->adj_size(logrec.size);
  2434. logrec.size += npad;
  2435. }
  2437. if ((ret = __os_malloc(dbenv,
  2438.     logrec.size, &logrec.data)) != 0)
  2439. return (ret);
  2441. if (npad > 0)
  2442. memset((u_int8_t *)logrec.data + logrec.size - npad, 0, npad);
  2444. bp = logrec.data;
  2446. memcpy(bp, &rectype, sizeof(rectype));
  2447. bp += sizeof(rectype);
  2449. memcpy(bp, &txn_num, sizeof(txn_num));
  2450. bp += sizeof(txn_num);
  2452. memcpy(bp, lsnp, sizeof(DB_LSN));
  2453. bp += sizeof(DB_LSN);
  2455. DB_ASSERT(dbp->log_filename != NULL);
  2456. if (dbp->log_filename->id == DB_LOGFILEID_INVALID &&
  2457.     (ret = __dbreg_lazy_id(dbp)) != 0)
  2458. return (ret);
  2460. uinttmp = (u_int32_t)dbp->log_filename->id;
  2461. memcpy(bp, &uinttmp, sizeof(uinttmp));
  2462. bp += sizeof(uinttmp);
  2464. uinttmp = (u_int32_t)mode;
  2465. memcpy(bp, &uinttmp, sizeof(uinttmp));
  2466. bp += sizeof(uinttmp);
  2468. uinttmp = (u_int32_t)old_pgno;
  2469. memcpy(bp, &uinttmp, sizeof(uinttmp));
  2470. bp += sizeof(uinttmp);
  2472. uinttmp = (u_int32_t)new_pgno;
  2473. memcpy(bp, &uinttmp, sizeof(uinttmp));
  2474. bp += sizeof(uinttmp);
  2476. uinttmp = (u_int32_t)old_indx;
  2477. memcpy(bp, &uinttmp, sizeof(uinttmp));
  2478. bp += sizeof(uinttmp);
  2480. uinttmp = (u_int32_t)new_indx;
  2481. memcpy(bp, &uinttmp, sizeof(uinttmp));
  2482. bp += sizeof(uinttmp);
  2484. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
  2485. ret = dbenv->log_put(dbenv,
  2486.    ret_lsnp, (DBT *)&logrec, flags | DB_NOCOPY);
  2487. if (txnid != NULL && ret == 0)
  2488. txnid->last_lsn = *ret_lsnp;
  2489. #ifdef LOG_DIAGNOSTIC
  2490. if (ret != 0)
  2491. (void)__ham_chgpg_print(dbenv,
  2492.     (DBT *)&logrec, ret_lsnp, NULL, NULL);
  2493. #endif
  2494. __os_free(dbenv, logrec.data);
  2495. return (ret);
  2496. }
  2498. /*
  2499.  * PUBLIC: int __ham_chgpg_getpgnos __P((DB_ENV *, DBT *, DB_LSN *,
  2500.  * PUBLIC:     db_recops, void *));
  2501.  */
  2502. int
  2503. __ham_chgpg_getpgnos(dbenv, rec, lsnp, notused1, summary)
  2504. DB_ENV *dbenv;
  2505. DBT *rec;
  2506. DB_LSN *lsnp;
  2507. db_recops notused1;
  2508. void *summary;
  2509. {
  2510. TXN_RECS *t;
  2511. int ret;
  2512. COMPQUIET(rec, NULL);
  2513. COMPQUIET(notused1, DB_TXN_ABORT);
  2515. t = (TXN_RECS *)summary;
  2517. if ((ret = __rep_check_alloc(dbenv, t, 1)) != 0)
  2518. return (ret);
  2520. t->array[t->npages].flags = LSN_PAGE_NOLOCK;
  2521. t->array[t->npages].lsn = *lsnp;
  2522. t->array[t->npages].fid = DB_LOGFILEID_INVALID;
  2523. memset(&t->array[t->npages].pgdesc, 0,
  2524.     sizeof(t->array[t->npages].pgdesc));
  2526. t->npages++;
  2528. return (0);
  2529. }
  2531. /*
  2532.  * PUBLIC: int __ham_chgpg_print __P((DB_ENV *, DBT *, DB_LSN *,
  2533.  * PUBLIC:     db_recops, void *));
  2534.  */
  2535. int
  2536. __ham_chgpg_print(dbenv, dbtp, lsnp, notused2, notused3)
  2537. DB_ENV *dbenv;
  2538. DBT *dbtp;
  2539. DB_LSN *lsnp;
  2540. db_recops notused2;
  2541. void *notused3;
  2542. {
  2543. __ham_chgpg_args *argp;
  2544. int ret;
  2546. notused2 = DB_TXN_ABORT;
  2547. notused3 = NULL;
  2549. if ((ret = __ham_chgpg_read(dbenv, dbtp->data, &argp)) != 0)
  2550. return (ret);
  2551. (void)printf(
  2552.     "[%lu][%lu]__ham_chgpg: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  2553.     (u_long)lsnp->file,
  2554.     (u_long)lsnp->offset,
  2555.     (u_long)argp->type,
  2556.     (u_long)argp->txnid->txnid,
  2557.     (u_long)argp->prev_lsn.file,
  2558.     (u_long)argp->prev_lsn.offset);
  2559. (void)printf("tfileid: %ldn", (long)argp->fileid);
  2560. (void)printf("tmode: %ldn", (long)argp->mode);
  2561. (void)printf("told_pgno: %lun", (u_long)argp->old_pgno);
  2562. (void)printf("tnew_pgno: %lun", (u_long)argp->new_pgno);
  2563. (void)printf("told_indx: %lun", (u_long)argp->old_indx);
  2564. (void)printf("tnew_indx: %lun", (u_long)argp->new_indx);
  2565. (void)printf("n");
  2566. __os_free(dbenv, argp);
  2567. return (0);
  2568. }
  2570. /*
  2571.  * PUBLIC: int __ham_chgpg_read __P((DB_ENV *, void *, __ham_chgpg_args **));
  2572.  */
  2573. int
  2574. __ham_chgpg_read(dbenv, recbuf, argpp)
  2575. DB_ENV *dbenv;
  2576. void *recbuf;
  2577. __ham_chgpg_args **argpp;
  2578. {
  2579. __ham_chgpg_args *argp;
  2580. u_int32_t uinttmp;
  2581. u_int8_t *bp;
  2582. int ret;
  2584. if ((ret = __os_malloc(dbenv,
  2585.     sizeof(__ham_chgpg_args) + sizeof(DB_TXN), &argp)) != 0)
  2586. return (ret);
  2588. argp->txnid = (DB_TXN *)&argp[1];
  2590. bp = recbuf;
  2591. memcpy(&argp->type, bp, sizeof(argp->type));
  2592. bp += sizeof(argp->type);
  2594. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  2595. bp += sizeof(argp->txnid->txnid);
  2597. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  2598. bp += sizeof(DB_LSN);
  2600. memcpy(&uinttmp, bp, sizeof(uinttmp));
  2601. argp->fileid = (int32_t)uinttmp;
  2602. bp += sizeof(uinttmp);
  2604. memcpy(&uinttmp, bp, sizeof(uinttmp));
  2605. argp->mode = (db_ham_mode)uinttmp;
  2606. bp += sizeof(uinttmp);
  2608. memcpy(&uinttmp, bp, sizeof(uinttmp));
  2609. argp->old_pgno = (db_pgno_t)uinttmp;
  2610. bp += sizeof(uinttmp);
  2612. memcpy(&uinttmp, bp, sizeof(uinttmp));
  2613. argp->new_pgno = (db_pgno_t)uinttmp;
  2614. bp += sizeof(uinttmp);
  2616. memcpy(&uinttmp, bp, sizeof(uinttmp));
  2617. argp->old_indx = (u_int32_t)uinttmp;
  2618. bp += sizeof(uinttmp);
  2620. memcpy(&uinttmp, bp, sizeof(uinttmp));
  2621. argp->new_indx = (u_int32_t)uinttmp;
  2622. bp += sizeof(uinttmp);
  2624. *argpp = argp;
  2625. return (0);
  2626. }
  2628. /*
  2629.  * PUBLIC: int __ham_init_print __P((DB_ENV *, int (***)(DB_ENV *,
  2630.  * PUBLIC:     DBT *, DB_LSN *, db_recops, void *), size_t *));
  2631.  */
  2632. int
  2633. __ham_init_print(dbenv, dtabp, dtabsizep)
  2634. DB_ENV *dbenv;
  2635. int (***dtabp)__P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  2636. size_t *dtabsizep;
  2637. {
  2638. int ret;
  2640. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2641.     __ham_insdel_print, DB___ham_insdel)) != 0)
  2642. return (ret);
  2643. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2644.     __ham_newpage_print, DB___ham_newpage)) != 0)
  2645. return (ret);
  2646. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2647.     __ham_splitdata_print, DB___ham_splitdata)) != 0)
  2648. return (ret);
  2649. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2650.     __ham_replace_print, DB___ham_replace)) != 0)
  2651. return (ret);
  2652. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2653.     __ham_copypage_print, DB___ham_copypage)) != 0)
  2654. return (ret);
  2655. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2656.     __ham_metagroup_print, DB___ham_metagroup)) != 0)
  2657. return (ret);
  2658. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2659.     __ham_groupalloc_print, DB___ham_groupalloc)) != 0)
  2660. return (ret);
  2661. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2662.     __ham_curadj_print, DB___ham_curadj)) != 0)
  2663. return (ret);
  2664. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2665.     __ham_chgpg_print, DB___ham_chgpg)) != 0)
  2666. return (ret);
  2667. return (0);
  2668. }
  2670. /*
  2671.  * PUBLIC: int __ham_init_getpgnos __P((DB_ENV *, int (***)(DB_ENV *,
  2672.  * PUBLIC:     DBT *, DB_LSN *, db_recops, void *), size_t *));
  2673.  */
  2674. int
  2675. __ham_init_getpgnos(dbenv, dtabp, dtabsizep)
  2676. DB_ENV *dbenv;
  2677. int (***dtabp)__P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  2678. size_t *dtabsizep;
  2679. {
  2680. int ret;
  2682. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2683.     __ham_insdel_getpgnos, DB___ham_insdel)) != 0)
  2684. return (ret);
  2685. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2686.     __ham_newpage_getpgnos, DB___ham_newpage)) != 0)
  2687. return (ret);
  2688. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2689.     __ham_splitdata_getpgnos, DB___ham_splitdata)) != 0)
  2690. return (ret);
  2691. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2692.     __ham_replace_getpgnos, DB___ham_replace)) != 0)
  2693. return (ret);
  2694. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2695.     __ham_copypage_getpgnos, DB___ham_copypage)) != 0)
  2696. return (ret);
  2697. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2698.     __ham_metagroup_getpgnos, DB___ham_metagroup)) != 0)
  2699. return (ret);
  2700. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2701.     __ham_groupalloc_getpgnos, DB___ham_groupalloc)) != 0)
  2702. return (ret);
  2703. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2704.     __ham_curadj_getpgnos, DB___ham_curadj)) != 0)
  2705. return (ret);
  2706. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2707.     __ham_chgpg_getpgnos, DB___ham_chgpg)) != 0)
  2708. return (ret);
  2709. return (0);
  2710. }
  2712. /*
  2713.  * PUBLIC: int __ham_init_recover __P((DB_ENV *, int (***)(DB_ENV *,
  2714.  * PUBLIC:     DBT *, DB_LSN *, db_recops, void *), size_t *));
  2715.  */
  2716. int
  2717. __ham_init_recover(dbenv, dtabp, dtabsizep)
  2718. DB_ENV *dbenv;
  2719. int (***dtabp)__P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  2720. size_t *dtabsizep;
  2721. {
  2722. int ret;
  2724. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2725.     __ham_insdel_recover, DB___ham_insdel)) != 0)
  2726. return (ret);
  2727. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2728.     __ham_newpage_recover, DB___ham_newpage)) != 0)
  2729. return (ret);
  2730. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2731.     __ham_splitdata_recover, DB___ham_splitdata)) != 0)
  2732. return (ret);
  2733. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2734.     __ham_replace_recover, DB___ham_replace)) != 0)
  2735. return (ret);
  2736. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2737.     __ham_copypage_recover, DB___ham_copypage)) != 0)
  2738. return (ret);
  2739. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2740.     __ham_metagroup_recover, DB___ham_metagroup)) != 0)
  2741. return (ret);
  2742. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2743.     __ham_groupalloc_recover, DB___ham_groupalloc)) != 0)
  2744. return (ret);
  2745. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2746.     __ham_curadj_recover, DB___ham_curadj)) != 0)
  2747. return (ret);
  2748. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  2749.     __ham_chgpg_recover, DB___ham_chgpg)) != 0)
  2750. return (ret);
  2751. return (0);
  2752. }