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

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

MySQL数据库

开发平台：

Visual C++

crdel_auto.c：源码内容
  1. /* Do not edit: automatically built by gen_rec.awk. */
  2. #include "db_config.h"
  4. #ifndef NO_SYSTEM_INCLUDES
  5. #include <sys/types.h>
  7. #include <ctype.h>
  8. #include <errno.h>
  9. #include <string.h>
  10. #endif
  12. #include "db_int.h"
  13. #include "db_page.h"
  14. #include "db_dispatch.h"
  15. #include "db_am.h"
  16. #include "txn.h"
  18. int
  19. __crdel_fileopen_log(dbenv, txnid, ret_lsnp, flags,
  20. name, mode)
  21. DB_ENV *dbenv;
  22. DB_TXN *txnid;
  23. DB_LSN *ret_lsnp;
  24. u_int32_t flags;
  25. const DBT *name;
  26. u_int32_t mode;
  27. {
  28. DBT logrec;
  29. DB_LSN *lsnp, null_lsn;
  30. u_int32_t zero;
  31. u_int32_t rectype, txn_num;
  32. int ret;
  33. u_int8_t *bp;
  35. rectype = DB_crdel_fileopen;
  36. if (txnid != NULL &&
  37.     TAILQ_FIRST(&txnid->kids) != NULL &&
  38.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  39. return (ret);
  40. txn_num = txnid == NULL ? 0 : txnid->txnid;
  41. if (txnid == NULL) {
  42. ZERO_LSN(null_lsn);
  43. lsnp = &null_lsn;
  44. } else
  45. lsnp = &txnid->last_lsn;
  46. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  47.     + sizeof(u_int32_t) + (name == NULL ? 0 : name->size)
  48.     + sizeof(mode);
  49. if ((ret = __os_malloc(dbenv, logrec.size, NULL, &logrec.data)) != 0)
  50. return (ret);
  52. bp = logrec.data;
  53. memcpy(bp, &rectype, sizeof(rectype));
  54. bp += sizeof(rectype);
  55. memcpy(bp, &txn_num, sizeof(txn_num));
  56. bp += sizeof(txn_num);
  57. memcpy(bp, lsnp, sizeof(DB_LSN));
  58. bp += sizeof(DB_LSN);
  59. if (name == NULL) {
  60. zero = 0;
  61. memcpy(bp, &zero, sizeof(u_int32_t));
  62. bp += sizeof(u_int32_t);
  63. } else {
  64. memcpy(bp, &name->size, sizeof(name->size));
  65. bp += sizeof(name->size);
  66. memcpy(bp, name->data, name->size);
  67. bp += name->size;
  68. }
  69. memcpy(bp, &mode, sizeof(mode));
  70. bp += sizeof(mode);
  71. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size);
  72. ret = log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags);
  73. if (txnid != NULL)
  74. txnid->last_lsn = *ret_lsnp;
  75. __os_free(logrec.data, logrec.size);
  76. return (ret);
  77. }
  79. int
  80. __crdel_fileopen_print(dbenv, dbtp, lsnp, notused2, notused3)
  81. DB_ENV *dbenv;
  82. DBT *dbtp;
  83. DB_LSN *lsnp;
  84. db_recops notused2;
  85. void *notused3;
  86. {
  87. __crdel_fileopen_args *argp;
  88. u_int32_t i;
  89. u_int ch;
  90. int ret;
  92. i = 0;
  93. ch = 0;
  94. notused2 = DB_TXN_ABORT;
  95. notused3 = NULL;
  97. if ((ret = __crdel_fileopen_read(dbenv, dbtp->data, &argp)) != 0)
  98. return (ret);
  99. printf("[%lu][%lu]crdel_fileopen: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  100.     (u_long)lsnp->file,
  101.     (u_long)lsnp->offset,
  102.     (u_long)argp->type,
  103.     (u_long)argp->txnid->txnid,
  104.     (u_long)argp->prev_lsn.file,
  105.     (u_long)argp->prev_lsn.offset);
  106. printf("tname: ");
  107. for (i = 0; i < argp->name.size; i++) {
  108. ch = ((u_int8_t *)argp->name.data)[i];
  109. if (isprint(ch) || ch == 0xa)
  110. putchar(ch);
  111. else
  112. printf("%#x ", ch);
  113. }
  114. printf("n");
  115. printf("tmode: %on", argp->mode);
  116. printf("n");
  117. __os_free(argp, 0);
  118. return (0);
  119. }
  121. int
  122. __crdel_fileopen_read(dbenv, recbuf, argpp)
  123. DB_ENV *dbenv;
  124. void *recbuf;
  125. __crdel_fileopen_args **argpp;
  126. {
  127. __crdel_fileopen_args *argp;
  128. u_int8_t *bp;
  129. int ret;
  131. ret = __os_malloc(dbenv, sizeof(__crdel_fileopen_args) +
  132.     sizeof(DB_TXN), NULL, &argp);
  133. if (ret != 0)
  134. return (ret);
  135. argp->txnid = (DB_TXN *)&argp[1];
  136. bp = recbuf;
  137. memcpy(&argp->type, bp, sizeof(argp->type));
  138. bp += sizeof(argp->type);
  139. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  140. bp += sizeof(argp->txnid->txnid);
  141. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  142. bp += sizeof(DB_LSN);
  143. memset(&argp->name, 0, sizeof(argp->name));
  144. memcpy(&argp->name.size, bp, sizeof(u_int32_t));
  145. bp += sizeof(u_int32_t);
  146. argp->name.data = bp;
  147. bp += argp->name.size;
  148. memcpy(&argp->mode, bp, sizeof(argp->mode));
  149. bp += sizeof(argp->mode);
  150. *argpp = argp;
  151. return (0);
  152. }
  154. int
  155. __crdel_metasub_log(dbenv, txnid, ret_lsnp, flags,
  156. fileid, pgno, page, lsn)
  157. DB_ENV *dbenv;
  158. DB_TXN *txnid;
  159. DB_LSN *ret_lsnp;
  160. u_int32_t flags;
  161. int32_t fileid;
  162. db_pgno_t pgno;
  163. const DBT *page;
  164. DB_LSN * lsn;
  165. {
  166. DBT logrec;
  167. DB_LSN *lsnp, null_lsn;
  168. u_int32_t zero;
  169. u_int32_t rectype, txn_num;
  170. int ret;
  171. u_int8_t *bp;
  173. rectype = DB_crdel_metasub;
  174. if (txnid != NULL &&
  175.     TAILQ_FIRST(&txnid->kids) != NULL &&
  176.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  177. return (ret);
  178. txn_num = txnid == NULL ? 0 : txnid->txnid;
  179. if (txnid == NULL) {
  180. ZERO_LSN(null_lsn);
  181. lsnp = &null_lsn;
  182. } else
  183. lsnp = &txnid->last_lsn;
  184. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  185.     + sizeof(fileid)
  186.     + sizeof(pgno)
  187.     + sizeof(u_int32_t) + (page == NULL ? 0 : page->size)
  188.     + sizeof(*lsn);
  189. if ((ret = __os_malloc(dbenv, logrec.size, NULL, &logrec.data)) != 0)
  190. return (ret);
  192. bp = logrec.data;
  193. memcpy(bp, &rectype, sizeof(rectype));
  194. bp += sizeof(rectype);
  195. memcpy(bp, &txn_num, sizeof(txn_num));
  196. bp += sizeof(txn_num);
  197. memcpy(bp, lsnp, sizeof(DB_LSN));
  198. bp += sizeof(DB_LSN);
  199. memcpy(bp, &fileid, sizeof(fileid));
  200. bp += sizeof(fileid);
  201. memcpy(bp, &pgno, sizeof(pgno));
  202. bp += sizeof(pgno);
  203. if (page == NULL) {
  204. zero = 0;
  205. memcpy(bp, &zero, sizeof(u_int32_t));
  206. bp += sizeof(u_int32_t);
  207. } else {
  208. memcpy(bp, &page->size, sizeof(page->size));
  209. bp += sizeof(page->size);
  210. memcpy(bp, page->data, page->size);
  211. bp += page->size;
  212. }
  213. if (lsn != NULL)
  214. memcpy(bp, lsn, sizeof(*lsn));
  215. else
  216. memset(bp, 0, sizeof(*lsn));
  217. bp += sizeof(*lsn);
  218. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size);
  219. ret = log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags);
  220. if (txnid != NULL)
  221. txnid->last_lsn = *ret_lsnp;
  222. __os_free(logrec.data, logrec.size);
  223. return (ret);
  224. }
  226. int
  227. __crdel_metasub_print(dbenv, dbtp, lsnp, notused2, notused3)
  228. DB_ENV *dbenv;
  229. DBT *dbtp;
  230. DB_LSN *lsnp;
  231. db_recops notused2;
  232. void *notused3;
  233. {
  234. __crdel_metasub_args *argp;
  235. u_int32_t i;
  236. u_int ch;
  237. int ret;
  239. i = 0;
  240. ch = 0;
  241. notused2 = DB_TXN_ABORT;
  242. notused3 = NULL;
  244. if ((ret = __crdel_metasub_read(dbenv, dbtp->data, &argp)) != 0)
  245. return (ret);
  246. printf("[%lu][%lu]crdel_metasub: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  247.     (u_long)lsnp->file,
  248.     (u_long)lsnp->offset,
  249.     (u_long)argp->type,
  250.     (u_long)argp->txnid->txnid,
  251.     (u_long)argp->prev_lsn.file,
  252.     (u_long)argp->prev_lsn.offset);
  253. printf("tfileid: %ldn", (long)argp->fileid);
  254. printf("tpgno: %dn", argp->pgno);
  255. printf("tpage: ");
  256. for (i = 0; i < argp->page.size; i++) {
  257. ch = ((u_int8_t *)argp->page.data)[i];
  258. if (isprint(ch) || ch == 0xa)
  259. putchar(ch);
  260. else
  261. printf("%#x ", ch);
  262. }
  263. printf("n");
  264. printf("tlsn: [%lu][%lu]n",
  265.     (u_long)argp->lsn.file, (u_long)argp->lsn.offset);
  266. printf("n");
  267. __os_free(argp, 0);
  268. return (0);
  269. }
  271. int
  272. __crdel_metasub_read(dbenv, recbuf, argpp)
  273. DB_ENV *dbenv;
  274. void *recbuf;
  275. __crdel_metasub_args **argpp;
  276. {
  277. __crdel_metasub_args *argp;
  278. u_int8_t *bp;
  279. int ret;
  281. ret = __os_malloc(dbenv, sizeof(__crdel_metasub_args) +
  282.     sizeof(DB_TXN), NULL, &argp);
  283. if (ret != 0)
  284. return (ret);
  285. argp->txnid = (DB_TXN *)&argp[1];
  286. bp = recbuf;
  287. memcpy(&argp->type, bp, sizeof(argp->type));
  288. bp += sizeof(argp->type);
  289. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  290. bp += sizeof(argp->txnid->txnid);
  291. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  292. bp += sizeof(DB_LSN);
  293. memcpy(&argp->fileid, bp, sizeof(argp->fileid));
  294. bp += sizeof(argp->fileid);
  295. memcpy(&argp->pgno, bp, sizeof(argp->pgno));
  296. bp += sizeof(argp->pgno);
  297. memset(&argp->page, 0, sizeof(argp->page));
  298. memcpy(&argp->page.size, bp, sizeof(u_int32_t));
  299. bp += sizeof(u_int32_t);
  300. argp->page.data = bp;
  301. bp += argp->page.size;
  302. memcpy(&argp->lsn, bp,  sizeof(argp->lsn));
  303. bp += sizeof(argp->lsn);
  304. *argpp = argp;
  305. return (0);
  306. }
  308. int
  309. __crdel_metapage_log(dbenv, txnid, ret_lsnp, flags,
  310. fileid, name, pgno, page)
  311. DB_ENV *dbenv;
  312. DB_TXN *txnid;
  313. DB_LSN *ret_lsnp;
  314. u_int32_t flags;
  315. int32_t fileid;
  316. const DBT *name;
  317. db_pgno_t pgno;
  318. const DBT *page;
  319. {
  320. DBT logrec;
  321. DB_LSN *lsnp, null_lsn;
  322. u_int32_t zero;
  323. u_int32_t rectype, txn_num;
  324. int ret;
  325. u_int8_t *bp;
  327. rectype = DB_crdel_metapage;
  328. if (txnid != NULL &&
  329.     TAILQ_FIRST(&txnid->kids) != NULL &&
  330.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  331. return (ret);
  332. txn_num = txnid == NULL ? 0 : txnid->txnid;
  333. if (txnid == NULL) {
  334. ZERO_LSN(null_lsn);
  335. lsnp = &null_lsn;
  336. } else
  337. lsnp = &txnid->last_lsn;
  338. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  339.     + sizeof(fileid)
  340.     + sizeof(u_int32_t) + (name == NULL ? 0 : name->size)
  341.     + sizeof(pgno)
  342.     + sizeof(u_int32_t) + (page == NULL ? 0 : page->size);
  343. if ((ret = __os_malloc(dbenv, logrec.size, NULL, &logrec.data)) != 0)
  344. return (ret);
  346. bp = logrec.data;
  347. memcpy(bp, &rectype, sizeof(rectype));
  348. bp += sizeof(rectype);
  349. memcpy(bp, &txn_num, sizeof(txn_num));
  350. bp += sizeof(txn_num);
  351. memcpy(bp, lsnp, sizeof(DB_LSN));
  352. bp += sizeof(DB_LSN);
  353. memcpy(bp, &fileid, sizeof(fileid));
  354. bp += sizeof(fileid);
  355. if (name == NULL) {
  356. zero = 0;
  357. memcpy(bp, &zero, sizeof(u_int32_t));
  358. bp += sizeof(u_int32_t);
  359. } else {
  360. memcpy(bp, &name->size, sizeof(name->size));
  361. bp += sizeof(name->size);
  362. memcpy(bp, name->data, name->size);
  363. bp += name->size;
  364. }
  365. memcpy(bp, &pgno, sizeof(pgno));
  366. bp += sizeof(pgno);
  367. if (page == NULL) {
  368. zero = 0;
  369. memcpy(bp, &zero, sizeof(u_int32_t));
  370. bp += sizeof(u_int32_t);
  371. } else {
  372. memcpy(bp, &page->size, sizeof(page->size));
  373. bp += sizeof(page->size);
  374. memcpy(bp, page->data, page->size);
  375. bp += page->size;
  376. }
  377. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size);
  378. ret = log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags);
  379. if (txnid != NULL)
  380. txnid->last_lsn = *ret_lsnp;
  381. __os_free(logrec.data, logrec.size);
  382. return (ret);
  383. }
  385. int
  386. __crdel_metapage_print(dbenv, dbtp, lsnp, notused2, notused3)
  387. DB_ENV *dbenv;
  388. DBT *dbtp;
  389. DB_LSN *lsnp;
  390. db_recops notused2;
  391. void *notused3;
  392. {
  393. __crdel_metapage_args *argp;
  394. u_int32_t i;
  395. u_int ch;
  396. int ret;
  398. i = 0;
  399. ch = 0;
  400. notused2 = DB_TXN_ABORT;
  401. notused3 = NULL;
  403. if ((ret = __crdel_metapage_read(dbenv, dbtp->data, &argp)) != 0)
  404. return (ret);
  405. printf("[%lu][%lu]crdel_metapage: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  406.     (u_long)lsnp->file,
  407.     (u_long)lsnp->offset,
  408.     (u_long)argp->type,
  409.     (u_long)argp->txnid->txnid,
  410.     (u_long)argp->prev_lsn.file,
  411.     (u_long)argp->prev_lsn.offset);
  412. printf("tfileid: %ldn", (long)argp->fileid);
  413. printf("tname: ");
  414. for (i = 0; i < argp->name.size; i++) {
  415. ch = ((u_int8_t *)argp->name.data)[i];
  416. if (isprint(ch) || ch == 0xa)
  417. putchar(ch);
  418. else
  419. printf("%#x ", ch);
  420. }
  421. printf("n");
  422. printf("tpgno: %dn", argp->pgno);
  423. printf("tpage: ");
  424. for (i = 0; i < argp->page.size; i++) {
  425. ch = ((u_int8_t *)argp->page.data)[i];
  426. if (isprint(ch) || ch == 0xa)
  427. putchar(ch);
  428. else
  429. printf("%#x ", ch);
  430. }
  431. printf("n");
  432. printf("n");
  433. __os_free(argp, 0);
  434. return (0);
  435. }
  437. int
  438. __crdel_metapage_read(dbenv, recbuf, argpp)
  439. DB_ENV *dbenv;
  440. void *recbuf;
  441. __crdel_metapage_args **argpp;
  442. {
  443. __crdel_metapage_args *argp;
  444. u_int8_t *bp;
  445. int ret;
  447. ret = __os_malloc(dbenv, sizeof(__crdel_metapage_args) +
  448.     sizeof(DB_TXN), NULL, &argp);
  449. if (ret != 0)
  450. return (ret);
  451. argp->txnid = (DB_TXN *)&argp[1];
  452. bp = recbuf;
  453. memcpy(&argp->type, bp, sizeof(argp->type));
  454. bp += sizeof(argp->type);
  455. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  456. bp += sizeof(argp->txnid->txnid);
  457. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  458. bp += sizeof(DB_LSN);
  459. memcpy(&argp->fileid, bp, sizeof(argp->fileid));
  460. bp += sizeof(argp->fileid);
  461. memset(&argp->name, 0, sizeof(argp->name));
  462. memcpy(&argp->name.size, bp, sizeof(u_int32_t));
  463. bp += sizeof(u_int32_t);
  464. argp->name.data = bp;
  465. bp += argp->name.size;
  466. memcpy(&argp->pgno, bp, sizeof(argp->pgno));
  467. bp += sizeof(argp->pgno);
  468. memset(&argp->page, 0, sizeof(argp->page));
  469. memcpy(&argp->page.size, bp, sizeof(u_int32_t));
  470. bp += sizeof(u_int32_t);
  471. argp->page.data = bp;
  472. bp += argp->page.size;
  473. *argpp = argp;
  474. return (0);
  475. }
  477. int
  478. __crdel_old_delete_print(dbenv, dbtp, lsnp, notused2, notused3)
  479. DB_ENV *dbenv;
  480. DBT *dbtp;
  481. DB_LSN *lsnp;
  482. db_recops notused2;
  483. void *notused3;
  484. {
  485. __crdel_old_delete_args *argp;
  486. u_int32_t i;
  487. u_int ch;
  488. int ret;
  490. i = 0;
  491. ch = 0;
  492. notused2 = DB_TXN_ABORT;
  493. notused3 = NULL;
  495. if ((ret = __crdel_old_delete_read(dbenv, dbtp->data, &argp)) != 0)
  496. return (ret);
  497. printf("[%lu][%lu]crdel_old_delete: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  498.     (u_long)lsnp->file,
  499.     (u_long)lsnp->offset,
  500.     (u_long)argp->type,
  501.     (u_long)argp->txnid->txnid,
  502.     (u_long)argp->prev_lsn.file,
  503.     (u_long)argp->prev_lsn.offset);
  504. printf("tname: ");
  505. for (i = 0; i < argp->name.size; i++) {
  506. ch = ((u_int8_t *)argp->name.data)[i];
  507. if (isprint(ch) || ch == 0xa)
  508. putchar(ch);
  509. else
  510. printf("%#x ", ch);
  511. }
  512. printf("n");
  513. printf("n");
  514. __os_free(argp, 0);
  515. return (0);
  516. }
  518. int
  519. __crdel_old_delete_read(dbenv, recbuf, argpp)
  520. DB_ENV *dbenv;
  521. void *recbuf;
  522. __crdel_old_delete_args **argpp;
  523. {
  524. __crdel_old_delete_args *argp;
  525. u_int8_t *bp;
  526. int ret;
  528. ret = __os_malloc(dbenv, sizeof(__crdel_old_delete_args) +
  529.     sizeof(DB_TXN), NULL, &argp);
  530. if (ret != 0)
  531. return (ret);
  532. argp->txnid = (DB_TXN *)&argp[1];
  533. bp = recbuf;
  534. memcpy(&argp->type, bp, sizeof(argp->type));
  535. bp += sizeof(argp->type);
  536. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  537. bp += sizeof(argp->txnid->txnid);
  538. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  539. bp += sizeof(DB_LSN);
  540. memset(&argp->name, 0, sizeof(argp->name));
  541. memcpy(&argp->name.size, bp, sizeof(u_int32_t));
  542. bp += sizeof(u_int32_t);
  543. argp->name.data = bp;
  544. bp += argp->name.size;
  545. *argpp = argp;
  546. return (0);
  547. }
  549. int
  550. __crdel_rename_log(dbenv, txnid, ret_lsnp, flags,
  551. fileid, name, newname)
  552. DB_ENV *dbenv;
  553. DB_TXN *txnid;
  554. DB_LSN *ret_lsnp;
  555. u_int32_t flags;
  556. int32_t fileid;
  557. const DBT *name;
  558. const DBT *newname;
  559. {
  560. DBT logrec;
  561. DB_LSN *lsnp, null_lsn;
  562. u_int32_t zero;
  563. u_int32_t rectype, txn_num;
  564. int ret;
  565. u_int8_t *bp;
  567. rectype = DB_crdel_rename;
  568. if (txnid != NULL &&
  569.     TAILQ_FIRST(&txnid->kids) != NULL &&
  570.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  571. return (ret);
  572. txn_num = txnid == NULL ? 0 : txnid->txnid;
  573. if (txnid == NULL) {
  574. ZERO_LSN(null_lsn);
  575. lsnp = &null_lsn;
  576. } else
  577. lsnp = &txnid->last_lsn;
  578. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  579.     + sizeof(fileid)
  580.     + sizeof(u_int32_t) + (name == NULL ? 0 : name->size)
  581.     + sizeof(u_int32_t) + (newname == NULL ? 0 : newname->size);
  582. if ((ret = __os_malloc(dbenv, logrec.size, NULL, &logrec.data)) != 0)
  583. return (ret);
  585. bp = logrec.data;
  586. memcpy(bp, &rectype, sizeof(rectype));
  587. bp += sizeof(rectype);
  588. memcpy(bp, &txn_num, sizeof(txn_num));
  589. bp += sizeof(txn_num);
  590. memcpy(bp, lsnp, sizeof(DB_LSN));
  591. bp += sizeof(DB_LSN);
  592. memcpy(bp, &fileid, sizeof(fileid));
  593. bp += sizeof(fileid);
  594. if (name == NULL) {
  595. zero = 0;
  596. memcpy(bp, &zero, sizeof(u_int32_t));
  597. bp += sizeof(u_int32_t);
  598. } else {
  599. memcpy(bp, &name->size, sizeof(name->size));
  600. bp += sizeof(name->size);
  601. memcpy(bp, name->data, name->size);
  602. bp += name->size;
  603. }
  604. if (newname == NULL) {
  605. zero = 0;
  606. memcpy(bp, &zero, sizeof(u_int32_t));
  607. bp += sizeof(u_int32_t);
  608. } else {
  609. memcpy(bp, &newname->size, sizeof(newname->size));
  610. bp += sizeof(newname->size);
  611. memcpy(bp, newname->data, newname->size);
  612. bp += newname->size;
  613. }
  614. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size);
  615. ret = log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags);
  616. if (txnid != NULL)
  617. txnid->last_lsn = *ret_lsnp;
  618. __os_free(logrec.data, logrec.size);
  619. return (ret);
  620. }
  622. int
  623. __crdel_rename_print(dbenv, dbtp, lsnp, notused2, notused3)
  624. DB_ENV *dbenv;
  625. DBT *dbtp;
  626. DB_LSN *lsnp;
  627. db_recops notused2;
  628. void *notused3;
  629. {
  630. __crdel_rename_args *argp;
  631. u_int32_t i;
  632. u_int ch;
  633. int ret;
  635. i = 0;
  636. ch = 0;
  637. notused2 = DB_TXN_ABORT;
  638. notused3 = NULL;
  640. if ((ret = __crdel_rename_read(dbenv, dbtp->data, &argp)) != 0)
  641. return (ret);
  642. printf("[%lu][%lu]crdel_rename: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  643.     (u_long)lsnp->file,
  644.     (u_long)lsnp->offset,
  645.     (u_long)argp->type,
  646.     (u_long)argp->txnid->txnid,
  647.     (u_long)argp->prev_lsn.file,
  648.     (u_long)argp->prev_lsn.offset);
  649. printf("tfileid: %ldn", (long)argp->fileid);
  650. printf("tname: ");
  651. for (i = 0; i < argp->name.size; i++) {
  652. ch = ((u_int8_t *)argp->name.data)[i];
  653. if (isprint(ch) || ch == 0xa)
  654. putchar(ch);
  655. else
  656. printf("%#x ", ch);
  657. }
  658. printf("n");
  659. printf("tnewname: ");
  660. for (i = 0; i < argp->newname.size; i++) {
  661. ch = ((u_int8_t *)argp->newname.data)[i];
  662. if (isprint(ch) || ch == 0xa)
  663. putchar(ch);
  664. else
  665. printf("%#x ", ch);
  666. }
  667. printf("n");
  668. printf("n");
  669. __os_free(argp, 0);
  670. return (0);
  671. }
  673. int
  674. __crdel_rename_read(dbenv, recbuf, argpp)
  675. DB_ENV *dbenv;
  676. void *recbuf;
  677. __crdel_rename_args **argpp;
  678. {
  679. __crdel_rename_args *argp;
  680. u_int8_t *bp;
  681. int ret;
  683. ret = __os_malloc(dbenv, sizeof(__crdel_rename_args) +
  684.     sizeof(DB_TXN), NULL, &argp);
  685. if (ret != 0)
  686. return (ret);
  687. argp->txnid = (DB_TXN *)&argp[1];
  688. bp = recbuf;
  689. memcpy(&argp->type, bp, sizeof(argp->type));
  690. bp += sizeof(argp->type);
  691. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  692. bp += sizeof(argp->txnid->txnid);
  693. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  694. bp += sizeof(DB_LSN);
  695. memcpy(&argp->fileid, bp, sizeof(argp->fileid));
  696. bp += sizeof(argp->fileid);
  697. memset(&argp->name, 0, sizeof(argp->name));
  698. memcpy(&argp->name.size, bp, sizeof(u_int32_t));
  699. bp += sizeof(u_int32_t);
  700. argp->name.data = bp;
  701. bp += argp->name.size;
  702. memset(&argp->newname, 0, sizeof(argp->newname));
  703. memcpy(&argp->newname.size, bp, sizeof(u_int32_t));
  704. bp += sizeof(u_int32_t);
  705. argp->newname.data = bp;
  706. bp += argp->newname.size;
  707. *argpp = argp;
  708. return (0);
  709. }
  711. int
  712. __crdel_delete_log(dbenv, txnid, ret_lsnp, flags,
  713. fileid, name)
  714. DB_ENV *dbenv;
  715. DB_TXN *txnid;
  716. DB_LSN *ret_lsnp;
  717. u_int32_t flags;
  718. int32_t fileid;
  719. const DBT *name;
  720. {
  721. DBT logrec;
  722. DB_LSN *lsnp, null_lsn;
  723. u_int32_t zero;
  724. u_int32_t rectype, txn_num;
  725. int ret;
  726. u_int8_t *bp;
  728. rectype = DB_crdel_delete;
  729. if (txnid != NULL &&
  730.     TAILQ_FIRST(&txnid->kids) != NULL &&
  731.     (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
  732. return (ret);
  733. txn_num = txnid == NULL ? 0 : txnid->txnid;
  734. if (txnid == NULL) {
  735. ZERO_LSN(null_lsn);
  736. lsnp = &null_lsn;
  737. } else
  738. lsnp = &txnid->last_lsn;
  739. logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
  740.     + sizeof(fileid)
  741.     + sizeof(u_int32_t) + (name == NULL ? 0 : name->size);
  742. if ((ret = __os_malloc(dbenv, logrec.size, NULL, &logrec.data)) != 0)
  743. return (ret);
  745. bp = logrec.data;
  746. memcpy(bp, &rectype, sizeof(rectype));
  747. bp += sizeof(rectype);
  748. memcpy(bp, &txn_num, sizeof(txn_num));
  749. bp += sizeof(txn_num);
  750. memcpy(bp, lsnp, sizeof(DB_LSN));
  751. bp += sizeof(DB_LSN);
  752. memcpy(bp, &fileid, sizeof(fileid));
  753. bp += sizeof(fileid);
  754. if (name == NULL) {
  755. zero = 0;
  756. memcpy(bp, &zero, sizeof(u_int32_t));
  757. bp += sizeof(u_int32_t);
  758. } else {
  759. memcpy(bp, &name->size, sizeof(name->size));
  760. bp += sizeof(name->size);
  761. memcpy(bp, name->data, name->size);
  762. bp += name->size;
  763. }
  764. DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size);
  765. ret = log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags);
  766. if (txnid != NULL)
  767. txnid->last_lsn = *ret_lsnp;
  768. __os_free(logrec.data, logrec.size);
  769. return (ret);
  770. }
  772. int
  773. __crdel_delete_print(dbenv, dbtp, lsnp, notused2, notused3)
  774. DB_ENV *dbenv;
  775. DBT *dbtp;
  776. DB_LSN *lsnp;
  777. db_recops notused2;
  778. void *notused3;
  779. {
  780. __crdel_delete_args *argp;
  781. u_int32_t i;
  782. u_int ch;
  783. int ret;
  785. i = 0;
  786. ch = 0;
  787. notused2 = DB_TXN_ABORT;
  788. notused3 = NULL;
  790. if ((ret = __crdel_delete_read(dbenv, dbtp->data, &argp)) != 0)
  791. return (ret);
  792. printf("[%lu][%lu]crdel_delete: rec: %lu txnid %lx prevlsn [%lu][%lu]n",
  793.     (u_long)lsnp->file,
  794.     (u_long)lsnp->offset,
  795.     (u_long)argp->type,
  796.     (u_long)argp->txnid->txnid,
  797.     (u_long)argp->prev_lsn.file,
  798.     (u_long)argp->prev_lsn.offset);
  799. printf("tfileid: %ldn", (long)argp->fileid);
  800. printf("tname: ");
  801. for (i = 0; i < argp->name.size; i++) {
  802. ch = ((u_int8_t *)argp->name.data)[i];
  803. if (isprint(ch) || ch == 0xa)
  804. putchar(ch);
  805. else
  806. printf("%#x ", ch);
  807. }
  808. printf("n");
  809. printf("n");
  810. __os_free(argp, 0);
  811. return (0);
  812. }
  814. int
  815. __crdel_delete_read(dbenv, recbuf, argpp)
  816. DB_ENV *dbenv;
  817. void *recbuf;
  818. __crdel_delete_args **argpp;
  819. {
  820. __crdel_delete_args *argp;
  821. u_int8_t *bp;
  822. int ret;
  824. ret = __os_malloc(dbenv, sizeof(__crdel_delete_args) +
  825.     sizeof(DB_TXN), NULL, &argp);
  826. if (ret != 0)
  827. return (ret);
  828. argp->txnid = (DB_TXN *)&argp[1];
  829. bp = recbuf;
  830. memcpy(&argp->type, bp, sizeof(argp->type));
  831. bp += sizeof(argp->type);
  832. memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
  833. bp += sizeof(argp->txnid->txnid);
  834. memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
  835. bp += sizeof(DB_LSN);
  836. memcpy(&argp->fileid, bp, sizeof(argp->fileid));
  837. bp += sizeof(argp->fileid);
  838. memset(&argp->name, 0, sizeof(argp->name));
  839. memcpy(&argp->name.size, bp, sizeof(u_int32_t));
  840. bp += sizeof(u_int32_t);
  841. argp->name.data = bp;
  842. bp += argp->name.size;
  843. *argpp = argp;
  844. return (0);
  845. }
  847. int
  848. __crdel_init_print(dbenv)
  849. DB_ENV *dbenv;
  850. {
  851. int ret;
  853. if ((ret = __db_add_recovery(dbenv,
  854.     __crdel_fileopen_print, DB_crdel_fileopen)) != 0)
  855. return (ret);
  856. if ((ret = __db_add_recovery(dbenv,
  857.     __crdel_metasub_print, DB_crdel_metasub)) != 0)
  858. return (ret);
  859. if ((ret = __db_add_recovery(dbenv,
  860.     __crdel_metapage_print, DB_crdel_metapage)) != 0)
  861. return (ret);
  862. if ((ret = __db_add_recovery(dbenv,
  863.     __crdel_old_delete_print, DB_crdel_old_delete)) != 0)
  864. return (ret);
  865. if ((ret = __db_add_recovery(dbenv,
  866.     __crdel_rename_print, DB_crdel_rename)) != 0)
  867. return (ret);
  868. if ((ret = __db_add_recovery(dbenv,
  869.     __crdel_delete_print, DB_crdel_delete)) != 0)
  870. return (ret);
  871. return (0);
  872. }
  874. int
  875. __crdel_init_recover(dbenv)
  876. DB_ENV *dbenv;
  877. {
  878. int ret;
  880. if ((ret = __db_add_recovery(dbenv,
  881.     __crdel_fileopen_recover, DB_crdel_fileopen)) != 0)
  882. return (ret);
  883. if ((ret = __db_add_recovery(dbenv,
  884.     __crdel_metasub_recover, DB_crdel_metasub)) != 0)
  885. return (ret);
  886. if ((ret = __db_add_recovery(dbenv,
  887.     __crdel_metapage_recover, DB_crdel_metapage)) != 0)
  888. return (ret);
  889. if ((ret = __db_add_recovery(dbenv,
  890.     __deprecated_recover, DB_crdel_old_delete)) != 0)
  891. return (ret);
  892. if ((ret = __db_add_recovery(dbenv,
  893.     __crdel_rename_recover, DB_crdel_rename)) != 0)
  894. return (ret);
  895. if ((ret = __db_add_recovery(dbenv,
  896.     __crdel_delete_recover, DB_crdel_delete)) != 0)
  897. return (ret);
  898. return (0);
  899. }