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

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

MySQL数据库

开发平台：

Visual C++

env_open.c：源码内容
  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 1996-2002
  5.  * Sleepycat Software.  All rights reserved.
  6.  */
  8. #include "db_config.h"
  10. #ifndef lint
  11. static const char revid[] = "$Id: env_open.c,v 11.111 2002/09/03 01:20:51 mjc Exp $";
  12. #endif /* not lint */
  14. #ifndef NO_SYSTEM_INCLUDES
  15. #include <sys/types.h>
  17. #include <ctype.h>
  18. #include <stdlib.h>
  19. #include <string.h>
  20. #include <unistd.h>
  21. #endif
  23. #include "db_int.h"
  24. #include "dbinc/crypto.h"
  25. #include "dbinc/db_page.h"
  26. #include "dbinc/db_shash.h"
  27. #include "dbinc/btree.h"
  28. #include "dbinc/hash.h"
  29. #include "dbinc/lock.h"
  30. #include "dbinc/log.h"
  31. #include "dbinc/mp.h"
  32. #include "dbinc/qam.h"
  33. #include "dbinc/rep.h"
  34. #include "dbinc/txn.h"
  35. #include "dbinc/fop.h"
  37. static int __db_parse __P((DB_ENV *, char *));
  38. static int __db_tmp_open __P((DB_ENV *, u_int32_t, char *, DB_FH *));
  39. static int __dbenv_config __P((DB_ENV *, const char *, u_int32_t));
  40. static int __dbenv_iremove __P((DB_ENV *, const char *, u_int32_t));
  41. static int __dbenv_refresh __P((DB_ENV *, u_int32_t));
  43. /*
  44.  * db_version --
  45.  * Return version information.
  46.  *
  47.  * EXTERN: char *db_version __P((int *, int *, int *));
  48.  */
  49. char *
  50. db_version(majverp, minverp, patchp)
  51. int *majverp, *minverp, *patchp;
  52. {
  53. if (majverp != NULL)
  54. *majverp = DB_VERSION_MAJOR;
  55. if (minverp != NULL)
  56. *minverp = DB_VERSION_MINOR;
  57. if (patchp != NULL)
  58. *patchp = DB_VERSION_PATCH;
  59. return ((char *)DB_VERSION_STRING);
  60. }
  62. /*
  63.  * __dbenv_open --
  64.  * Initialize an environment.
  65.  *
  66.  * PUBLIC: int __dbenv_open __P((DB_ENV *, const char *, u_int32_t, int));
  67.  */
  68. int
  69. __dbenv_open(dbenv, db_home, flags, mode)
  70. DB_ENV *dbenv;
  71. const char *db_home;
  72. u_int32_t flags;
  73. int mode;
  74. {
  75. DB_MPOOL *dbmp;
  76. int ret;
  77. u_int32_t init_flags, orig_flags;
  79. orig_flags = dbenv->flags;
  81. #undef OKFLAGS
  82. #define OKFLAGS
  83. DB_CREATE | DB_INIT_CDB | DB_INIT_LOCK | DB_INIT_LOG |
  84. DB_INIT_MPOOL | DB_INIT_TXN | DB_JOINENV | DB_LOCKDOWN |
  85. DB_PRIVATE | DB_RECOVER | DB_RECOVER_FATAL | DB_SYSTEM_MEM |
  86. DB_THREAD | DB_USE_ENVIRON | DB_USE_ENVIRON_ROOT
  87. #undef OKFLAGS_CDB
  88. #define OKFLAGS_CDB
  89. DB_CREATE | DB_INIT_CDB | DB_INIT_MPOOL | DB_LOCKDOWN |
  90. DB_PRIVATE | DB_SYSTEM_MEM | DB_THREAD |
  91. DB_USE_ENVIRON | DB_USE_ENVIRON_ROOT
  93. /*
  94.  * Flags saved in the init_flags field of the environment, representing
  95.  * flags to DB_ENV->set_flags and DB_ENV->open that need to be set.
  96.  */
  97. #define DB_INITENV_CDB 0x0001 /* DB_INIT_CDB */
  98. #define DB_INITENV_CDB_ALLDB 0x0002 /* DB_INIT_CDB_ALLDB */
  99. #define DB_INITENV_LOCK 0x0004 /* DB_INIT_LOCK */
  100. #define DB_INITENV_LOG 0x0008 /* DB_INIT_LOG */
  101. #define DB_INITENV_MPOOL 0x0010 /* DB_INIT_MPOOL */
  102. #define DB_INITENV_TXN 0x0020 /* DB_INIT_TXN */
  104. if ((ret = __db_fchk(dbenv, "DB_ENV->open", flags, OKFLAGS)) != 0)
  105. return (ret);
  106. if (LF_ISSET(DB_INIT_CDB) &&
  107.     (ret = __db_fchk(dbenv, "DB_ENV->open", flags, OKFLAGS_CDB)) != 0)
  108. return (ret);
  109. if ((ret = __db_fcchk(dbenv,
  110.     "DB_ENV->open", flags, DB_PRIVATE, DB_SYSTEM_MEM)) != 0)
  111. return (ret);
  112. if ((ret = __db_fcchk(dbenv,
  113.     "DB_ENV->open", flags, DB_RECOVER, DB_RECOVER_FATAL)) != 0)
  114. return (ret);
  115. if ((ret = __db_fcchk(dbenv, "DB_ENV->open", flags, DB_JOINENV,
  116.     DB_CREATE | DB_INIT_LOCK | DB_INIT_LOG | DB_INIT_MPOOL |
  117.     DB_INIT_TXN | DB_PRIVATE)) != 0)
  118. return (ret);
  120. /*
  121.  * Currently we support one kind of mutex that is intra-process only,
  122.  * POSIX 1003.1 pthreads, because a variety of systems don't support
  123.  * the full pthreads API, and our only alternative is test-and-set.
  124.  */
  125. #ifdef HAVE_MUTEX_THREAD_ONLY
  126. if (!LF_ISSET(DB_PRIVATE)) {
  127. __db_err(dbenv,
  128.     "Berkeley DB library configured to support only DB_PRIVATE environments");
  129. return (EINVAL);
  130. }
  131. #endif
  133. /*
  134.  * If we're doing recovery, destroy the environment so that we create
  135.  * all the regions from scratch.  I'd like to reuse already created
  136.  * regions, but that's hard.  We would have to create the environment
  137.  * region from scratch, at least, as we have no way of knowing if its
  138.  * linked lists are corrupted.
  139.  *
  140.  * I suppose we could set flags while modifying those links, but that
  141.  * is going to be difficult to get right.  The major concern I have
  142.  * is if the application stomps the environment with a rogue pointer.
  143.  * We have no way of detecting that, and we could be forced into a
  144.  * situation where we start up and then crash, repeatedly.
  145.  *
  146.  * Note that we do not check any flags like DB_PRIVATE before calling
  147.  * remove.  We don't care if the current environment was private or
  148.  * not, we just want to nail any files that are left-over for whatever
  149.  * reason, from whatever session.
  150.  */
  151. if (LF_ISSET(DB_RECOVER | DB_RECOVER_FATAL))
  152. if ((ret = __dbenv_iremove(dbenv, db_home, DB_FORCE)) != 0 ||
  153.     (ret = __dbenv_refresh(dbenv, orig_flags)) != 0)
  154. return (ret);
  156. /* Initialize the DB_ENV structure. */
  157. if ((ret = __dbenv_config(dbenv, db_home, flags)) != 0)
  158. goto err;
  160. /* Convert the DB_ENV->open flags to internal flags. */
  161. if (LF_ISSET(DB_CREATE))
  162. F_SET(dbenv, DB_ENV_CREATE);
  163. if (LF_ISSET(DB_LOCKDOWN))
  164. F_SET(dbenv, DB_ENV_LOCKDOWN);
  165. if (LF_ISSET(DB_PRIVATE))
  166. F_SET(dbenv, DB_ENV_PRIVATE);
  167. if (LF_ISSET(DB_RECOVER_FATAL))
  168. F_SET(dbenv, DB_ENV_FATAL);
  169. if (LF_ISSET(DB_SYSTEM_MEM))
  170. F_SET(dbenv, DB_ENV_SYSTEM_MEM);
  171. if (LF_ISSET(DB_THREAD))
  172. F_SET(dbenv, DB_ENV_THREAD);
  174. /* Default permissions are read-write for both owner and group. */
  175. dbenv->db_mode = mode == 0 ? __db_omode("rwrw--") : mode;
  177. /*
  178.  * Create/join the environment.  We pass in the flags that
  179.  * will be of interest to an environment joining later;  if
  180.  * we're not the ones to do the create, we
  181.  * pull out whatever has been stored, if we don't do a create.
  182.  */
  183. init_flags = 0;
  184. init_flags |= (LF_ISSET(DB_INIT_CDB) ? DB_INITENV_CDB : 0);
  185. init_flags |= (LF_ISSET(DB_INIT_LOCK) ? DB_INITENV_LOCK : 0);
  186. init_flags |= (LF_ISSET(DB_INIT_LOG) ? DB_INITENV_LOG : 0);
  187. init_flags |= (LF_ISSET(DB_INIT_MPOOL) ? DB_INITENV_MPOOL : 0);
  188. init_flags |= (LF_ISSET(DB_INIT_TXN) ? DB_INITENV_TXN : 0);
  189. init_flags |=
  190.     (F_ISSET(dbenv, DB_ENV_CDB_ALLDB) ? DB_INITENV_CDB_ALLDB : 0);
  192. if ((ret = __db_e_attach(dbenv, &init_flags)) != 0)
  193. goto err;
  195. /*
  196.  * __db_e_attach will return the saved init_flags field, which
  197.  * contains the DB_INIT_* flags used when we were created.
  198.  */
  199. if (LF_ISSET(DB_JOINENV)) {
  200. LF_CLR(DB_JOINENV);
  202. LF_SET((init_flags & DB_INITENV_CDB) ? DB_INIT_CDB : 0);
  203. LF_SET((init_flags & DB_INITENV_LOCK) ? DB_INIT_LOCK : 0);
  204. LF_SET((init_flags & DB_INITENV_LOG) ? DB_INIT_LOG : 0);
  205. LF_SET((init_flags & DB_INITENV_MPOOL) ? DB_INIT_MPOOL : 0);
  206. LF_SET((init_flags & DB_INITENV_TXN) ? DB_INIT_TXN : 0);
  208. if (LF_ISSET(DB_INITENV_CDB_ALLDB) &&
  209.     (ret = dbenv->set_flags(dbenv, DB_CDB_ALLDB, 1)) != 0)
  210. goto err;
  211. }
  213. /* Initialize for CDB product. */
  214. if (LF_ISSET(DB_INIT_CDB)) {
  215. LF_SET(DB_INIT_LOCK);
  216. F_SET(dbenv, DB_ENV_CDB);
  217. }
  219. /*
  220.  * Initialize the subsystems.  Transactions imply logging but do not
  221.  * imply locking.  While almost all applications want both locking
  222.  * and logging, it would not be unreasonable for a single threaded
  223.  * process to want transactions for atomicity guarantees, but not
  224.  * necessarily need concurrency.
  225.  */
  227. if (LF_ISSET(DB_INIT_MPOOL))
  228. if ((ret = __memp_open(dbenv)) != 0)
  229. goto err;
  231. #ifdef HAVE_CRYPTO
  232. /*
  233.  * Initialize the ciphering area prior to any running of recovery so
  234.  * that we can initialize the keys, etc. before recovery.
  235.  *
  236.  * !!!
  237.  * This must be after the mpool init, but before the log initialization
  238.  * because log_open may attempt to run log_recover during its open.
  239.  */
  240. if ((ret = __crypto_region_init(dbenv)) != 0)
  241. goto err;
  242. #endif
  244. if (LF_ISSET(DB_INIT_LOG | DB_INIT_TXN))
  245. if ((ret = __log_open(dbenv)) != 0)
  246. goto err;
  247. if (LF_ISSET(DB_INIT_LOCK))
  248. if ((ret = __lock_open(dbenv)) != 0)
  249. goto err;
  250. if (LF_ISSET(DB_INIT_TXN)) {
  251. if ((ret = __txn_open(dbenv)) != 0)
  252. goto err;
  254. /*
  255.  * If the application is running with transactions, initialize
  256.  * the function tables.
  257.  */
  258. if ((ret = __bam_init_recover(dbenv, &dbenv->recover_dtab,
  259.     &dbenv->recover_dtab_size)) != 0)
  260. goto err;
  261. if ((ret = __crdel_init_recover(dbenv, &dbenv->recover_dtab,
  262.     &dbenv->recover_dtab_size)) != 0)
  263. goto err;
  264. if ((ret = __db_init_recover(dbenv, &dbenv->recover_dtab,
  265.     &dbenv->recover_dtab_size)) != 0)
  266. goto err;
  267. if ((ret = __dbreg_init_recover(dbenv, &dbenv->recover_dtab,
  268.     &dbenv->recover_dtab_size)) != 0)
  269. goto err;
  270. if ((ret = __fop_init_recover(dbenv, &dbenv->recover_dtab,
  271.     &dbenv->recover_dtab_size)) != 0)
  272. goto err;
  273. if ((ret = __ham_init_recover(dbenv, &dbenv->recover_dtab,
  274.     &dbenv->recover_dtab_size)) != 0)
  275. goto err;
  276. if ((ret = __qam_init_recover(dbenv, &dbenv->recover_dtab,
  277.     &dbenv->recover_dtab_size)) != 0)
  278. goto err;
  279. if ((ret = __txn_init_recover(dbenv, &dbenv->recover_dtab,
  280.     &dbenv->recover_dtab_size)) != 0)
  281. goto err;
  283. /* Perform recovery for any previous run. */
  284. if (LF_ISSET(DB_RECOVER | DB_RECOVER_FATAL) &&
  285.     (ret = __db_apprec(dbenv, NULL,
  286.     LF_ISSET(DB_RECOVER | DB_RECOVER_FATAL))) != 0)
  287. goto err;
  288. }
  290. /* Initialize the replication area just in case. */
  291. if ((ret = __rep_region_init(dbenv)) != 0)
  292. goto err;
  294. /*
  295.  * Initialize the DB list, and its mutex as necessary.  If the env
  296.  * handle isn't free-threaded we don't need a mutex because there
  297.  * will never be more than a single DB handle on the list.  If the
  298.  * mpool wasn't initialized, then we can't ever open a DB handle.
  299.  *
  300.  * We also need to initialize the MT mutex as necessary, so do them
  301.  * both.  If we error, __dbenv_refresh() will clean up.
  302.  *
  303.  * !!!
  304.  * This must come after the __memp_open call above because if we are
  305.  * recording mutexes for system resources, we will do it in the mpool
  306.  * region for environments and db handles.  So, the mpool region must
  307.  * already be initialized.
  308.  */
  309. LIST_INIT(&dbenv->dblist);
  310. if (F_ISSET(dbenv, DB_ENV_THREAD) && LF_ISSET(DB_INIT_MPOOL)) {
  311. dbmp = dbenv->mp_handle;
  312. if ((ret = __db_mutex_setup(
  313.     dbenv, dbmp->reginfo, &dbenv->dblist_mutexp,
  314.     MUTEX_ALLOC | MUTEX_THREAD)) != 0)
  315. goto err;
  316. if ((ret = __db_mutex_setup(
  317.     dbenv, dbmp->reginfo, &dbenv->mt_mutexp,
  318.     MUTEX_ALLOC | MUTEX_THREAD)) != 0)
  319. goto err;
  320. }
  322. /*
  323.  * If we've created the regions, are running with transactions, and did
  324.  * not just run recovery, we need to log the fact that the transaction
  325.  * IDs got reset.
  326.  *
  327.  * If we ran recovery, there may be prepared-but-not-yet-committed
  328.  * transactions that need to be resolved.  Recovery resets the minimum
  329.  * transaction ID and logs the reset if that's appropriate, so we
  330.  * don't need to do anything here in the recover case.
  331.  */
  332. if (TXN_ON(dbenv) &&
  333.     F_ISSET((REGINFO *)dbenv->reginfo, REGION_CREATE) &&
  334.     !LF_ISSET(DB_RECOVER | DB_RECOVER_FATAL) &&
  335.     (ret = __txn_reset(dbenv)) != 0)
  336. goto err;
  338. return (0);
  340. err: /* If we fail after creating the regions, remove them. */
  341. if (dbenv->reginfo != NULL &&
  342.     F_ISSET((REGINFO *)dbenv->reginfo, REGION_CREATE)) {
  343. ret = __db_panic(dbenv, ret);
  345. (void)__dbenv_refresh(dbenv, orig_flags);
  346. (void)__dbenv_iremove(dbenv, db_home, DB_FORCE);
  347. }
  348. (void)__dbenv_refresh(dbenv, orig_flags);
  350. return (ret);
  351. }
  353. /*
  354.  * __dbenv_remove --
  355.  * Discard an environment.
  356.  *
  357.  * PUBLIC: int __dbenv_remove __P((DB_ENV *, const char *, u_int32_t));
  358.  */
  359. int
  360. __dbenv_remove(dbenv, db_home, flags)
  361. DB_ENV *dbenv;
  362. const char *db_home;
  363. u_int32_t flags;
  364. {
  365. int ret, t_ret;
  367. ret = __dbenv_iremove(dbenv, db_home, flags);
  369. if ((t_ret = dbenv->close(dbenv, 0)) != 0 && ret == 0)
  370. ret = t_ret;
  372. return (ret);
  373. }
  375. /*
  376.  * __dbenv_iremove --
  377.  * Discard an environment, internal version.
  378.  */
  379. static int
  380. __dbenv_iremove(dbenv, db_home, flags)
  381. DB_ENV *dbenv;
  382. const char *db_home;
  383. u_int32_t flags;
  384. {
  385. int ret;
  387. #undef OKFLAGS
  388. #define OKFLAGS
  389. DB_FORCE | DB_USE_ENVIRON | DB_USE_ENVIRON_ROOT
  391. /* Validate arguments. */
  392. if ((ret = __db_fchk(dbenv, "DB_ENV->remove", flags, OKFLAGS)) != 0)
  393. return (ret);
  395. ENV_ILLEGAL_AFTER_OPEN(dbenv, "DB_ENV->remove");
  397. /* Initialize the DB_ENV structure. */
  398. if ((ret = __dbenv_config(dbenv, db_home, flags)) != 0)
  399. return (ret);
  401. /* Remove the environment. */
  402. return (__db_e_remove(dbenv, flags));
  403. }
  405. /*
  406.  * __dbenv_config --
  407.  * Initialize the DB_ENV structure.
  408.  */
  409. static int
  410. __dbenv_config(dbenv, db_home, flags)
  411. DB_ENV *dbenv;
  412. const char *db_home;
  413. u_int32_t flags;
  414. {
  415. FILE *fp;
  416. int ret;
  417. char *p, buf[256];
  419. /*
  420.  * Set the database home.  Do this before calling __db_appname,
  421.  * it uses the home directory.
  422.  */
  423. if ((ret = __db_home(dbenv, db_home, flags)) != 0)
  424. return (ret);
  426. /* Parse the config file. */
  427. if ((ret =
  428.     __db_appname(dbenv, DB_APP_NONE, "DB_CONFIG", 0, NULL, &p)) != 0)
  429. return (ret);
  431. fp = fopen(p, "r");
  432. __os_free(dbenv, p);
  434. if (fp != NULL) {
  435. while (fgets(buf, sizeof(buf), fp) != NULL) {
  436. if ((p = strchr(buf, 'n')) != NULL)
  437. *p = '';
  438. else if (strlen(buf) + 1 == sizeof(buf)) {
  439. __db_err(dbenv, "DB_CONFIG: line too long");
  440. (void)fclose(fp);
  441. return (EINVAL);
  442. }
  443. if (buf[0] == '' ||
  444.     buf[0] == '#' || isspace((int)buf[0]))
  445. continue;
  447. if ((ret = __db_parse(dbenv, buf)) != 0) {
  448. (void)fclose(fp);
  449. return (ret);
  450. }
  451. }
  452. (void)fclose(fp);
  453. }
  455. /*
  456.  * If no temporary directory path was specified in the config file,
  457.  * choose one.
  458.  */
  459. if (dbenv->db_tmp_dir == NULL && (ret = __os_tmpdir(dbenv, flags)) != 0)
  460. return (ret);
  462. /*
  463.  * The locking file descriptor is rarely on.  Set the fd to -1, not
  464.  * because it's ever tested, but to make sure we catch mistakes.
  465.  */
  466. if ((ret = __os_calloc(
  467.     dbenv, 1, sizeof(*dbenv->lockfhp), &dbenv->lockfhp)) != 0)
  468. return (ret);
  469. dbenv->lockfhp->fd = -1;
  471. /* Flag that the DB_ENV structure has been initialized. */
  472. F_SET(dbenv, DB_ENV_OPEN_CALLED);
  474. return (0);
  475. }
  477. /*
  478.  * __dbenv_close --
  479.  * DB_ENV destructor.
  480.  *
  481.  * PUBLIC: int __dbenv_close __P((DB_ENV *, u_int32_t));
  482.  */
  483. int
  484. __dbenv_close(dbenv, flags)
  485. DB_ENV *dbenv;
  486. u_int32_t flags;
  487. {
  488. char **p;
  489. int ret, t_ret;
  491. COMPQUIET(flags, 0);
  493. PANIC_CHECK(dbenv);
  494. ret = 0;
  496. /*
  497.  * Before checking the reference count, we have to see if we
  498.  * were in the middle of restoring transactions and need to
  499.  * close the open files.
  500.  */
  501. if (TXN_ON(dbenv) && (t_ret = __txn_preclose(dbenv)) != 0 && ret == 0)
  502. ret = t_ret;
  504. if (dbenv->rep_handle != NULL &&
  505.     (t_ret = __rep_preclose(dbenv, 1)) != 0 && ret == 0)
  506. ret = t_ret;
  508. if (dbenv->db_ref != 0) {
  509. __db_err(dbenv,
  510.     "Database handles open during environment close");
  511. if (ret == 0)
  512. ret = EINVAL;
  513. }
  515. /*
  516.  * Detach from the regions and undo the allocations done by
  517.  * DB_ENV->open.
  518.  */
  519. if ((t_ret = __dbenv_refresh(dbenv, 0)) != 0 && ret == 0)
  520. ret = t_ret;
  522. /* Do per-subsystem destruction. */
  523. __lock_dbenv_close(dbenv); /* void */
  524. if ((t_ret = __rep_dbenv_close(dbenv)) != 0 && ret == 0)
  525. ret = t_ret;
  527. #ifdef HAVE_CRYPTO
  528. if ((t_ret = __crypto_dbenv_close(dbenv)) != 0 && ret == 0)
  529. ret = t_ret;
  530. #endif
  532. /* Release any string-based configuration parameters we've copied. */
  533. if (dbenv->db_log_dir != NULL)
  534. __os_free(dbenv, dbenv->db_log_dir);
  535. if (dbenv->db_tmp_dir != NULL)
  536. __os_free(dbenv, dbenv->db_tmp_dir);
  537. if (dbenv->db_data_dir != NULL) {
  538. for (p = dbenv->db_data_dir; *p != NULL; ++p)
  539. __os_free(dbenv, *p);
  540. __os_free(dbenv, dbenv->db_data_dir);
  541. }
  543. /* Discard the structure. */
  544. memset(dbenv, CLEAR_BYTE, sizeof(DB_ENV));
  545. __os_free(NULL, dbenv);
  547. return (ret);
  548. }
  550. /*
  551.  * __dbenv_refresh --
  552.  * Refresh the DB_ENV structure, releasing resources allocated by
  553.  * DB_ENV->open, and returning it to the state it was in just before
  554.  * open was called.  (Note that this means that any state set by
  555.  * pre-open configuration functions must be preserved.)
  556.  */
  557. static int
  558. __dbenv_refresh(dbenv, orig_flags)
  559. DB_ENV *dbenv;
  560. u_int32_t orig_flags;
  561. {
  562. DB_MPOOL *dbmp;
  563. int ret, t_ret;
  565. ret = 0;
  567. /*
  568.  * Close subsystems, in the reverse order they were opened (txn
  569.  * must be first, it may want to discard locks and flush the log).
  570.  *
  571.  * !!!
  572.  * Note that these functions, like all of __dbenv_refresh, only undo
  573.  * the effects of __dbenv_open.  Functions that undo work done by
  574.  * db_env_create or by a configurator function should go in
  575.  * __dbenv_close.
  576.  */
  577. if (TXN_ON(dbenv) &&
  578.     (t_ret = __txn_dbenv_refresh(dbenv)) != 0 && ret == 0)
  579. ret = t_ret;
  581. if (LOGGING_ON(dbenv) &&
  582.     (t_ret = __log_dbenv_refresh(dbenv)) != 0 && ret == 0)
  583. ret = t_ret;
  585. /*
  586.  * Locking should come after logging, because closing log results
  587.  * in files closing which may require locks being released.
  588.  */
  589. if (LOCKING_ON(dbenv) &&
  590.     (t_ret = __lock_dbenv_refresh(dbenv)) != 0 && ret == 0)
  591. ret = t_ret;
  593. /*
  594.  * Discard DB list and its mutex.
  595.  * Discard the MT mutex.
  596.  *
  597.  * !!!
  598.  * This must be done before we close the mpool region because we
  599.  * may have allocated the DB handle mutex in the mpool region.
  600.  * It must be done *after* we close the log region, though, because
  601.  * we close databases and try to acquire the mutex when we close
  602.  * log file handles.  Ick.
  603.  */
  604. LIST_INIT(&dbenv->dblist);
  605. if (dbenv->dblist_mutexp != NULL) {
  606. dbmp = dbenv->mp_handle;
  607. __db_mutex_free(dbenv, dbmp->reginfo, dbenv->dblist_mutexp);
  608. }
  609. if (dbenv->mt_mutexp != NULL) {
  610. dbmp = dbenv->mp_handle;
  611. __db_mutex_free(dbenv, dbmp->reginfo, dbenv->mt_mutexp);
  612. }
  613. if (dbenv->mt != NULL) {
  614. __os_free(dbenv, dbenv->mt);
  615. dbenv->mt = NULL;
  616. }
  618. if (MPOOL_ON(dbenv)) {
  619. /*
  620.  * If it's a private environment, flush the contents to disk.
  621.  * Recovery would have put everything back together, but it's
  622.  * faster and cleaner to flush instead.
  623.  */
  624. if (F_ISSET(dbenv, DB_ENV_PRIVATE) &&
  625.     (t_ret = dbenv->memp_sync(dbenv, NULL)) != 0 && ret == 0)
  626. ret = t_ret;
  627. if ((t_ret = __memp_dbenv_refresh(dbenv)) != 0 && ret == 0)
  628. ret = t_ret;
  629. }
  631. /* Detach from the region. */
  632. if (dbenv->reginfo != NULL) {
  633. if ((t_ret = __db_e_detach(dbenv, 0)) != 0 && ret == 0)
  634. ret = t_ret;
  635. /*
  636.  * !!!
  637.  * Don't free dbenv->reginfo or set the reference to NULL,
  638.  * that was done by __db_e_detach().
  639.  */
  640. }
  642. /* Undo changes and allocations done by __dbenv_open. */
  643. if (dbenv->db_home != NULL) {
  644. __os_free(dbenv, dbenv->db_home);
  645. dbenv->db_home = NULL;
  646. }
  648. dbenv->db_mode = 0;
  650. if (dbenv->lockfhp != NULL) {
  651. __os_free(dbenv, dbenv->lockfhp);
  652. dbenv->lockfhp = NULL;
  653. }
  655. if (dbenv->recover_dtab != NULL) {
  656. __os_free(dbenv, dbenv->recover_dtab);
  657. dbenv->recover_dtab = NULL;
  658. dbenv->recover_dtab_size = 0;
  659. }
  661. dbenv->flags = orig_flags;
  663. return (ret);
  664. }
  666. #define DB_ADDSTR(add) {
  667. if ((add) != NULL) {
  668. /* If leading slash, start over. */
  669. if (__os_abspath(add)) {
  670. p = str;
  671. slash = 0;
  672. }
  673. /* Append to the current string. */
  674. len = strlen(add);
  675. if (slash)
  676. *p++ = PATH_SEPARATOR[0];
  677. memcpy(p, add, len);
  678. p += len;
  679. slash = strchr(PATH_SEPARATOR, p[-1]) == NULL;
  680. }
  681. }
  683. /*
  684.  * __db_appname --
  685.  * Given an optional DB environment, directory and file name and type
  686.  * of call, build a path based on the DB_ENV->open rules, and return
  687.  * it in allocated space.
  688.  *
  689.  * PUBLIC: int __db_appname __P((DB_ENV *, APPNAME,
  690.  * PUBLIC:    const char *, u_int32_t, DB_FH *, char **));
  691.  */
  692. int
  693. __db_appname(dbenv, appname, file, tmp_oflags, fhp, namep)
  694. DB_ENV *dbenv;
  695. APPNAME appname;
  696. const char *file;
  697. u_int32_t tmp_oflags;
  698. DB_FH *fhp;
  699. char **namep;
  700. {
  701. size_t len, str_len;
  702. int data_entry, ret, slash, tmp_create;
  703. const char *a, *b;
  704. char *p, *str;
  706. a = b = NULL;
  707. data_entry = -1;
  708. tmp_create = 0;
  710. /*
  711.  * We don't return a name when creating temporary files, just a file
  712.  * handle.  Default to an error now.
  713.  */
  714. if (fhp != NULL)
  715. F_CLR(fhp, DB_FH_VALID);
  716. if (namep != NULL)
  717. *namep = NULL;
  719. /*
  720.  * Absolute path names are never modified.  If the file is an absolute
  721.  * path, we're done.
  722.  */
  723. if (file != NULL && __os_abspath(file))
  724. return (__os_strdup(dbenv, file, namep));
  726. /* Everything else is relative to the environment home. */
  727. if (dbenv != NULL)
  728. a = dbenv->db_home;
  730. retry: /*
  731.  * DB_APP_NONE:
  732.  *      DB_HOME/file
  733.  * DB_APP_DATA:
  734.  *      DB_HOME/DB_DATA_DIR/file
  735.  * DB_APP_LOG:
  736.  *      DB_HOME/DB_LOG_DIR/file
  737.  * DB_APP_TMP:
  738.  *      DB_HOME/DB_TMP_DIR/<create>
  739.  */
  740. switch (appname) {
  741. case DB_APP_NONE:
  742. break;
  743. case DB_APP_DATA:
  744. if (dbenv != NULL && dbenv->db_data_dir != NULL &&
  745.     (b = dbenv->db_data_dir[++data_entry]) == NULL) {
  746. data_entry = -1;
  747. b = dbenv->db_data_dir[0];
  748. }
  749. break;
  750. case DB_APP_LOG:
  751. if (dbenv != NULL)
  752. b = dbenv->db_log_dir;
  753. break;
  754. case DB_APP_TMP:
  755. if (dbenv != NULL)
  756. b = dbenv->db_tmp_dir;
  757. tmp_create = 1;
  758. break;
  759. }
  761. len =
  762.     (a == NULL ? 0 : strlen(a) + 1) +
  763.     (b == NULL ? 0 : strlen(b) + 1) +
  764.     (file == NULL ? 0 : strlen(file) + 1);
  766. /*
  767.  * Allocate space to hold the current path information, as well as any
  768.  * temporary space that we're going to need to create a temporary file
  769.  * name.
  770.  */
  771. #define DB_TRAIL "BDBXXXXXX"
  772. str_len = len + sizeof(DB_TRAIL) + 10;
  773. if ((ret = __os_malloc(dbenv, str_len, &str)) != 0)
  774. return (ret);
  776. slash = 0;
  777. p = str;
  778. DB_ADDSTR(a);
  779. DB_ADDSTR(b);
  780. DB_ADDSTR(file);
  781. *p = '';
  783. /*
  784.  * If we're opening a data file, see if it exists.  If it does,
  785.  * return it, otherwise, try and find another one to open.
  786.  */
  787. if (__os_exists(str, NULL) != 0 && data_entry != -1) {
  788. __os_free(dbenv, str);
  789. b = NULL;
  790. goto retry;
  791. }
  793. /* Create the file if so requested. */
  794. if (tmp_create &&
  795.     (ret = __db_tmp_open(dbenv, tmp_oflags, str, fhp)) != 0) {
  796. __os_free(dbenv, str);
  797. return (ret);
  798. }
  800. if (namep == NULL)
  801. __os_free(dbenv, str);
  802. else
  803. *namep = str;
  804. return (0);
  805. }
  807. /*
  808.  * __db_home --
  809.  * Find the database home.
  810.  *
  811.  * PUBLIC: int __db_home __P((DB_ENV *, const char *, u_int32_t));
  812.  */
  813. int
  814. __db_home(dbenv, db_home, flags)
  815. DB_ENV *dbenv;
  816. const char *db_home;
  817. u_int32_t flags;
  818. {
  819. const char *p;
  821. /*
  822.  * Use db_home by default, this allows utilities to reasonably
  823.  * override the environment either explicitly or by using a -h
  824.  * option.  Otherwise, use the environment if it's permitted
  825.  * and initialized.
  826.  */
  827. if ((p = db_home) == NULL &&
  828.     (LF_ISSET(DB_USE_ENVIRON) ||
  829.     (LF_ISSET(DB_USE_ENVIRON_ROOT) && __os_isroot())) &&
  830.     (p = getenv("DB_HOME")) != NULL && p[0] == '') {
  831. __db_err(dbenv, "illegal DB_HOME environment variable");
  832. return (EINVAL);
  833. }
  835. return (p == NULL ? 0 : __os_strdup(dbenv, p, &dbenv->db_home));
  836. }
  838. #define __DB_OVFL(v, max)
  839. if (v > max) {
  840. __v = v;
  841. __max = max;
  842. goto toobig;
  843. }
  845. /*
  846.  * __db_parse --
  847.  * Parse a single NAME VALUE pair.
  848.  */
  849. static int
  850. __db_parse(dbenv, s)
  851. DB_ENV *dbenv;
  852. char *s;
  853. {
  854. u_long __max, __v, v1, v2, v3;
  855. u_int32_t flags;
  856. char *name, *p, *value, v4;
  858. /*
  859.  * !!!
  860.  * The value of 40 is hard-coded into format arguments to sscanf
  861.  * below, it can't be changed here without changing it there, too.
  862.  */
  863. char arg[40];
  865. /*
  866.  * Name/value pairs are parsed as two white-space separated strings.
  867.  * Leading and trailing white-space is trimmed from the value, but
  868.  * it may contain embedded white-space.  Note: we use the isspace(3)
  869.  * macro because it's more portable, but that means that you can use
  870.  * characters like form-feed to separate the strings.
  871.  */
  872. name = s;
  873. for (p = name; *p != '' && !isspace((int)*p); ++p)
  874. ;
  875. if (*p == '' || p == name)
  876. goto illegal;
  877. *p = '';
  878. for (++p; isspace((int)*p); ++p)
  879. ;
  880. if (*p == '')
  881. goto illegal;
  882. value = p;
  883. for (++p; *p != ''; ++p)
  884. ;
  885. for (--p; isspace((int)*p); --p)
  886. ;
  887. ++p;
  888. if (p == value) {
  889. illegal: __db_err(dbenv, "mis-formatted name-value pair: %s", s);
  890. return (EINVAL);
  891. }
  892. *p = '';
  894. if (!strcasecmp(name, "set_cachesize")) {
  895. if (sscanf(value, "%lu %lu %lu %c", &v1, &v2, &v3, &v4) != 3)
  896. goto badarg;
  897. __DB_OVFL(v1, UINT32_T_MAX);
  898. __DB_OVFL(v2, UINT32_T_MAX);
  899. __DB_OVFL(v3, 10000);
  900. return (dbenv->set_cachesize(
  901.     dbenv, (u_int32_t)v1, (u_int32_t)v2, (int)v3));
  902. }
  904. if (!strcasecmp(name, "set_data_dir") ||
  905.     !strcasecmp(name, "db_data_dir")) /* Compatibility. */
  906. return (dbenv->set_data_dir(dbenv, value));
  908. if (!strcasecmp(name, "set_flags")) {
  909. if (sscanf(value, "%40s %c", arg, &v4) != 1)
  910. goto badarg;
  912. if (!strcasecmp(value, "db_cdb_alldb"))
  913. return (dbenv->set_flags(dbenv, DB_CDB_ALLDB, 1));
  914. if (!strcasecmp(value, "db_direct_db"))
  915. return (dbenv->set_flags(dbenv, DB_DIRECT_DB, 1));
  916. if (!strcasecmp(value, "db_direct_log"))
  917. return (dbenv->set_flags(dbenv, DB_DIRECT_LOG, 1));
  918. if (!strcasecmp(value, "db_nolocking"))
  919. return (dbenv->set_flags(dbenv, DB_NOLOCKING, 1));
  920. if (!strcasecmp(value, "db_nommap"))
  921. return (dbenv->set_flags(dbenv, DB_NOMMAP, 1));
  922. if (!strcasecmp(value, "db_overwrite"))
  923. return (dbenv->set_flags(dbenv, DB_OVERWRITE, 1));
  924. if (!strcasecmp(value, "db_nopanic"))
  925. return (dbenv->set_flags(dbenv, DB_NOPANIC, 1));
  926. if (!strcasecmp(value, "db_region_init"))
  927. return (dbenv->set_flags(dbenv, DB_REGION_INIT, 1));
  928. if (!strcasecmp(value, "db_txn_nosync"))
  929. return (dbenv->set_flags(dbenv, DB_TXN_NOSYNC, 1));
  930. if (!strcasecmp(value, "db_txn_write_nosync"))
  931. return (
  932.     dbenv->set_flags(dbenv, DB_TXN_WRITE_NOSYNC, 1));
  933. if (!strcasecmp(value, "db_yieldcpu"))
  934. return (dbenv->set_flags(dbenv, DB_YIELDCPU, 1));
  935. goto badarg;
  936. }
  938. if (!strcasecmp(name, "set_lg_bsize")) {
  939. if (sscanf(value, "%lu %c", &v1, &v4) != 1)
  940. goto badarg;
  941. __DB_OVFL(v1, UINT32_T_MAX);
  942. return (dbenv->set_lg_bsize(dbenv, (u_int32_t)v1));
  943. }
  945. if (!strcasecmp(name, "set_lg_max")) {
  946. if (sscanf(value, "%lu %c", &v1, &v4) != 1)
  947. goto badarg;
  948. __DB_OVFL(v1, UINT32_T_MAX);
  949. return (dbenv->set_lg_max(dbenv, (u_int32_t)v1));
  950. }
  952. if (!strcasecmp(name, "set_lg_regionmax")) {
  953. if (sscanf(value, "%lu %c", &v1, &v4) != 1)
  954. goto badarg;
  955. __DB_OVFL(v1, UINT32_T_MAX);
  956. return (dbenv->set_lg_regionmax(dbenv, (u_int32_t)v1));
  957. }
  959. if (!strcasecmp(name, "set_lg_dir") ||
  960.     !strcasecmp(name, "db_log_dir")) /* Compatibility. */
  961. return (dbenv->set_lg_dir(dbenv, value));
  963. if (!strcasecmp(name, "set_lk_detect")) {
  964. if (sscanf(value, "%40s %c", arg, &v4) != 1)
  965. goto badarg;
  966. if (!strcasecmp(value, "db_lock_default"))
  967. flags = DB_LOCK_DEFAULT;
  968. else if (!strcasecmp(value, "db_lock_expire"))
  969. flags = DB_LOCK_EXPIRE;
  970. else if (!strcasecmp(value, "db_lock_maxlocks"))
  971. flags = DB_LOCK_MAXLOCKS;
  972. else if (!strcasecmp(value, "db_lock_minlocks"))
  973. flags = DB_LOCK_MINLOCKS;
  974. else if (!strcasecmp(value, "db_lock_minwrite"))
  975. flags = DB_LOCK_MINWRITE;
  976. else if (!strcasecmp(value, "db_lock_oldest"))
  977. flags = DB_LOCK_OLDEST;
  978. else if (!strcasecmp(value, "db_lock_random"))
  979. flags = DB_LOCK_RANDOM;
  980. else if (!strcasecmp(value, "db_lock_youngest"))
  981. flags = DB_LOCK_YOUNGEST;
  982. else
  983. goto badarg;
  984. return (dbenv->set_lk_detect(dbenv, flags));
  985. }
  987. if (!strcasecmp(name, "set_lk_max")) {
  988. if (sscanf(value, "%lu %c", &v1, &v4) != 1)
  989. goto badarg;
  990. __DB_OVFL(v1, UINT32_T_MAX);
  991. return (dbenv->set_lk_max(dbenv, (u_int32_t)v1));
  992. }
  994. if (!strcasecmp(name, "set_lk_max_locks")) {
  995. if (sscanf(value, "%lu %c", &v1, &v4) != 1)
  996. goto badarg;
  997. __DB_OVFL(v1, UINT32_T_MAX);
  998. return (dbenv->set_lk_max_locks(dbenv, (u_int32_t)v1));
  999. }
  1001. if (!strcasecmp(name, "set_lk_max_lockers")) {
  1002. if (sscanf(value, "%lu %c", &v1, &v4) != 1)
  1003. goto badarg;
  1004. __DB_OVFL(v1, UINT32_T_MAX);
  1005. return (dbenv->set_lk_max_lockers(dbenv, (u_int32_t)v1));
  1006. }
  1008. if (!strcasecmp(name, "set_lk_max_objects")) {
  1009. if (sscanf(value, "%lu %c", &v1, &v4) != 1)
  1010. goto badarg;
  1011. __DB_OVFL(v1, UINT32_T_MAX);
  1012. return (dbenv->set_lk_max_objects(dbenv, (u_int32_t)v1));
  1013. }
  1015. if (!strcasecmp(name, "set_lock_timeout")) {
  1016. if (sscanf(value, "%lu %c", &v1, &v4) != 1)
  1017. goto badarg;
  1018. __DB_OVFL(v1, UINT32_T_MAX);
  1019. return (dbenv->set_timeout(
  1020.     dbenv, (u_int32_t)v1, DB_SET_LOCK_TIMEOUT));
  1021. }
  1023. if (!strcasecmp(name, "set_mp_mmapsize")) {
  1024. if (sscanf(value, "%lu %c", &v1, &v4) != 1)
  1025. goto badarg;
  1026. __DB_OVFL(v1, UINT32_T_MAX);
  1027. return (dbenv->set_mp_mmapsize(dbenv, (u_int32_t)v1));
  1028. }
  1030. if (!strcasecmp(name, "set_region_init")) {
  1031. if (sscanf(value, "%lu %c", &v1, &v4) != 1 || v1 != 1)
  1032. goto badarg;
  1033. return (dbenv->set_flags(
  1034.     dbenv, DB_REGION_INIT, v1 == 0 ? 0 : 1));
  1035. }
  1037. if (!strcasecmp(name, "set_shm_key")) {
  1038. if (sscanf(value, "%lu %c", &v1, &v4) != 1)
  1039. goto badarg;
  1040. return (dbenv->set_shm_key(dbenv, (long)v1));
  1041. }
  1043. if (!strcasecmp(name, "set_tas_spins")) {
  1044. if (sscanf(value, "%lu %c", &v1, &v4) != 1)
  1045. goto badarg;
  1046. __DB_OVFL(v1, UINT32_T_MAX);
  1047. return (dbenv->set_tas_spins(dbenv, (u_int32_t)v1));
  1048. }
  1050. if (!strcasecmp(name, "set_tmp_dir") ||
  1051.     !strcasecmp(name, "db_tmp_dir")) /* Compatibility.*/
  1052. return (dbenv->set_tmp_dir(dbenv, value));
  1054. if (!strcasecmp(name, "set_tx_max")) {
  1055. if (sscanf(value, "%lu %c", &v1, &v4) != 1)
  1056. goto badarg;
  1057. __DB_OVFL(v1, UINT32_T_MAX);
  1058. return (dbenv->set_tx_max(dbenv, (u_int32_t)v1));
  1059. }
  1061. if (!strcasecmp(name, "set_txn_timeout")) {
  1062. if (sscanf(value, "%lu %c", &v1, &v4) != 1)
  1063. goto badarg;
  1064. __DB_OVFL(v1, UINT32_T_MAX);
  1065. return (dbenv->set_timeout(
  1066.     dbenv, (u_int32_t)v1, DB_SET_TXN_TIMEOUT));
  1067. }
  1069. if (!strcasecmp(name, "set_verbose")) {
  1070. if (sscanf(value, "%40s %c", arg, &v4) != 1)
  1071. goto badarg;
  1073. if (!strcasecmp(value, "db_verb_chkpoint"))
  1074. flags = DB_VERB_CHKPOINT;
  1075. else if (!strcasecmp(value, "db_verb_deadlock"))
  1076. flags = DB_VERB_DEADLOCK;
  1077. else if (!strcasecmp(value, "db_verb_recovery"))
  1078. flags = DB_VERB_RECOVERY;
  1079. else if (!strcasecmp(value, "db_verb_waitsfor"))
  1080. flags = DB_VERB_WAITSFOR;
  1081. else
  1082. goto badarg;
  1083. return (dbenv->set_verbose(dbenv, flags, 1));
  1084. }
  1086. __db_err(dbenv, "unrecognized name-value pair: %s", s);
  1087. return (EINVAL);
  1089. badarg: __db_err(dbenv, "incorrect arguments for name-value pair: %s", s);
  1090. return (EINVAL);
  1092. toobig: __db_err(dbenv,
  1093.     "%s: %lu larger than maximum value %lu", s, __v, __max);
  1094. return (EINVAL);
  1095. }
  1097. /*
  1098.  * __db_tmp_open --
  1099.  * Create a temporary file.
  1100.  */
  1101. static int
  1102. __db_tmp_open(dbenv, tmp_oflags, path, fhp)
  1103. DB_ENV *dbenv;
  1104. u_int32_t tmp_oflags;
  1105. char *path;
  1106. DB_FH *fhp;
  1107. {
  1108. u_int32_t id;
  1109. int mode, isdir, ret;
  1110. const char *p;
  1111. char *trv;
  1113. /*
  1114.  * Check the target directory; if you have six X's and it doesn't
  1115.  * exist, this runs for a *very* long time.
  1116.  */
  1117. if ((ret = __os_exists(path, &isdir)) != 0) {
  1118. __db_err(dbenv, "%s: %s", path, db_strerror(ret));
  1119. return (ret);
  1120. }
  1121. if (!isdir) {
  1122. __db_err(dbenv, "%s: %s", path, db_strerror(EINVAL));
  1123. return (EINVAL);
  1124. }
  1126. /* Build the path. */
  1127. for (trv = path; *trv != ''; ++trv)
  1128. ;
  1129. *trv = PATH_SEPARATOR[0];
  1130. for (p = DB_TRAIL; (*++trv = *p) != ''; ++p)
  1131. ;
  1133. /* Replace the X's with the process ID. */
  1134. for (__os_id(&id); *--trv == 'X'; id /= 10)
  1135. switch (id % 10) {
  1136. case 0: *trv = '0'; break;
  1137. case 1: *trv = '1'; break;
  1138. case 2: *trv = '2'; break;
  1139. case 3: *trv = '3'; break;
  1140. case 4: *trv = '4'; break;
  1141. case 5: *trv = '5'; break;
  1142. case 6: *trv = '6'; break;
  1143. case 7: *trv = '7'; break;
  1144. case 8: *trv = '8'; break;
  1145. case 9: *trv = '9'; break;
  1146. }
  1147. ++trv;
  1149. /* Set up open flags and mode. */
  1150. mode = __db_omode("rw----");
  1152. /* Loop, trying to open a file. */
  1153. for (;;) {
  1154. if ((ret = __os_open(dbenv, path,
  1155.     tmp_oflags | DB_OSO_CREATE | DB_OSO_EXCL | DB_OSO_TEMP,
  1156.     mode, fhp)) == 0)
  1157. return (0);
  1159. /*
  1160.  * !!!:
  1161.  * If we don't get an EEXIST error, then there's something
  1162.  * seriously wrong.  Unfortunately, if the implementation
  1163.  * doesn't return EEXIST for O_CREAT and O_EXCL regardless
  1164.  * of other possible errors, we've lost.
  1165.  */
  1166. if (ret != EEXIST) {
  1167. __db_err(dbenv,
  1168.     "tmp_open: %s: %s", path, db_strerror(ret));
  1169. return (ret);
  1170. }
  1172. /*
  1173.  * Tricky little algorithm for backward compatibility.
  1174.  * Assumes sequential ordering of lower-case characters.
  1175.  */
  1176. for (;;) {
  1177. if (*trv == '')
  1178. return (EINVAL);
  1179. if (*trv == 'z')
  1180. *trv++ = 'a';
  1181. else {
  1182. if (isdigit((int)*trv))
  1183. *trv = 'a';
  1184. else
  1185. ++*trv;
  1186. break;
  1187. }
  1188. }
  1189. }
  1190. /* NOTREACHED */
  1191. }