/*- * See the file LICENSE for redistribution information. * * Copyright (c) 1996-2005 * Sleepycat Software. All rights reserved. * * $Id: env_open.c,v 12.36 2005/10/31 02:22:28 bostic Exp $ */ #include "db_config.h" #ifndef NO_SYSTEM_INCLUDES #include #include #include #include #include #endif #include "db_int.h" #include "dbinc/crypto.h" #include "dbinc/db_page.h" #include "dbinc/db_shash.h" #include "dbinc/btree.h" #include "dbinc/hash.h" #include "dbinc/fop.h" #include "dbinc/lock.h" #include "dbinc/log.h" #include "dbinc/mp.h" #include "dbinc/qam.h" #include "dbinc/txn.h" static int __db_parse __P((DB_ENV *, char *)); static int __db_tmp_open __P((DB_ENV *, u_int32_t, char *, DB_FH **)); static int __env_config __P((DB_ENV *, const char *, u_int32_t)); static int __env_refresh __P((DB_ENV *, u_int32_t, int)); static int __env_remove_int __P((DB_ENV *, const char *, u_int32_t)); /* * db_version -- * Return version information. * * EXTERN: char *db_version __P((int *, int *, int *)); */ char * db_version(majverp, minverp, patchp) int *majverp, *minverp, *patchp; { if (majverp != NULL) *majverp = DB_VERSION_MAJOR; if (minverp != NULL) *minverp = DB_VERSION_MINOR; if (patchp != NULL) *patchp = DB_VERSION_PATCH; return ((char *)DB_VERSION_STRING); } /* * __env_open_pp -- * DB_ENV->open pre/post processing. * * PUBLIC: int __env_open_pp __P((DB_ENV *, const char *, u_int32_t, int)); */ int __env_open_pp(dbenv, db_home, flags, mode) DB_ENV *dbenv; const char *db_home; u_int32_t flags; int mode; { DB_THREAD_INFO *ip; u_int32_t orig_flags; int need_recovery, ret, t_ret; need_recovery = 0; #undef OKFLAGS #define OKFLAGS \ (DB_CREATE | DB_INIT_CDB | DB_INIT_LOCK | DB_INIT_LOG | \ DB_INIT_MPOOL | DB_INIT_REP | DB_INIT_TXN | DB_LOCKDOWN | \ DB_PRIVATE | DB_RECOVER | DB_RECOVER_FATAL | DB_REGISTER | \ DB_SYSTEM_MEM | DB_THREAD | DB_USE_ENVIRON | DB_USE_ENVIRON_ROOT) #undef OKFLAGS_CDB #define OKFLAGS_CDB \ (DB_CREATE | DB_INIT_CDB | DB_INIT_MPOOL | DB_LOCKDOWN | \ DB_PRIVATE | DB_SYSTEM_MEM | DB_THREAD | \ DB_USE_ENVIRON | DB_USE_ENVIRON_ROOT) if ((ret = __db_fchk(dbenv, "DB_ENV->open", flags, OKFLAGS)) != 0) return (ret); if ((ret = __db_fcchk( dbenv, "DB_ENV->open", flags, DB_INIT_CDB, ~OKFLAGS_CDB)) != 0) return (ret); if ((ret = __db_fcchk(dbenv, "DB_ENV->open", flags, DB_PRIVATE, DB_REGISTER | DB_SYSTEM_MEM)) != 0) return (ret); if (LF_ISSET(DB_INIT_REP)) { if (!LF_ISSET(DB_INIT_LOCK)) { __db_err(dbenv, "replication requires locking support"); return (EINVAL); } if (!LF_ISSET(DB_INIT_TXN)) { __db_err( dbenv, "replication requires transaction support"); return (EINVAL); } } if (LF_ISSET(DB_RECOVER | DB_RECOVER_FATAL)) { if ((ret = __db_fcchk(dbenv, "DB_ENV->open", flags, DB_RECOVER, DB_RECOVER_FATAL)) != 0) return (ret); if (!LF_ISSET(DB_CREATE)) { __db_err(dbenv, "recovery requires the create flag"); return (EINVAL); } if (!LF_ISSET(DB_INIT_TXN)) { __db_err( dbenv, "recovery requires transaction support"); return (EINVAL); } } /* * Currently we support one kind of mutex that is intra-process only, * POSIX 1003.1 pthreads, because a variety of systems don't support * the full pthreads API, and our only alternative is test-and-set. */ #ifdef HAVE_MUTEX_THREAD_ONLY if (!LF_ISSET(DB_PRIVATE)) { __db_err(dbenv, "Berkeley DB library configured to support only private environments"); return (EINVAL); } #endif #if defined(HAVE_MUTEX_FCNTL) /* * !!! * We need a file descriptor for fcntl(2) locking. We use the file * handle from the REGENV file for this purpose. * * Since we may be using shared memory regions, e.g., shmget(2), and * not a mapped-in regular file, the backing file may be only a few * bytes in length. So, this depends on the ability to call fcntl to * lock file offsets much larger than the actual physical file. I * think that's safe -- besides, very few systems actually need this * kind of support, SunOS is the only one still in wide use of which * I'm aware. * * The error case is if an application lacks spinlocks and wants to be * threaded. That doesn't work because fcntl will lock the underlying * process, including all its threads. */ if (F_ISSET(dbenv, DB_ENV_THREAD)) { __db_err(dbenv, "architecture lacks fast mutexes: applications cannot be threaded"); return (EINVAL); } #endif if (LF_ISSET(DB_INIT_REP) && !__os_support_replication()) { __db_err(dbenv, "Berkeley DB library does not support replication on this system"); return (EINVAL); } /* * If we're going to register with the environment, that's the first * thing we do. */ if (LF_ISSET(DB_REGISTER)) { if (!__os_support_db_register()) { __db_err(dbenv, "Berkeley DB library does not support DB_REGISTER on this system"); return (EINVAL); } if ((ret = __envreg_register(dbenv, db_home, &need_recovery)) != 0) return (ret); if (need_recovery) { if (!LF_ISSET(DB_RECOVER)) { __db_err(dbenv, "No recovery flag was specified, and recovery is needed"); ret = DB_RUNRECOVERY; goto err; } } else LF_CLR(DB_RECOVER | DB_RECOVER_FATAL); } /* * If we're doing recovery, destroy the environment so that we create * all the regions from scratch. The major concern I have is if the * application stomps the environment with a rogue pointer. We have * no way of detecting that, and we could be forced into a situation * where we start up and then crash, repeatedly. * * Note that we do not check any flags like DB_PRIVATE before calling * remove. We don't care if the current environment was private or * not, we just want to nail any files that are left-over for whatever * reason, from whatever session. */ if (LF_ISSET(DB_RECOVER | DB_RECOVER_FATAL)) { orig_flags = dbenv->flags; if ((ret = __env_remove_int(dbenv, db_home, DB_FORCE)) != 0 || (ret = __env_refresh(dbenv, orig_flags, 0)) != 0) goto err; } ret = __env_open(dbenv, db_home, flags, mode); if (ret == 0 && dbenv->thr_hashtab != NULL && (t_ret = __env_set_state(dbenv, &ip, THREAD_OUT)) != 0) ret = t_ret; err: if (need_recovery) { /* * If recovery succeeded, release our exclusive lock, other * processes can now proceed. * * If recovery failed, unregister now. */ if (ret == 0 && (t_ret = __envreg_xunlock(dbenv)) != 0) ret = t_ret; if (ret != 0) (void)__envreg_unregister(dbenv, 1); } return (ret); } /* * __env_open -- * DB_ENV->open. * * PUBLIC: int __env_open __P((DB_ENV *, const char *, u_int32_t, int)); */ int __env_open(dbenv, db_home, flags, mode) DB_ENV *dbenv; const char *db_home; u_int32_t flags; int mode; { DB_THREAD_INFO *ip; REGINFO *infop; u_int32_t init_flags, orig_flags; int rep_check, ret; orig_flags = dbenv->flags; rep_check = 0; ip = NULL; /* Initialize the DB_ENV structure. */ if ((ret = __env_config(dbenv, db_home, flags)) != 0) goto err; /* Convert the DB_ENV->open flags to internal flags. */ if (LF_ISSET(DB_CREATE)) F_SET(dbenv, DB_ENV_CREATE); if (LF_ISSET(DB_LOCKDOWN)) F_SET(dbenv, DB_ENV_LOCKDOWN); if (LF_ISSET(DB_PRIVATE)) F_SET(dbenv, DB_ENV_PRIVATE); if (LF_ISSET(DB_RECOVER_FATAL)) F_SET(dbenv, DB_ENV_FATAL); if (LF_ISSET(DB_SYSTEM_MEM)) F_SET(dbenv, DB_ENV_SYSTEM_MEM); if (LF_ISSET(DB_THREAD)) F_SET(dbenv, DB_ENV_THREAD); /* Default permissions are read-write for both owner and group. */ dbenv->db_mode = mode == 0 ? __db_omode("rw-rw----") : mode; /* * Flags saved in the init_flags field of the environment, representing * flags to DB_ENV->set_flags and DB_ENV->open that need to be set. */ #define DB_INITENV_CDB 0x0001 /* DB_INIT_CDB */ #define DB_INITENV_CDB_ALLDB 0x0002 /* DB_INIT_CDB_ALLDB */ #define DB_INITENV_LOCK 0x0004 /* DB_INIT_LOCK */ #define DB_INITENV_LOG 0x0008 /* DB_INIT_LOG */ #define DB_INITENV_MPOOL 0x0010 /* DB_INIT_MPOOL */ #define DB_INITENV_REP 0x0020 /* DB_INIT_REP */ #define DB_INITENV_TXN 0x0040 /* DB_INIT_TXN */ /* * Create/join the environment. We pass in the flags of interest to * a thread subsequently joining an environment we create. If we're * not the ones to create the environment, our flags will be updated * to match the existing environment. */ init_flags = 0; if (LF_ISSET(DB_INIT_CDB)) FLD_SET(init_flags, DB_INITENV_CDB); if (LF_ISSET(DB_INIT_LOCK)) FLD_SET(init_flags, DB_INITENV_LOCK); if (LF_ISSET(DB_INIT_LOG)) FLD_SET(init_flags, DB_INITENV_LOG); if (LF_ISSET(DB_INIT_MPOOL)) FLD_SET(init_flags, DB_INITENV_MPOOL); if (LF_ISSET(DB_INIT_REP)) FLD_SET(init_flags, DB_INITENV_REP); if (LF_ISSET(DB_INIT_TXN)) FLD_SET(init_flags, DB_INITENV_TXN); if (F_ISSET(dbenv, DB_ENV_CDB_ALLDB)) FLD_SET(init_flags, DB_INITENV_CDB_ALLDB); if ((ret = __db_e_attach(dbenv, &init_flags)) != 0) goto err; /* * __db_e_attach will return the saved init_flags field, which contains * the DB_INIT_* flags used when the environment was created. * * We may be joining an environment -- reset our flags to match the * ones in the environment. */ if (FLD_ISSET(init_flags, DB_INITENV_CDB)) LF_SET(DB_INIT_CDB); if (FLD_ISSET(init_flags, DB_INITENV_LOCK)) LF_SET(DB_INIT_LOCK); if (FLD_ISSET(init_flags, DB_INITENV_LOG)) LF_SET(DB_INIT_LOG); if (FLD_ISSET(init_flags, DB_INITENV_MPOOL)) LF_SET(DB_INIT_MPOOL); if (FLD_ISSET(init_flags, DB_INITENV_REP)) LF_SET(DB_INIT_REP); if (FLD_ISSET(init_flags, DB_INITENV_TXN)) LF_SET(DB_INIT_TXN); if (FLD_ISSET(init_flags, DB_INITENV_CDB_ALLDB) && (ret = __env_set_flags(dbenv, DB_CDB_ALLDB, 1)) != 0) goto err; /* * Save the flags matching the database environment: we've replaced * the argument flags with the flags corresponding to the existing, * underlying set of subsystems. */ dbenv->open_flags = flags; /* Initialize for CDB product. */ if (LF_ISSET(DB_INIT_CDB)) { LF_SET(DB_INIT_LOCK); F_SET(dbenv, DB_ENV_CDB); } /* * The DB_ENV structure has been initialized. This has to be set * before we start calling into the subsystems, some of them look * for it. */ F_SET(dbenv, DB_ENV_OPEN_CALLED); /* * Initialize the subsystems. * * Initialize the mutex regions first. There's no ordering requirement, * but it's simpler to get this in place so we don't have to keep track * of mutexes for later allocation, once the mutex region is created we * can go ahead and do the allocation for real. */ if ((ret = __mutex_open(dbenv)) != 0) goto err; /* __mutex_open creates the thread info region, enter it now. */ ENV_ENTER(dbenv, ip); /* * Initialize the replication area next, so that we can lock out this * call if we're currently running recovery for replication. */ if (LF_ISSET(DB_INIT_REP) && (ret = __rep_open(dbenv)) != 0) goto err; rep_check = IS_ENV_REPLICATED(dbenv) ? 1 : 0; if (rep_check && (ret = __env_rep_enter(dbenv, 0)) != 0) goto err; if (LF_ISSET(DB_INIT_MPOOL)) if ((ret = __memp_open(dbenv)) != 0) goto err; /* * Initialize the ciphering area prior to any running of recovery so * that we can initialize the keys, etc. before recovery. * * !!! * This must be after the mpool init, but before the log initialization * because log_open may attempt to run log_recover during its open. */ if (LF_ISSET(DB_INIT_MPOOL | DB_INIT_LOG | DB_INIT_TXN) && (ret = __crypto_region_init(dbenv)) != 0) goto err; /* * Transactions imply logging but do not imply locking. While almost * all applications want both locking and logging, it would not be * unreasonable for a single threaded process to want transactions for * atomicity guarantees, but not necessarily need concurrency. */ if (LF_ISSET(DB_INIT_LOG | DB_INIT_TXN)) if ((ret = __log_open(dbenv)) != 0) goto err; if (LF_ISSET(DB_INIT_LOCK)) if ((ret = __lock_open(dbenv)) != 0) goto err; if (LF_ISSET(DB_INIT_TXN)) { if ((ret = __txn_open(dbenv)) != 0) goto err; /* * If the application is running with transactions, initialize * the function tables. */ if ((ret = __bam_init_recover(dbenv, &dbenv->recover_dtab, &dbenv->recover_dtab_size)) != 0) goto err; if ((ret = __crdel_init_recover(dbenv, &dbenv->recover_dtab, &dbenv->recover_dtab_size)) != 0) goto err; if ((ret = __db_init_recover(dbenv, &dbenv->recover_dtab, &dbenv->recover_dtab_size)) != 0) goto err; if ((ret = __dbreg_init_recover(dbenv, &dbenv->recover_dtab, &dbenv->recover_dtab_size)) != 0) goto err; if ((ret = __fop_init_recover(dbenv, &dbenv->recover_dtab, &dbenv->recover_dtab_size)) != 0) goto err; if ((ret = __ham_init_recover(dbenv, &dbenv->recover_dtab, &dbenv->recover_dtab_size)) != 0) goto err; if ((ret = __qam_init_recover(dbenv, &dbenv->recover_dtab, &dbenv->recover_dtab_size)) != 0) goto err; if ((ret = __txn_init_recover(dbenv, &dbenv->recover_dtab, &dbenv->recover_dtab_size)) != 0) goto err; } /* * Initialize the DB list, and its mutex as necessary. If the env * handle isn't free-threaded we don't need a mutex because there * will never be more than a single DB handle on the list. If the * mpool wasn't initialized, then we can't ever open a DB handle. * * We also need to initialize the MT mutex as necessary, so do them * both. * * !!! * This must come after the __memp_open call above because if we are * recording mutexes for system resources, we will do it in the mpool * region for environments and db handles. So, the mpool region must * already be initialized. */ LIST_INIT(&dbenv->dblist); if (LF_ISSET(DB_INIT_MPOOL)) { if ((ret = __mutex_alloc(dbenv, MTX_ENV_DBLIST, DB_MUTEX_THREAD, &dbenv->mtx_dblist)) != 0) goto err; if ((ret = __mutex_alloc(dbenv, MTX_TWISTER, DB_MUTEX_THREAD, &dbenv->mtx_mt)) != 0) goto err; /* Register DB's pgin/pgout functions. */ if ((ret = __memp_register( dbenv, DB_FTYPE_SET, __db_pgin, __db_pgout)) != 0) goto err; } /* Perform recovery for any previous run. */ if (LF_ISSET(DB_RECOVER | DB_RECOVER_FATAL) && (ret = __db_apprec(dbenv, NULL, NULL, 1, LF_ISSET(DB_RECOVER | DB_RECOVER_FATAL))) != 0) goto err; /* * If we've created the regions, are running with transactions, and did * not just run recovery, we need to log the fact that the transaction * IDs got reset. * * If we ran recovery, there may be prepared-but-not-yet-committed * transactions that need to be resolved. Recovery resets the minimum * transaction ID and logs the reset if that's appropriate, so we * don't need to do anything here in the recover case. */ infop = dbenv->reginfo; if (TXN_ON(dbenv) && !F_ISSET(dbenv, DB_ENV_LOG_INMEMORY) && F_ISSET(infop, REGION_CREATE) && !LF_ISSET(DB_RECOVER | DB_RECOVER_FATAL) && (ret = __txn_reset(dbenv)) != 0) goto err; /* The database environment is ready for business. */ if ((ret = __db_e_golive(dbenv)) != 0) goto err; if (rep_check && (ret = __env_db_rep_exit(dbenv)) != 0) goto err; ENV_LEAVE(dbenv, ip); return (0); err: /* * If we fail after creating the regions, panic and remove them. * * !!! * No need to call __env_db_rep_exit, that work is done by the calls to * __env_refresh. */ infop = dbenv->reginfo; if (infop != NULL && F_ISSET(infop, REGION_CREATE)) { ret = __db_panic(dbenv, ret); /* Refresh the DB_ENV so we can use it to call remove. */ (void)__env_refresh(dbenv, orig_flags, rep_check); (void)__env_remove_int(dbenv, db_home, DB_FORCE); (void)__env_refresh(dbenv, orig_flags, 0); } else (void)__env_refresh(dbenv, orig_flags, rep_check); if (ip != NULL) ENV_LEAVE(dbenv, ip); return (ret); } /* * __env_remove -- * DB_ENV->remove. * * PUBLIC: int __env_remove __P((DB_ENV *, const char *, u_int32_t)); */ int __env_remove(dbenv, db_home, flags) DB_ENV *dbenv; const char *db_home; u_int32_t flags; { int ret, t_ret; #undef OKFLAGS #define OKFLAGS \ (DB_FORCE | DB_USE_ENVIRON | DB_USE_ENVIRON_ROOT) /* Validate arguments. */ if ((ret = __db_fchk(dbenv, "DB_ENV->remove", flags, OKFLAGS)) != 0) return (ret); ENV_ILLEGAL_AFTER_OPEN(dbenv, "DB_ENV->remove"); ret = __env_remove_int(dbenv, db_home, flags); if ((t_ret = __env_close(dbenv, 0)) != 0 && ret == 0) ret = t_ret; return (ret); } /* * __env_remove_int -- * Discard an environment, internal version. */ static int __env_remove_int(dbenv, db_home, flags) DB_ENV *dbenv; const char *db_home; u_int32_t flags; { int ret; /* Initialize the DB_ENV structure. */ if ((ret = __env_config(dbenv, db_home, flags)) != 0) return (ret); /* The DB_ENV structure has been initialized. */ F_SET(dbenv, DB_ENV_OPEN_CALLED); /* Remove the environment. */ return (__db_e_remove(dbenv, flags)); } /* * __env_config -- * Initialization of the DB_ENV structure, read the DB_CONFIG file. */ static int __env_config(dbenv, db_home, flags) DB_ENV *dbenv; const char *db_home; u_int32_t flags; { FILE *fp; int ret; char *p, buf[256]; /* * Set the database home. Do this before calling __db_appname, * it uses the home directory. */ if ((ret = __db_home(dbenv, db_home, flags)) != 0) return (ret); /* Parse the config file. */ p = NULL; if ((ret = __db_appname(dbenv, DB_APP_NONE, "DB_CONFIG", 0, NULL, &p)) != 0) return (ret); if (p == NULL) fp = NULL; else { fp = fopen(p, "r"); __os_free(dbenv, p); } if (fp != NULL) { while (fgets(buf, sizeof(buf), fp) != NULL) { if ((p = strchr(buf, '\n')) != NULL) *p = '\0'; else if (strlen(buf) + 1 == sizeof(buf)) { __db_err(dbenv, "DB_CONFIG: line too long"); (void)fclose(fp); return (EINVAL); } if (buf[0] == '\0' || buf[0] == '#' || isspace((int)buf[0])) continue; if ((ret = __db_parse(dbenv, buf)) != 0) { (void)fclose(fp); return (ret); } } (void)fclose(fp); } /* * If no temporary directory path was specified in the config file, * choose one. */ if (dbenv->db_tmp_dir == NULL && (ret = __os_tmpdir(dbenv, flags)) != 0) return (ret); return (0); } /* * __env_close_pp -- * DB_ENV->close pre/post processor. * * PUBLIC: int __env_close_pp __P((DB_ENV *, u_int32_t)); */ int __env_close_pp(dbenv, flags) DB_ENV *dbenv; u_int32_t flags; { DB_THREAD_INFO *ip; int rep_check, ret, t_ret; ret = 0; PANIC_CHECK(dbenv); ENV_ENTER(dbenv, ip); /* * Validate arguments, but as a DB_ENV handle destructor, we can't * fail. */ if (flags != 0 && (t_ret = __db_ferr(dbenv, "DB_ENV->close", 0)) != 0 && ret == 0) ret = t_ret; rep_check = IS_ENV_REPLICATED(dbenv) ? 1 : 0; if (rep_check && (t_ret = __env_rep_enter(dbenv, 0)) != 0 && ret == 0) ret = t_ret; if ((t_ret = __env_close(dbenv, rep_check)) != 0 && ret == 0) ret = t_ret; /* Don't ENV_LEAVE as we have already detached from the region. */ return (ret); } /* * __env_close -- * DB_ENV->close. * * PUBLIC: int __env_close __P((DB_ENV *, int)); */ int __env_close(dbenv, rep_check) DB_ENV *dbenv; int rep_check; { int ret, t_ret; char **p; ret = 0; /* * Before checking the reference count, we have to see if we were in * the middle of restoring transactions and need to close the open * files. */ if (TXN_ON(dbenv) && (t_ret = __txn_preclose(dbenv)) != 0 && ret == 0) ret = t_ret; if (REP_ON(dbenv) && (t_ret = __rep_preclose(dbenv)) != 0 && ret == 0) ret = t_ret; /* * Detach from the regions and undo the allocations done by * DB_ENV->open. */ if ((t_ret = __env_refresh(dbenv, 0, rep_check)) != 0 && ret == 0) ret = t_ret; /* Do per-subsystem close. */ if ((t_ret = __lock_dbenv_close(dbenv)) != 0 && ret == 0) ret = t_ret; if ((t_ret = __rep_dbenv_close(dbenv)) != 0 && ret == 0) ret = t_ret; #ifdef HAVE_CRYPTO /* * Crypto comes last, because higher level close functions need * cryptography. */ if ((t_ret = __crypto_dbenv_close(dbenv)) != 0 && ret == 0) ret = t_ret; #endif /* Release any string-based configuration parameters we've copied. */ if (dbenv->db_log_dir != NULL) __os_free(dbenv, dbenv->db_log_dir); if (dbenv->db_tmp_dir != NULL) __os_free(dbenv, dbenv->db_tmp_dir); if (dbenv->db_data_dir != NULL) { for (p = dbenv->db_data_dir; *p != NULL; ++p) __os_free(dbenv, *p); __os_free(dbenv, dbenv->db_data_dir); } /* If we're registered, clean up. */ if (dbenv->registry != NULL) { (void)__envreg_unregister(dbenv, 0); dbenv->registry = NULL; } /* Discard the structure. */ memset(dbenv, CLEAR_BYTE, sizeof(DB_ENV)); __os_free(NULL, dbenv); return (ret); } /* * __env_refresh -- * Refresh the DB_ENV structure, releasing resources allocated by * DB_ENV->open, and returning it to the state it was in just before * open was called. (Note that this means that any state set by * pre-open configuration functions must be preserved.) */ static int __env_refresh(dbenv, orig_flags, rep_check) DB_ENV *dbenv; u_int32_t orig_flags; int rep_check; { DB *ldbp; DB_THREAD_INFO *ip; int ret, t_ret; ret = 0; /* * Refresh subsystems, in the reverse order they were opened (txn * must be first, it may want to discard locks and flush the log). * * !!! * Note that these functions, like all of __env_refresh, only undo * the effects of __env_open. Functions that undo work done by * db_env_create or by a configuration function should go in * __env_close. */ if (TXN_ON(dbenv) && (t_ret = __txn_dbenv_refresh(dbenv)) != 0 && ret == 0) ret = t_ret; if (LOGGING_ON(dbenv) && (t_ret = __log_dbenv_refresh(dbenv)) != 0 && ret == 0) ret = t_ret; /* * Locking should come after logging, because closing log results * in files closing which may require locks being released. */ if (LOCKING_ON(dbenv)) { if (!F_ISSET(dbenv, DB_ENV_THREAD) && dbenv->env_lref != NULL && (t_ret = __lock_id_free(dbenv, ((DB_LOCKER *)dbenv->env_lref)->id)) != 0 && ret == 0) ret = t_ret; dbenv->env_lref = NULL; if ((t_ret = __lock_dbenv_refresh(dbenv)) != 0 && ret == 0) ret = t_ret; } /* * Discard DB list and its mutex. * Discard the MT mutex. * * !!! * This must be done before we close the mpool region because we * may have allocated the DB handle mutex in the mpool region. * It must be done *after* we close the log region, though, because * we close databases and try to acquire the mutex when we close * log file handles. Ick. */ if (dbenv->db_ref != 0) { __db_err(dbenv, "Database handles still open at environment close"); for (ldbp = LIST_FIRST(&dbenv->dblist); ldbp != NULL; ldbp = LIST_NEXT(ldbp, dblistlinks)) __db_err(dbenv, "Open database handle: %s%s%s", ldbp->fname == NULL ? "unnamed" : ldbp->fname, ldbp->dname == NULL ? "" : "/", ldbp->dname == NULL ? "" : ldbp->dname); if (ret == 0) ret = EINVAL; } LIST_INIT(&dbenv->dblist); if ((t_ret = __mutex_free(dbenv, &dbenv->mtx_dblist)) != 0 && ret == 0) ret = t_ret; if ((t_ret = __mutex_free(dbenv, &dbenv->mtx_mt)) != 0 && ret == 0) ret = t_ret; if (dbenv->mt != NULL) { __os_free(dbenv, dbenv->mt); dbenv->mt = NULL; } if (MPOOL_ON(dbenv)) { /* * If it's a private environment, flush the contents to disk. * Recovery would have put everything back together, but it's * faster and cleaner to flush instead. */ if (F_ISSET(dbenv, DB_ENV_PRIVATE) && (t_ret = __memp_sync(dbenv, NULL)) != 0 && ret == 0) ret = t_ret; if ((t_ret = __memp_dbenv_refresh(dbenv)) != 0 && ret == 0) ret = t_ret; } /* * If we're included in a shared replication handle count, this * is our last chance to decrement that count. * * !!! * We can't afford to do anything dangerous after we decrement the * handle count, of course, as replication may be proceeding with * client recovery. However, since we're discarding the regions * as soon as we drop the handle count, there's little opportunity * to do harm. */ if (rep_check && (t_ret = __env_db_rep_exit(dbenv)) != 0 && ret == 0) ret = t_ret; /* * Detach from the region. * * Must come after we call __env_db_rep_exit above. */ __rep_dbenv_refresh(dbenv); /* * Mark the thread as out of the env before we get rid * of the handles needed to do so. */ if (dbenv->thr_hashtab != NULL && (t_ret = __env_set_state(dbenv, &ip, THREAD_OUT)) != 0 && ret == 0) ret = t_ret; if (MUTEX_ON(dbenv) && (t_ret = __mutex_dbenv_refresh(dbenv)) != 0 && ret == 0) ret = t_ret; if (dbenv->reginfo != NULL) { if ((t_ret = __db_e_detach(dbenv, 0)) != 0 && ret == 0) ret = t_ret; /* * !!! * Don't free dbenv->reginfo or set the reference to NULL, * that was done by __db_e_detach(). */ } /* Undo changes and allocations done by __env_open. */ if (dbenv->db_home != NULL) { __os_free(dbenv, dbenv->db_home); dbenv->db_home = NULL; } if (dbenv->db_abshome != NULL) { __os_free(dbenv, dbenv->db_abshome); dbenv->db_abshome = NULL; } if (dbenv->mutex_iq != NULL) { __os_free(dbenv, dbenv->mutex_iq); dbenv->mutex_iq = NULL; } dbenv->open_flags = 0; dbenv->db_mode = 0; if (dbenv->recover_dtab != NULL) { __os_free(dbenv, dbenv->recover_dtab); dbenv->recover_dtab = NULL; dbenv->recover_dtab_size = 0; } dbenv->flags = orig_flags; return (ret); } #define DB_ADDSTR(add) { \ /* \ * The string might be NULL or zero-length, and the p[-1] \ * might indirect to before the beginning of our buffer. \ */ \ if ((add) != NULL && (add)[0] != '\0') { \ /* If leading slash, start over. */ \ if (__os_abspath(add)) { \ p = str; \ slash = 0; \ } \ /* Append to the current string. */ \ len = strlen(add); \ if (slash) \ *p++ = PATH_SEPARATOR[0]; \ memcpy(p, add, len); \ p += len; \ slash = strchr(PATH_SEPARATOR, p[-1]) == NULL; \ } \ } /* * __env_get_open_flags * Retrieve the flags passed to DB_ENV->open. * * PUBLIC: int __env_get_open_flags __P((DB_ENV *, u_int32_t *)); */ int __env_get_open_flags(dbenv, flagsp) DB_ENV *dbenv; u_int32_t *flagsp; { ENV_ILLEGAL_BEFORE_OPEN(dbenv, "DB_ENV->get_open_flags"); *flagsp = dbenv->open_flags; return (0); } /* * __db_appname -- * Given an optional DB environment, directory and file name and type * of call, build a path based on the DB_ENV->open rules, and return * it in allocated space. * * PUBLIC: int __db_appname __P((DB_ENV *, APPNAME, * PUBLIC: const char *, u_int32_t, DB_FH **, char **)); */ int __db_appname(dbenv, appname, file, tmp_oflags, fhpp, namep) DB_ENV *dbenv; APPNAME appname; const char *file; u_int32_t tmp_oflags; DB_FH **fhpp; char **namep; { size_t len, str_len; int data_entry, ret, slash, tmp_create; const char *a, *b; char *p, *str; a = b = NULL; data_entry = -1; tmp_create = 0; /* * We don't return a name when creating temporary files, just a file * handle. Default to an error now. */ if (fhpp != NULL) *fhpp = NULL; if (namep != NULL) *namep = NULL; /* * Absolute path names are never modified. If the file is an absolute * path, we're done. */ if (file != NULL && __os_abspath(file)) return (__os_strdup(dbenv, file, namep)); /* Everything else is relative to the environment home. */ if (dbenv != NULL) a = dbenv->db_home; retry: /* * DB_APP_NONE: * DB_HOME/file * DB_APP_DATA: * DB_HOME/DB_DATA_DIR/file * DB_APP_LOG: * DB_HOME/DB_LOG_DIR/file * DB_APP_TMP: * DB_HOME/DB_TMP_DIR/ */ switch (appname) { case DB_APP_NONE: break; case DB_APP_DATA: if (dbenv != NULL && dbenv->db_data_dir != NULL && (b = dbenv->db_data_dir[++data_entry]) == NULL) { data_entry = -1; b = dbenv->db_data_dir[0]; } break; case DB_APP_LOG: if (dbenv != NULL) b = dbenv->db_log_dir; break; case DB_APP_TMP: if (dbenv != NULL) b = dbenv->db_tmp_dir; tmp_create = 1; break; } len = (a == NULL ? 0 : strlen(a) + 1) + (b == NULL ? 0 : strlen(b) + 1) + (file == NULL ? 0 : strlen(file) + 1); /* * Allocate space to hold the current path information, as well as any * temporary space that we're going to need to create a temporary file * name. */ #define DB_TRAIL "BDBXXXXX" str_len = len + sizeof(DB_TRAIL) + 10; if ((ret = __os_malloc(dbenv, str_len, &str)) != 0) return (ret); slash = 0; p = str; DB_ADDSTR(a); DB_ADDSTR(b); DB_ADDSTR(file); *p = '\0'; /* * If we're opening a data file, see if it exists. If it does, * return it, otherwise, try and find another one to open. */ if (__os_exists(str, NULL) != 0 && data_entry != -1) { __os_free(dbenv, str); b = NULL; goto retry; } /* Create the file if so requested. */ if (tmp_create && (ret = __db_tmp_open(dbenv, tmp_oflags, str, fhpp)) != 0) { __os_free(dbenv, str); return (ret); } if (namep == NULL) __os_free(dbenv, str); else *namep = str; return (0); } /* * __db_home -- * Find the database home. * * PUBLIC: int __db_home __P((DB_ENV *, const char *, u_int32_t)); */ int __db_home(dbenv, db_home, flags) DB_ENV *dbenv; const char *db_home; u_int32_t flags; { int ret; const char *p; char path[MAXPATHLEN]; /* * Use db_home by default, this allows utilities to reasonably * override the environment either explicitly or by using a -h * option. Otherwise, use the environment if it's permitted * and initialized. */ if ((p = db_home) == NULL && (LF_ISSET(DB_USE_ENVIRON) || (LF_ISSET(DB_USE_ENVIRON_ROOT) && __os_isroot())) && (p = getenv("DB_HOME")) != NULL && p[0] == '\0') { __db_err(dbenv, "illegal DB_HOME environment variable"); return (EINVAL); } if (p != NULL && (ret = __os_strdup(dbenv, p, &dbenv->db_home)) != 0) return (ret); /* * Get the absolute pathname of the current directory. We use this * to build absolute pathnames when removing log files. * * XXX * Can't trust getcwd(3) to set a valid errno, so don't try to display * one unless we know it's good. It's likely a permissions problem: * use something bland and useless in the default return value, so we * don't send somebody off in the wrong direction. */ __os_set_errno(0); if ((p = getcwd(path, sizeof(path))) == NULL) { if ((ret = __os_get_errno()) == 0) { __db_err(dbenv, "no absolute path for the current directory"); ret = EAGAIN; } else __db_err(dbenv, "no absolute path for the current directory: %s", db_strerror(ret)); return (ret); } if (p != NULL && (ret = __os_strdup(dbenv, p, &dbenv->db_abshome)) != 0) return (ret); return (0); } #define __DB_OVFL(v, max) \ if (v > max) { \ __v = v; \ __max = max; \ goto toobig; \ } /* * __db_parse -- * Parse a single NAME VALUE pair. */ static int __db_parse(dbenv, s) DB_ENV *dbenv; char *s; { u_long __max, __v, v1, v2, v3; u_int32_t flags; char *name, *p, *value, v4; /* * !!! * The constant 40 is hard-coded into format arguments to sscanf * below, it can't be changed here without changing it there, too. * The additional bytes are for a trailing nul byte and because we * are reading user input -- I don't want to risk any off-by-ones. */ char arg[40 + 5]; /* * Name/value pairs are parsed as two white-space separated strings. * Leading and trailing white-space is trimmed from the value, but * it may contain embedded white-space. Note: we use the isspace(3) * macro because it's more portable, but that means that you can use * characters like form-feed to separate the strings. */ name = s; for (p = name; *p != '\0' && !isspace((int)*p); ++p) ; if (*p == '\0' || p == name) goto illegal; *p = '\0'; for (++p; isspace((int)*p); ++p) ; if (*p == '\0') goto illegal; value = p; for (++p; *p != '\0'; ++p) ; for (--p; isspace((int)*p); --p) ; ++p; if (p == value) { illegal: __db_err(dbenv, "mis-formatted name-value pair: %s", s); return (EINVAL); } *p = '\0'; if (strcasecmp(name, "mutex_set_align") == 0) { if (sscanf(value, "%lu %c", &v1, &v4) != 1) goto badarg; __DB_OVFL(v1, UINT32_MAX); return (__mutex_set_align(dbenv, (u_int32_t)v1)); } if (strcasecmp(name, "mutex_set_increment") == 0) { if (sscanf(value, "%lu %c", &v1, &v4) != 1) goto badarg; __DB_OVFL(v1, UINT32_MAX); return (__mutex_set_increment(dbenv, (u_int32_t)v1)); } if (strcasecmp(name, "mutex_set_max") == 0) { if (sscanf(value, "%lu %c", &v1, &v4) != 1) goto badarg; __DB_OVFL(v1, UINT32_MAX); return (__mutex_set_max(dbenv, (u_int32_t)v1)); } if (strcasecmp(name, "mutex_set_tas_spins") == 0) { if (sscanf(value, "%lu %c", &v1, &v4) != 1) goto badarg; __DB_OVFL(v1, UINT32_MAX); return (__mutex_set_tas_spins(dbenv, (u_int32_t)v1)); } if (strcasecmp(name, "rep_set_config") == 0) { if (sscanf(value, "%40s %c", arg, &v4) != 1) goto badarg; if (strcasecmp(value, "rep_bulk") == 0) return (__rep_set_config(dbenv, DB_REP_CONF_BULK, 1)); if (strcasecmp(value, "rep_delayclient") == 0) return (__rep_set_config(dbenv, DB_REP_CONF_DELAYCLIENT, 1)); if (strcasecmp(value, "rep_noautoinit") == 0) return (__rep_set_config(dbenv, DB_REP_CONF_NOAUTOINIT, 1)); if (strcasecmp(value, "rep_nowait") == 0) return (__rep_set_config(dbenv, DB_REP_CONF_NOWAIT, 1)); goto badarg; } if (strcasecmp(name, "set_cachesize") == 0) { if (sscanf(value, "%lu %lu %lu %c", &v1, &v2, &v3, &v4) != 3) goto badarg; __DB_OVFL(v1, UINT32_MAX); __DB_OVFL(v2, UINT32_MAX); __DB_OVFL(v3, 10000); return (__memp_set_cachesize( dbenv, (u_int32_t)v1, (u_int32_t)v2, (int)v3)); } if (strcasecmp(name, "set_data_dir") == 0 || strcasecmp(name, "db_data_dir") == 0) /* Compatibility. */ return (__env_set_data_dir(dbenv, value)); /* Undocumented. */ if (strcasecmp(name, "set_intermediate_dir") == 0) { if (sscanf(value, "%lu %c", &v1, &v4) != 1) goto badarg; #ifdef INT_MAX __DB_OVFL(v1, INT_MAX); #endif return (__env_set_intermediate_dir(dbenv, (int)v1, 0)); } if (strcasecmp(name, "set_flags") == 0) { if (sscanf(value, "%40s %c", arg, &v4) != 1) goto badarg; if (strcasecmp(value, "db_auto_commit") == 0) return (__env_set_flags(dbenv, DB_AUTO_COMMIT, 1)); if (strcasecmp(value, "db_cdb_alldb") == 0) return (__env_set_flags(dbenv, DB_CDB_ALLDB, 1)); if (strcasecmp(value, "db_direct_db") == 0) return (__env_set_flags(dbenv, DB_DIRECT_DB, 1)); if (strcasecmp(value, "db_direct_log") == 0) return (__env_set_flags(dbenv, DB_DIRECT_LOG, 1)); if (strcasecmp(value, "db_dsync_db") == 0) return (__env_set_flags(dbenv, DB_DSYNC_DB, 1)); if (strcasecmp(value, "db_dsync_log") == 0) return (__env_set_flags(dbenv, DB_DSYNC_LOG, 1)); if (strcasecmp(value, "db_log_autoremove") == 0) return (__env_set_flags(dbenv, DB_LOG_AUTOREMOVE, 1)); if (strcasecmp(value, "db_log_inmemory") == 0) return (__env_set_flags(dbenv, DB_LOG_INMEMORY, 1)); if (strcasecmp(value, "db_nolocking") == 0) return (__env_set_flags(dbenv, DB_NOLOCKING, 1)); if (strcasecmp(value, "db_nommap") == 0) return (__env_set_flags(dbenv, DB_NOMMAP, 1)); if (strcasecmp(value, "db_nopanic") == 0) return (__env_set_flags(dbenv, DB_NOPANIC, 1)); if (strcasecmp(value, "db_overwrite") == 0) return (__env_set_flags(dbenv, DB_OVERWRITE, 1)); if (strcasecmp(value, "db_region_init") == 0) return (__env_set_flags(dbenv, DB_REGION_INIT, 1)); if (strcasecmp(value, "db_txn_nosync") == 0) return (__env_set_flags(dbenv, DB_TXN_NOSYNC, 1)); if (strcasecmp(value, "db_txn_write_nosync") == 0) return ( __env_set_flags(dbenv, DB_TXN_WRITE_NOSYNC, 1)); if (strcasecmp(value, "db_yieldcpu") == 0) return (__env_set_flags(dbenv, DB_YIELDCPU, 1)); goto badarg; } if (strcasecmp(name, "set_lg_bsize") == 0) { if (sscanf(value, "%lu %c", &v1, &v4) != 1) goto badarg; __DB_OVFL(v1, UINT32_MAX); return (__log_set_lg_bsize(dbenv, (u_int32_t)v1)); } if (strcasecmp(name, "set_lg_filemode") == 0) { if (sscanf(value, "%lu %c", &v1, &v4) != 1) goto badarg; __DB_OVFL(v1, INT_MAX); return (__log_set_lg_filemode(dbenv, (int)v1)); } if (strcasecmp(name, "set_lg_max") == 0) { if (sscanf(value, "%lu %c", &v1, &v4) != 1) goto badarg; __DB_OVFL(v1, UINT32_MAX); return (__log_set_lg_max(dbenv, (u_int32_t)v1)); } if (strcasecmp(name, "set_lg_regionmax") == 0) { if (sscanf(value, "%lu %c", &v1, &v4) != 1) goto badarg; __DB_OVFL(v1, UINT32_MAX); return (__log_set_lg_regionmax(dbenv, (u_int32_t)v1)); } if (strcasecmp(name, "set_lg_dir") == 0 || strcasecmp(name, "db_log_dir") == 0) /* Compatibility. */ return (__log_set_lg_dir(dbenv, value)); if (strcasecmp(name, "set_lk_detect") == 0) { if (sscanf(value, "%40s %c", arg, &v4) != 1) goto badarg; if (strcasecmp(value, "db_lock_default") == 0) flags = DB_LOCK_DEFAULT; else if (strcasecmp(value, "db_lock_expire") == 0) flags = DB_LOCK_EXPIRE; else if (strcasecmp(value, "db_lock_maxlocks") == 0) flags = DB_LOCK_MAXLOCKS; else if (strcasecmp(value, "db_lock_maxwrite") == 0) flags = DB_LOCK_MAXWRITE; else if (strcasecmp(value, "db_lock_minlocks") == 0) flags = DB_LOCK_MINLOCKS; else if (strcasecmp(value, "db_lock_minwrite") == 0) flags = DB_LOCK_MINWRITE; else if (strcasecmp(value, "db_lock_oldest") == 0) flags = DB_LOCK_OLDEST; else if (strcasecmp(value, "db_lock_random") == 0) flags = DB_LOCK_RANDOM; else if (strcasecmp(value, "db_lock_youngest") == 0) flags = DB_LOCK_YOUNGEST; else goto badarg; return (__lock_set_lk_detect(dbenv, flags)); } if (strcasecmp(name, "set_lk_max") == 0) { if (sscanf(value, "%lu %c", &v1, &v4) != 1) goto badarg; __DB_OVFL(v1, UINT32_MAX); return (__lock_set_lk_max(dbenv, (u_int32_t)v1)); } if (strcasecmp(name, "set_lk_max_locks") == 0) { if (sscanf(value, "%lu %c", &v1, &v4) != 1) goto badarg; __DB_OVFL(v1, UINT32_MAX); return (__lock_set_lk_max_locks(dbenv, (u_int32_t)v1)); } if (strcasecmp(name, "set_lk_max_lockers") == 0) { if (sscanf(value, "%lu %c", &v1, &v4) != 1) goto badarg; __DB_OVFL(v1, UINT32_MAX); return (__lock_set_lk_max_lockers(dbenv, (u_int32_t)v1)); } if (strcasecmp(name, "set_lk_max_objects") == 0) { if (sscanf(value, "%lu %c", &v1, &v4) != 1) goto badarg; __DB_OVFL(v1, UINT32_MAX); return (__lock_set_lk_max_objects(dbenv, (u_int32_t)v1)); } if (strcasecmp(name, "set_lock_timeout") == 0) { if (sscanf(value, "%lu %c", &v1, &v4) != 1) goto badarg; __DB_OVFL(v1, UINT32_MAX); return (__lock_set_env_timeout( dbenv, (u_int32_t)v1, DB_SET_LOCK_TIMEOUT)); } if (strcasecmp(name, "set_mp_max_openfd") == 0) { if (sscanf(value, "%lu %c", &v1, &v4) != 1) goto badarg; __DB_OVFL(v1, INT_MAX); return (__memp_set_mp_max_openfd(dbenv, (int)v1)); } if (strcasecmp(name, "set_mp_max_write") == 0) { if (sscanf(value, "%lu %lu %c", &v1, &v2, &v4) != 2) goto badarg; __DB_OVFL(v1, INT_MAX); __DB_OVFL(v2, INT_MAX); return (__memp_set_mp_max_write(dbenv, (int)v1, (int)v2)); } if (strcasecmp(name, "set_mp_mmapsize") == 0) { if (sscanf(value, "%lu %c", &v1, &v4) != 1) goto badarg; __DB_OVFL(v1, UINT32_MAX); return (__memp_set_mp_mmapsize(dbenv, (u_int32_t)v1)); } if (strcasecmp(name, "set_region_init") == 0) { if (sscanf(value, "%lu %c", &v1, &v4) != 1 || v1 != 1) goto badarg; return (__env_set_flags( dbenv, DB_REGION_INIT, v1 == 0 ? 0 : 1)); } if (strcasecmp(name, "set_shm_key") == 0) { if (sscanf(value, "%lu %c", &v1, &v4) != 1) goto badarg; return (__env_set_shm_key(dbenv, (long)v1)); } /* * The set_tas_spins method has been replaced by mutex_set_tas_spins. * The set_tas_spins name remains for DB_CONFIG compatibility. */ if (strcasecmp(name, "set_tas_spins") == 0) { if (sscanf(value, "%lu %c", &v1, &v4) != 1) goto badarg; __DB_OVFL(v1, UINT32_MAX); return (__mutex_set_tas_spins(dbenv, (u_int32_t)v1)); } if (strcasecmp(name, "set_tmp_dir") == 0 || strcasecmp(name, "db_tmp_dir") == 0) /* Compatibility.*/ return (__env_set_tmp_dir(dbenv, value)); if (strcasecmp(name, "set_tx_max") == 0) { if (sscanf(value, "%lu %c", &v1, &v4) != 1) goto badarg; __DB_OVFL(v1, UINT32_MAX); return (__txn_set_tx_max(dbenv, (u_int32_t)v1)); } if (strcasecmp(name, "set_txn_timeout") == 0) { if (sscanf(value, "%lu %c", &v1, &v4) != 1) goto badarg; __DB_OVFL(v1, UINT32_MAX); return (__lock_set_env_timeout( dbenv, (u_int32_t)v1, DB_SET_TXN_TIMEOUT)); } if (strcasecmp(name, "set_verbose") == 0) { if (sscanf(value, "%40s %c", arg, &v4) != 1) goto badarg; else if (strcasecmp(value, "db_verb_deadlock") == 0) flags = DB_VERB_DEADLOCK; else if (strcasecmp(value, "db_verb_recovery") == 0) flags = DB_VERB_RECOVERY; else if (strcasecmp(value, "db_verb_register") == 0) flags = DB_VERB_REGISTER; else if (strcasecmp(value, "db_verb_replication") == 0) flags = DB_VERB_REPLICATION; else if (strcasecmp(value, "db_verb_waitsfor") == 0) flags = DB_VERB_WAITSFOR; else goto badarg; return (__env_set_verbose(dbenv, flags, 1)); } __db_err(dbenv, "unrecognized name-value pair: %s", s); return (EINVAL); badarg: __db_err(dbenv, "incorrect arguments for name-value pair: %s", s); return (EINVAL); toobig: __db_err(dbenv, "%s: %lu larger than maximum value %lu", s, __v, __max); return (EINVAL); } /* * __db_tmp_open -- * Create a temporary file. */ static int __db_tmp_open(dbenv, tmp_oflags, path, fhpp) DB_ENV *dbenv; u_int32_t tmp_oflags; char *path; DB_FH **fhpp; { pid_t pid; db_threadid_t tid; int filenum, i, isdir, ret; char *firstx, *trv; /* * Check the target directory; if you have six X's and it doesn't * exist, this runs for a *very* long time. */ if ((ret = __os_exists(path, &isdir)) != 0) { __db_err(dbenv, "%s: %s", path, db_strerror(ret)); return (ret); } if (!isdir) { __db_err(dbenv, "%s: %s", path, db_strerror(EINVAL)); return (EINVAL); } /* Build the path. */ (void)strncat(path, PATH_SEPARATOR, 1); (void)strcat(path, DB_TRAIL); /* Replace the X's with the process ID (in decimal). */ __os_id(dbenv, &pid, &tid); for (trv = path + strlen(path); *--trv == 'X'; pid /= 10) *trv = '0' + (u_char)(pid % 10); firstx = trv + 1; /* Loop, trying to open a file. */ for (filenum = 1;; filenum++) { if ((ret = __os_open(dbenv, path, tmp_oflags | DB_OSO_CREATE | DB_OSO_EXCL | DB_OSO_TEMP, __db_omode(OWNER_RW), fhpp)) == 0) return (0); /* * !!!: * If we don't get an EEXIST error, then there's something * seriously wrong. Unfortunately, if the implementation * doesn't return EEXIST for O_CREAT and O_EXCL regardless * of other possible errors, we've lost. */ if (ret != EEXIST) { __db_err(dbenv, "tmp_open: %s: %s", path, db_strerror(ret)); return (ret); } /* * Generate temporary file names in a backwards-compatible way. * If pid == 12345, the result is: * /DB12345 (tried above, the first time through). * /DBa2345 ... /DBz2345 * /DBaa345 ... /DBaz345 * /DBba345, and so on. * * XXX * This algorithm is O(n**2) -- that is, creating 100 temporary * files requires 5,000 opens, creating 1000 files requires * 500,000. If applications open a lot of temporary files, we * could improve performance by switching to timestamp-based * file names. */ for (i = filenum, trv = firstx; i > 0; i = (i - 1) / 26) if (*trv++ == '\0') return (EINVAL); for (i = filenum; i > 0; i = (i - 1) / 26) *--trv = 'a' + ((i - 1) % 26); } /* NOTREACHED */ }