fop_rec.c
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:7k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 2001-2002
  5.  * Sleepycat Software.  All rights reserved.
  6.  */
  7. #include "db_config.h"
  8. #ifndef lint
  9. static const char revid[] = "$Id: fop_rec.c,v 1.18 2002/08/14 20:27:01 bostic Exp $";
  10. #endif /* not lint */
  11. #ifndef NO_SYSTEM_INCLUDES
  12. #include <sys/types.h>
  13. #include <string.h>
  14. #endif
  15. #include "db_int.h"
  16. #include "dbinc/db_page.h"
  17. #include "dbinc/fop.h"
  18. #include "dbinc/db_am.h"
  19. #include "dbinc/txn.h"
  20. /*
  21.  * __fop_create_recover --
  22.  * Recovery function for create.
  23.  *
  24.  * PUBLIC: int __fop_create_recover
  25.  * PUBLIC:   __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  26.  */
  27. int
  28. __fop_create_recover(dbenv, dbtp, lsnp, op, info)
  29. DB_ENV *dbenv;
  30. DBT *dbtp;
  31. DB_LSN *lsnp;
  32. db_recops op;
  33. void *info;
  34. {
  35. DB_FH fh;
  36. __fop_create_args *argp;
  37. char *real_name;
  38. int ret;
  39. real_name = NULL;
  40. COMPQUIET(info, NULL);
  41. REC_PRINT(__fop_create_print);
  42. REC_NOOP_INTRO(__fop_create_read);
  43. if ((ret = __db_appname(dbenv, (APPNAME)argp->appname,
  44.     (const char *)argp->name.data, 0, NULL, &real_name)) != 0)
  45. goto out;
  46. if (DB_UNDO(op))
  47. (void)__os_unlink(dbenv, real_name);
  48. else if (DB_REDO(op))
  49. if ((ret = __os_open(dbenv, real_name,
  50.     DB_OSO_CREATE | DB_OSO_EXCL, argp->mode, &fh)) == 0)
  51. __os_closehandle(dbenv, &fh);
  52. *lsnp = argp->prev_lsn;
  53. out: if (real_name != NULL)
  54. __os_free(dbenv, real_name);
  55. REC_NOOP_CLOSE;
  56. }
  57. /*
  58.  * __fop_remove_recover --
  59.  * Recovery function for remove.
  60.  *
  61.  * PUBLIC: int __fop_remove_recover
  62.  * PUBLIC:   __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  63.  */
  64. int
  65. __fop_remove_recover(dbenv, dbtp, lsnp, op, info)
  66. DB_ENV *dbenv;
  67. DBT *dbtp;
  68. DB_LSN *lsnp;
  69. db_recops op;
  70. void *info;
  71. {
  72. __fop_remove_args *argp;
  73. char *real_name;
  74. int ret;
  75. real_name = NULL;
  76. COMPQUIET(info, NULL);
  77. REC_PRINT(__fop_remove_print);
  78. REC_NOOP_INTRO(__fop_remove_read);
  79. if ((ret = __db_appname(dbenv, (APPNAME)argp->appname,
  80.     (const char *)argp->name.data, 0, NULL, &real_name)) != 0)
  81. goto out;
  82. if (DB_REDO(op) && (ret = dbenv->memp_nameop(dbenv,
  83.     (u_int8_t *)argp->fid.data, NULL, real_name, NULL)) != 0)
  84. goto out;
  85. *lsnp = argp->prev_lsn;
  86. out: if (real_name != NULL)
  87. __os_free(dbenv, real_name);
  88. REC_NOOP_CLOSE;
  89. }
  90. /*
  91.  * __fop_write_recover --
  92.  * Recovery function for writechunk.
  93.  *
  94.  * PUBLIC: int __fop_write_recover
  95.  * PUBLIC:   __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  96.  */
  97. int
  98. __fop_write_recover(dbenv, dbtp, lsnp, op, info)
  99. DB_ENV *dbenv;
  100. DBT *dbtp;
  101. DB_LSN *lsnp;
  102. db_recops op;
  103. void *info;
  104. {
  105. __fop_write_args *argp;
  106. int ret;
  107. COMPQUIET(info, NULL);
  108. REC_PRINT(__fop_write_print);
  109. REC_NOOP_INTRO(__fop_write_read);
  110. if (DB_UNDO(op))
  111. DB_ASSERT(argp->flag != 0);
  112. else if (DB_REDO(op))
  113. ret = __fop_write(dbenv,
  114.     argp->txnid, argp->name.data, argp->appname, NULL,
  115.     argp->offset, argp->page.data, argp->page.size, argp->flag);
  116. *lsnp = argp->prev_lsn;
  117. REC_NOOP_CLOSE;
  118. }
  119. /*
  120.  * __fop_rename_recover --
  121.  * Recovery function for rename.
  122.  *
  123.  * PUBLIC: int __fop_rename_recover
  124.  * PUBLIC:   __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  125.  */
  126. int
  127. __fop_rename_recover(dbenv, dbtp, lsnp, op, info)
  128. DB_ENV *dbenv;
  129. DBT *dbtp;
  130. DB_LSN *lsnp;
  131. db_recops op;
  132. void *info;
  133. {
  134. __fop_rename_args *argp;
  135. DBMETA *meta;
  136. char *real_new, *real_old, *src;
  137. int ret;
  138. u_int8_t *fileid, mbuf[DBMETASIZE];
  139. real_new = NULL;
  140. real_old = NULL;
  141. ret = 0;
  142. meta = (DBMETA *)&mbuf[0];
  143. COMPQUIET(info, NULL);
  144. REC_PRINT(__fop_rename_print);
  145. REC_NOOP_INTRO(__fop_rename_read);
  146. fileid = argp->fileid.data;
  147. if ((ret = __db_appname(dbenv, (APPNAME)argp->appname,
  148.     (const char *)argp->newname.data, 0, NULL, &real_new)) != 0)
  149. goto out;
  150. if ((ret = __db_appname(dbenv, (APPNAME)argp->appname,
  151.     (const char *)argp->oldname.data, 0, NULL, &real_old)) != 0)
  152. goto out;
  153. /*
  154.  * Verify that we are manipulating the correct file.  We should always
  155.  * be OK on an ABORT or an APPLY, but during recovery, we have to
  156.  * check.
  157.  */
  158. if (op != DB_TXN_ABORT && op != DB_TXN_APPLY) {
  159. src = DB_UNDO(op) ? real_new : real_old;
  160. /*
  161.  * Interpret any error as meaning that the file either doesn't
  162.  * exist, doesn't have a meta-data page, or is in some other
  163.  * way, shape or form, incorrect, so that we should not restore
  164.  * it.
  165.  */
  166. if (__fop_read_meta(
  167.     dbenv, src, mbuf, DBMETASIZE, NULL, 1, 0) != 0)
  168. goto done;
  169. if (__db_chk_meta(dbenv, NULL, meta, 1) != 0)
  170. goto done;
  171. if (memcmp(argp->fileid.data, meta->uid, DB_FILE_ID_LEN) != 0)
  172. goto done;
  173. }
  174. if (DB_UNDO(op))
  175. (void)dbenv->memp_nameop(dbenv, fileid,
  176.     (const char *)argp->oldname.data, real_new, real_old);
  177. if (DB_REDO(op))
  178. (void)dbenv->memp_nameop(dbenv, fileid,
  179.     (const char *)argp->newname.data, real_old, real_new);
  180. done: *lsnp = argp->prev_lsn;
  181. out: if (real_new != NULL)
  182. __os_free(dbenv, real_new);
  183. if (real_old != NULL)
  184. __os_free(dbenv, real_old);
  185. REC_NOOP_CLOSE;
  186. }
  187. /*
  188.  * __fop_file_remove_recover --
  189.  * Recovery function for file_remove.  On the REDO pass, we need to
  190.  * make sure no one recreated the file while we weren't looking.  On an
  191.  * undo pass must check if the file we are interested in is the one that
  192.  * exists and then set the status of the child transaction depending on
  193.  * what we find out.
  194.  *
  195.  * PUBLIC: int __fop_file_remove_recover
  196.  * PUBLIC:   __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  197.  */
  198. int
  199. __fop_file_remove_recover(dbenv, dbtp, lsnp, op, info)
  200. DB_ENV *dbenv;
  201. DBT *dbtp;
  202. DB_LSN *lsnp;
  203. db_recops op;
  204. void *info;
  205. {
  206. __fop_file_remove_args *argp;
  207. DBMETA *meta;
  208. char *real_name;
  209. int is_real, is_tmp, ret;
  210. u_int8_t mbuf[DBMETASIZE];
  211. u_int32_t cstat;
  212. real_name = NULL;
  213. is_real = is_tmp = 0;
  214. meta = (DBMETA *)&mbuf[0];
  215. REC_PRINT(__fop_file_remove_print);
  216. REC_NOOP_INTRO(__fop_file_remove_read);
  217. /*
  218.  * This record is only interesting on the backward, forward, and
  219.  * apply phases.
  220.  */
  221. if (op != DB_TXN_BACKWARD_ROLL &&
  222.     op != DB_TXN_FORWARD_ROLL && op != DB_TXN_APPLY)
  223. goto done;
  224. if ((ret = __db_appname(dbenv,
  225.     (APPNAME)argp->appname, argp->name.data, 0, NULL, &real_name)) != 0)
  226. goto out;
  227. /* Verify that we are manipulating the correct file.  */
  228. if ((ret = __fop_read_meta(dbenv,
  229.     real_name, mbuf, DBMETASIZE, NULL, 1, 0)) != 0) {
  230. /* File does not exist. */
  231. cstat = TXN_EXPECTED;
  232. } else {
  233. /*
  234.  * We can ignore errors here since we'll simply fail the
  235.  * checks below and assume this is the wrong file.
  236.  */
  237. (void)__db_chk_meta(dbenv, NULL, meta, 1);
  238. is_real =
  239.     memcmp(argp->real_fid.data, meta->uid, DB_FILE_ID_LEN) == 0;
  240. is_tmp =
  241.     memcmp(argp->tmp_fid.data, meta->uid, DB_FILE_ID_LEN) == 0;
  242. if (!is_real && !is_tmp)
  243. /* File exists, but isn't what we were removing. */
  244. cstat = TXN_IGNORE;
  245. else
  246. /* File exists and is the one that we were removing. */
  247. cstat = TXN_COMMIT;
  248. }
  249. if (DB_UNDO(op)) {
  250. /* On the backward pass, we leave a note for the child txn. */
  251. if ((ret = __db_txnlist_update(dbenv,
  252.     info, argp->child, cstat, NULL)) == DB_NOTFOUND)
  253. ret = __db_txnlist_add(dbenv,
  254.     info, argp->child, cstat, NULL);
  255. } else if (DB_REDO(op)) {
  256. /*
  257.  * On the forward pass, check if someone recreated the
  258.  * file while we weren't looking.
  259.  */
  260. if (cstat == TXN_COMMIT)
  261. (void)dbenv->memp_nameop(dbenv,
  262.     is_real ? argp->real_fid.data : argp->tmp_fid.data,
  263.     NULL, real_name, NULL);
  264. }
  265. done: *lsnp = argp->prev_lsn;
  266. ret = 0;
  267. out: if (real_name != NULL)
  268. __os_free(dbenv, real_name);
  269. REC_NOOP_CLOSE;
  270. }