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

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

MySQL数据库

开发平台：

Visual C++

fop_util.c：源码内容
  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 2001-2002
  5.  * Sleepycat Software.  All rights reserved.
  6.  */
  8. #include "db_config.h"
  10. #ifndef lint
  11. static const char revid[] = "$Id: fop_util.c,v 1.52 2002/09/10 02:41:42 bostic Exp $";
  12. #endif /* not lint */
  14. #ifndef NO_SYSTEM_INCLUDES
  15. #include <sys/types.h>
  17. #include <stddef.h>
  18. #include <stdlib.h>
  19. #include <string.h>
  20. #endif
  22. #include "db_int.h"
  23. #include "dbinc/db_page.h"
  24. #include "dbinc/db_shash.h"
  25. #include "dbinc/db_am.h"
  26. #include "dbinc/fop.h"
  27. #include "dbinc/lock.h"
  28. #include "dbinc/log.h"
  29. #include "dbinc/txn.h"
  31. static int __fop_set_pgsize __P((DB *, DB_FH *, const char *));
  33. /*
  34.  * Acquire the environment meta-data lock.  The parameters are the
  35.  * environment (ENV), the locker id to use in acquiring the lock (ID)
  36.  * and a pointer to a DB_LOCK.
  37.  */
  38. #define GET_ENVLOCK(ENV, ID, L) do {
  39. DBT __dbt;
  40. u_int32_t __lockval;
  42. if (LOCKING_ON((ENV))) {
  43. __lockval = 0;
  44. __dbt.data = &__lockval;
  45. __dbt.size = sizeof(__lockval);
  46. if ((ret = (ENV)->lock_get((ENV), (ID),
  47.     0, &__dbt, DB_LOCK_WRITE, (L))) != 0)
  48. goto err;
  49. }
  50. } while (0)
  52. #define REL_ENVLOCK(ENV, L)
  53. (!LOCK_ISSET(*(L)) ? 0 : (ENV)->lock_put((ENV), (L)))
  55. /*
  56.  * If our caller is doing fcntl(2) locking, then we can't close it
  57.  * because that would discard the caller's lock.  Otherwise, close
  58.  * the handle.
  59.  */
  60. #define CLOSE_HANDLE(D, F) {
  61. if (F_ISSET((F), DB_FH_VALID)) {
  62. if (LF_ISSET(DB_FCNTL_LOCKING))
  63. (D)->saved_open_fhp = (F);
  64. else if ((ret = __os_closehandle((D)->dbenv,(F))) != 0)
  65. goto err;
  66. }
  67. }
  69. /*
  70.  * __fop_lock_handle --
  71.  *
  72.  * Get the handle lock for a database.  If the envlock is specified,
  73.  * do this as a lock_vec call that releases the enviroment lock before
  74.  * acquiring the handle lock.
  75.  *
  76.  * PUBLIC: int __fop_lock_handle __P((DB_ENV *,
  77.  * PUBLIC:     DB *, u_int32_t, db_lockmode_t, DB_LOCK *, u_int32_t));
  78.  *
  79.  */
  80. int
  81. __fop_lock_handle(dbenv, dbp, locker, mode, elock, flags)
  82. DB_ENV *dbenv;
  83. DB *dbp;
  84. u_int32_t locker;
  85. db_lockmode_t mode;
  86. DB_LOCK *elock;
  87. u_int32_t flags;
  88. {
  89. DBT fileobj;
  90. DB_LOCKREQ reqs[2], *ereq;
  91. DB_LOCK_ILOCK lock_desc;
  92. int ret;
  94. if (!LOCKING_ON(dbenv) || F_ISSET(dbp, DB_AM_COMPENSATE))
  95. return (0);
  97. /*
  98.  * If we are in recovery, the only locking we should be
  99.  * doing is on the global environment.
  100.  */
  101. if (IS_RECOVERING(dbenv)) {
  102. if (elock != NULL)
  103. REL_ENVLOCK(dbenv, elock);
  104. return (0);
  105. }
  107. memcpy(&lock_desc.fileid, &dbp->fileid, DB_FILE_ID_LEN);
  108. lock_desc.pgno = dbp->meta_pgno;
  109. lock_desc.type = DB_HANDLE_LOCK;
  111. memset(&fileobj, 0, sizeof(fileobj));
  112. fileobj.data = &lock_desc;
  113. fileobj.size = sizeof(lock_desc);
  114. DB_TEST_SUBLOCKS(dbenv, flags);
  115. if (elock == NULL)
  116. ret = dbenv->lock_get(dbenv, locker,
  117.     flags, &fileobj, mode, &dbp->handle_lock);
  118. else {
  119. reqs[0].op = DB_LOCK_PUT;
  120. reqs[0].lock = *elock;
  121. reqs[1].op = DB_LOCK_GET;
  122. reqs[1].mode = mode;
  123. reqs[1].obj = &fileobj;
  124. reqs[1].timeout = 0;
  125. if ((ret = __lock_vec(dbenv,
  126.     locker, flags, reqs, 2, &ereq)) == 0) {
  127. dbp->handle_lock = reqs[1].lock;
  128. LOCK_INIT(*elock);
  129. } else if (ereq != reqs)
  130. LOCK_INIT(*elock);
  131. }
  133. dbp->cur_lid = locker;
  134. return (ret);
  135. }
  137. /*
  138.  * __fop_file_setup --
  139.  *
  140.  * Perform all the needed checking and locking to open up or create a
  141.  * file.
  142.  *
  143.  * There's a reason we don't push this code down into the buffer cache.
  144.  * The problem is that there's no information external to the file that
  145.  * we can use as a unique ID.  UNIX has dev/inode pairs, but they are
  146.  * not necessarily unique after reboot, if the file was mounted via NFS.
  147.  * Windows has similar problems, as the FAT filesystem doesn't maintain
  148.  * dev/inode numbers across reboot.  So, we must get something from the
  149.  * file we can use to ensure that, even after a reboot, the file we're
  150.  * joining in the cache is the right file for us to join.  The solution
  151.  * we use is to maintain a file ID that's stored in the database, and
  152.  * that's why we have to open and read the file before calling into the
  153.  * buffer cache or obtaining a lock (we use this unique fileid to lock
  154.  * as well as to identify like files in the cache).
  155.  *
  156.  * PUBLIC: int __fop_file_setup __P((DB *,
  157.  * PUBLIC:     DB_TXN *, const char *, int, u_int32_t, u_int32_t *));
  158.  */
  159. int
  160. __fop_file_setup(dbp, txn, name, mode, flags, retidp)
  161. DB *dbp;
  162. DB_TXN *txn;
  163. const char *name;
  164. int mode;
  165. u_int32_t flags, *retidp;
  166. {
  167. DB_ENV *dbenv;
  168. DB_FH fh, *fhp;
  169. DB_LOCK elock, tmp_lock;
  170. DB_TXN *stxn;
  171. db_lockmode_t lmode;
  172. u_int32_t locker, oflags;
  173. u_int8_t mbuf[DBMETASIZE];
  174. int created_fhp, created_locker, ret, tmp_created, truncating;
  175. char *real_name, *real_tmpname, *tmpname;
  177. DB_ASSERT(name != NULL);
  179. *retidp = TXN_INVALID;
  181. dbenv = dbp->dbenv;
  182. LOCK_INIT(elock);
  183. LOCK_INIT(tmp_lock);
  184. stxn = NULL;
  185. created_fhp = created_locker = 0;
  186. real_name = real_tmpname = tmpname = NULL;
  187. tmp_created = truncating = 0;
  189. /*
  190.  * If we open a file handle and our caller is doing fcntl(2) locking,
  191.  * we can't close it because that would discard the caller's lock.
  192.  * Save it until we close the DB handle.
  193.  */
  194. if (LF_ISSET(DB_FCNTL_LOCKING)) {
  195. if ((ret = __os_malloc(dbenv, sizeof(*fhp), &fhp)) != 0)
  196. return (ret);
  197. created_fhp = 1;
  198. } else
  199. fhp = &fh;
  200. memset(fhp, 0, sizeof(*fhp));
  202. /*
  203.  * Get a lockerid for this handle.  There are paths through queue
  204.  * rename and remove where this dbp already has a locker, so make
  205.  * sure we don't clobber it and conflict.
  206.  */
  207. if (LOCKING_ON(dbenv) &&
  208.     !F_ISSET(dbp, DB_AM_COMPENSATE) && dbp->lid == DB_LOCK_INVALIDID) {
  209. if ((ret = __lock_id(dbenv, &dbp->lid)) != 0)
  210. goto err;
  211. created_locker = 1;
  212. }
  214. locker = txn == NULL ? dbp->lid : txn->txnid;
  216. /* Get the real backing file name. */
  217. if ((ret = __db_appname(dbenv,
  218.     DB_APP_DATA, name, 0, NULL, &real_name)) != 0)
  219. goto err;
  221. /* Fill in the default file mode. */
  222. if (mode == 0)
  223. mode = __db_omode("rwrw--");
  225. oflags = 0;
  226. if (LF_ISSET(DB_RDONLY))
  227. oflags |= DB_OSO_RDONLY;
  229. retry: if (!F_ISSET(dbp, DB_AM_COMPENSATE))
  230. GET_ENVLOCK(dbenv, locker, &elock);
  231. if ((ret = __os_exists(real_name, NULL)) == 0) {
  232. if (LF_ISSET(DB_EXCL)) {
  233. ret = EEXIST;
  234. goto err;
  235. }
  236. reopen: if ((ret = __fop_read_meta(dbenv, real_name,
  237.     mbuf, sizeof(mbuf), fhp, 0, oflags)) != 0)
  238. goto err;
  240. if ((ret = __db_meta_setup(dbenv,
  241.     dbp, real_name, (DBMETA *)mbuf, flags, 1)) != 0)
  242. goto err;
  244. /* Now, get our handle lock. */
  245. lmode = LF_ISSET(DB_TRUNCATE) ? DB_LOCK_WRITE : DB_LOCK_READ;
  246. if ((ret = __fop_lock_handle(dbenv,
  247.     dbp, locker, lmode, NULL, DB_LOCK_NOWAIT)) == 0) {
  248. if ((ret = REL_ENVLOCK(dbenv, &elock)) != 0)
  249. goto err;
  250. } else {
  251. /* Someone else has file locked; need to wait. */
  252. if ((ret = __os_closehandle(dbenv, fhp)) != 0)
  253. goto err;
  254. ret = __fop_lock_handle(dbenv,
  255.     dbp, locker, lmode, &elock, 0);
  256. if (ret == DB_LOCK_NOTEXIST)
  257. goto retry;
  258. if (ret != 0)
  259. goto err;
  260. /*
  261.  * XXX I need to convince myself that I don't need
  262.  * to re-read the metadata page here.
  263.  * XXX If you do need to re-read it you'd better
  264.  * decrypt it too...
  265.  */
  266. if ((ret = __os_open(dbenv, real_name, 0, 0, fhp)) != 0)
  267. goto err;
  268. }
  270. /*
  271.  * Check for a truncate which needs to leap over to the
  272.  * create case.
  273.  */
  274. if (LF_ISSET(DB_TRUNCATE)) {
  275. /*
  276.  * Sadly, we need to close and reopen the handle
  277.  * in order to do the actual truncate.  We couldn't
  278.  * do the truncate on the initial open because we
  279.  * needed to read the old file-id in order to lock.
  280.  */
  281. if ((ret = __os_closehandle(dbenv, fhp)) != 0)
  282. goto err;
  283. if ((ret = __os_open(dbenv,
  284.     real_name, DB_OSO_TRUNC, 0, fhp)) != 0)
  285. goto err;
  286. /*
  287.  * This is not-transactional, so we'll do the
  288.  * open/create in-place.
  289.  */
  290. tmp_lock = dbp->handle_lock;
  291. truncating = 1;
  292. tmpname = (char *)name;
  293. goto creat2;
  294. }
  296. /*
  297.  * Check for a file in the midst of a rename
  298.  */
  299. if (F_ISSET(dbp, DB_AM_IN_RENAME)) {
  300. if (LF_ISSET(DB_CREATE)) {
  301. F_CLR(dbp, DB_AM_IN_RENAME);
  302. goto create;
  303. } else {
  304. ret = ENOENT;
  305. goto err;
  306. }
  307. }
  309. CLOSE_HANDLE(dbp, fhp);
  310. goto done;
  311. }
  313. /* File does not exist. */
  314. if (!LF_ISSET(DB_CREATE))
  315. goto err;
  316. ret = 0;
  318. /*
  319.  * Need to create file; we need to set up the file,
  320.  * the fileid and the locks.  Then we need to call
  321.  * the appropriate routines to create meta-data pages.
  322.  */
  323. if ((ret = REL_ENVLOCK(dbenv, &elock)) != 0)
  324. goto err;
  326. create: if ((ret = __db_backup_name(dbenv, name, txn, &tmpname)) != 0)
  327. goto err;
  328. if (TXN_ON(dbenv) && txn != NULL &&
  329.     (ret = dbenv->txn_begin(dbenv, txn, &stxn, 0)) != 0)
  330. goto err;
  331. if ((ret = __fop_create(dbenv,
  332.     stxn, fhp, tmpname, DB_APP_DATA, mode)) != 0)
  333. goto err;
  334. tmp_created = 1;
  335. creat2: if ((ret = __db_appname(dbenv,
  336.     DB_APP_DATA, tmpname, 0, NULL, &real_tmpname)) != 0)
  337. goto err;
  339. /* Set the pagesize if it isn't yet set. */
  340. if (dbp->pgsize == 0 &&
  341.     (ret = __fop_set_pgsize(dbp, fhp, real_tmpname)) != 0)
  342. goto errmsg;
  344. /* Construct a file_id. */
  345. if ((ret = __os_fileid(dbenv, real_tmpname, 1, dbp->fileid)) != 0)
  346. goto errmsg;
  348. if ((ret = __db_new_file(dbp, stxn, fhp, tmpname)) != 0)
  349. goto err;
  350. CLOSE_HANDLE(dbp, fhp);
  352. /* Now move the file into place. */
  353. if (!F_ISSET(dbp, DB_AM_COMPENSATE))
  354. GET_ENVLOCK(dbenv, locker, &elock);
  355. if (!truncating && __os_exists(real_name, NULL) == 0) {
  356. /*
  357.  * Someone managed to create the file; remove our temp
  358.  * and try to open the file that now exists.
  359.  */
  360. (void)__fop_remove(dbenv,
  361.     NULL, dbp->fileid, tmpname, DB_APP_DATA);
  362. if (LOCKING_ON(dbenv))
  363. dbenv->lock_put(dbenv, &dbp->handle_lock);
  364. LOCK_INIT(dbp->handle_lock);
  366. /* If we have a saved handle; close it. */
  367. if (LF_ISSET(DB_FCNTL_LOCKING))
  368. (void)__os_closehandle(dbenv, fhp);
  369. if (stxn != NULL) {
  370. ret = stxn->abort(stxn);
  371. stxn = NULL;
  372. }
  373. if (ret != 0)
  374. goto err;
  375. goto reopen;
  376. }
  378. /* We've successfully created, move the file into place. */
  379. if ((ret = __fop_lock_handle(dbenv,
  380.     dbp, locker, DB_LOCK_WRITE, &elock, 0)) != 0)
  381. goto err;
  382. if (!truncating && (ret = __fop_rename(dbenv,
  383.     stxn, tmpname, name, dbp->fileid, DB_APP_DATA)) != 0)
  384. goto err;
  386. /* If this was a truncate; release lock on the old file. */
  387. if (LOCK_ISSET(tmp_lock) && (ret = __lock_put(dbenv, &tmp_lock)) != 0)
  388. goto err;
  390. if (stxn != NULL) {
  391. *retidp = stxn->txnid;
  392. ret = stxn->commit(stxn, 0);
  393. stxn = NULL;
  394. } else
  395. *retidp = TXN_INVALID;
  397. if (ret != 0)
  398. goto err;
  400. F_SET(dbp, DB_AM_CREATED);
  402. if (0) {
  403. errmsg: __db_err(dbenv, "%s: %s", name, db_strerror(ret));
  405. err: if (stxn != NULL)
  406. (void)stxn->abort(stxn);
  407. if (tmp_created && txn == NULL)
  408. (void)__fop_remove(dbenv,
  409.     NULL, NULL, tmpname, DB_APP_DATA);
  410. if (F_ISSET(fhp, DB_FH_VALID))
  411. (void)__os_closehandle(dbenv, fhp);
  412. if (LOCK_ISSET(tmp_lock))
  413. __lock_put(dbenv, &tmp_lock);
  414. if (LOCK_ISSET(dbp->handle_lock) && txn == NULL)
  415. __lock_put(dbenv, &dbp->handle_lock);
  416. if (LOCK_ISSET(elock))
  417. (void)REL_ENVLOCK(dbenv, &elock);
  418. if (created_locker) {
  419. (void)__lock_id_free(dbenv, dbp->lid);
  420. dbp->lid = DB_LOCK_INVALIDID;
  421. }
  422. if (created_fhp)
  423. __os_free(dbenv, fhp);
  424. }
  426. done: if (!truncating && tmpname != NULL)
  427. __os_free(dbenv, tmpname);
  428. if (real_name != NULL)
  429. __os_free(dbenv, real_name);
  430. if (real_tmpname != NULL)
  431. __os_free(dbenv, real_tmpname);
  433. return (ret);
  434. }
  436. /*
  437.  * __fop_set_pgsize --
  438.  * Set the page size based on file information.
  439.  */
  440. static int
  441. __fop_set_pgsize(dbp, fhp, name)
  442. DB *dbp;
  443. DB_FH *fhp;
  444. const char *name;
  445. {
  446. DB_ENV *dbenv;
  447. u_int32_t iopsize;
  448. int ret;
  450. dbenv = dbp->dbenv;
  452. /*
  453.  * Use the filesystem's optimum I/O size as the pagesize if a pagesize
  454.  * not specified.  Some filesystems have 64K as their optimum I/O size,
  455.  * but as that results in fairly large default caches, we limit the
  456.  * default pagesize to 16K.
  457.  */
  458. if ((ret = __os_ioinfo(dbenv, name, fhp, NULL, NULL, &iopsize)) != 0) {
  459. __db_err(dbenv, "%s: %s", name, db_strerror(ret));
  460. return (ret);
  461. }
  462. if (iopsize < 512)
  463. iopsize = 512;
  464. if (iopsize > 16 * 1024)
  465. iopsize = 16 * 1024;
  467. /*
  468.  * Sheer paranoia, but we don't want anything that's not a power-of-2
  469.  * (we rely on that for alignment of various types on the pages), and
  470.  * we want a multiple of the sector size as well.  If the value
  471.  * we got out of __os_ioinfo looks bad, use a default instead.
  472.  */
  473. if (!IS_VALID_PAGESIZE(iopsize))
  474. iopsize = DB_DEF_IOSIZE;
  476. dbp->pgsize = iopsize;
  477. F_SET(dbp, DB_AM_PGDEF);
  479. return (0);
  480. }
  482. /*
  483.  * __fop_subdb_setup --
  484.  *
  485.  * Subdb setup is significantly simpler than file setup.  In terms of
  486.  * locking, for the duration of the operation/transaction, the locks on
  487.  * the meta-data page will suffice to protect us from simultaneous operations
  488.  * on the sub-database.  Before we complete the operation though, we'll get a
  489.  * handle lock on the subdatabase so that on one else can try to remove it
  490.  * while we've got it open.  We use an object that looks like the meta-data
  491.  * page lock with a different type (DB_HANDLE_LOCK) for the long-term handle.
  492.  * locks.
  493.  *
  494.  * PUBLIC: int __fop_subdb_setup __P((DB *, DB_TXN *,
  495.  * PUBLIC:     const char *, const char *, int, u_int32_t));
  496.  */
  497. int
  498. __fop_subdb_setup(dbp, txn, mname, name, mode, flags)
  499. DB *dbp;
  500. DB_TXN *txn;
  501. const char *mname, *name;
  502. int mode;
  503. u_int32_t flags;
  504. {
  505. DB *mdbp;
  506. DB_ENV *dbenv;
  507. int do_remove, ret;
  509. mdbp = NULL;
  510. dbenv = dbp->dbenv;
  512. if ((ret = __db_master_open(dbp, txn, mname, flags, mode, &mdbp)) != 0)
  513. return (ret);
  515. /*
  516.  * We are going to close this instance of the master, so we can
  517.  * steal its handle instead of reopening a handle on the database.
  518.  */
  519. if (LF_ISSET(DB_FCNTL_LOCKING)) {
  520. dbp->saved_open_fhp = mdbp->saved_open_fhp;
  521. mdbp->saved_open_fhp = NULL;
  522. }
  524. /* Now copy the pagesize. */
  525. dbp->pgsize = mdbp->pgsize;
  526. F_SET(dbp, DB_AM_SUBDB);
  528. if (name != NULL && (ret = __db_master_update(mdbp, dbp, txn,
  529.     name, dbp->type, MU_OPEN, NULL, flags)) != 0)
  530. goto err;
  532. /*
  533.  * Hijack the master's locker ID as well, so that our locks don't
  534.  * conflict with the master's.  Since we're closing the master,
  535.  * that lid would just have been freed anyway.  Once we've gotten
  536.  * the locker id, we need to acquire the handle lock for this
  537.  * subdatabase.
  538.  */
  539. dbp->lid = mdbp->lid;
  540. mdbp->lid = DB_LOCK_INVALIDID;
  542. DB_TEST_RECOVERY(dbp, DB_TEST_POSTLOG, ret, mname);
  544. /*
  545.  * We copy our fileid from our master so that we all open
  546.  * the same file in mpool.  We'll use the meta-pgno to lock
  547.  * so that we end up with different handle locks.
  548.  */
  550. memcpy(dbp->fileid, mdbp->fileid, DB_FILE_ID_LEN);
  551. if ((ret = __fop_lock_handle(dbenv, dbp,
  552.     txn == NULL ? dbp->lid : txn->txnid,
  553.     F_ISSET(dbp, DB_AM_CREATED) || LF_ISSET(DB_WRITEOPEN) ?
  554.     DB_LOCK_WRITE : DB_LOCK_READ, NULL, 0)) != 0)
  555. goto err;
  557. if ((ret = __db_init_subdb(mdbp, dbp, name, txn)) != 0)
  558. goto err;
  560. /*
  561.  * In the file create case, these happen in separate places so we have
  562.  * two different tests.  They end up in the same place for subdbs, but
  563.  * for compatibility with file testing, we put them both here anyway.
  564.  */
  565. DB_TEST_RECOVERY(dbp, DB_TEST_POSTLOGMETA, ret, mname);
  566. DB_TEST_RECOVERY(dbp, DB_TEST_POSTSYNC, ret, mname);
  568. /*
  569.  * File exists and we have the appropriate locks; we should now
  570.  * process a normal open.
  571.  */
  572. if (F_ISSET(mdbp, DB_AM_CREATED)) {
  573. F_SET(dbp, DB_AM_CREATED_MSTR);
  574. F_CLR(mdbp, DB_AM_DISCARD);
  575. }
  577. /*
  578.  * The master's handle lock is under the control of the
  579.  * subdb (it acquired the master's locker.  We want to
  580.  * keep the master's handle lock so that no one can remove
  581.  * the file while the subdb is open.  If we register the
  582.  * trade event and then invalidate the copy of the lock
  583.  * in the master's handle, that will accomplish this.  However,
  584.  * before we register this event, we'd better remove any
  585.  * events that we've already registered for the master.
  586.  */
  588. if (!F_ISSET(dbp, DB_AM_RECOVER) && txn != NULL) {
  589. /* Unregister old master events. */
  590.  __txn_remlock(dbenv,
  591.     txn, &mdbp->handle_lock, DB_LOCK_INVALIDID);
  593. /* Now register the new event. */
  594. if ((ret = __txn_lockevent(dbenv,
  595.     txn, dbp, &mdbp->handle_lock, dbp->lid)) != 0)
  596. goto err;
  597. }
  598. LOCK_INIT(mdbp->handle_lock);
  599. return (__db_close_i(mdbp, txn, 0));
  601. err:
  602. DB_TEST_RECOVERY_LABEL
  603. if (LOCK_ISSET(dbp->handle_lock) && txn == NULL)
  604. __lock_put(dbenv, &dbp->handle_lock);
  606. /* If we created the master file then we need to remove it.  */
  607. if (mdbp != NULL) {
  608. do_remove = F_ISSET(mdbp, DB_AM_CREATED) ? 1 : 0;
  609. if (do_remove)
  610. F_SET(mdbp, DB_AM_DISCARD);
  611. (void)__db_close_i(mdbp, txn, 0);
  612. if (do_remove) {
  613. (void)db_create(&mdbp, dbp->dbenv, 0);
  614. (void)__db_remove_i(mdbp, txn, mname, NULL);
  615. }
  616. }
  617. return (ret);
  618. }
  620. /*
  621.  * __fop_remove_setup --
  622.  * Open handle appropriately and lock for removal of a database file.
  623.  *
  624.  * PUBLIC: int __fop_remove_setup __P((DB *,
  625.  * PUBLIC:      DB_TXN *, const char *, u_int32_t));
  626.  */
  627. int
  628. __fop_remove_setup(dbp, txn, name, flags)
  629. DB *dbp;
  630. DB_TXN *txn;
  631. const char *name;
  632. u_int32_t flags;
  633. {
  634. DB_ENV *dbenv;
  635. DB_LOCK elock;
  636. u_int8_t mbuf[DBMETASIZE];
  637. int ret;
  639. COMPQUIET(flags, 0);
  640. dbenv = dbp->dbenv;
  641. PANIC_CHECK(dbenv);
  642. LOCK_INIT(elock);
  644. /* Create locker if necessary. */
  645. if (LOCKING_ON(dbenv)) {
  646. if (txn != NULL)
  647. dbp->lid = txn->txnid;
  648. else if (dbp->lid == DB_LOCK_INVALIDID) {
  649. if ((ret = __lock_id(dbenv, &dbp->lid)) != 0)
  650. goto err;
  651. }
  652. }
  654. /*
  655.  * Lock environment to protect file open.  That will enable us to
  656.  * read the meta-data page and get the fileid so that we can lock
  657.  * the handle.
  658.  */
  659. GET_ENVLOCK(dbenv, dbp->lid, &elock);
  660. if ((ret = __fop_read_meta(dbenv,
  661.     name, mbuf, sizeof(mbuf), NULL, 0, 0)) != 0)
  662. goto err;
  664. if ((ret =
  665.     __db_meta_setup(dbenv, dbp, name, (DBMETA *)mbuf, flags, 1)) != 0)
  666. goto err;
  668. /* Now, release the environment and get the handle lock. */
  669. if ((ret = __fop_lock_handle(dbenv,
  670.     dbp, dbp->lid, DB_LOCK_WRITE, &elock, 0)) != 0)
  671. goto err;
  673. return (0);
  675. err: (void)REL_ENVLOCK(dbenv, &elock);
  676. return (ret);
  677. }
  679. /*
  680.  * __fop_read_meta --
  681.  * Read the meta-data page from a file and return it in buf.  The
  682.  * open file handle is returned in fhp.
  683.  *
  684.  * PUBLIC: int __fop_read_meta __P((DB_ENV *,
  685.  * PUBLIC:     const char *, u_int8_t *, size_t, DB_FH *, int, u_int32_t));
  686.  */
  687. int
  688. __fop_read_meta(dbenv, name, buf, size, fhp, errok, flags)
  689. DB_ENV *dbenv;
  690. const char *name;
  691. u_int8_t *buf;
  692. size_t size;
  693. DB_FH *fhp;
  694. int errok;
  695. u_int32_t flags;
  696. {
  697. DB_FH fh, *lfhp;
  698. size_t nr;
  699. int ret;
  701. lfhp = fhp == NULL ? &fh : fhp;
  702. memset(lfhp, 0, sizeof(*fhp));
  703. if ((ret = __os_open(dbenv, name, flags, 0, lfhp)) != 0)
  704. goto err;
  705. if ((ret = __os_read(dbenv, lfhp, buf, size, &nr)) != 0) {
  706. if (!errok)
  707. __db_err(dbenv, "%s: %s", name, db_strerror(ret));
  708. goto err;
  709. }
  711. if (nr != size) {
  712. if (!errok)
  713. __db_err(dbenv,
  714.     "%s: unexpected file type or format", name);
  715. ret = EINVAL;
  716. goto err;
  717. }
  719. err: /*
  720.  * On error, we always close the handle.  If there is no error,
  721.  * then we only return the handle if the user didn't pass us
  722.  * a handle into which to return it.  If fhp is valid, then
  723.  * lfhp is the same as fhp.
  724.  */
  725. if (F_ISSET(lfhp, DB_FH_VALID) && (ret != 0 || fhp == NULL))
  726. __os_closehandle(dbenv, lfhp);
  727. return (ret);
  728. }
  730. /*
  731.  * __fop_dummy --
  732.  * This implements the creation and name swapping of dummy files that
  733.  * we use for remove and rename (remove is simply a rename with a delayed
  734.  * remove).
  735.  *
  736.  * PUBLIC: int __fop_dummy __P((DB *,
  737.  * PUBLIC:     DB_TXN *, const char *, const char *, u_int32_t));
  738.  */
  739. int
  740. __fop_dummy(dbp, txn, old, new, flags)
  741. DB *dbp;
  742. DB_TXN *txn;
  743. const char *old, *new;
  744. u_int32_t flags;
  745. {
  746. DB *tmpdbp;
  747. DB_ENV *dbenv;
  748. DB_LOCK elock;
  749. DB_LSN lsn;
  750. DBT fiddbt, namedbt, tmpdbt;
  751. DB_TXN *stxn;
  752. char *back;
  753. char *realback, *realnew, *realold;
  754. int ret, t_ret;
  755. u_int8_t mbuf[DBMETASIZE];
  756. u_int32_t locker, stxnid;
  758. dbenv = dbp->dbenv;
  759. LOCK_INIT(elock);
  760. realback = NULL;
  761. realnew = NULL;
  762. realold = NULL;
  763. back = NULL;
  764. stxn = NULL;
  765. tmpdbp = NULL;
  767. DB_ASSERT(txn != NULL);
  768. locker = txn->txnid;
  770. /* Begin sub transaction to encapsulate the rename. */
  771. if (TXN_ON(dbenv) &&
  772.     (ret = dbenv->txn_begin(dbenv, txn, &stxn, 0)) != 0)
  773. goto err;
  775. /* We need to create a dummy file as a place holder. */
  776. if ((ret = __db_backup_name(dbenv, new, stxn, &back)) != 0)
  777. goto err;
  778. if ((ret = __db_appname(dbenv,
  779.     DB_APP_DATA, back, flags, NULL, &realback)) != 0)
  780. goto err;
  781. if ((ret = __fop_create(dbenv, stxn, NULL, back, DB_APP_DATA, 0)) != 0)
  782. goto err;
  784. memset(mbuf, 0, sizeof(mbuf));
  785. if ((ret =
  786.     __os_fileid(dbenv, realback, 1, ((DBMETA *)mbuf)->uid)) != 0)
  787. goto err;
  788. ((DBMETA *)mbuf)->magic = DB_RENAMEMAGIC;
  789. if ((ret = __fop_write(dbenv,
  790.     stxn, back, DB_APP_DATA, NULL, 0, mbuf, DBMETASIZE, 1)) != 0)
  791. goto err;
  793. /* Create a dummy dbp handle. */
  794. if ((ret = db_create(&tmpdbp, dbenv, 0)) != 0)
  795. goto err;
  796. memcpy(&tmpdbp->fileid, ((DBMETA *)mbuf)->uid, DB_FILE_ID_LEN);
  798. /* Now, lock the name space while we initialize this file. */
  799. if ((ret = __db_appname(dbenv,
  800.     DB_APP_DATA, new, 0, NULL, &realnew)) != 0)
  801. goto err;
  802. GET_ENVLOCK(dbenv, locker, &elock);
  803. if (__os_exists(realnew, NULL) == 0) {
  804. ret = EEXIST;
  805. goto err;
  806. }
  808. /*
  809.  * While we have the namespace locked, do the renames and then
  810.  * swap for the handle lock.
  811.  */
  812. if ((ret = __fop_rename(dbenv,
  813.     stxn, old, new, dbp->fileid, DB_APP_DATA)) != 0)
  814. goto err;
  815. if ((ret = __fop_rename(dbenv,
  816.     stxn, back, old, tmpdbp->fileid, DB_APP_DATA)) != 0)
  817. goto err;
  818. if ((ret = __fop_lock_handle(dbenv,
  819.     tmpdbp, locker, DB_LOCK_WRITE, &elock, 0)) != 0)
  820. goto err;
  822. /*
  823.  * We just acquired a transactional lock on the tmp handle.
  824.  * We need to null out the tmp handle's lock so that it
  825.  * doesn't create problems for us in the close path.
  826.  */
  827. LOCK_INIT(tmpdbp->handle_lock);
  829. if (stxn != NULL) {
  830. /* Commit the child. */
  831. stxnid = stxn->txnid;
  832. ret = stxn->commit(stxn, 0);
  833. stxn = NULL;
  835. /* Now log the child information in the parent. */
  836. memset(&fiddbt, 0, sizeof(fiddbt));
  837. memset(&tmpdbt, 0, sizeof(fiddbt));
  838. memset(&namedbt, 0, sizeof(namedbt));
  839. fiddbt.data = dbp->fileid;
  840. fiddbt.size = DB_FILE_ID_LEN;
  841. tmpdbt.data = tmpdbp->fileid;
  842. tmpdbt.size = DB_FILE_ID_LEN;
  843. namedbt.data = (void *)old;
  844. namedbt.size = (u_int32_t)strlen(old) + 1;
  845. if ((t_ret =
  846.     __fop_file_remove_log(dbenv, txn, &lsn, 0, &fiddbt,
  847.     &tmpdbt, &namedbt, DB_APP_DATA, stxnid)) != 0 && ret == 0)
  848. ret = t_ret;
  849. }
  851. /* This is a delayed delete of the dummy file. */
  852. if ((ret = __db_appname(dbenv,
  853.     DB_APP_DATA, old, flags, NULL, &realold)) != 0)
  854. goto err;
  855. if ((ret = __txn_remevent(dbenv, txn, realold, NULL)) != 0)
  856. goto err;
  858. err: (void)REL_ENVLOCK(dbenv, &elock);
  859. if (stxn != NULL)
  860. (void)stxn->abort(stxn);
  861. if (tmpdbp != NULL &&
  862.     (t_ret = __db_close_i(tmpdbp, NULL, 0)) != 0 && ret == 0)
  863. ret = t_ret;
  864. if (realold != NULL)
  865. __os_free(dbenv, realold);
  866. if (realnew != NULL)
  867. __os_free(dbenv, realnew);
  868. if (realback != NULL)
  869. __os_free(dbenv, realback);
  870. if (back != NULL)
  871. __os_free(dbenv, back);
  872. return (ret);
  873. }
  875. /*
  876.  * __fop_dbrename --
  877.  * Do the appropriate file locking and file system operations
  878.  * to effect a dbrename in the absence of transactions (__fop_dummy
  879.  * and the subsequent calls in __db_rename do the work for the
  880.  * transactional case).
  881.  *
  882.  * PUBLIC: int __fop_dbrename __P((DB *, const char *, const char *));
  883.  */
  884. int
  885. __fop_dbrename(dbp, old, new)
  886. DB *dbp;
  887. const char *old, *new;
  888. {
  889. DB_ENV *dbenv;
  890. DB_LOCK elock;
  891. char *real_new, *real_old;
  892. int ret, tret;
  894. dbenv = dbp->dbenv;
  895. real_new = NULL;
  896. real_old = NULL;
  897. LOCK_INIT(elock);
  899. /* Find the real newname of the file. */
  900. if ((ret = __db_appname(dbenv,
  901.     DB_APP_DATA, new, 0, NULL, &real_new)) != 0)
  902. goto err;
  904. /*
  905.  * It is an error to rename a file over one that already exists,
  906.  * as that wouldn't be transaction-safe.
  907.  */
  908. GET_ENVLOCK(dbenv, dbp->lid, &elock);
  909. if (__os_exists(real_new, NULL) == 0) {
  910. ret = EEXIST;
  911. __db_err(dbenv, "rename: file %s exists", real_new);
  912. goto err;
  913. }
  915. if ((ret = __db_appname(dbenv,
  916.     DB_APP_DATA, old, 0, NULL, &real_old)) != 0)
  917. goto err;
  919. ret = dbenv->memp_nameop(dbenv, dbp->fileid, new, real_old, real_new);
  921. err: if ((tret = REL_ENVLOCK(dbenv, &elock)) != 0 && ret == 0)
  922. ret = tret;
  923. if (real_old != NULL)
  924. __os_free(dbenv, real_old);
  925. if (real_new != NULL)
  926. __os_free(dbenv, real_new);
  927. return (ret);
  928. }