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

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

MySQL数据库

开发平台：

Visual C++

fileops_auto.c：源码内容
  1. /* Do not edit: automatically built by gen_rec.awk. */
  2. #include "db_config.h"
  4. #ifndef NO_SYSTEM_INCLUDES
  5. #include <sys/types.h>
  7. #include <ctype.h>
  8. #include <string.h>
  9. #endif
  11. #include "db_int.h"
  12. #include "dbinc/crypto.h"
  13. #include "dbinc/db_page.h"
  14. #include "dbinc/db_dispatch.h"
  15. #include "dbinc/db_am.h"
  16. #include "dbinc/log.h"
  17. #include "dbinc/rep.h"
  18. #include "dbinc/txn.h"
  19. #include "dbinc/fop.h"
  21. /*
  22.  * PUBLIC: int __fop_create_log __P((DB_ENV *, DB_TXN *, DB_LSN *,
  23.  * PUBLIC:     u_int32_t, const DBT *, u_int32_t, u_int32_t));
  24.  */
  25. int
  26. __fop_create_log(dbenv, txnid, ret_lsnp, flags,
  27.     name, appname, mode)
  28. DB_ENV *dbenv;
  29. DB_TXN *txnid;
  30. DB_LSN *ret_lsnp;
  31. u_int32_t flags;
  32. const DBT *name;
  33. u_int32_t appname;
  34. u_int32_t mode;
  35. {
  36. DBT logrec;
  37. DB_LSN *lsnp, null_lsn;
  38. u_int32_t zero;
  39. u_int32_t uinttmp;
  40. u_int32_t npad, rectype, txn_num;
  41. int ret;
  42. u_int8_t *bp;
  44. rectype = DB___fop_create;
  45. npad = 0;
  47. if (txnid == NULL) {
  48. txn_num = 0;
  49. null_lsn.file = 0;
  50. null_lsn.offset = 0;
  51. lsnp = &null_lsn;
  52. } else {
  53. if (TAILQ_FIRST(&txnid->kids) != NULL &&
  54.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  55. return (ret);
  56. txn_num = txnid->txnid;
  57. lsnp = &txnid->last_lsn;
  58. }
  60. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  61.     + sizeof(u_int32_t) + (name == NULL ? 0 : name->size)
  62.     + sizeof(u_int32_t)
  63.     + sizeof(u_int32_t);
  64. if (CRYPTO_ON(dbenv)) {
  65. npad =
  66.     ((DB_CIPHER *)dbenv->crypto_handle)->adj_size(logrec.size);
  67. logrec.size += npad;
  68. }
  70. if ((ret = __os_malloc(dbenv,
  71.     logrec.size, &logrec.data)) != 0)
  72. return (ret);
  74. if (npad > 0)
  75. memset((u_int8_t *)logrec.data + logrec.size - npad, 0, npad);
  77. bp = logrec.data;
  79. memcpy(bp, &rectype, sizeof(rectype));
  80. bp += sizeof(rectype);
  82. memcpy(bp, &txn_num, sizeof(txn_num));
  83. bp += sizeof(txn_num);
  85. memcpy(bp, lsnp, sizeof(DB_LSN));
  86. bp += sizeof(DB_LSN);
  88. if (name == NULL) {
  89. zero = 0;
  90. memcpy(bp, &zero, sizeof(u_int32_t));
  91. bp += sizeof(u_int32_t);
  92. } else {
  93. memcpy(bp, &name->size, sizeof(name->size));
  94. bp += sizeof(name->size);
  95. memcpy(bp, name->data, name->size);
  96. bp += name->size;
  97. }
  99. uinttmp = (u_int32_t)appname;
  100. memcpy(bp, &uinttmp, sizeof(uinttmp));
  101. bp += sizeof(uinttmp);
  103. uinttmp = (u_int32_t)mode;
  104. memcpy(bp, &uinttmp, sizeof(uinttmp));
  105. bp += sizeof(uinttmp);
  107. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
  108. ret = dbenv->log_put(dbenv,
  109.    ret_lsnp, (DBT *)&logrec, flags | DB_NOCOPY);
  110. if (txnid != NULL && ret == 0)
  111. txnid->last_lsn = *ret_lsnp;
  112. #ifdef LOG_DIAGNOSTIC
  113. if (ret != 0)
  114. (void)__fop_create_print(dbenv,
  115.     (DBT *)&logrec, ret_lsnp, NULL, NULL);
  116. #endif
  117. __os_free(dbenv, logrec.data);
  118. return (ret);
  119. }
  121. /*
  122.  * PUBLIC: int __fop_create_getpgnos __P((DB_ENV *, DBT *, DB_LSN *,
  123.  * PUBLIC:     db_recops, void *));
  124.  */
  125. int
  126. __fop_create_getpgnos(dbenv, rec, lsnp, notused1, summary)
  127. DB_ENV *dbenv;
  128. DBT *rec;
  129. DB_LSN *lsnp;
  130. db_recops notused1;
  131. void *summary;
  132. {
  133. TXN_RECS *t;
  134. int ret;
  135. COMPQUIET(rec, NULL);
  136. COMPQUIET(notused1, DB_TXN_ABORT);
  138. t = (TXN_RECS *)summary;
  140. if ((ret = __rep_check_alloc(dbenv, t, 1)) != 0)
  141. return (ret);
  143. t->array[t->npages].flags = LSN_PAGE_NOLOCK;
  144. t->array[t->npages].lsn = *lsnp;
  145. t->array[t->npages].fid = DB_LOGFILEID_INVALID;
  146. memset(&t->array[t->npages].pgdesc, 0,
  147.     sizeof(t->array[t->npages].pgdesc));
  149. t->npages++;
  151. return (0);
  152. }
  154. /*
  155.  * PUBLIC: int __fop_create_print __P((DB_ENV *, DBT *, DB_LSN *,
  156.  * PUBLIC:     db_recops, void *));
  157.  */
  158. int
  159. __fop_create_print(dbenv, dbtp, lsnp, notused2, notused3)
  160. DB_ENV *dbenv;
  161. DBT *dbtp;
  162. DB_LSN *lsnp;
  163. db_recops notused2;
  164. void *notused3;
  165. {
  166. __fop_create_args *argp;
  167. u_int32_t i;
  168. int ch;
  169. int ret;
  171. notused2 = DB_TXN_ABORT;
  172. notused3 = NULL;
  174. if ((ret = __fop_create_read(dbenv, dbtp->data, &argp)) != 0)
  175. return (ret);
  176. (void)printf(
  177.     "[%lu][%lu]__fop_create: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  178.     (u_long)lsnp->file,
  179.     (u_long)lsnp->offset,
  180.     (u_long)argp->type,
  181.     (u_long)argp->txnid->txnid,
  182.     (u_long)argp->prev_lsn.file,
  183.     (u_long)argp->prev_lsn.offset);
  184. (void)printf("tname: ");
  185. for (i = 0; i < argp->name.size; i++) {
  186. ch = ((u_int8_t *)argp->name.data)[i];
  187. printf(isprint(ch) || ch == 0x0a ? "%c" : "%#x ", ch);
  188. }
  189. (void)printf("n");
  190. (void)printf("tappname: %lun", (u_long)argp->appname);
  191. (void)printf("tmode: %on", argp->mode);
  192. (void)printf("n");
  193. __os_free(dbenv, argp);
  194. return (0);
  195. }
  197. /*
  198.  * PUBLIC: int __fop_create_read __P((DB_ENV *, void *, __fop_create_args **));
  199.  */
  200. int
  201. __fop_create_read(dbenv, recbuf, argpp)
  202. DB_ENV *dbenv;
  203. void *recbuf;
  204. __fop_create_args **argpp;
  205. {
  206. __fop_create_args *argp;
  207. u_int32_t uinttmp;
  208. u_int8_t *bp;
  209. int ret;
  211. if ((ret = __os_malloc(dbenv,
  212.     sizeof(__fop_create_args) + sizeof(DB_TXN), &argp)) != 0)
  213. return (ret);
  215. argp->txnid = (DB_TXN *)&argp[1];
  217. bp = recbuf;
  218. memcpy(&argp->type, bp, sizeof(argp->type));
  219. bp += sizeof(argp->type);
  221. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  222. bp += sizeof(argp->txnid->txnid);
  224. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  225. bp += sizeof(DB_LSN);
  227. memset(&argp->name, 0, sizeof(argp->name));
  228. memcpy(&argp->name.size, bp, sizeof(u_int32_t));
  229. bp += sizeof(u_int32_t);
  230. argp->name.data = bp;
  231. bp += argp->name.size;
  233. memcpy(&uinttmp, bp, sizeof(uinttmp));
  234. argp->appname = (u_int32_t)uinttmp;
  235. bp += sizeof(uinttmp);
  237. memcpy(&uinttmp, bp, sizeof(uinttmp));
  238. argp->mode = (u_int32_t)uinttmp;
  239. bp += sizeof(uinttmp);
  241. *argpp = argp;
  242. return (0);
  243. }
  245. /*
  246.  * PUBLIC: int __fop_remove_log __P((DB_ENV *, DB_TXN *, DB_LSN *,
  247.  * PUBLIC:     u_int32_t, const DBT *, const DBT *, u_int32_t));
  248.  */
  249. int
  250. __fop_remove_log(dbenv, txnid, ret_lsnp, flags,
  251.     name, fid, appname)
  252. DB_ENV *dbenv;
  253. DB_TXN *txnid;
  254. DB_LSN *ret_lsnp;
  255. u_int32_t flags;
  256. const DBT *name;
  257. const DBT *fid;
  258. u_int32_t appname;
  259. {
  260. DBT logrec;
  261. DB_LSN *lsnp, null_lsn;
  262. u_int32_t zero;
  263. u_int32_t uinttmp;
  264. u_int32_t npad, rectype, txn_num;
  265. int ret;
  266. u_int8_t *bp;
  268. rectype = DB___fop_remove;
  269. npad = 0;
  271. if (txnid == NULL) {
  272. txn_num = 0;
  273. null_lsn.file = 0;
  274. null_lsn.offset = 0;
  275. lsnp = &null_lsn;
  276. } else {
  277. if (TAILQ_FIRST(&txnid->kids) != NULL &&
  278.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  279. return (ret);
  280. txn_num = txnid->txnid;
  281. lsnp = &txnid->last_lsn;
  282. }
  284. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  285.     + sizeof(u_int32_t) + (name == NULL ? 0 : name->size)
  286.     + sizeof(u_int32_t) + (fid == NULL ? 0 : fid->size)
  287.     + sizeof(u_int32_t);
  288. if (CRYPTO_ON(dbenv)) {
  289. npad =
  290.     ((DB_CIPHER *)dbenv->crypto_handle)->adj_size(logrec.size);
  291. logrec.size += npad;
  292. }
  294. if ((ret = __os_malloc(dbenv,
  295.     logrec.size, &logrec.data)) != 0)
  296. return (ret);
  298. if (npad > 0)
  299. memset((u_int8_t *)logrec.data + logrec.size - npad, 0, npad);
  301. bp = logrec.data;
  303. memcpy(bp, &rectype, sizeof(rectype));
  304. bp += sizeof(rectype);
  306. memcpy(bp, &txn_num, sizeof(txn_num));
  307. bp += sizeof(txn_num);
  309. memcpy(bp, lsnp, sizeof(DB_LSN));
  310. bp += sizeof(DB_LSN);
  312. if (name == NULL) {
  313. zero = 0;
  314. memcpy(bp, &zero, sizeof(u_int32_t));
  315. bp += sizeof(u_int32_t);
  316. } else {
  317. memcpy(bp, &name->size, sizeof(name->size));
  318. bp += sizeof(name->size);
  319. memcpy(bp, name->data, name->size);
  320. bp += name->size;
  321. }
  323. if (fid == NULL) {
  324. zero = 0;
  325. memcpy(bp, &zero, sizeof(u_int32_t));
  326. bp += sizeof(u_int32_t);
  327. } else {
  328. memcpy(bp, &fid->size, sizeof(fid->size));
  329. bp += sizeof(fid->size);
  330. memcpy(bp, fid->data, fid->size);
  331. bp += fid->size;
  332. }
  334. uinttmp = (u_int32_t)appname;
  335. memcpy(bp, &uinttmp, sizeof(uinttmp));
  336. bp += sizeof(uinttmp);
  338. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
  339. ret = dbenv->log_put(dbenv,
  340.    ret_lsnp, (DBT *)&logrec, flags | DB_NOCOPY);
  341. if (txnid != NULL && ret == 0)
  342. txnid->last_lsn = *ret_lsnp;
  343. #ifdef LOG_DIAGNOSTIC
  344. if (ret != 0)
  345. (void)__fop_remove_print(dbenv,
  346.     (DBT *)&logrec, ret_lsnp, NULL, NULL);
  347. #endif
  348. __os_free(dbenv, logrec.data);
  349. return (ret);
  350. }
  352. /*
  353.  * PUBLIC: int __fop_remove_getpgnos __P((DB_ENV *, DBT *, DB_LSN *,
  354.  * PUBLIC:     db_recops, void *));
  355.  */
  356. int
  357. __fop_remove_getpgnos(dbenv, rec, lsnp, notused1, summary)
  358. DB_ENV *dbenv;
  359. DBT *rec;
  360. DB_LSN *lsnp;
  361. db_recops notused1;
  362. void *summary;
  363. {
  364. TXN_RECS *t;
  365. int ret;
  366. COMPQUIET(rec, NULL);
  367. COMPQUIET(notused1, DB_TXN_ABORT);
  369. t = (TXN_RECS *)summary;
  371. if ((ret = __rep_check_alloc(dbenv, t, 1)) != 0)
  372. return (ret);
  374. t->array[t->npages].flags = LSN_PAGE_NOLOCK;
  375. t->array[t->npages].lsn = *lsnp;
  376. t->array[t->npages].fid = DB_LOGFILEID_INVALID;
  377. memset(&t->array[t->npages].pgdesc, 0,
  378.     sizeof(t->array[t->npages].pgdesc));
  380. t->npages++;
  382. return (0);
  383. }
  385. /*
  386.  * PUBLIC: int __fop_remove_print __P((DB_ENV *, DBT *, DB_LSN *,
  387.  * PUBLIC:     db_recops, void *));
  388.  */
  389. int
  390. __fop_remove_print(dbenv, dbtp, lsnp, notused2, notused3)
  391. DB_ENV *dbenv;
  392. DBT *dbtp;
  393. DB_LSN *lsnp;
  394. db_recops notused2;
  395. void *notused3;
  396. {
  397. __fop_remove_args *argp;
  398. u_int32_t i;
  399. int ch;
  400. int ret;
  402. notused2 = DB_TXN_ABORT;
  403. notused3 = NULL;
  405. if ((ret = __fop_remove_read(dbenv, dbtp->data, &argp)) != 0)
  406. return (ret);
  407. (void)printf(
  408.     "[%lu][%lu]__fop_remove: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  409.     (u_long)lsnp->file,
  410.     (u_long)lsnp->offset,
  411.     (u_long)argp->type,
  412.     (u_long)argp->txnid->txnid,
  413.     (u_long)argp->prev_lsn.file,
  414.     (u_long)argp->prev_lsn.offset);
  415. (void)printf("tname: ");
  416. for (i = 0; i < argp->name.size; i++) {
  417. ch = ((u_int8_t *)argp->name.data)[i];
  418. printf(isprint(ch) || ch == 0x0a ? "%c" : "%#x ", ch);
  419. }
  420. (void)printf("n");
  421. (void)printf("tfid: ");
  422. for (i = 0; i < argp->fid.size; i++) {
  423. ch = ((u_int8_t *)argp->fid.data)[i];
  424. printf(isprint(ch) || ch == 0x0a ? "%c" : "%#x ", ch);
  425. }
  426. (void)printf("n");
  427. (void)printf("tappname: %lun", (u_long)argp->appname);
  428. (void)printf("n");
  429. __os_free(dbenv, argp);
  430. return (0);
  431. }
  433. /*
  434.  * PUBLIC: int __fop_remove_read __P((DB_ENV *, void *, __fop_remove_args **));
  435.  */
  436. int
  437. __fop_remove_read(dbenv, recbuf, argpp)
  438. DB_ENV *dbenv;
  439. void *recbuf;
  440. __fop_remove_args **argpp;
  441. {
  442. __fop_remove_args *argp;
  443. u_int32_t uinttmp;
  444. u_int8_t *bp;
  445. int ret;
  447. if ((ret = __os_malloc(dbenv,
  448.     sizeof(__fop_remove_args) + sizeof(DB_TXN), &argp)) != 0)
  449. return (ret);
  451. argp->txnid = (DB_TXN *)&argp[1];
  453. bp = recbuf;
  454. memcpy(&argp->type, bp, sizeof(argp->type));
  455. bp += sizeof(argp->type);
  457. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  458. bp += sizeof(argp->txnid->txnid);
  460. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  461. bp += sizeof(DB_LSN);
  463. memset(&argp->name, 0, sizeof(argp->name));
  464. memcpy(&argp->name.size, bp, sizeof(u_int32_t));
  465. bp += sizeof(u_int32_t);
  466. argp->name.data = bp;
  467. bp += argp->name.size;
  469. memset(&argp->fid, 0, sizeof(argp->fid));
  470. memcpy(&argp->fid.size, bp, sizeof(u_int32_t));
  471. bp += sizeof(u_int32_t);
  472. argp->fid.data = bp;
  473. bp += argp->fid.size;
  475. memcpy(&uinttmp, bp, sizeof(uinttmp));
  476. argp->appname = (u_int32_t)uinttmp;
  477. bp += sizeof(uinttmp);
  479. *argpp = argp;
  480. return (0);
  481. }
  483. /*
  484.  * PUBLIC: int __fop_write_log __P((DB_ENV *, DB_TXN *, DB_LSN *,
  485.  * PUBLIC:     u_int32_t, const DBT *, u_int32_t, u_int32_t, const DBT *,
  486.  * PUBLIC:     u_int32_t));
  487.  */
  488. int
  489. __fop_write_log(dbenv, txnid, ret_lsnp, flags,
  490.     name, appname, offset, page, flag)
  491. DB_ENV *dbenv;
  492. DB_TXN *txnid;
  493. DB_LSN *ret_lsnp;
  494. u_int32_t flags;
  495. const DBT *name;
  496. u_int32_t appname;
  497. u_int32_t offset;
  498. const DBT *page;
  499. u_int32_t flag;
  500. {
  501. DBT logrec;
  502. DB_LSN *lsnp, null_lsn;
  503. u_int32_t zero;
  504. u_int32_t uinttmp;
  505. u_int32_t npad, rectype, txn_num;
  506. int ret;
  507. u_int8_t *bp;
  509. rectype = DB___fop_write;
  510. npad = 0;
  512. if (txnid == NULL) {
  513. txn_num = 0;
  514. null_lsn.file = 0;
  515. null_lsn.offset = 0;
  516. lsnp = &null_lsn;
  517. } else {
  518. if (TAILQ_FIRST(&txnid->kids) != NULL &&
  519.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  520. return (ret);
  521. txn_num = txnid->txnid;
  522. lsnp = &txnid->last_lsn;
  523. }
  525. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  526.     + sizeof(u_int32_t) + (name == NULL ? 0 : name->size)
  527.     + sizeof(u_int32_t)
  528.     + sizeof(u_int32_t)
  529.     + sizeof(u_int32_t) + (page == NULL ? 0 : page->size)
  530.     + sizeof(u_int32_t);
  531. if (CRYPTO_ON(dbenv)) {
  532. npad =
  533.     ((DB_CIPHER *)dbenv->crypto_handle)->adj_size(logrec.size);
  534. logrec.size += npad;
  535. }
  537. if ((ret = __os_malloc(dbenv,
  538.     logrec.size, &logrec.data)) != 0)
  539. return (ret);
  541. if (npad > 0)
  542. memset((u_int8_t *)logrec.data + logrec.size - npad, 0, npad);
  544. bp = logrec.data;
  546. memcpy(bp, &rectype, sizeof(rectype));
  547. bp += sizeof(rectype);
  549. memcpy(bp, &txn_num, sizeof(txn_num));
  550. bp += sizeof(txn_num);
  552. memcpy(bp, lsnp, sizeof(DB_LSN));
  553. bp += sizeof(DB_LSN);
  555. if (name == NULL) {
  556. zero = 0;
  557. memcpy(bp, &zero, sizeof(u_int32_t));
  558. bp += sizeof(u_int32_t);
  559. } else {
  560. memcpy(bp, &name->size, sizeof(name->size));
  561. bp += sizeof(name->size);
  562. memcpy(bp, name->data, name->size);
  563. bp += name->size;
  564. }
  566. uinttmp = (u_int32_t)appname;
  567. memcpy(bp, &uinttmp, sizeof(uinttmp));
  568. bp += sizeof(uinttmp);
  570. uinttmp = (u_int32_t)offset;
  571. memcpy(bp, &uinttmp, sizeof(uinttmp));
  572. bp += sizeof(uinttmp);
  574. if (page == NULL) {
  575. zero = 0;
  576. memcpy(bp, &zero, sizeof(u_int32_t));
  577. bp += sizeof(u_int32_t);
  578. } else {
  579. memcpy(bp, &page->size, sizeof(page->size));
  580. bp += sizeof(page->size);
  581. memcpy(bp, page->data, page->size);
  582. bp += page->size;
  583. }
  585. uinttmp = (u_int32_t)flag;
  586. memcpy(bp, &uinttmp, sizeof(uinttmp));
  587. bp += sizeof(uinttmp);
  589. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
  590. ret = dbenv->log_put(dbenv,
  591.    ret_lsnp, (DBT *)&logrec, flags | DB_NOCOPY);
  592. if (txnid != NULL && ret == 0)
  593. txnid->last_lsn = *ret_lsnp;
  594. #ifdef LOG_DIAGNOSTIC
  595. if (ret != 0)
  596. (void)__fop_write_print(dbenv,
  597.     (DBT *)&logrec, ret_lsnp, NULL, NULL);
  598. #endif
  599. __os_free(dbenv, logrec.data);
  600. return (ret);
  601. }
  603. /*
  604.  * PUBLIC: int __fop_write_getpgnos __P((DB_ENV *, DBT *, DB_LSN *,
  605.  * PUBLIC:     db_recops, void *));
  606.  */
  607. int
  608. __fop_write_getpgnos(dbenv, rec, lsnp, notused1, summary)
  609. DB_ENV *dbenv;
  610. DBT *rec;
  611. DB_LSN *lsnp;
  612. db_recops notused1;
  613. void *summary;
  614. {
  615. TXN_RECS *t;
  616. int ret;
  617. COMPQUIET(rec, NULL);
  618. COMPQUIET(notused1, DB_TXN_ABORT);
  620. t = (TXN_RECS *)summary;
  622. if ((ret = __rep_check_alloc(dbenv, t, 1)) != 0)
  623. return (ret);
  625. t->array[t->npages].flags = LSN_PAGE_NOLOCK;
  626. t->array[t->npages].lsn = *lsnp;
  627. t->array[t->npages].fid = DB_LOGFILEID_INVALID;
  628. memset(&t->array[t->npages].pgdesc, 0,
  629.     sizeof(t->array[t->npages].pgdesc));
  631. t->npages++;
  633. return (0);
  634. }
  636. /*
  637.  * PUBLIC: int __fop_write_print __P((DB_ENV *, DBT *, DB_LSN *,
  638.  * PUBLIC:     db_recops, void *));
  639.  */
  640. int
  641. __fop_write_print(dbenv, dbtp, lsnp, notused2, notused3)
  642. DB_ENV *dbenv;
  643. DBT *dbtp;
  644. DB_LSN *lsnp;
  645. db_recops notused2;
  646. void *notused3;
  647. {
  648. __fop_write_args *argp;
  649. u_int32_t i;
  650. int ch;
  651. int ret;
  653. notused2 = DB_TXN_ABORT;
  654. notused3 = NULL;
  656. if ((ret = __fop_write_read(dbenv, dbtp->data, &argp)) != 0)
  657. return (ret);
  658. (void)printf(
  659.     "[%lu][%lu]__fop_write: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  660.     (u_long)lsnp->file,
  661.     (u_long)lsnp->offset,
  662.     (u_long)argp->type,
  663.     (u_long)argp->txnid->txnid,
  664.     (u_long)argp->prev_lsn.file,
  665.     (u_long)argp->prev_lsn.offset);
  666. (void)printf("tname: ");
  667. for (i = 0; i < argp->name.size; i++) {
  668. ch = ((u_int8_t *)argp->name.data)[i];
  669. printf(isprint(ch) || ch == 0x0a ? "%c" : "%#x ", ch);
  670. }
  671. (void)printf("n");
  672. (void)printf("tappname: %lun", (u_long)argp->appname);
  673. (void)printf("toffset: %lun", (u_long)argp->offset);
  674. (void)printf("tpage: ");
  675. for (i = 0; i < argp->page.size; i++) {
  676. ch = ((u_int8_t *)argp->page.data)[i];
  677. printf(isprint(ch) || ch == 0x0a ? "%c" : "%#x ", ch);
  678. }
  679. (void)printf("n");
  680. (void)printf("tflag: %lun", (u_long)argp->flag);
  681. (void)printf("n");
  682. __os_free(dbenv, argp);
  683. return (0);
  684. }
  686. /*
  687.  * PUBLIC: int __fop_write_read __P((DB_ENV *, void *, __fop_write_args **));
  688.  */
  689. int
  690. __fop_write_read(dbenv, recbuf, argpp)
  691. DB_ENV *dbenv;
  692. void *recbuf;
  693. __fop_write_args **argpp;
  694. {
  695. __fop_write_args *argp;
  696. u_int32_t uinttmp;
  697. u_int8_t *bp;
  698. int ret;
  700. if ((ret = __os_malloc(dbenv,
  701.     sizeof(__fop_write_args) + sizeof(DB_TXN), &argp)) != 0)
  702. return (ret);
  704. argp->txnid = (DB_TXN *)&argp[1];
  706. bp = recbuf;
  707. memcpy(&argp->type, bp, sizeof(argp->type));
  708. bp += sizeof(argp->type);
  710. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  711. bp += sizeof(argp->txnid->txnid);
  713. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  714. bp += sizeof(DB_LSN);
  716. memset(&argp->name, 0, sizeof(argp->name));
  717. memcpy(&argp->name.size, bp, sizeof(u_int32_t));
  718. bp += sizeof(u_int32_t);
  719. argp->name.data = bp;
  720. bp += argp->name.size;
  722. memcpy(&uinttmp, bp, sizeof(uinttmp));
  723. argp->appname = (u_int32_t)uinttmp;
  724. bp += sizeof(uinttmp);
  726. memcpy(&uinttmp, bp, sizeof(uinttmp));
  727. argp->offset = (u_int32_t)uinttmp;
  728. bp += sizeof(uinttmp);
  730. memset(&argp->page, 0, sizeof(argp->page));
  731. memcpy(&argp->page.size, bp, sizeof(u_int32_t));
  732. bp += sizeof(u_int32_t);
  733. argp->page.data = bp;
  734. bp += argp->page.size;
  736. memcpy(&uinttmp, bp, sizeof(uinttmp));
  737. argp->flag = (u_int32_t)uinttmp;
  738. bp += sizeof(uinttmp);
  740. *argpp = argp;
  741. return (0);
  742. }
  744. /*
  745.  * PUBLIC: int __fop_rename_log __P((DB_ENV *, DB_TXN *, DB_LSN *,
  746.  * PUBLIC:     u_int32_t, const DBT *, const DBT *, const DBT *, u_int32_t));
  747.  */
  748. int
  749. __fop_rename_log(dbenv, txnid, ret_lsnp, flags,
  750.     oldname, newname, fileid, appname)
  751. DB_ENV *dbenv;
  752. DB_TXN *txnid;
  753. DB_LSN *ret_lsnp;
  754. u_int32_t flags;
  755. const DBT *oldname;
  756. const DBT *newname;
  757. const DBT *fileid;
  758. u_int32_t appname;
  759. {
  760. DBT logrec;
  761. DB_LSN *lsnp, null_lsn;
  762. u_int32_t zero;
  763. u_int32_t uinttmp;
  764. u_int32_t npad, rectype, txn_num;
  765. int ret;
  766. u_int8_t *bp;
  768. rectype = DB___fop_rename;
  769. npad = 0;
  771. if (txnid == NULL) {
  772. txn_num = 0;
  773. null_lsn.file = 0;
  774. null_lsn.offset = 0;
  775. lsnp = &null_lsn;
  776. } else {
  777. if (TAILQ_FIRST(&txnid->kids) != NULL &&
  778.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  779. return (ret);
  780. txn_num = txnid->txnid;
  781. lsnp = &txnid->last_lsn;
  782. }
  784. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  785.     + sizeof(u_int32_t) + (oldname == NULL ? 0 : oldname->size)
  786.     + sizeof(u_int32_t) + (newname == NULL ? 0 : newname->size)
  787.     + sizeof(u_int32_t) + (fileid == NULL ? 0 : fileid->size)
  788.     + sizeof(u_int32_t);
  789. if (CRYPTO_ON(dbenv)) {
  790. npad =
  791.     ((DB_CIPHER *)dbenv->crypto_handle)->adj_size(logrec.size);
  792. logrec.size += npad;
  793. }
  795. if ((ret = __os_malloc(dbenv,
  796.     logrec.size, &logrec.data)) != 0)
  797. return (ret);
  799. if (npad > 0)
  800. memset((u_int8_t *)logrec.data + logrec.size - npad, 0, npad);
  802. bp = logrec.data;
  804. memcpy(bp, &rectype, sizeof(rectype));
  805. bp += sizeof(rectype);
  807. memcpy(bp, &txn_num, sizeof(txn_num));
  808. bp += sizeof(txn_num);
  810. memcpy(bp, lsnp, sizeof(DB_LSN));
  811. bp += sizeof(DB_LSN);
  813. if (oldname == NULL) {
  814. zero = 0;
  815. memcpy(bp, &zero, sizeof(u_int32_t));
  816. bp += sizeof(u_int32_t);
  817. } else {
  818. memcpy(bp, &oldname->size, sizeof(oldname->size));
  819. bp += sizeof(oldname->size);
  820. memcpy(bp, oldname->data, oldname->size);
  821. bp += oldname->size;
  822. }
  824. if (newname == NULL) {
  825. zero = 0;
  826. memcpy(bp, &zero, sizeof(u_int32_t));
  827. bp += sizeof(u_int32_t);
  828. } else {
  829. memcpy(bp, &newname->size, sizeof(newname->size));
  830. bp += sizeof(newname->size);
  831. memcpy(bp, newname->data, newname->size);
  832. bp += newname->size;
  833. }
  835. if (fileid == NULL) {
  836. zero = 0;
  837. memcpy(bp, &zero, sizeof(u_int32_t));
  838. bp += sizeof(u_int32_t);
  839. } else {
  840. memcpy(bp, &fileid->size, sizeof(fileid->size));
  841. bp += sizeof(fileid->size);
  842. memcpy(bp, fileid->data, fileid->size);
  843. bp += fileid->size;
  844. }
  846. uinttmp = (u_int32_t)appname;
  847. memcpy(bp, &uinttmp, sizeof(uinttmp));
  848. bp += sizeof(uinttmp);
  850. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
  851. ret = dbenv->log_put(dbenv,
  852.    ret_lsnp, (DBT *)&logrec, flags | DB_NOCOPY);
  853. if (txnid != NULL && ret == 0)
  854. txnid->last_lsn = *ret_lsnp;
  855. #ifdef LOG_DIAGNOSTIC
  856. if (ret != 0)
  857. (void)__fop_rename_print(dbenv,
  858.     (DBT *)&logrec, ret_lsnp, NULL, NULL);
  859. #endif
  860. __os_free(dbenv, logrec.data);
  861. return (ret);
  862. }
  864. /*
  865.  * PUBLIC: int __fop_rename_getpgnos __P((DB_ENV *, DBT *, DB_LSN *,
  866.  * PUBLIC:     db_recops, void *));
  867.  */
  868. int
  869. __fop_rename_getpgnos(dbenv, rec, lsnp, notused1, summary)
  870. DB_ENV *dbenv;
  871. DBT *rec;
  872. DB_LSN *lsnp;
  873. db_recops notused1;
  874. void *summary;
  875. {
  876. TXN_RECS *t;
  877. int ret;
  878. COMPQUIET(rec, NULL);
  879. COMPQUIET(notused1, DB_TXN_ABORT);
  881. t = (TXN_RECS *)summary;
  883. if ((ret = __rep_check_alloc(dbenv, t, 1)) != 0)
  884. return (ret);
  886. t->array[t->npages].flags = LSN_PAGE_NOLOCK;
  887. t->array[t->npages].lsn = *lsnp;
  888. t->array[t->npages].fid = DB_LOGFILEID_INVALID;
  889. memset(&t->array[t->npages].pgdesc, 0,
  890.     sizeof(t->array[t->npages].pgdesc));
  892. t->npages++;
  894. return (0);
  895. }
  897. /*
  898.  * PUBLIC: int __fop_rename_print __P((DB_ENV *, DBT *, DB_LSN *,
  899.  * PUBLIC:     db_recops, void *));
  900.  */
  901. int
  902. __fop_rename_print(dbenv, dbtp, lsnp, notused2, notused3)
  903. DB_ENV *dbenv;
  904. DBT *dbtp;
  905. DB_LSN *lsnp;
  906. db_recops notused2;
  907. void *notused3;
  908. {
  909. __fop_rename_args *argp;
  910. u_int32_t i;
  911. int ch;
  912. int ret;
  914. notused2 = DB_TXN_ABORT;
  915. notused3 = NULL;
  917. if ((ret = __fop_rename_read(dbenv, dbtp->data, &argp)) != 0)
  918. return (ret);
  919. (void)printf(
  920.     "[%lu][%lu]__fop_rename: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  921.     (u_long)lsnp->file,
  922.     (u_long)lsnp->offset,
  923.     (u_long)argp->type,
  924.     (u_long)argp->txnid->txnid,
  925.     (u_long)argp->prev_lsn.file,
  926.     (u_long)argp->prev_lsn.offset);
  927. (void)printf("toldname: ");
  928. for (i = 0; i < argp->oldname.size; i++) {
  929. ch = ((u_int8_t *)argp->oldname.data)[i];
  930. printf(isprint(ch) || ch == 0x0a ? "%c" : "%#x ", ch);
  931. }
  932. (void)printf("n");
  933. (void)printf("tnewname: ");
  934. for (i = 0; i < argp->newname.size; i++) {
  935. ch = ((u_int8_t *)argp->newname.data)[i];
  936. printf(isprint(ch) || ch == 0x0a ? "%c" : "%#x ", ch);
  937. }
  938. (void)printf("n");
  939. (void)printf("tfileid: ");
  940. for (i = 0; i < argp->fileid.size; i++) {
  941. ch = ((u_int8_t *)argp->fileid.data)[i];
  942. printf(isprint(ch) || ch == 0x0a ? "%c" : "%#x ", ch);
  943. }
  944. (void)printf("n");
  945. (void)printf("tappname: %lun", (u_long)argp->appname);
  946. (void)printf("n");
  947. __os_free(dbenv, argp);
  948. return (0);
  949. }
  951. /*
  952.  * PUBLIC: int __fop_rename_read __P((DB_ENV *, void *, __fop_rename_args **));
  953.  */
  954. int
  955. __fop_rename_read(dbenv, recbuf, argpp)
  956. DB_ENV *dbenv;
  957. void *recbuf;
  958. __fop_rename_args **argpp;
  959. {
  960. __fop_rename_args *argp;
  961. u_int32_t uinttmp;
  962. u_int8_t *bp;
  963. int ret;
  965. if ((ret = __os_malloc(dbenv,
  966.     sizeof(__fop_rename_args) + sizeof(DB_TXN), &argp)) != 0)
  967. return (ret);
  969. argp->txnid = (DB_TXN *)&argp[1];
  971. bp = recbuf;
  972. memcpy(&argp->type, bp, sizeof(argp->type));
  973. bp += sizeof(argp->type);
  975. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  976. bp += sizeof(argp->txnid->txnid);
  978. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  979. bp += sizeof(DB_LSN);
  981. memset(&argp->oldname, 0, sizeof(argp->oldname));
  982. memcpy(&argp->oldname.size, bp, sizeof(u_int32_t));
  983. bp += sizeof(u_int32_t);
  984. argp->oldname.data = bp;
  985. bp += argp->oldname.size;
  987. memset(&argp->newname, 0, sizeof(argp->newname));
  988. memcpy(&argp->newname.size, bp, sizeof(u_int32_t));
  989. bp += sizeof(u_int32_t);
  990. argp->newname.data = bp;
  991. bp += argp->newname.size;
  993. memset(&argp->fileid, 0, sizeof(argp->fileid));
  994. memcpy(&argp->fileid.size, bp, sizeof(u_int32_t));
  995. bp += sizeof(u_int32_t);
  996. argp->fileid.data = bp;
  997. bp += argp->fileid.size;
  999. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1000. argp->appname = (u_int32_t)uinttmp;
  1001. bp += sizeof(uinttmp);
  1003. *argpp = argp;
  1004. return (0);
  1005. }
  1007. /*
  1008.  * PUBLIC: int __fop_file_remove_log __P((DB_ENV *, DB_TXN *,
  1009.  * PUBLIC:     DB_LSN *, u_int32_t, const DBT *, const DBT *, const DBT *,
  1010.  * PUBLIC:     u_int32_t, u_int32_t));
  1011.  */
  1012. int
  1013. __fop_file_remove_log(dbenv, txnid, ret_lsnp, flags,
  1014.     real_fid, tmp_fid, name, appname, child)
  1015. DB_ENV *dbenv;
  1016. DB_TXN *txnid;
  1017. DB_LSN *ret_lsnp;
  1018. u_int32_t flags;
  1019. const DBT *real_fid;
  1020. const DBT *tmp_fid;
  1021. const DBT *name;
  1022. u_int32_t appname;
  1023. u_int32_t child;
  1024. {
  1025. DBT logrec;
  1026. DB_LSN *lsnp, null_lsn;
  1027. u_int32_t zero;
  1028. u_int32_t uinttmp;
  1029. u_int32_t npad, rectype, txn_num;
  1030. int ret;
  1031. u_int8_t *bp;
  1033. rectype = DB___fop_file_remove;
  1034. npad = 0;
  1036. if (txnid == NULL) {
  1037. txn_num = 0;
  1038. null_lsn.file = 0;
  1039. null_lsn.offset = 0;
  1040. lsnp = &null_lsn;
  1041. } else {
  1042. if (TAILQ_FIRST(&txnid->kids) != NULL &&
  1043.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  1044. return (ret);
  1045. txn_num = txnid->txnid;
  1046. lsnp = &txnid->last_lsn;
  1047. }
  1049. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  1050.     + sizeof(u_int32_t) + (real_fid == NULL ? 0 : real_fid->size)
  1051.     + sizeof(u_int32_t) + (tmp_fid == NULL ? 0 : tmp_fid->size)
  1052.     + sizeof(u_int32_t) + (name == NULL ? 0 : name->size)
  1053.     + sizeof(u_int32_t)
  1054.     + sizeof(u_int32_t);
  1055. if (CRYPTO_ON(dbenv)) {
  1056. npad =
  1057.     ((DB_CIPHER *)dbenv->crypto_handle)->adj_size(logrec.size);
  1058. logrec.size += npad;
  1059. }
  1061. if ((ret = __os_malloc(dbenv,
  1062.     logrec.size, &logrec.data)) != 0)
  1063. return (ret);
  1065. if (npad > 0)
  1066. memset((u_int8_t *)logrec.data + logrec.size - npad, 0, npad);
  1068. bp = logrec.data;
  1070. memcpy(bp, &rectype, sizeof(rectype));
  1071. bp += sizeof(rectype);
  1073. memcpy(bp, &txn_num, sizeof(txn_num));
  1074. bp += sizeof(txn_num);
  1076. memcpy(bp, lsnp, sizeof(DB_LSN));
  1077. bp += sizeof(DB_LSN);
  1079. if (real_fid == NULL) {
  1080. zero = 0;
  1081. memcpy(bp, &zero, sizeof(u_int32_t));
  1082. bp += sizeof(u_int32_t);
  1083. } else {
  1084. memcpy(bp, &real_fid->size, sizeof(real_fid->size));
  1085. bp += sizeof(real_fid->size);
  1086. memcpy(bp, real_fid->data, real_fid->size);
  1087. bp += real_fid->size;
  1088. }
  1090. if (tmp_fid == NULL) {
  1091. zero = 0;
  1092. memcpy(bp, &zero, sizeof(u_int32_t));
  1093. bp += sizeof(u_int32_t);
  1094. } else {
  1095. memcpy(bp, &tmp_fid->size, sizeof(tmp_fid->size));
  1096. bp += sizeof(tmp_fid->size);
  1097. memcpy(bp, tmp_fid->data, tmp_fid->size);
  1098. bp += tmp_fid->size;
  1099. }
  1101. if (name == NULL) {
  1102. zero = 0;
  1103. memcpy(bp, &zero, sizeof(u_int32_t));
  1104. bp += sizeof(u_int32_t);
  1105. } else {
  1106. memcpy(bp, &name->size, sizeof(name->size));
  1107. bp += sizeof(name->size);
  1108. memcpy(bp, name->data, name->size);
  1109. bp += name->size;
  1110. }
  1112. uinttmp = (u_int32_t)appname;
  1113. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1114. bp += sizeof(uinttmp);
  1116. uinttmp = (u_int32_t)child;
  1117. memcpy(bp, &uinttmp, sizeof(uinttmp));
  1118. bp += sizeof(uinttmp);
  1120. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) <= logrec.size);
  1121. ret = dbenv->log_put(dbenv,
  1122.    ret_lsnp, (DBT *)&logrec, flags | DB_NOCOPY);
  1123. if (txnid != NULL && ret == 0)
  1124. txnid->last_lsn = *ret_lsnp;
  1125. #ifdef LOG_DIAGNOSTIC
  1126. if (ret != 0)
  1127. (void)__fop_file_remove_print(dbenv,
  1128.     (DBT *)&logrec, ret_lsnp, NULL, NULL);
  1129. #endif
  1130. __os_free(dbenv, logrec.data);
  1131. return (ret);
  1132. }
  1134. /*
  1135.  * PUBLIC: int __fop_file_remove_getpgnos __P((DB_ENV *, DBT *,
  1136.  * PUBLIC:     DB_LSN *, db_recops, void *));
  1137.  */
  1138. int
  1139. __fop_file_remove_getpgnos(dbenv, rec, lsnp, notused1, summary)
  1140. DB_ENV *dbenv;
  1141. DBT *rec;
  1142. DB_LSN *lsnp;
  1143. db_recops notused1;
  1144. void *summary;
  1145. {
  1146. TXN_RECS *t;
  1147. int ret;
  1148. COMPQUIET(rec, NULL);
  1149. COMPQUIET(notused1, DB_TXN_ABORT);
  1151. t = (TXN_RECS *)summary;
  1153. if ((ret = __rep_check_alloc(dbenv, t, 1)) != 0)
  1154. return (ret);
  1156. t->array[t->npages].flags = LSN_PAGE_NOLOCK;
  1157. t->array[t->npages].lsn = *lsnp;
  1158. t->array[t->npages].fid = DB_LOGFILEID_INVALID;
  1159. memset(&t->array[t->npages].pgdesc, 0,
  1160.     sizeof(t->array[t->npages].pgdesc));
  1162. t->npages++;
  1164. return (0);
  1165. }
  1167. /*
  1168.  * PUBLIC: int __fop_file_remove_print __P((DB_ENV *, DBT *,
  1169.  * PUBLIC:     DB_LSN *, db_recops, void *));
  1170.  */
  1171. int
  1172. __fop_file_remove_print(dbenv, dbtp, lsnp, notused2, notused3)
  1173. DB_ENV *dbenv;
  1174. DBT *dbtp;
  1175. DB_LSN *lsnp;
  1176. db_recops notused2;
  1177. void *notused3;
  1178. {
  1179. __fop_file_remove_args *argp;
  1180. u_int32_t i;
  1181. int ch;
  1182. int ret;
  1184. notused2 = DB_TXN_ABORT;
  1185. notused3 = NULL;
  1187. if ((ret = __fop_file_remove_read(dbenv, dbtp->data, &argp)) != 0)
  1188. return (ret);
  1189. (void)printf(
  1190.     "[%lu][%lu]__fop_file_remove: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  1191.     (u_long)lsnp->file,
  1192.     (u_long)lsnp->offset,
  1193.     (u_long)argp->type,
  1194.     (u_long)argp->txnid->txnid,
  1195.     (u_long)argp->prev_lsn.file,
  1196.     (u_long)argp->prev_lsn.offset);
  1197. (void)printf("treal_fid: ");
  1198. for (i = 0; i < argp->real_fid.size; i++) {
  1199. ch = ((u_int8_t *)argp->real_fid.data)[i];
  1200. printf(isprint(ch) || ch == 0x0a ? "%c" : "%#x ", ch);
  1201. }
  1202. (void)printf("n");
  1203. (void)printf("ttmp_fid: ");
  1204. for (i = 0; i < argp->tmp_fid.size; i++) {
  1205. ch = ((u_int8_t *)argp->tmp_fid.data)[i];
  1206. printf(isprint(ch) || ch == 0x0a ? "%c" : "%#x ", ch);
  1207. }
  1208. (void)printf("n");
  1209. (void)printf("tname: ");
  1210. for (i = 0; i < argp->name.size; i++) {
  1211. ch = ((u_int8_t *)argp->name.data)[i];
  1212. printf(isprint(ch) || ch == 0x0a ? "%c" : "%#x ", ch);
  1213. }
  1214. (void)printf("n");
  1215. (void)printf("tappname: %lun", (u_long)argp->appname);
  1216. (void)printf("tchild: 0x%lxn", (u_long)argp->child);
  1217. (void)printf("n");
  1218. __os_free(dbenv, argp);
  1219. return (0);
  1220. }
  1222. /*
  1223.  * PUBLIC: int __fop_file_remove_read __P((DB_ENV *, void *,
  1224.  * PUBLIC:     __fop_file_remove_args **));
  1225.  */
  1226. int
  1227. __fop_file_remove_read(dbenv, recbuf, argpp)
  1228. DB_ENV *dbenv;
  1229. void *recbuf;
  1230. __fop_file_remove_args **argpp;
  1231. {
  1232. __fop_file_remove_args *argp;
  1233. u_int32_t uinttmp;
  1234. u_int8_t *bp;
  1235. int ret;
  1237. if ((ret = __os_malloc(dbenv,
  1238.     sizeof(__fop_file_remove_args) + sizeof(DB_TXN), &argp)) != 0)
  1239. return (ret);
  1241. argp->txnid = (DB_TXN *)&argp[1];
  1243. bp = recbuf;
  1244. memcpy(&argp->type, bp, sizeof(argp->type));
  1245. bp += sizeof(argp->type);
  1247. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  1248. bp += sizeof(argp->txnid->txnid);
  1250. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  1251. bp += sizeof(DB_LSN);
  1253. memset(&argp->real_fid, 0, sizeof(argp->real_fid));
  1254. memcpy(&argp->real_fid.size, bp, sizeof(u_int32_t));
  1255. bp += sizeof(u_int32_t);
  1256. argp->real_fid.data = bp;
  1257. bp += argp->real_fid.size;
  1259. memset(&argp->tmp_fid, 0, sizeof(argp->tmp_fid));
  1260. memcpy(&argp->tmp_fid.size, bp, sizeof(u_int32_t));
  1261. bp += sizeof(u_int32_t);
  1262. argp->tmp_fid.data = bp;
  1263. bp += argp->tmp_fid.size;
  1265. memset(&argp->name, 0, sizeof(argp->name));
  1266. memcpy(&argp->name.size, bp, sizeof(u_int32_t));
  1267. bp += sizeof(u_int32_t);
  1268. argp->name.data = bp;
  1269. bp += argp->name.size;
  1271. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1272. argp->appname = (u_int32_t)uinttmp;
  1273. bp += sizeof(uinttmp);
  1275. memcpy(&uinttmp, bp, sizeof(uinttmp));
  1276. argp->child = (u_int32_t)uinttmp;
  1277. bp += sizeof(uinttmp);
  1279. *argpp = argp;
  1280. return (0);
  1281. }
  1283. /*
  1284.  * PUBLIC: int __fop_init_print __P((DB_ENV *, int (***)(DB_ENV *,
  1285.  * PUBLIC:     DBT *, DB_LSN *, db_recops, void *), size_t *));
  1286.  */
  1287. int
  1288. __fop_init_print(dbenv, dtabp, dtabsizep)
  1289. DB_ENV *dbenv;
  1290. int (***dtabp)__P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  1291. size_t *dtabsizep;
  1292. {
  1293. int ret;
  1295. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  1296.     __fop_create_print, DB___fop_create)) != 0)
  1297. return (ret);
  1298. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  1299.     __fop_remove_print, DB___fop_remove)) != 0)
  1300. return (ret);
  1301. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  1302.     __fop_write_print, DB___fop_write)) != 0)
  1303. return (ret);
  1304. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  1305.     __fop_rename_print, DB___fop_rename)) != 0)
  1306. return (ret);
  1307. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  1308.     __fop_file_remove_print, DB___fop_file_remove)) != 0)
  1309. return (ret);
  1310. return (0);
  1311. }
  1313. /*
  1314.  * PUBLIC: int __fop_init_getpgnos __P((DB_ENV *, int (***)(DB_ENV *,
  1315.  * PUBLIC:     DBT *, DB_LSN *, db_recops, void *), size_t *));
  1316.  */
  1317. int
  1318. __fop_init_getpgnos(dbenv, dtabp, dtabsizep)
  1319. DB_ENV *dbenv;
  1320. int (***dtabp)__P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  1321. size_t *dtabsizep;
  1322. {
  1323. int ret;
  1325. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  1326.     __fop_create_getpgnos, DB___fop_create)) != 0)
  1327. return (ret);
  1328. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  1329.     __fop_remove_getpgnos, DB___fop_remove)) != 0)
  1330. return (ret);
  1331. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  1332.     __fop_write_getpgnos, DB___fop_write)) != 0)
  1333. return (ret);
  1334. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  1335.     __fop_rename_getpgnos, DB___fop_rename)) != 0)
  1336. return (ret);
  1337. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  1338.     __fop_file_remove_getpgnos, DB___fop_file_remove)) != 0)
  1339. return (ret);
  1340. return (0);
  1341. }
  1343. /*
  1344.  * PUBLIC: int __fop_init_recover __P((DB_ENV *, int (***)(DB_ENV *,
  1345.  * PUBLIC:     DBT *, DB_LSN *, db_recops, void *), size_t *));
  1346.  */
  1347. int
  1348. __fop_init_recover(dbenv, dtabp, dtabsizep)
  1349. DB_ENV *dbenv;
  1350. int (***dtabp)__P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  1351. size_t *dtabsizep;
  1352. {
  1353. int ret;
  1355. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  1356.     __fop_create_recover, DB___fop_create)) != 0)
  1357. return (ret);
  1358. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  1359.     __fop_remove_recover, DB___fop_remove)) != 0)
  1360. return (ret);
  1361. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  1362.     __fop_write_recover, DB___fop_write)) != 0)
  1363. return (ret);
  1364. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  1365.     __fop_rename_recover, DB___fop_rename)) != 0)
  1366. return (ret);
  1367. if ((ret = __db_add_recovery(dbenv, dtabp, dtabsizep,
  1368.     __fop_file_remove_recover, DB___fop_file_remove)) != 0)
  1369. return (ret);
  1370. return (0);
  1371. }