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

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

MySQL数据库

开发平台：

Visual C++

qam_rec.c：源码内容
  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 1999, 2000
  5.  * Sleepycat Software.  All rights reserved.
  6.  */
  8. #include "db_config.h"
  10. #ifndef lint
  11. static const char revid[] = "$Id: qam_rec.c,v 11.34 2001/01/19 18:01:59 bostic Exp $";
  12. #endif /* not lint */
  14. #ifndef NO_SYSTEM_INCLUDES
  15. #include <sys/types.h>
  17. #include <string.h>
  18. #endif
  20. #include "db_int.h"
  21. #include "db_page.h"
  22. #include "db_shash.h"
  23. #include "lock.h"
  24. #include "db_am.h"
  25. #include "qam.h"
  26. #include "log.h"
  28. /*
  29.  * __qam_inc_recover --
  30.  * Recovery function for inc.
  31.  *
  32.  * PUBLIC: int __qam_inc_recover __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  33.  */
  34. int
  35. __qam_inc_recover(dbenv, dbtp, lsnp, op, info)
  36. DB_ENV *dbenv;
  37. DBT *dbtp;
  38. DB_LSN *lsnp;
  39. db_recops op;
  40. void *info;
  41. {
  42. __qam_inc_args *argp;
  43. DB *file_dbp;
  44. DBC *dbc;
  45. DB_LOCK lock;
  46. DB_MPOOLFILE *mpf;
  47. QMETA *meta;
  48. db_pgno_t metapg;
  49. int cmp_p, modified, ret;
  51. COMPQUIET(info, NULL);
  52. REC_PRINT(__qam_inc_print);
  53. REC_INTRO(__qam_inc_read, 1);
  55. metapg = ((QUEUE *)file_dbp->q_internal)->q_meta;
  57. if ((ret = __db_lget(dbc,
  58.     LCK_ROLLBACK, metapg,  DB_LOCK_WRITE, 0, &lock)) != 0)
  59. goto done;
  60. if ((ret = memp_fget(mpf, &metapg, 0, &meta)) != 0) {
  61. if (DB_REDO(op)) {
  62. if ((ret = memp_fget(mpf,
  63.     &metapg, DB_MPOOL_CREATE, &meta)) != 0) {
  64. (void)__LPUT(dbc, lock);
  65. goto out;
  66. }
  67. meta->dbmeta.pgno = metapg;
  68. meta->dbmeta.type = P_QAMMETA;
  70. } else {
  71. *lsnp = argp->prev_lsn;
  72. ret = 0;
  73. (void)__LPUT(dbc, lock);
  74. goto out;
  75. }
  76. }
  78. modified = 0;
  79. cmp_p = log_compare(&LSN(meta), &argp->lsn);
  80. CHECK_LSN(op, cmp_p, &LSN(meta), &argp->lsn);
  82. /*
  83.  * The cur_recno never goes backwards.  It is a point of
  84.  * contention among appenders.  If one fails cur_recno will
  85.  * most likely be beyond that one when it aborts.
  86.  * We move it ahead on either an abort or a commit
  87.  * and make the LSN reflect that fact.
  88.  */
  89. if (cmp_p == 0) {
  90. modified = 1;
  91. meta->cur_recno++;
  92. if (meta->cur_recno == RECNO_OOB)
  93. meta->cur_recno++;
  94. meta->dbmeta.lsn = *lsnp;
  95. }
  96. if ((ret = memp_fput(mpf, meta, modified ? DB_MPOOL_DIRTY : 0)))
  97. goto out;
  99. (void)__LPUT(dbc, lock);
  101. done: *lsnp = argp->prev_lsn;
  102. ret = 0;
  104. out: REC_CLOSE;
  105. }
  107. /*
  108.  * __qam_incfirst_recover --
  109.  * Recovery function for incfirst.
  110.  *
  111.  * PUBLIC: int __qam_incfirst_recover
  112.  * PUBLIC:   __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  113.  */
  114. int
  115. __qam_incfirst_recover(dbenv, dbtp, lsnp, op, info)
  116. DB_ENV *dbenv;
  117. DBT *dbtp;
  118. DB_LSN *lsnp;
  119. db_recops op;
  120. void *info;
  121. {
  122. __qam_incfirst_args *argp;
  123. DB *file_dbp;
  124. DBC *dbc;
  125. DB_LOCK lock;
  126. DB_MPOOLFILE *mpf;
  127. QMETA *meta;
  128. QUEUE_CURSOR *cp;
  129. db_pgno_t metapg;
  130. int exact, modified, ret, rec_ext;
  132. COMPQUIET(info, NULL);
  133. REC_PRINT(__qam_incfirst_print);
  134. REC_INTRO(__qam_incfirst_read, 1);
  136. metapg = ((QUEUE *)file_dbp->q_internal)->q_meta;
  138. if ((ret = __db_lget(dbc,
  139.     LCK_ROLLBACK, metapg,  DB_LOCK_WRITE, 0, &lock)) != 0)
  140. goto done;
  141. if ((ret = memp_fget(mpf, &metapg, 0, &meta)) != 0) {
  142. if (DB_REDO(op)) {
  143. if ((ret = memp_fget(mpf,
  144.     &metapg, DB_MPOOL_CREATE, &meta)) != 0) {
  145. (void)__LPUT(dbc, lock);
  146. goto out;
  147. }
  148. meta->dbmeta.pgno = metapg;
  149. meta->dbmeta.type = P_QAMMETA;
  150. } else {
  151. *lsnp = argp->prev_lsn;
  152. ret = 0;
  153. (void)__LPUT(dbc, lock);
  154. goto out;
  155. }
  156. }
  158. modified = 0;
  160. /*
  161.  * Only move first_recno backwards so we pick up the aborted delete.
  162.  * When going forward we need to be careful since
  163.  * we may have bumped over a locked record.
  164.  */
  165. if (DB_UNDO(op)) {
  166. if (QAM_BEFORE_FIRST(meta, argp->recno)) {
  167. meta->first_recno = argp->recno;
  168. modified = 1;
  169. }
  170. } else {
  171. if (log_compare(&LSN(meta), lsnp) < 0) {
  172. LSN(meta) = *lsnp;
  173. modified = 1;
  174. }
  175. rec_ext = 0;
  176. if (meta->page_ext != 0)
  177. rec_ext = meta->page_ext * meta->rec_page;
  178. cp = (QUEUE_CURSOR *)dbc->internal;
  179. if (meta->first_recno == RECNO_OOB)
  180. meta->first_recno++;
  181. while (meta->first_recno != meta->cur_recno
  182.     && !QAM_BEFORE_FIRST(meta, argp->recno + 1)) {
  183. if ((ret = __qam_position(dbc,
  184.     &meta->first_recno, QAM_READ, &exact)) != 0)
  185. goto out;
  186. if (cp->page != NULL)
  187. __qam_fput(file_dbp, cp->pgno, cp->page, 0);
  189. if (exact == 1)
  190. break;
  191. if (cp->page != NULL &&
  192.     rec_ext != 0 && meta->first_recno % rec_ext == 0)
  193. if ((ret =
  194.     __qam_fremove(file_dbp, cp->pgno)) != 0)
  195. goto out;
  196. meta->first_recno++;
  197. if (meta->first_recno == RECNO_OOB)
  198. meta->first_recno++;
  199. modified = 1;
  200. }
  201. }
  203. if ((ret = memp_fput(mpf, meta, modified ? DB_MPOOL_DIRTY : 0)))
  204. goto out;
  206. (void)__LPUT(dbc, lock);
  208. done: *lsnp = argp->prev_lsn;
  209. ret = 0;
  211. out: REC_CLOSE;
  212. }
  214. /*
  215.  * __qam_mvptr_recover --
  216.  * Recovery function for mvptr.
  217.  *
  218.  * PUBLIC: int __qam_mvptr_recover
  219.  * PUBLIC:   __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  220.  */
  221. int
  222. __qam_mvptr_recover(dbenv, dbtp, lsnp, op, info)
  223. DB_ENV *dbenv;
  224. DBT *dbtp;
  225. DB_LSN *lsnp;
  226. db_recops op;
  227. void *info;
  228. {
  229. __qam_mvptr_args *argp;
  230. DB *file_dbp;
  231. DBC *dbc;
  232. DB_LOCK lock;
  233. DB_MPOOLFILE *mpf;
  234. QMETA *meta;
  235. db_pgno_t metapg;
  236. int cmp_p, modified, ret;
  238. COMPQUIET(info, NULL);
  239. REC_PRINT(__qam_mvptr_print);
  240. REC_INTRO(__qam_mvptr_read, 1);
  242. metapg = ((QUEUE *)file_dbp->q_internal)->q_meta;
  244. if ((ret = __db_lget(dbc,
  245.     LCK_ROLLBACK, metapg,  DB_LOCK_WRITE, 0, &lock)) != 0)
  246. goto done;
  247. if ((ret = memp_fget(mpf, &metapg, 0, &meta)) != 0) {
  248. if (DB_REDO(op)) {
  249. if ((ret = memp_fget(mpf,
  250.     &metapg, DB_MPOOL_CREATE, &meta)) != 0) {
  251. (void)__LPUT(dbc, lock);
  252. goto out;
  253. }
  254. meta->dbmeta.pgno = metapg;
  255. meta->dbmeta.type = P_QAMMETA;
  256. } else {
  257. *lsnp = argp->prev_lsn;
  258. ret = 0;
  259. (void)__LPUT(dbc, lock);
  260. goto out;
  261. }
  262. }
  264. modified = 0;
  265. cmp_p = log_compare(&meta->dbmeta.lsn, &argp->metalsn);
  267. /*
  268.  * We never undo a movement of one of the pointers.
  269.  * Just move them along regardless of abort/commit.
  270.  */
  271. if (cmp_p == 0) {
  272. if (argp->opcode & QAM_SETFIRST)
  273. meta->first_recno = argp->new_first;
  275. if (argp->opcode & QAM_SETCUR)
  276. meta->cur_recno = argp->new_cur;
  278. modified = 1;
  279. meta->dbmeta.lsn = *lsnp;
  280. }
  282. if ((ret = memp_fput(mpf, meta, modified ? DB_MPOOL_DIRTY : 0)))
  283. goto out;
  285. (void)__LPUT(dbc, lock);
  287. done: *lsnp = argp->prev_lsn;
  288. ret = 0;
  290. out: REC_CLOSE;
  291. }
  292. /*
  293.  * __qam_del_recover --
  294.  * Recovery function for del.
  295.  * Non-extent version or if there is no data (zero len).
  296.  *
  297.  * PUBLIC: int __qam_del_recover
  298.  * PUBLIC:     __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  299.  */
  300. int
  301. __qam_del_recover(dbenv, dbtp, lsnp, op, info)
  302. DB_ENV *dbenv;
  303. DBT *dbtp;
  304. DB_LSN *lsnp;
  305. db_recops op;
  306. void *info;
  307. {
  308. __qam_del_args *argp;
  309. DB *file_dbp;
  310. DBC *dbc;
  311. DB_LOCK lock;
  312. DB_MPOOLFILE *mpf;
  313. QAMDATA *qp;
  314. QMETA *meta;
  315. QPAGE *pagep;
  316. db_pgno_t metapg;
  317. int cmp_n, modified, ret;
  319. COMPQUIET(info, NULL);
  320. REC_PRINT(__qam_del_print);
  321. REC_INTRO(__qam_del_read, 1);
  323. if ((ret = __qam_fget(file_dbp,
  324.      &argp->pgno, DB_MPOOL_CREATE, &pagep)) != 0)
  325. goto out;
  327. modified = 0;
  328. if (pagep->pgno == PGNO_INVALID) {
  329. pagep->pgno = argp->pgno;
  330. pagep->type = P_QAMDATA;
  331. modified = 1;
  332. }
  334. cmp_n = log_compare(lsnp, &LSN(pagep));
  336. if (DB_UNDO(op)) {
  337. /* make sure first is behind us */
  338. metapg = ((QUEUE *)file_dbp->q_internal)->q_meta;
  339. if ((ret = __db_lget(dbc,
  340.     LCK_ROLLBACK, metapg, DB_LOCK_WRITE, 0, &lock)) != 0)
  341. return (ret);
  342. if ((ret = memp_fget(file_dbp->mpf, &metapg, 0, &meta)) != 0) {
  343. (void)__LPUT(dbc, lock);
  344. goto done;
  345. }
  346. if (meta->first_recno == RECNO_OOB ||
  347.     (QAM_BEFORE_FIRST(meta, argp->recno)
  348.     && (meta->first_recno <= meta->cur_recno
  349.     || meta->first_recno -
  350.     argp->recno < argp->recno - meta->cur_recno))) {
  351. meta->first_recno = argp->recno;
  352. (void)memp_fput(file_dbp->mpf, meta, DB_MPOOL_DIRTY);
  353. } else
  354. (void)memp_fput(file_dbp->mpf, meta, 0);
  355. (void)__LPUT(dbc, lock);
  357. /* Need to undo delete - mark the record as present */
  358. qp = QAM_GET_RECORD(file_dbp, pagep, argp->indx);
  359. F_SET(qp, QAM_VALID);
  361. /*
  362.  * Move the LSN back to this point;  do not move it forward.
  363.  * Only move it back if we're in recovery.  If we're in
  364.  * an abort, because we don't hold a page lock, we could
  365.  * foul up a concurrent put.  Having too late an LSN
  366.  * is harmless in queue except when we're determining
  367.  * what we need to roll forward during recovery.  [#2588]
  368.  */
  369. if (op == DB_TXN_BACKWARD_ROLL && cmp_n < 0)
  370. LSN(pagep) = argp->lsn;
  371. modified = 1;
  372. } else if (cmp_n > 0 && DB_REDO(op)) {
  373. /* Need to redo delete - clear the valid bit */
  374. qp = QAM_GET_RECORD(file_dbp, pagep, argp->indx);
  375. F_CLR(qp, QAM_VALID);
  376. LSN(pagep) = *lsnp;
  377. modified = 1;
  378. }
  379. if ((ret = __qam_fput(file_dbp,
  380.     argp->pgno, pagep, modified ? DB_MPOOL_DIRTY : 0)))
  381. goto out;
  383. done: *lsnp = argp->prev_lsn;
  384. ret = 0;
  386. out: REC_CLOSE;
  387. }
  388. /*
  389.  * __qam_delext_recover --
  390.  * Recovery function for del in an extent based queue.
  391.  *
  392.  * PUBLIC: int __qam_delext_recover __P((DB_ENV *,
  393.  * PUBLIC:     DBT *, DB_LSN *, db_recops, void *));
  394.  */
  395. int
  396. __qam_delext_recover(dbenv, dbtp, lsnp, op, info)
  397. DB_ENV *dbenv;
  398. DBT *dbtp;
  399. DB_LSN *lsnp;
  400. db_recops op;
  401. void *info;
  402. {
  403. __qam_delext_args *argp;
  404. DB *file_dbp;
  405. DBC *dbc;
  406. DB_LOCK lock;
  407. DB_MPOOLFILE *mpf;
  408. QAMDATA *qp;
  409. QMETA *meta;
  410. QPAGE *pagep;
  411. db_pgno_t metapg;
  412. int cmp_n, modified, ret;
  414. COMPQUIET(info, NULL);
  415. REC_PRINT(__qam_delext_print);
  416. REC_INTRO(__qam_delext_read, 1);
  418. if ((ret = __qam_fget(file_dbp,
  419.      &argp->pgno, DB_MPOOL_CREATE, &pagep)) != 0)
  420. goto out;
  422. modified = 0;
  423. if (pagep->pgno == PGNO_INVALID) {
  424. pagep->pgno = argp->pgno;
  425. pagep->type = P_QAMDATA;
  426. modified = 1;
  427. }
  429. cmp_n = log_compare(lsnp, &LSN(pagep));
  431. if (DB_UNDO(op)) {
  432. /* make sure first is behind us */
  433. metapg = ((QUEUE *)file_dbp->q_internal)->q_meta;
  434. if ((ret = __db_lget(dbc,
  435.     LCK_ROLLBACK, metapg, DB_LOCK_WRITE, 0, &lock)) != 0)
  436. return (ret);
  437. if ((ret = memp_fget(file_dbp->mpf, &metapg, 0, &meta)) != 0) {
  438. (void)__LPUT(dbc, lock);
  439. goto done;
  440. }
  441. if (meta->first_recno == RECNO_OOB ||
  442.     (QAM_BEFORE_FIRST(meta, argp->recno)
  443.     && (meta->first_recno <= meta->cur_recno
  444.     || meta->first_recno -
  445.     argp->recno < argp->recno - meta->cur_recno))) {
  446. meta->first_recno = argp->recno;
  447. (void)memp_fput(file_dbp->mpf, meta, DB_MPOOL_DIRTY);
  448. } else
  449. (void)memp_fput(file_dbp->mpf, meta, 0);
  450. (void)__LPUT(dbc, lock);
  452. if ((ret = __qam_pitem(dbc, pagep,
  453.     argp->indx, argp->recno, &argp->data)) != 0)
  454. goto done;
  456. /*
  457.  * Move the LSN back to this point;  do not move it forward.
  458.  * Only move it back if we're in recovery.  If we're in
  459.  * an abort, because we don't hold a page lock, we could
  460.  * foul up a concurrent put.  Having too late an LSN
  461.  * is harmless in queue except when we're determining
  462.  * what we need to roll forward during recovery.  [#2588]
  463.  */
  464. if (op == DB_TXN_BACKWARD_ROLL && cmp_n < 0)
  465. LSN(pagep) = argp->lsn;
  466. modified = 1;
  467. } else if (cmp_n > 0 && DB_REDO(op)) {
  468. /* Need to redo delete - clear the valid bit */
  469. qp = QAM_GET_RECORD(file_dbp, pagep, argp->indx);
  470. F_CLR(qp, QAM_VALID);
  471. LSN(pagep) = *lsnp;
  472. modified = 1;
  473. }
  474. if ((ret = __qam_fput(file_dbp,
  475.     argp->pgno, pagep, modified ? DB_MPOOL_DIRTY : 0)))
  476. goto out;
  478. done: *lsnp = argp->prev_lsn;
  479. ret = 0;
  481. out: REC_CLOSE;
  482. }
  484. /*
  485.  * __qam_add_recover --
  486.  * Recovery function for add.
  487.  *
  488.  * PUBLIC: int __qam_add_recover __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  489.  */
  490. int
  491. __qam_add_recover(dbenv, dbtp, lsnp, op, info)
  492. DB_ENV *dbenv;
  493. DBT *dbtp;
  494. DB_LSN *lsnp;
  495. db_recops op;
  496. void *info;
  497. {
  498. __qam_add_args *argp;
  499. DB *file_dbp;
  500. DBC *dbc;
  501. DB_MPOOLFILE *mpf;
  502. QAMDATA *qp;
  503. QMETA *meta;
  504. QPAGE *pagep;
  505. db_pgno_t metapg;
  506. int cmp_n, modified, ret;
  508. COMPQUIET(info, NULL);
  509. REC_PRINT(__qam_add_print);
  510. REC_INTRO(__qam_add_read, 1);
  512. modified = 0;
  513. if ((ret = __qam_fget(file_dbp,
  514.     &argp->pgno, DB_MPOOL_CREATE, &pagep)) != 0)
  515. goto out;
  517. if (pagep->pgno == PGNO_INVALID) {
  518. pagep->pgno = argp->pgno;
  519. pagep->type = P_QAMDATA;
  520. modified = 1;
  521. }
  523. cmp_n = log_compare(lsnp, &LSN(pagep));
  525. if (cmp_n > 0 && DB_REDO(op)) {
  526. /* Need to redo add - put the record on page */
  527. if ((ret = __qam_pitem(dbc, pagep, argp->indx, argp->recno,
  528. &argp->data)) != 0)
  529. goto err;
  530. LSN(pagep) = *lsnp;
  531. modified = 1;
  532. /* Make sure first pointer includes this record. */
  533. metapg = ((QUEUE *)file_dbp->q_internal)->q_meta;
  534. if ((ret = memp_fget(mpf, &metapg, 0, &meta)) != 0)
  535. goto err;
  536. if (QAM_BEFORE_FIRST(meta, argp->recno)) {
  537. meta->first_recno = argp->recno;
  538. if ((ret = memp_fput(mpf, meta, DB_MPOOL_DIRTY)) != 0)
  539. goto err;
  540. } else
  541. if ((ret = memp_fput(mpf, meta, 0)) != 0)
  542. goto err;
  544. } else if (DB_UNDO(op)) {
  545. /*
  546.  * Need to undo add
  547.  * If this was an overwrite, put old record back.
  548.  * Otherwise just clear the valid bit
  549.  */
  550. if (argp->olddata.size != 0) {
  551. if ((ret = __qam_pitem(dbc, pagep,
  552.     argp->indx, argp->recno, &argp->olddata)) != 0)
  553. goto err;
  555. if (!(argp->vflag & QAM_VALID)) {
  556. qp = QAM_GET_RECORD(
  557.     file_dbp, pagep, argp->indx);
  558. F_CLR(qp, QAM_VALID);
  559. }
  560. modified = 1;
  561. } else {
  562. qp = QAM_GET_RECORD(file_dbp, pagep, argp->indx);
  563. qp->flags = 0;
  564. modified = 1;
  565. }
  567. /*
  568.  * Move the LSN back to this point;  do not move it forward.
  569.  * Only move it back if we're in recovery.  If we're in
  570.  * an abort, because we don't hold a page lock, we could
  571.  * foul up a concurrent put.  Having too late an LSN
  572.  * is harmless in queue except when we're determining
  573.  * what we need to roll forward during recovery.  [#2588]
  574.  */
  575. if (op == DB_TXN_BACKWARD_ROLL && cmp_n < 0)
  576. LSN(pagep) = argp->lsn;
  577. }
  579. err: if ((ret = __qam_fput(file_dbp,
  580.     argp->pgno, pagep, modified ? DB_MPOOL_DIRTY : 0)))
  581. goto out;
  583. done: *lsnp = argp->prev_lsn;
  584. ret = 0;
  586. out: REC_CLOSE;
  587. }
  588. /*
  589.  * __qam_delete_recover --
  590.  * Recovery function for delete of an extent.
  591.  *
  592.  * PUBLIC: int __qam_delete_recover
  593.  * PUBLIC:   __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  594.  */
  595. int
  596. __qam_delete_recover(dbenv, dbtp, lsnp, op, info)
  597. DB_ENV *dbenv;
  598. DBT *dbtp;
  599. DB_LSN *lsnp;
  600. db_recops op;
  601. void *info;
  602. {
  603. __qam_delete_args *argp;
  604. int ret;
  605. char *backup, *real_back, *real_name;
  607. COMPQUIET(info, NULL);
  609. REC_PRINT(__qam_delete_print);
  611. backup = real_back = real_name = NULL;
  612. if ((ret = __qam_delete_read(dbenv, dbtp->data, &argp)) != 0)
  613. goto out;
  615. if (DB_REDO(op)) {
  616. /*
  617.  * On a recovery, as we recreate what was going on, we
  618.  * recreate the creation of the file.  And so, even though
  619.  * it committed, we need to delete it.  Try to delete it,
  620.  * but it is not an error if that delete fails.
  621.  */
  622. if ((ret = __db_appname(dbenv, DB_APP_DATA,
  623.     NULL, argp->name.data, 0, NULL, &real_name)) != 0)
  624. goto out;
  625. if (__os_exists(real_name, NULL) == 0) {
  626. if ((ret = __os_unlink(dbenv, real_name)) != 0)
  627. goto out;
  628. }
  629. } else if (DB_UNDO(op)) {
  630. /*
  631.  * Trying to undo.  File may or may not have been deleted.
  632.  * Try to move the backup to the original.  If the backup
  633.  * exists, then this is right.  If it doesn't exist, then
  634.  * nothing will happen and that's OK.
  635.  */
  636. if ((ret =  __db_backup_name(dbenv, argp->name.data,
  637.     &backup, &argp->lsn)) != 0)
  638. goto out;
  639. if ((ret = __db_appname(dbenv,
  640.     DB_APP_DATA, NULL, backup, 0, NULL, &real_back)) != 0)
  641. goto out;
  642. if ((ret = __db_appname(dbenv, DB_APP_DATA,
  643.     NULL, argp->name.data, 0, NULL, &real_name)) != 0)
  644. goto out;
  645. if (__os_exists(real_back, NULL) == 0)
  646. if ((ret =
  647.      __os_rename(dbenv, real_back, real_name)) != 0)
  648. goto out;
  649. }
  650. *lsnp = argp->prev_lsn;
  651. ret = 0;
  653. out: if (argp != NULL)
  654. __os_free(argp, 0);
  655. if (backup != NULL)
  656. __os_freestr(backup);
  657. if (real_back != NULL)
  658. __os_freestr(real_back);
  659. if (real_name != NULL)
  660. __os_freestr(real_name);
  661. return (ret);
  662. }
  663. /*
  664.  * __qam_rename_recover --
  665.  * Recovery function for rename.
  666.  *
  667.  * PUBLIC: int __qam_rename_recover
  668.  * PUBLIC:   __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  669.  */
  670. int
  671. __qam_rename_recover(dbenv, dbtp, lsnp, op, info)
  672. DB_ENV *dbenv;
  673. DBT *dbtp;
  674. DB_LSN *lsnp;
  675. db_recops op;
  676. void *info;
  677. {
  678. __qam_rename_args *argp;
  679. char *new_name, *real_name;
  680. int ret;
  682. COMPQUIET(info, NULL);
  684. REC_PRINT(__qam_rename_print);
  686. new_name = real_name = NULL;
  688. if ((ret = __qam_rename_read(dbenv, dbtp->data, &argp)) != 0)
  689. goto out;
  691. if (DB_REDO(op)) {
  692. if ((ret = __db_appname(dbenv, DB_APP_DATA,
  693.     NULL, argp->name.data, 0, NULL, &real_name)) != 0)
  694. goto out;
  695. if (__os_exists(real_name, NULL) == 0) {
  696. if ((ret = __db_appname(dbenv,
  697.     DB_APP_DATA, NULL, argp->newname.data,
  698.     0, NULL, &new_name)) != 0)
  699. goto out;
  700. if ((ret = __os_rename(dbenv,
  701.     real_name, new_name)) != 0)
  702. goto out;
  703. }
  704. } else {
  705. if ((ret = __db_appname(dbenv, DB_APP_DATA,
  706.     NULL, argp->newname.data, 0, NULL, &new_name)) != 0)
  707. goto out;
  708. if (__os_exists(new_name, NULL) == 0) {
  709. if ((ret = __db_appname(dbenv,
  710.     DB_APP_DATA, NULL, argp->name.data,
  711.     0, NULL, &real_name)) != 0)
  712. goto out;
  713. if ((ret = __os_rename(dbenv,
  714.     new_name, real_name)) != 0)
  715. goto out;
  716. }
  717. }
  719. *lsnp = argp->prev_lsn;
  720. ret = 0;
  722. out: if (argp != NULL)
  723. __os_free(argp, 0);
  725. if (new_name != NULL)
  726. __os_free(new_name, 0);
  728. if (real_name != NULL)
  729. __os_free(real_name, 0);
  731. return (ret);
  732. }