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

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_basic.c,v 1.23 2002/08/11 02:11:23 margo Exp $";
  10. #endif /* not lint */
  11. #ifndef NO_SYSTEM_INCLUDES
  12. #include <string.h>
  13. #include <sys/types.h>
  14. #endif
  15. #include "db_int.h"
  16. #include "dbinc/log.h"
  17. #include "dbinc/db_page.h"
  18. #include "dbinc/fop.h"
  19. #include "dbinc/txn.h"
  20. #include "dbinc/db_am.h"
  21. /*
  22.  * This file implements the basic file-level operations.  This code
  23.  * ought to be fairly independent of DB, other than through its
  24.  * error-reporting mechanism.
  25.  */
  26. /*
  27.  * __fop_create --
  28.  * Create a (transactionally protected) file system object.  This is used
  29.  * to create DB files now, potentially blobs, queue extents and anything
  30.  * else you wish to store in a file system object.
  31.  *
  32.  * PUBLIC: int __fop_create __P((DB_ENV *,
  33.  * PUBLIC:     DB_TXN *, DB_FH *, const char *, APPNAME, int));
  34.  */
  35. int
  36. __fop_create(dbenv, txn, fhp, name, appname, mode)
  37. DB_ENV *dbenv;
  38. DB_TXN *txn;
  39. DB_FH *fhp;
  40. const char *name;
  41. APPNAME appname;
  42. int mode;
  43. {
  44. DB_FH fh;
  45. DB_LSN lsn;
  46. DBT data;
  47. char *real_name;
  48. int do_close, ret;
  49. ret = 0;
  50. real_name = NULL;
  51. if (fhp != NULL)
  52. do_close = 0;
  53. else {
  54. fhp = &fh;
  55. memset(fhp, 0, sizeof(fh));
  56. do_close = 1;
  57. }
  58. if (mode == 0)
  59. mode = __db_omode("rw----");
  60. if ((ret =
  61.     __db_appname(dbenv, appname, name, 0, NULL, &real_name)) != 0)
  62. goto err;
  63. if (DBENV_LOGGING(dbenv)) {
  64. memset(&data, 0, sizeof(data));
  65. data.data = (void *)name;
  66. data.size = (u_int32_t)strlen(name) + 1;
  67. if ((ret = __fop_create_log(dbenv,
  68.     txn, &lsn, DB_FLUSH, &data, (u_int32_t)appname, mode)) != 0)
  69. goto err;
  70. }
  71. DB_ENV_TEST_RECOVERY(dbenv, DB_TEST_POSTLOG, ret, name);
  72. ret =
  73.     __os_open(dbenv, real_name, DB_OSO_CREATE | DB_OSO_EXCL, mode, fhp);
  74. err:
  75. DB_TEST_RECOVERY_LABEL
  76. if (do_close && F_ISSET(fhp, DB_FH_VALID))
  77. __os_closehandle(dbenv, fhp);
  78. if (real_name != NULL)
  79. __os_free(dbenv, real_name);
  80. return (ret);
  81. }
  82. /*
  83.  * __fop_remove --
  84.  * Remove a file system object.
  85.  *
  86.  * PUBLIC: int __fop_remove __P((DB_ENV *,
  87.  * PUBLIC:     DB_TXN *, u_int8_t *, const char *, APPNAME));
  88.  */
  89. int
  90. __fop_remove(dbenv, txn, fileid, name, appname)
  91. DB_ENV *dbenv;
  92. DB_TXN *txn;
  93. u_int8_t *fileid;
  94. const char *name;
  95. APPNAME appname;
  96. {
  97. DB_LSN lsn;
  98. DBT fdbt, ndbt;
  99. char *real_name;
  100. int ret;
  101. real_name = NULL;
  102. if ((ret =
  103.     __db_appname(dbenv, appname, name, 0, NULL, &real_name)) != 0)
  104. goto err;
  105. if (txn == NULL) {
  106. if (fileid != NULL && (ret = dbenv->memp_nameop(
  107.     dbenv, fileid, NULL, real_name, NULL)) != 0)
  108. goto err;
  109. } else {
  110. if (DBENV_LOGGING(dbenv)) {
  111. memset(&fdbt, 0, sizeof(ndbt));
  112. fdbt.data = fileid;
  113. fdbt.size = fileid == NULL ? 0 : DB_FILE_ID_LEN;
  114. memset(&ndbt, 0, sizeof(ndbt));
  115. ndbt.data = (void *)name;
  116. ndbt.size = (u_int32_t)strlen(name) + 1;
  117. if ((ret = __fop_remove_log(dbenv,
  118.     txn, &lsn, 0, &ndbt, &fdbt, appname)) != 0)
  119. goto err;
  120. }
  121. ret = __txn_remevent(dbenv, txn, real_name, fileid);
  122. }
  123. err: if (real_name != NULL)
  124. __os_free(dbenv, real_name);
  125. return (ret);
  126. }
  127. /*
  128.  * __fop_write
  129.  *
  130.  * Write "size" bytes from "buf" to file "name" beginning at offset "off."
  131.  * If the file is open, supply a handle in fhp.  Istmp indicate if this is
  132.  * an operation that needs to be undone in the face of failure (i.e., if
  133.  * this is a write to a temporary file, we're simply going to remove the
  134.  * file, so don't worry about undoing the write).
  135.  *
  136.  * Currently, we *only* use this with istmp true.  If we need more general
  137.  * handling, then we'll have to zero out regions on abort (and possibly
  138.  * log the before image of the data in the log record).
  139.  *
  140.  * PUBLIC: int __fop_write __P((DB_ENV *, DB_TXN *, const char *, APPNAME,
  141.  * PUBLIC:     DB_FH *, u_int32_t, u_int8_t *, u_int32_t, u_int32_t));
  142.  */
  143. int
  144. __fop_write(dbenv, txn, name, appname, fhp, off, buf, size, istmp)
  145. DB_ENV *dbenv;
  146. DB_TXN *txn;
  147. const char *name;
  148. APPNAME appname;
  149. DB_FH *fhp;
  150. u_int32_t off;
  151. u_int8_t *buf;
  152. u_int32_t size, istmp;
  153. {
  154. DB_FH fh;
  155. DB_LSN lsn;
  156. DBT data, namedbt;
  157. char *real_name;
  158. int ret, t_ret, we_opened;
  159. size_t nbytes;
  160. ret = 0;
  161. we_opened = 0;
  162. real_name = NULL;
  163. if ((ret =
  164.     __db_appname(dbenv, appname, name, 0, NULL, &real_name)) != 0)
  165. goto err;
  166. if (DBENV_LOGGING(dbenv)) {
  167. memset(&data, 0, sizeof(data));
  168. data.data = buf;
  169. data.size = size;
  170. memset(&namedbt, 0, sizeof(namedbt));
  171. namedbt.data = (void *)name;
  172. namedbt.size = (u_int32_t)strlen(name) + 1;
  173. if ((ret = __fop_write_log(dbenv,
  174.     txn, &lsn, 0, &namedbt, appname, off, &data, istmp)) != 0)
  175. goto err;
  176. }
  177. if (fhp == NULL) {
  178. /* File isn't open; we need to reopen it. */
  179. if ((ret = __os_open(dbenv, real_name, 0, 0, &fh)) != 0)
  180. goto err;
  181. fhp = &fh;
  182. we_opened = 1;
  183. } else
  184. we_opened = 0;
  185. /* Seek to offset. */
  186. if ((ret = __os_seek(dbenv, fhp, 0, 0, off, 0, DB_OS_SEEK_SET)) != 0)
  187. goto err;
  188. /* Now do the write. */
  189. if ((ret = __os_write(dbenv, fhp, buf, size, &nbytes)) != 0)
  190. goto err;
  191. err: if (we_opened)
  192. if ((t_ret = __os_closehandle(dbenv, fhp)) != 0 && ret == 0)
  193. ret = t_ret;
  194. if (real_name != NULL)
  195. __os_free(dbenv, real_name);
  196. return (ret);
  197. }
  198. /*
  199.  * __fop_rename --
  200.  * Change a file's name.
  201.  *
  202.  * PUBLIC: int __fop_rename __P((DB_ENV *,
  203.  * PUBLIC:      DB_TXN *, const char *, const char *, u_int8_t *, APPNAME));
  204.  */
  205. int
  206. __fop_rename(dbenv, txn, oldname, newname, fid, appname)
  207. DB_ENV *dbenv;
  208. DB_TXN *txn;
  209. const char *oldname;
  210. const char *newname;
  211. u_int8_t *fid;
  212. APPNAME appname;
  213. {
  214. DB_LSN lsn;
  215. DBT fiddbt, new, old;
  216. int ret;
  217. char *n, *o;
  218. if ((ret = __db_appname(dbenv, appname, oldname, 0, NULL, &o)) != 0)
  219. goto err;
  220. if ((ret = __db_appname(dbenv, appname, newname, 0, NULL, &n)) != 0)
  221. goto err;
  222. if (DBENV_LOGGING(dbenv)) {
  223. memset(&old, 0, sizeof(old));
  224. memset(&new, 0, sizeof(new));
  225. memset(&fiddbt, 0, sizeof(fiddbt));
  226. old.data = (void *)oldname;
  227. old.size = (u_int32_t)strlen(oldname) + 1;
  228. new.data = (void *)newname;
  229. new.size = (u_int32_t)strlen(newname) + 1;
  230. fiddbt.data = fid;
  231. fiddbt.size = DB_FILE_ID_LEN;
  232. if ((ret = __fop_rename_log(dbenv, txn, &lsn,
  233.     DB_FLUSH, &old, &new, &fiddbt, (u_int32_t)appname)) != 0)
  234. goto err;
  235. }
  236. ret = dbenv->memp_nameop(dbenv, fid, newname, o, n);
  237. err: if (o != oldname)
  238. __os_free(dbenv, o);
  239. if (n != newname)
  240. __os_free(dbenv, n);
  241. return (ret);
  242. }