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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
db.c
资源名称：mysql-3.23.35.tar.gz　[点击查看]
上传用户：tsgydb
上传日期：2007-04-14
资源大小：10674k
文件大小：61k
源码类别：

MySQL数据库

开发平台：

Visual C++

db.c：源码内容
  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 1996, 1997, 1998, 1999, 2000
  5.  * Sleepycat Software.  All rights reserved.
  6.  */
  7. /*
  8.  * Copyright (c) 1990, 1993, 1994, 1995, 1996
  9.  * Keith Bostic.  All rights reserved.
  10.  */
  11. /*
  12.  * Copyright (c) 1990, 1993, 1994, 1995
  13.  * The Regents of the University of California.  All rights reserved.
  14.  *
  15.  * Redistribution and use in source and binary forms, with or without
  16.  * modification, are permitted provided that the following conditions
  17.  * are met:
  18.  * 1. Redistributions of source code must retain the above copyright
  19.  *    notice, this list of conditions and the following disclaimer.
  20.  * 2. Redistributions in binary form must reproduce the above copyright
  21.  *    notice, this list of conditions and the following disclaimer in the
  22.  *    documentation and/or other materials provided with the distribution.
  23.  * 3. Neither the name of the University nor the names of its contributors
  24.  *    may be used to endorse or promote products derived from this software
  25.  *    without specific prior written permission.
  26.  *
  27.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  28.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  29.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  30.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  31.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  32.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  33.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  34.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  35.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  36.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  37.  * SUCH DAMAGE.
  38.  */
  40. #include "db_config.h"
  42. #ifndef lint
  43. static const char revid[] = "$Id: db.c,v 11.117 2001/01/11 18:19:50 bostic Exp $";
  44. #endif /* not lint */
  46. #ifndef NO_SYSTEM_INCLUDES
  47. #include <sys/types.h>
  49. #include <stddef.h>
  50. #include <stdlib.h>
  51. #include <string.h>
  52. #endif
  54. #include "db_int.h"
  55. #include "db_page.h"
  56. #include "db_shash.h"
  57. #include "db_swap.h"
  58. #include "btree.h"
  59. #include "db_am.h"
  60. #include "hash.h"
  61. #include "lock.h"
  62. #include "log.h"
  63. #include "mp.h"
  64. #include "qam.h"
  65. #include "common_ext.h"
  67. /* Actions that __db_master_update can take. */
  68. typedef enum { MU_REMOVE, MU_RENAME, MU_OPEN } mu_action;
  70. /* Flag values that __db_file_setup can return. */
  71. #define DB_FILE_SETUP_CREATE 0x01
  72. #define DB_FILE_SETUP_ZERO 0x02
  74. static int __db_file_setup __P((DB *,
  75.        const char *, u_int32_t, int, db_pgno_t, int *));
  76. static int __db_master_update __P((DB *,
  77.        const char *, u_int32_t,
  78.        db_pgno_t *, mu_action, const char *, u_int32_t));
  79. static int __db_refresh __P((DB *));
  80. static int __db_remove_callback __P((DB *, void *));
  81. static int __db_set_pgsize __P((DB *, DB_FH *, char *));
  82. static int __db_subdb_remove __P((DB *, const char *, const char *));
  83. static int __db_subdb_rename __P(( DB *,
  84. const char *, const char *, const char *));
  85. #if     CONFIG_TEST
  86. static void __db_makecopy __P((const char *, const char *));
  87. static int __db_testdocopy __P((DB *, const char *));
  88. static int __qam_testdocopy __P((DB *, const char *));
  89. #endif
  91. /*
  92.  * __db_open --
  93.  * Main library interface to the DB access methods.
  94.  *
  95.  * PUBLIC: int __db_open __P((DB *,
  96.  * PUBLIC:     const char *, const char *, DBTYPE, u_int32_t, int));
  97.  */
  98. int
  99. __db_open(dbp, name, subdb, type, flags, mode)
  100. DB *dbp;
  101. const char *name, *subdb;
  102. DBTYPE type;
  103. u_int32_t flags;
  104. int mode;
  105. {
  106. DB_ENV *dbenv;
  107. DB_LOCK open_lock;
  108. DB *mdbp;
  109. db_pgno_t meta_pgno;
  110. u_int32_t ok_flags;
  111. int ret, t_ret;
  113. dbenv = dbp->dbenv;
  114. mdbp = NULL;
  116. /* Validate arguments. */
  117. #define OKFLAGS
  118.     (DB_CREATE | DB_EXCL | DB_FCNTL_LOCKING |
  119.     DB_NOMMAP | DB_RDONLY | DB_RDWRMASTER | DB_THREAD | DB_TRUNCATE)
  120. if ((ret = __db_fchk(dbenv, "DB->open", flags, OKFLAGS)) != 0)
  121. return (ret);
  122. if (LF_ISSET(DB_EXCL) && !LF_ISSET(DB_CREATE))
  123. return (__db_ferr(dbenv, "DB->open", 1));
  124. if (LF_ISSET(DB_RDONLY) && LF_ISSET(DB_CREATE))
  125. return (__db_ferr(dbenv, "DB->open", 1));
  126. #ifdef HAVE_VXWORKS
  127. if (LF_ISSET(DB_TRUNCATE)) {
  128. __db_err(dbenv, "DB_TRUNCATE unsupported in VxWorks");
  129. return (__db_eopnotsup(dbenv));
  130. }
  131. #endif
  132. switch (type) {
  133. case DB_UNKNOWN:
  134. if (LF_ISSET(DB_CREATE|DB_TRUNCATE)) {
  135. __db_err(dbenv,
  136.     "%s: DB_UNKNOWN type specified with DB_CREATE or DB_TRUNCATE",
  137.     name);
  138. return (EINVAL);
  139. }
  140. ok_flags = 0;
  141. break;
  142. case DB_BTREE:
  143. ok_flags = DB_OK_BTREE;
  144. break;
  145. case DB_HASH:
  146. ok_flags = DB_OK_HASH;
  147. break;
  148. case DB_QUEUE:
  149. ok_flags = DB_OK_QUEUE;
  150. break;
  151. case DB_RECNO:
  152. ok_flags = DB_OK_RECNO;
  153. break;
  154. default:
  155. __db_err(dbenv, "unknown type: %lu", (u_long)type);
  156. return (EINVAL);
  157. }
  158. if (ok_flags)
  159. DB_ILLEGAL_METHOD(dbp, ok_flags);
  161. /* The environment may have been created, but never opened. */
  162. if (!F_ISSET(dbenv, DB_ENV_DBLOCAL | DB_ENV_OPEN_CALLED)) {
  163. __db_err(dbenv, "environment not yet opened");
  164. return (EINVAL);
  165. }
  167. /*
  168.  * Historically, you could pass in an environment that didn't have a
  169.  * mpool, and DB would create a private one behind the scenes.  This
  170.  * no longer works.
  171.  */
  172. if (!F_ISSET(dbenv, DB_ENV_DBLOCAL) && !MPOOL_ON(dbenv)) {
  173. __db_err(dbenv, "environment did not include a memory pool.");
  174. return (EINVAL);
  175. }
  177. /*
  178.  * You can't specify threads during DB->open if subsystems in the
  179.  * environment weren't configured with them.
  180.  */
  181. if (LF_ISSET(DB_THREAD) &&
  182.     !F_ISSET(dbenv, DB_ENV_DBLOCAL | DB_ENV_THREAD)) {
  183. __db_err(dbenv, "environment not created using DB_THREAD");
  184. return (EINVAL);
  185. }
  187. /*
  188.  * If the environment was configured with threads, the DB handle
  189.  * must also be free-threaded, so we force the DB_THREAD flag on.
  190.  * (See SR #2033 for why this is a requirement--recovery needs
  191.  * to be able to grab a dbp using __db_fileid_to_dbp, and it has
  192.  * no way of knowing which dbp goes with which thread, so whichever
  193.  * one it finds has to be usable in any of them.)
  194.  */
  195. if (F_ISSET(dbenv, DB_ENV_THREAD))
  196. LF_SET(DB_THREAD);
  198. /* DB_TRUNCATE is not transaction recoverable. */
  199. if (LF_ISSET(DB_TRUNCATE) && TXN_ON(dbenv)) {
  200. __db_err(dbenv,
  201.     "DB_TRUNCATE illegal in a transaction protected environment");
  202. return (EINVAL);
  203. }
  205. /* Subdatabase checks. */
  206. if (subdb != NULL) {
  207. /* Subdatabases must be created in named files. */
  208. if (name == NULL) {
  209. __db_err(dbenv,
  210.     "multiple databases cannot be created in temporary files");
  211. return (EINVAL);
  212. }
  214. /* QAM can't be done as a subdatabase. */
  215. if (type == DB_QUEUE) {
  216. __db_err(dbenv, "Queue databases must be one-per-file");
  217. return (EINVAL);
  218. }
  219. }
  221. /* Convert any DB->open flags. */
  222. if (LF_ISSET(DB_RDONLY))
  223. F_SET(dbp, DB_AM_RDONLY);
  225. /* Fill in the type. */
  226. dbp->type = type;
  228. /*
  229.  * If we're potentially creating a database, wrap the open inside of
  230.  * a transaction.
  231.  */
  232. if (TXN_ON(dbenv) && LF_ISSET(DB_CREATE))
  233. if ((ret = __db_metabegin(dbp, &open_lock)) != 0)
  234. return (ret);
  236. /*
  237.  * If we're opening a subdatabase, we have to open (and potentially
  238.  * create) the main database, and then get (and potentially store)
  239.  * our base page number in that database.  Then, we can finally open
  240.  * the subdatabase.
  241.  */
  242. if (subdb == NULL)
  243. meta_pgno = PGNO_BASE_MD;
  244. else {
  245. /*
  246.  * Open the master database, optionally creating or updating
  247.  * it, and retrieve the metadata page number.
  248.  */
  249. if ((ret =
  250.     __db_master_open(dbp, name, flags, mode, &mdbp)) != 0)
  251. goto err;
  253. /* Copy the page size and file id from the master. */
  254. dbp->pgsize = mdbp->pgsize;
  255. F_SET(dbp, DB_AM_SUBDB);
  256. memcpy(dbp->fileid, mdbp->fileid, DB_FILE_ID_LEN);
  258. if ((ret = __db_master_update(mdbp,
  259.     subdb, type, &meta_pgno, MU_OPEN, NULL, flags)) != 0)
  260. goto err;
  262. /*
  263.  * Clear the exclusive open and truncation flags, they only
  264.  * apply to the open of the master database.
  265.  */
  266. LF_CLR(DB_EXCL | DB_TRUNCATE);
  267. }
  269. ret = __db_dbopen(dbp, name, flags, mode, meta_pgno);
  271. /*
  272.  * You can open the database that describes the subdatabases in the
  273.  * rest of the file read-only.  The content of each key's data is
  274.  * unspecified and applications should never be adding new records
  275.  * or updating existing records.  However, during recovery, we need
  276.  * to open these databases R/W so we can redo/undo changes in them.
  277.  * Likewise, we need to open master databases read/write during
  278.  * rename and remove so we can be sure they're fully sync'ed, so
  279.  * we provide an override flag for the purpose.
  280.  */
  281. if (subdb == NULL && !IS_RECOVERING(dbenv) && !LF_ISSET(DB_RDONLY) &&
  282.     !LF_ISSET(DB_RDWRMASTER) && F_ISSET(dbp, DB_AM_SUBDB)) {
  283. __db_err(dbenv,
  284.     "files containing multiple databases may only be opened read-only");
  285. ret = EINVAL;
  286. goto err;
  287. }
  289. err: /*
  290.  * End any transaction, committing if we were successful, aborting
  291.  * otherwise.
  292.  */
  293. if (TXN_ON(dbenv) && LF_ISSET(DB_CREATE))
  294. if ((t_ret = __db_metaend(dbp,
  295.     &open_lock, ret == 0, NULL, NULL)) != 0 && ret == 0)
  296. ret = t_ret;
  298. /* If we were successful, don't discard the file on close. */
  299. if (ret == 0)
  300. F_CLR(dbp, DB_AM_DISCARD);
  302. /* If we were unsuccessful, destroy the DB handle. */
  303. if (ret != 0) {
  304. /* In recovery we set log_fileid early. */
  305. if (IS_RECOVERING(dbenv))
  306. dbp->log_fileid = DB_LOGFILEID_INVALID;
  307. __db_refresh(dbp);
  308. }
  310. if (mdbp != NULL) {
  311. /* If we were successful, don't discard the file on close. */
  312. if (ret == 0)
  313. F_CLR(mdbp, DB_AM_DISCARD);
  314. if ((t_ret = mdbp->close(mdbp, 0)) != 0 && ret == 0)
  315. ret = t_ret;
  316. }
  318. return (ret);
  319. }
  321. /*
  322.  * __db_dbopen --
  323.  * Open a database.
  324.  * PUBLIC: int __db_dbopen __P((DB *, const char *, u_int32_t, int, db_pgno_t));
  325.  */
  326. int
  327. __db_dbopen(dbp, name, flags, mode, meta_pgno)
  328. DB *dbp;
  329. const char *name;
  330. u_int32_t flags;
  331. int mode;
  332. db_pgno_t meta_pgno;
  333. {
  334. DB_ENV *dbenv;
  335. int ret, retinfo;
  337. dbenv = dbp->dbenv;
  339. /* Set up the underlying file. */
  340. if ((ret = __db_file_setup(dbp,
  341.     name, flags, mode, meta_pgno, &retinfo)) != 0)
  342. return (ret);
  344. /*
  345.  * If we created the file, set the truncate flag for the mpool.  This
  346.  * isn't for anything we've done, it's protection against stupid user
  347.  * tricks: if the user deleted a file behind Berkeley DB's back, we
  348.  * may still have pages in the mpool that match the file's "unique" ID.
  349.  */
  350. if (retinfo & DB_FILE_SETUP_CREATE)
  351. flags |= DB_TRUNCATE;
  353. /* Set up the underlying environment. */
  354. if ((ret = __db_dbenv_setup(dbp, name, flags)) != 0)
  355. return (ret);
  357. /*
  358.  * Do access method specific initialization.
  359.  *
  360.  * !!!
  361.  * Set the open flag.  (The underlying access method open functions
  362.  * may want to do things like acquire cursors, so the open flag has
  363.  * to be set before calling them.)
  364.  */
  365. F_SET(dbp, DB_OPEN_CALLED);
  367. if (retinfo & DB_FILE_SETUP_ZERO)
  368. return (0);
  370. switch (dbp->type) {
  371. case DB_BTREE:
  372. ret = __bam_open(dbp, name, meta_pgno, flags);
  373. break;
  374. case DB_HASH:
  375. ret = __ham_open(dbp, name, meta_pgno, flags);
  376. break;
  377. case DB_RECNO:
  378. ret = __ram_open(dbp, name, meta_pgno, flags);
  379. break;
  380. case DB_QUEUE:
  381. ret = __qam_open(dbp, name, meta_pgno, mode, flags);
  382. break;
  383. case DB_UNKNOWN:
  384. return (__db_unknown_type(dbp->dbenv,
  385.      "__db_dbopen", dbp->type));
  386. break;
  387. }
  388. return (ret);
  389. }
  391. /*
  392.  * __db_master_open --
  393.  * Open up a handle on a master database.
  394.  *
  395.  * PUBLIC: int __db_master_open __P((DB *,
  396.  * PUBLIC:     const char *, u_int32_t, int, DB **));
  397.  */
  398. int
  399. __db_master_open(subdbp, name, flags, mode, dbpp)
  400. DB *subdbp;
  401. const char *name;
  402. u_int32_t flags;
  403. int mode;
  404. DB **dbpp;
  405. {
  406. DB *dbp;
  407. int ret;
  409. /* Open up a handle on the main database. */
  410. if ((ret = db_create(&dbp, subdbp->dbenv, 0)) != 0)
  411. return (ret);
  413. /*
  414.  * It's always a btree.
  415.  * Run in the transaction we've created.
  416.  * Set the pagesize in case we're creating a new database.
  417.  * Flag that we're creating a database with subdatabases.
  418.  */
  419. dbp->type = DB_BTREE;
  420. dbp->open_txn = subdbp->open_txn;
  421. dbp->pgsize = subdbp->pgsize;
  422. F_SET(dbp, DB_AM_SUBDB);
  424. if ((ret = __db_dbopen(dbp, name, flags, mode, PGNO_BASE_MD)) != 0) {
  425. if (!F_ISSET(dbp, DB_AM_DISCARD))
  426. dbp->close(dbp, 0);
  427. return (ret);
  428. }
  430. *dbpp = dbp;
  431. return (0);
  432. }
  434. /*
  435.  * __db_master_update --
  436.  * Add/Remove a subdatabase from a master database.
  437.  */
  438. static int
  439. __db_master_update(mdbp, subdb, type, meta_pgnop, action, newname, flags)
  440. DB *mdbp;
  441. const char *subdb;
  442. u_int32_t type;
  443. db_pgno_t *meta_pgnop; /* may be NULL on MU_RENAME */
  444. mu_action action;
  445. const char *newname;
  446. u_int32_t flags;
  447. {
  448. DB_ENV *dbenv;
  449. DBC *dbc, *ndbc;
  450. DBT key, data, ndata;
  451. PAGE *p;
  452. db_pgno_t t_pgno;
  453. int modify, ret, t_ret;
  455. dbenv = mdbp->dbenv;
  456. dbc = ndbc = NULL;
  457. p = NULL;
  459. /* Might we modify the master database?  If so, we'll need to lock. */
  460. modify = (action != MU_OPEN || LF_ISSET(DB_CREATE)) ? 1 : 0;
  462. memset(&key, 0, sizeof(key));
  463. memset(&data, 0, sizeof(data));
  465. /*
  466.  * Open up a cursor.  If this is CDB and we're creating the database,
  467.  * make it an update cursor.
  468.  */
  469. if ((ret = mdbp->cursor(mdbp, mdbp->open_txn, &dbc,
  470.     (CDB_LOCKING(dbenv) && modify) ? DB_WRITECURSOR : 0)) != 0)
  471. goto err;
  473. /*
  474.  * Try to point the cursor at the record.
  475.  *
  476.  * If we're removing or potentially creating an entry, lock the page
  477.  * with DB_RMW.
  478.  *
  479.  * !!!
  480.  * We don't include the name's nul termination in the database.
  481.  */
  482. key.data = (char *)subdb;
  483. key.size = strlen(subdb);
  484. /* In the rename case, we do multiple cursor ops, so MALLOC is safer. */
  485. F_SET(&data, DB_DBT_MALLOC);
  486. ret = dbc->c_get(dbc, &key, &data,
  487.     DB_SET | ((STD_LOCKING(dbc) && modify) ? DB_RMW : 0));
  489. /*
  490.  * What we do next--whether or not we found a record for the
  491.  * specified subdatabase--depends on what the specified action is.
  492.  * Handle ret appropriately as the first statement of each case.
  493.  */
  494. switch (action) {
  495. case MU_REMOVE:
  496. /*
  497.  * We should have found something if we're removing it.  Note
  498.  * that in the common case where the DB we're asking to remove
  499.  * doesn't exist, we won't get this far;  __db_subdb_remove
  500.  * will already have returned an error from __db_open.
  501.  */
  502. if (ret != 0)
  503. goto err;
  505. /*
  506.  * Delete the subdatabase entry first;  if this fails,
  507.  * we don't want to touch the actual subdb pages.
  508.  */
  509. if ((ret = dbc->c_del(dbc, 0)) != 0)
  510. goto err;
  512. /*
  513.  * We're handling actual data, not on-page meta-data,
  514.  * so it hasn't been converted to/from opposite
  515.  * endian architectures.  Do it explicitly, now.
  516.  */
  517. memcpy(meta_pgnop, data.data, sizeof(db_pgno_t));
  518. DB_NTOHL(meta_pgnop);
  519. if ((ret = memp_fget(mdbp->mpf, meta_pgnop, 0, &p)) != 0)
  520. goto err;
  522. /* Free and put the page. */
  523. if ((ret = __db_free(dbc, p)) != 0) {
  524. p = NULL;
  525. goto err;
  526. }
  527. p = NULL;
  528. break;
  529. case MU_RENAME:
  530. /* We should have found something if we're renaming it. */
  531. if (ret != 0)
  532. goto err;
  534. /*
  535.  * Before we rename, we need to make sure we're not
  536.  * overwriting another subdatabase, or else this operation
  537.  * won't be undoable.  Open a second cursor and check
  538.  * for the existence of newname;  it shouldn't appear under
  539.  * us since we hold the metadata lock.
  540.  */
  541. if ((ret = mdbp->cursor(mdbp, mdbp->open_txn, &ndbc, 0)) != 0)
  542. goto err;
  543. DB_ASSERT(newname != NULL);
  544. key.data = (void *) newname;
  545. key.size = strlen(newname);
  547. /*
  548.  * We don't actually care what the meta page of the potentially-
  549.  * overwritten DB is;  we just care about existence.
  550.  */
  551. memset(&ndata, 0, sizeof(ndata));
  552. F_SET(&ndata, DB_DBT_USERMEM | DB_DBT_PARTIAL);
  554. if ((ret = ndbc->c_get(ndbc, &key, &ndata, DB_SET)) == 0) {
  555. /* A subdb called newname exists.  Bail. */
  556. ret = EEXIST;
  557. __db_err(dbenv, "rename: database %s exists", newname);
  558. goto err;
  559. } else if (ret != DB_NOTFOUND)
  560. goto err;
  562. /*
  563.  * Now do the put first;  we don't want to lose our
  564.  * sole reference to the subdb.  Use the second cursor
  565.  * so that the first one continues to point to the old record.
  566.  */
  567. if ((ret = ndbc->c_put(ndbc, &key, &data, DB_KEYFIRST)) != 0)
  568. goto err;
  569. if ((ret = dbc->c_del(dbc, 0)) != 0) {
  570. /*
  571.  * If the delete fails, try to delete the record
  572.  * we just put, in case we're not txn-protected.
  573.  */
  574. (void)ndbc->c_del(ndbc, 0);
  575. goto err;
  576. }
  578. break;
  579. case MU_OPEN:
  580. /*
  581.  * Get the subdatabase information.  If it already exists,
  582.  * copy out the page number and we're done.
  583.  */
  584. switch (ret) {
  585. case 0:
  586. memcpy(meta_pgnop, data.data, sizeof(db_pgno_t));
  587. DB_NTOHL(meta_pgnop);
  588. goto done;
  589. case DB_NOTFOUND:
  590. if (LF_ISSET(DB_CREATE))
  591. break;
  592. /*
  593.  * No db_err, it is reasonable to remove a
  594.  * nonexistent db.
  595.  */
  596. ret = ENOENT;
  597. goto err;
  598. default:
  599. goto err;
  600. }
  602. if ((ret = __db_new(dbc,
  603.     type == DB_HASH ? P_HASHMETA : P_BTREEMETA, &p)) != 0)
  604. goto err;
  605. *meta_pgnop = PGNO(p);
  607. /*
  608.  * XXX
  609.  * We're handling actual data, not on-page meta-data, so it
  610.  * hasn't been converted to/from opposite endian architectures.
  611.  * Do it explicitly, now.
  612.  */
  613. t_pgno = PGNO(p);
  614. DB_HTONL(&t_pgno);
  615. memset(&ndata, 0, sizeof(ndata));
  616. ndata.data = &t_pgno;
  617. ndata.size = sizeof(db_pgno_t);
  618. if ((ret = dbc->c_put(dbc, &key, &ndata, DB_KEYLAST)) != 0)
  619. goto err;
  620. break;
  621. }
  623. err:
  624. done: /*
  625.  * If we allocated a page: if we're successful, mark the page dirty
  626.  * and return it to the cache, otherwise, discard/free it.
  627.  */
  628. if (p != NULL) {
  629. if (ret == 0) {
  630. if ((t_ret =
  631.     memp_fput(mdbp->mpf, p, DB_MPOOL_DIRTY)) != 0)
  632. ret = t_ret;
  633. /*
  634.  * Since we cannot close this file until after
  635.  * transaction commit, we need to sync the dirty
  636.  * pages, because we'll read these directly from
  637.  * disk to open.
  638.  */
  639. if ((t_ret = mdbp->sync(mdbp, 0)) != 0 && ret == 0)
  640. ret = t_ret;
  641. } else
  642. (void)__db_free(dbc, p);
  643. }
  645. /* Discard the cursor(s) and data. */
  646. if (data.data != NULL)
  647. __os_free(data.data, data.size);
  648. if (dbc != NULL && (t_ret = dbc->c_close(dbc)) != 0 && ret == 0)
  649. ret = t_ret;
  650. if (ndbc != NULL && (t_ret = ndbc->c_close(ndbc)) != 0 && ret == 0)
  651. ret = t_ret;
  653. return (ret);
  654. }
  656. /*
  657.  * __db_dbenv_setup --
  658.  * Set up the underlying environment during a db_open.
  659.  *
  660.  * PUBLIC: int __db_dbenv_setup __P((DB *, const char *, u_int32_t));
  661.  */
  662. int
  663. __db_dbenv_setup(dbp, name, flags)
  664. DB *dbp;
  665. const char *name;
  666. u_int32_t flags;
  667. {
  668. DB *ldbp;
  669. DB_ENV *dbenv;
  670. DBT pgcookie;
  671. DB_MPOOL_FINFO finfo;
  672. DB_PGINFO pginfo;
  673. int ret;
  674. u_int32_t maxid;
  676. dbenv = dbp->dbenv;
  678. /* If we don't yet have an environment, it's time to create it. */
  679. if (!F_ISSET(dbenv, DB_ENV_OPEN_CALLED)) {
  680. /* Make sure we have at least DB_MINCACHE pages in our cache. */
  681. if (dbenv->mp_gbytes == 0 &&
  682.     dbenv->mp_bytes < dbp->pgsize * DB_MINPAGECACHE &&
  683.     (ret = dbenv->set_cachesize(
  684.     dbenv, 0, dbp->pgsize * DB_MINPAGECACHE, 0)) != 0)
  685. return (ret);
  687. if ((ret = dbenv->open(dbenv, NULL, DB_CREATE |
  688.     DB_INIT_MPOOL | DB_PRIVATE | LF_ISSET(DB_THREAD), 0)) != 0)
  689. return (ret);
  690. }
  692. /* Register DB's pgin/pgout functions. */
  693. if ((ret =
  694.     memp_register(dbenv, DB_FTYPE_SET, __db_pgin, __db_pgout)) != 0)
  695. return (ret);
  697. /*
  698.  * Open a backing file in the memory pool.
  699.  *
  700.  * If we need to pre- or post-process a file's pages on I/O, set the
  701.  * file type.  If it's a hash file, always call the pgin and pgout
  702.  * routines.  This means that hash files can never be mapped into
  703.  * process memory.  If it's a btree file and requires swapping, we
  704.  * need to page the file in and out.  This has to be right -- we can't
  705.  * mmap files that are being paged in and out.
  706.  */
  707. memset(&finfo, 0, sizeof(finfo));
  708. switch (dbp->type) {
  709. case DB_BTREE:
  710. case DB_RECNO:
  711. finfo.ftype =
  712.     F_ISSET(dbp, DB_AM_SWAP) ? DB_FTYPE_SET : DB_FTYPE_NOTSET;
  713. finfo.clear_len = DB_PAGE_DB_LEN;
  714. break;
  715. case DB_HASH:
  716. finfo.ftype = DB_FTYPE_SET;
  717. finfo.clear_len = DB_PAGE_DB_LEN;
  718. break;
  719. case DB_QUEUE:
  720. finfo.ftype =
  721.     F_ISSET(dbp, DB_AM_SWAP) ? DB_FTYPE_SET : DB_FTYPE_NOTSET;
  722. finfo.clear_len = DB_PAGE_QUEUE_LEN;
  723. break;
  724. case DB_UNKNOWN:
  725. /*
  726.  * If we're running in the verifier, our database might
  727.  * be corrupt and we might not know its type--but we may
  728.  * still want to be able to verify and salvage.
  729.  *
  730.  * If we can't identify the type, it's not going to be safe
  731.  * to call __db_pgin--we pretty much have to give up all
  732.  * hope of salvaging cross-endianness.  Proceed anyway;
  733.  * at worst, the database will just appear more corrupt
  734.  * than it actually is, but at best, we may be able
  735.  * to salvage some data even with no metadata page.
  736.  */
  737. if (F_ISSET(dbp, DB_AM_VERIFYING)) {
  738. finfo.ftype = DB_FTYPE_NOTSET;
  739. finfo.clear_len = DB_PAGE_DB_LEN;
  740. break;
  741. }
  742. return (__db_unknown_type(dbp->dbenv,
  743.      "__db_dbenv_setup", dbp->type));
  744. }
  745. finfo.pgcookie = &pgcookie;
  746. finfo.fileid = dbp->fileid;
  747. finfo.lsn_offset = 0;
  749. pginfo.db_pagesize = dbp->pgsize;
  750. pginfo.needswap = F_ISSET(dbp, DB_AM_SWAP);
  751. pgcookie.data = &pginfo;
  752. pgcookie.size = sizeof(DB_PGINFO);
  754. if ((ret = memp_fopen(dbenv, name,
  755.     LF_ISSET(DB_RDONLY | DB_NOMMAP | DB_ODDFILESIZE | DB_TRUNCATE),
  756.     0, dbp->pgsize, &finfo, &dbp->mpf)) != 0)
  757. return (ret);
  759. /*
  760.  * We may need a per-thread mutex.  Allocate it from the environment
  761.  * region, there's supposed to be extra space there for that purpose.
  762.  */
  763. if (LF_ISSET(DB_THREAD)) {
  764. if ((ret = __db_mutex_alloc(
  765.     dbenv, dbenv->reginfo, (MUTEX **)&dbp->mutexp)) != 0)
  766. return (ret);
  767. if ((ret = __db_mutex_init(
  768.     dbenv, dbp->mutexp, 0, MUTEX_THREAD)) != 0) {
  769. __db_mutex_free(dbenv, dbenv->reginfo, dbp->mutexp);
  770. return (ret);
  771. }
  772. }
  774. /* Get a log file id. */
  775. if (LOGGING_ON(dbenv) && !IS_RECOVERING(dbenv) &&
  776. #if !defined(DEBUG_ROP)
  777.     !F_ISSET(dbp, DB_AM_RDONLY) &&
  778. #endif
  779.     (ret = log_register(dbenv, dbp, name)) != 0)
  780. return (ret);
  782. /*
  783.  * Insert ourselves into the DB_ENV's dblist.  We allocate a
  784.  * unique ID to each {fileid, meta page number} pair, and to
  785.  * each temporary file (since they all have a zero fileid).
  786.  * This ID gives us something to use to tell which DB handles
  787.  * go with which databases in all the cursor adjustment
  788.  * routines, where we don't want to do a lot of ugly and
  789.  * expensive memcmps.
  790.  */
  791. MUTEX_THREAD_LOCK(dbenv, dbenv->dblist_mutexp);
  792. for (maxid = 0, ldbp = LIST_FIRST(&dbenv->dblist);
  793.     ldbp != NULL; ldbp = LIST_NEXT(dbp, dblistlinks)) {
  794. if (name != NULL &&
  795.     memcmp(ldbp->fileid, dbp->fileid, DB_FILE_ID_LEN) == 0 &&
  796.     ldbp->meta_pgno == dbp->meta_pgno)
  797. break;
  798. if (ldbp->adj_fileid > maxid)
  799. maxid = ldbp->adj_fileid;
  800. }
  802. /*
  803.  * If ldbp is NULL, we didn't find a match, or we weren't
  804.  * really looking because name is NULL.  Assign the dbp an
  805.  * adj_fileid one higher than the largest we found, and
  806.  * insert it at the head of the master dbp list.
  807.  *
  808.  * If ldbp is not NULL, it is a match for our dbp.  Give dbp
  809.  * the same ID that ldbp has, and add it after ldbp so they're
  810.  * together in the list.
  811.  */
  812. if (ldbp == NULL) {
  813. dbp->adj_fileid = maxid + 1;
  814. LIST_INSERT_HEAD(&dbenv->dblist, dbp, dblistlinks);
  815. } else {
  816. dbp->adj_fileid = ldbp->adj_fileid;
  817. LIST_INSERT_AFTER(ldbp, dbp, dblistlinks);
  818. }
  819. MUTEX_THREAD_UNLOCK(dbenv, dbenv->dblist_mutexp);
  821. return (0);
  822. }
  824. /*
  825.  * __db_file_setup --
  826.  * Setup the file or in-memory data.
  827.  * Read the database metadata and resolve it with our arguments.
  828.  */
  829. static int
  830. __db_file_setup(dbp, name, flags, mode, meta_pgno, retflags)
  831. DB *dbp;
  832. const char *name;
  833. u_int32_t flags;
  834. int mode;
  835. db_pgno_t meta_pgno;
  836. int *retflags;
  837. {
  838. DB *mdb;
  839. DBT namedbt;
  840. DB_ENV *dbenv;
  841. DB_FH *fhp, fh;
  842. DB_LSN lsn;
  843. DB_TXN *txn;
  844. size_t nr;
  845. u_int32_t magic, oflags;
  846. int ret, retry_cnt, t_ret;
  847. char *real_name, mbuf[DBMETASIZE];
  849. #define IS_SUBDB_SETUP (meta_pgno != PGNO_BASE_MD)
  851. dbenv = dbp->dbenv;
  852. dbp->meta_pgno = meta_pgno;
  853. txn = NULL;
  854. *retflags = 0;
  856. /*
  857.  * If we open a file handle and our caller is doing fcntl(2) locking,
  858.  * we can't close it because that would discard the caller's lock.
  859.  * Save it until we close the DB handle.
  860.  */
  861. if (LF_ISSET(DB_FCNTL_LOCKING)) {
  862. if ((ret = __os_malloc(dbenv, sizeof(*fhp), NULL, &fhp)) != 0)
  863. return (ret);
  864. } else
  865. fhp = &fh;
  866. memset(fhp, 0, sizeof(*fhp));
  868. /*
  869.  * If the file is in-memory, set up is simple.  Otherwise, do the
  870.  * hard work of opening and reading the file.
  871.  *
  872.  * If we have a file name, try and read the first page, figure out
  873.  * what type of file it is, and initialize everything we can based
  874.  * on that file's meta-data page.
  875.  *
  876.  * !!!
  877.  * There's a reason we don't push this code down into the buffer cache.
  878.  * The problem is that there's no information external to the file that
  879.  * we can use as a unique ID.  UNIX has dev/inode pairs, but they are
  880.  * not necessarily unique after reboot, if the file was mounted via NFS.
  881.  * Windows has similar problems, as the FAT filesystem doesn't maintain
  882.  * dev/inode numbers across reboot.  So, we must get something from the
  883.  * file we can use to ensure that, even after a reboot, the file we're
  884.  * joining in the cache is the right file for us to join.  The solution
  885.  * we use is to maintain a file ID that's stored in the database, and
  886.  * that's why we have to open and read the file before calling into the
  887.  * buffer cache.
  888.  *
  889.  * The secondary reason is that there's additional information that
  890.  * we want to have before instantiating a file in the buffer cache:
  891.  * the page size, file type (btree/hash), if swapping is required,
  892.  * and flags (DB_RDONLY, DB_CREATE, DB_TRUNCATE).  We could handle
  893.  * needing this information by allowing it to be set for a file in
  894.  * the buffer cache even after the file has been opened, and, of
  895.  * course, supporting the ability to flush a file from the cache as
  896.  * necessary, e.g., if we guessed wrongly about the page size.  Given
  897.  * that we have to read the file anyway to get the file ID, we might
  898.  * as well get the rest, too.
  899.  *
  900.  * Get the real file name.
  901.  */
  902. if (name == NULL) {
  903. F_SET(dbp, DB_AM_INMEM);
  905. if (dbp->type == DB_UNKNOWN) {
  906. __db_err(dbenv,
  907.     "DBTYPE of unknown without existing file");
  908. return (EINVAL);
  909. }
  910. real_name = NULL;
  912. /* Set the page size if we don't have one yet. */
  913. if (dbp->pgsize == 0)
  914. dbp->pgsize = DB_DEF_IOSIZE;
  916. /*
  917.  * If the file is a temporary file and we're doing locking,
  918.  * then we have to create a unique file ID.  We can't use our
  919.  * normal dev/inode pair (or whatever this OS uses in place of
  920.  * dev/inode pairs) because no backing file will be created
  921.  * until the mpool cache is filled forcing the buffers to disk.
  922.  * Grab a random locker ID to use as a file ID.  The created
  923.  * ID must never match a potential real file ID -- we know it
  924.  * won't because real file IDs contain a time stamp after the
  925.  * dev/inode pair, and we're simply storing a 4-byte value.
  926.  *
  927.  * !!!
  928.  * Store the locker in the file id structure -- we can get it
  929.  * from there as necessary, and it saves having two copies.
  930.  */
  931. if (LOCKING_ON(dbenv) &&
  932.     (ret = lock_id(dbenv, (u_int32_t *)dbp->fileid)) != 0)
  933. return (ret);
  935. return (0);
  936. }
  938. /* Get the real backing file name. */
  939. if ((ret = __db_appname(dbenv,
  940.     DB_APP_DATA, NULL, name, 0, NULL, &real_name)) != 0)
  941. return (ret);
  943. /*
  944.  * Open the backing file.  We need to make sure that multiple processes
  945.  * attempting to create the file at the same time are properly ordered
  946.  * so that only one of them creates the "unique" file ID, so we open it
  947.  * O_EXCL and O_CREAT so two simultaneous attempts to create the region
  948.  * will return failure in one of the attempts.  If we're the one that
  949.  * fails, simply retry without the O_CREAT flag, which will require the
  950.  * meta-data page exist.
  951.  */
  953. /* Fill in the default file mode. */
  954. if (mode == 0)
  955. mode = __db_omode("rwrw--");
  957. oflags = 0;
  958. if (LF_ISSET(DB_RDONLY))
  959. oflags |= DB_OSO_RDONLY;
  960. if (LF_ISSET(DB_TRUNCATE))
  961. oflags |= DB_OSO_TRUNC;
  963. retry_cnt = 0;
  964. open_retry:
  965. *retflags = 0;
  966. ret = 0;
  967. if (!IS_SUBDB_SETUP && LF_ISSET(DB_CREATE)) {
  968. if (dbp->open_txn != NULL) {
  969. /*
  970.  * Start a child transaction to wrap this individual
  971.  * create.
  972.  */
  973. if ((ret =
  974.     txn_begin(dbenv, dbp->open_txn, &txn, 0)) != 0)
  975. goto err_msg;
  977. memset(&namedbt, 0, sizeof(namedbt));
  978. namedbt.data = (char *)name;
  979. namedbt.size = strlen(name) + 1;
  980. if ((ret = __crdel_fileopen_log(dbenv, txn,
  981.     &lsn, DB_FLUSH, &namedbt, mode)) != 0)
  982. goto err_msg;
  983. }
  984. DB_TEST_RECOVERY(dbp, DB_TEST_PREOPEN, ret, name);
  985. if ((ret = __os_open(dbenv, real_name,
  986.     oflags | DB_OSO_CREATE | DB_OSO_EXCL, mode, fhp)) == 0) {
  987. DB_TEST_RECOVERY(dbp, DB_TEST_POSTOPEN, ret, name);
  989. /* Commit the file create. */
  990. if (dbp->open_txn != NULL) {
  991. if ((ret = txn_commit(txn, DB_TXN_SYNC)) != 0)
  992. goto err_msg;
  993. txn = NULL;
  994. }
  996. /*
  997.  * We created the file.  This means that if we later
  998.  * fail, we need to delete the file and if we're going
  999.  * to do that, we need to trash any pages in the
  1000.  * memory pool.  Since we only know here that we
  1001.  * created the file, we're going to set the flag here
  1002.  * and clear it later if we commit successfully.
  1003.  */
  1004. F_SET(dbp, DB_AM_DISCARD);
  1005. *retflags |= DB_FILE_SETUP_CREATE;
  1006. } else {
  1007. /*
  1008.  * Abort the file create.  If the abort fails, report
  1009.  * the error returned by txn_abort(), rather than the
  1010.  * open error, for no particular reason.
  1011.  */
  1012. if (dbp->open_txn != NULL) {
  1013. if ((t_ret = txn_abort(txn)) != 0) {
  1014. ret = t_ret;
  1015. goto err_msg;
  1016. }
  1017. txn = NULL;
  1018. }
  1020. /*
  1021.  * If we were not doing an exclusive open, try again
  1022.  * without the create flag.
  1023.  */
  1024. if (ret == EEXIST && !LF_ISSET(DB_EXCL)) {
  1025. LF_CLR(DB_CREATE);
  1026. DB_TEST_RECOVERY(dbp,
  1027.     DB_TEST_POSTOPEN, ret, name);
  1028. goto open_retry;
  1029. }
  1030. }
  1031. } else
  1032. ret = __os_open(dbenv, real_name, oflags, mode, fhp);
  1034. /*
  1035.  * Be quiet if we couldn't open the file because it didn't exist
  1036.  * or we did not have permission,
  1037.  * the customers don't like those messages appearing in the logs.
  1038.  * Otherwise, complain loudly.
  1039.  */
  1040. if (ret != 0) {
  1041. if (ret == EACCES || ret == ENOENT)
  1042. goto err;
  1043. goto err_msg;
  1044. }
  1046. /* Set the page size if we don't have one yet. */
  1047. if (dbp->pgsize == 0) {
  1048. if (IS_SUBDB_SETUP) {
  1049. if ((ret = __db_master_open(dbp,
  1050.     name, flags, mode, &mdb)) != 0)
  1051. goto err;
  1052. dbp->pgsize = mdb->pgsize;
  1053. (void)mdb->close(mdb, 0);
  1054. } else if ((ret = __db_set_pgsize(dbp, fhp, real_name)) != 0)
  1055. goto err;
  1056. }
  1058. /*
  1059.  * Seek to the metadata offset; if it's a master database open or a
  1060.  * database without subdatabases, we're seeking to 0, but that's OK.
  1061.  */
  1062. if ((ret = __os_seek(dbenv, fhp,
  1063.     dbp->pgsize, meta_pgno, 0, 0, DB_OS_SEEK_SET)) != 0)
  1064. goto err_msg;
  1066. /*
  1067.  * Read the metadata page.  We read DBMETASIZE bytes, which is larger
  1068.  * than any access method's metadata page and smaller than any disk
  1069.  * sector.
  1070.  */
  1071. if ((ret = __os_read(dbenv, fhp, mbuf, sizeof(mbuf), &nr)) != 0)
  1072. goto err_msg;
  1074. if (nr == sizeof(mbuf)) {
  1075. /*
  1076.  * Figure out what access method we're dealing with, and then
  1077.  * call access method specific code to check error conditions
  1078.  * based on conflicts between the found file and application
  1079.  * arguments.  A found file overrides some user information --
  1080.  * we don't consider it an error, for example, if the user set
  1081.  * an expected byte order and the found file doesn't match it.
  1082.  */
  1083. F_CLR(dbp, DB_AM_SWAP);
  1084. magic = ((DBMETA *)mbuf)->magic;
  1086. swap_retry: switch (magic) {
  1087. case DB_BTREEMAGIC:
  1088. if ((ret =
  1089.     __bam_metachk(dbp, name, (BTMETA *)mbuf)) != 0)
  1090. goto err;
  1091. break;
  1092. case DB_HASHMAGIC:
  1093. if ((ret =
  1094.     __ham_metachk(dbp, name, (HMETA *)mbuf)) != 0)
  1095. goto err;
  1096. break;
  1097. case DB_QAMMAGIC:
  1098. if ((ret =
  1099.     __qam_metachk(dbp, name, (QMETA *)mbuf)) != 0)
  1100. goto err;
  1101. break;
  1102. case 0:
  1103. /*
  1104.  * There are two ways we can get a 0 magic number.
  1105.  * If we're creating a subdatabase, then the magic
  1106.  * number will be 0.  We allocate a page as part of
  1107.  * finding out what the base page number will be for
  1108.  * the new subdatabase, but it's not initialized in
  1109.  * any way.
  1110.  *
  1111.  * The second case happens if we are in recovery
  1112.  * and we are going to recreate a database, it's
  1113.  * possible that it's page was created (on systems
  1114.  * where pages must be created explicitly to avoid
  1115.  * holes in files) but is still 0.
  1116.  */
  1117. if (IS_SUBDB_SETUP) { /* Case 1 */
  1118. if ((IS_RECOVERING(dbenv)
  1119.     && F_ISSET((DB_LOG *)
  1120.     dbenv->lg_handle, DBLOG_FORCE_OPEN))
  1121.     || ((DBMETA *)mbuf)->pgno != PGNO_INVALID)
  1122. goto empty;
  1124. ret = EINVAL;
  1125. goto err;
  1126. }
  1127. /* Case 2 */
  1128. if (IS_RECOVERING(dbenv)) {
  1129. *retflags |= DB_FILE_SETUP_ZERO;
  1130. goto empty;
  1131. }
  1132. goto bad_format;
  1133. default:
  1134. if (F_ISSET(dbp, DB_AM_SWAP))
  1135. goto bad_format;
  1137. M_32_SWAP(magic);
  1138. F_SET(dbp, DB_AM_SWAP);
  1139. goto swap_retry;
  1140. }
  1141. } else {
  1142. /*
  1143.  * Only newly created files are permitted to fail magic
  1144.  * number tests.
  1145.  */
  1146. if (nr != 0 || (!IS_RECOVERING(dbenv) && IS_SUBDB_SETUP))
  1147. goto bad_format;
  1149. /* Let the caller know that we had a 0-length file. */
  1150. if (!LF_ISSET(DB_CREATE | DB_TRUNCATE))
  1151. *retflags |= DB_FILE_SETUP_ZERO;
  1153. /*
  1154.  * The only way we can reach here with the DB_CREATE flag set
  1155.  * is if we created the file.  If that's not the case, then
  1156.  * either (a) someone else created the file but has not yet
  1157.  * written out the metadata page, or (b) we truncated the file
  1158.  * (DB_TRUNCATE) leaving it zero-length.  In the case of (a),
  1159.  * we want to sleep and give the file creator time to write
  1160.  * the metadata page.  In the case of (b), we want to continue.
  1161.  *
  1162.  * !!!
  1163.  * There's a race in the case of two processes opening the file
  1164.  * with the DB_TRUNCATE flag set at roughly the same time, and
  1165.  * they could theoretically hurt each other.  Sure hope that's
  1166.  * unlikely.
  1167.  */
  1168. if (!LF_ISSET(DB_CREATE | DB_TRUNCATE) &&
  1169.     !IS_RECOVERING(dbenv)) {
  1170. if (retry_cnt++ < 3) {
  1171. __os_sleep(dbenv, 1, 0);
  1172. goto open_retry;
  1173. }
  1174. bad_format: if (!IS_RECOVERING(dbenv))
  1175. __db_err(dbenv,
  1176.     "%s: unexpected file type or format", name);
  1177. ret = EINVAL;
  1178. goto err;
  1179. }
  1181. DB_ASSERT (dbp->type != DB_UNKNOWN);
  1183. empty: /*
  1184.  * The file is empty, and that's OK.  If it's not a subdatabase,
  1185.  * though, we do need to generate a unique file ID for it.  The
  1186.  * unique file ID includes a timestamp so that we can't collide
  1187.  * with any other files, even when the file IDs (dev/inode pair)
  1188.  * are reused.
  1189.  */
  1190. if (!IS_SUBDB_SETUP) {
  1191. if (*retflags & DB_FILE_SETUP_ZERO)
  1192. memset(dbp->fileid, 0, DB_FILE_ID_LEN);
  1193. else if ((ret = __os_fileid(dbenv,
  1194.     real_name, 1, dbp->fileid)) != 0)
  1195. goto err_msg;
  1196. }
  1197. }
  1199. if (0) {
  1200. err_msg: __db_err(dbenv, "%s: %s", name, db_strerror(ret));
  1201. }
  1203. /*
  1204.  * Abort any running transaction -- it can only exist if something
  1205.  * went wrong.
  1206.  */
  1207. err:
  1208. DB_TEST_RECOVERY_LABEL
  1210. /*
  1211.  * If we opened a file handle and our caller is doing fcntl(2) locking,
  1212.  * then we can't close it because that would discard the caller's lock.
  1213.  * Otherwise, close the handle.
  1214.  */
  1215. if (F_ISSET(fhp, DB_FH_VALID)) {
  1216. if (ret == 0 && LF_ISSET(DB_FCNTL_LOCKING))
  1217. dbp->saved_open_fhp = fhp;
  1218. else
  1219. if ((t_ret = __os_closehandle(fhp)) != 0 && ret == 0)
  1220. ret = t_ret;
  1221. }
  1223. /*
  1224.  * This must be done after the file is closed, since
  1225.  * txn_abort() may remove the file, and an open file
  1226.  * cannot be removed on a Windows platforms.
  1227.  */
  1228. if (txn != NULL)
  1229. (void)txn_abort(txn);
  1231. if (real_name != NULL)
  1232. __os_freestr(real_name);
  1234. return (ret);
  1235. }
  1237. /*
  1238.  * __db_set_pgsize --
  1239.  * Set the page size based on file information.
  1240.  */
  1241. static int
  1242. __db_set_pgsize(dbp, fhp, name)
  1243. DB *dbp;
  1244. DB_FH *fhp;
  1245. char *name;
  1246. {
  1247. DB_ENV *dbenv;
  1248. u_int32_t iopsize;
  1249. int ret;
  1251. dbenv = dbp->dbenv;
  1253. /*
  1254.  * Use the filesystem's optimum I/O size as the pagesize if a pagesize
  1255.  * not specified.  Some filesystems have 64K as their optimum I/O size,
  1256.  * but as that results in fairly large default caches, we limit the
  1257.  * default pagesize to 16K.
  1258.  */
  1259. if ((ret = __os_ioinfo(dbenv, name, fhp, NULL, NULL, &iopsize)) != 0) {
  1260. __db_err(dbenv, "%s: %s", name, db_strerror(ret));
  1261. return (ret);
  1262. }
  1263. if (iopsize < 512)
  1264. iopsize = 512;
  1265. if (iopsize > 16 * 1024)
  1266. iopsize = 16 * 1024;
  1268. /*
  1269.  * Sheer paranoia, but we don't want anything that's not a power-of-2
  1270.  * (we rely on that for alignment of various types on the pages), and
  1271.  * we want a multiple of the sector size as well.
  1272.  */
  1273. OS_ROUNDOFF(iopsize, 512);
  1275. dbp->pgsize = iopsize;
  1276. F_SET(dbp, DB_AM_PGDEF);
  1278. return (0);
  1279. }
  1281. /*
  1282.  * __db_close --
  1283.  * DB destructor.
  1284.  *
  1285.  * PUBLIC: int __db_close __P((DB *, u_int32_t));
  1286.  */
  1287. int
  1288. __db_close(dbp, flags)
  1289. DB *dbp;
  1290. u_int32_t flags;
  1291. {
  1292. DB_ENV *dbenv;
  1293. DBC *dbc;
  1294. int ret, t_ret;
  1296. ret = 0;
  1298. dbenv = dbp->dbenv;
  1299. PANIC_CHECK(dbenv);
  1301. /* Validate arguments. */
  1302. if ((ret = __db_closechk(dbp, flags)) != 0)
  1303. goto err;
  1305. /* If never opened, or not currently open, it's easy. */
  1306. if (!F_ISSET(dbp, DB_OPEN_CALLED))
  1307. goto never_opened;
  1309. /* Sync the underlying access method. */
  1310. if (!LF_ISSET(DB_NOSYNC) && !F_ISSET(dbp, DB_AM_DISCARD) &&
  1311.     (t_ret = dbp->sync(dbp, 0)) != 0 && ret == 0)
  1312. ret = t_ret;
  1314. /*
  1315.  * Go through the active cursors and call the cursor recycle routine,
  1316.  * which resolves pending operations and moves the cursors onto the
  1317.  * free list.  Then, walk the free list and call the cursor destroy
  1318.  * routine.
  1319.  */
  1320. while ((dbc = TAILQ_FIRST(&dbp->active_queue)) != NULL)
  1321. if ((t_ret = dbc->c_close(dbc)) != 0 && ret == 0)
  1322. ret = t_ret;
  1323. while ((dbc = TAILQ_FIRST(&dbp->free_queue)) != NULL)
  1324. if ((t_ret = __db_c_destroy(dbc)) != 0 && ret == 0)
  1325. ret = t_ret;
  1327. /*
  1328.  * Close any outstanding join cursors.  Join cursors destroy
  1329.  * themselves on close and have no separate destroy routine.
  1330.  */
  1331. while ((dbc = TAILQ_FIRST(&dbp->join_queue)) != NULL)
  1332. if ((t_ret = dbc->c_close(dbc)) != 0 && ret == 0)
  1333. ret = t_ret;
  1335. /* Remove this DB handle from the DB_ENV's dblist. */
  1336. MUTEX_THREAD_LOCK(dbenv, dbenv->dblist_mutexp);
  1337. LIST_REMOVE(dbp, dblistlinks);
  1338. MUTEX_THREAD_UNLOCK(dbenv, dbenv->dblist_mutexp);
  1340. /* Sync the memory pool. */
  1341. if (!LF_ISSET(DB_NOSYNC) && !F_ISSET(dbp, DB_AM_DISCARD) &&
  1342.     (t_ret = memp_fsync(dbp->mpf)) != 0 &&
  1343.     t_ret != DB_INCOMPLETE && ret == 0)
  1344. ret = t_ret;
  1346. /* Close any handle we've been holding since the open.  */
  1347. if (dbp->saved_open_fhp != NULL &&
  1348.     F_ISSET(dbp->saved_open_fhp, DB_FH_VALID) &&
  1349.     (t_ret = __os_closehandle(dbp->saved_open_fhp)) != 0 && ret == 0)
  1350. ret = t_ret;
  1352. never_opened:
  1353. /*
  1354.  * Call the access specific close function.
  1355.  *
  1356.  * !!!
  1357.  * Because of where the function is called in the close process,
  1358.  * these routines can't do anything that would dirty pages or
  1359.  * otherwise affect closing down the database.
  1360.  */
  1361. if ((t_ret = __ham_db_close(dbp)) != 0 && ret == 0)
  1362. ret = t_ret;
  1363. if ((t_ret = __bam_db_close(dbp)) != 0 && ret == 0)
  1364. ret = t_ret;
  1365. if ((t_ret = __qam_db_close(dbp)) != 0 && ret == 0)
  1366. ret = t_ret;
  1368. err:
  1369. /* Refresh the structure and close any local environment. */
  1370. if ((t_ret = __db_refresh(dbp)) != 0 && ret == 0)
  1371. ret = t_ret;
  1372. if (F_ISSET(dbenv, DB_ENV_DBLOCAL) &&
  1373.     --dbenv->dblocal_ref == 0 &&
  1374.     (t_ret = dbenv->close(dbenv, 0)) != 0 && ret == 0)
  1375. ret = t_ret;
  1377. memset(dbp, CLEAR_BYTE, sizeof(*dbp));
  1378. __os_free(dbp, sizeof(*dbp));
  1380. return (ret);
  1381. }
  1383. /*
  1384.  * __db_refresh --
  1385.  * Refresh the DB structure, releasing any allocated resources.
  1386.  */
  1387. static int
  1388. __db_refresh(dbp)
  1389. DB *dbp;
  1390. {
  1391. DB_ENV *dbenv;
  1392. DBC *dbc;
  1393. int ret, t_ret;
  1395. ret = 0;
  1397. dbenv = dbp->dbenv;
  1399. /*
  1400.  * Go through the active cursors and call the cursor recycle routine,
  1401.  * which resolves pending operations and moves the cursors onto the
  1402.  * free list.  Then, walk the free list and call the cursor destroy
  1403.  * routine.
  1404.  */
  1405. while ((dbc = TAILQ_FIRST(&dbp->active_queue)) != NULL)
  1406. if ((t_ret = dbc->c_close(dbc)) != 0 && ret == 0)
  1407. ret = t_ret;
  1408. while ((dbc = TAILQ_FIRST(&dbp->free_queue)) != NULL)
  1409. if ((t_ret = __db_c_destroy(dbc)) != 0 && ret == 0)
  1410. ret = t_ret;
  1412. dbp->type = 0;
  1414. /* Close the memory pool file handle. */
  1415. if (dbp->mpf != NULL) {
  1416. if (F_ISSET(dbp, DB_AM_DISCARD))
  1417. (void)__memp_fremove(dbp->mpf);
  1418. if ((t_ret = memp_fclose(dbp->mpf)) != 0 && ret == 0)
  1419. ret = t_ret;
  1420. dbp->mpf = NULL;
  1421. }
  1423. /* Discard the thread mutex. */
  1424. if (dbp->mutexp != NULL) {
  1425. __db_mutex_free(dbenv, dbenv->reginfo, dbp->mutexp);
  1426. dbp->mutexp = NULL;
  1427. }
  1429. /* Discard the log file id. */
  1430. if (!IS_RECOVERING(dbenv)
  1431.     && dbp->log_fileid != DB_LOGFILEID_INVALID)
  1432. (void)log_unregister(dbenv, dbp);
  1434. F_CLR(dbp, DB_AM_DISCARD);
  1435. F_CLR(dbp, DB_AM_INMEM);
  1436. F_CLR(dbp, DB_AM_RDONLY);
  1437. F_CLR(dbp, DB_AM_SWAP);
  1438. F_CLR(dbp, DB_DBM_ERROR);
  1439. F_CLR(dbp, DB_OPEN_CALLED);
  1441. return (ret);
  1442. }
  1444. /*
  1445.  * __db_remove
  1446.  * Remove method for DB.
  1447.  *
  1448.  * PUBLIC: int __db_remove __P((DB *, const char *, const char *, u_int32_t));
  1449.  */
  1450. int
  1451. __db_remove(dbp, name, subdb, flags)
  1452. DB *dbp;
  1453. const char *name, *subdb;
  1454. u_int32_t flags;
  1455. {
  1456. DBT namedbt;
  1457. DB_ENV *dbenv;
  1458. DB_LOCK remove_lock;
  1459. DB_LSN newlsn;
  1460. int ret, t_ret, (*callback_func) __P((DB *, void *));
  1461. char *backup, *real_back, *real_name;
  1462. void *cookie;
  1464. dbenv = dbp->dbenv;
  1465. ret = 0;
  1466. backup = real_back = real_name = NULL;
  1468. PANIC_CHECK(dbenv);
  1469. /*
  1470.  * Cannot use DB_ILLEGAL_AFTER_OPEN here because that returns
  1471.  * and we cannot return, but must deal with the error and destroy
  1472.  * the handle anyway.
  1473.  */
  1474. if (F_ISSET(dbp, DB_OPEN_CALLED)) {
  1475. ret = __db_mi_open(dbp->dbenv, "remove", 1);
  1476. goto err_close;
  1477. }
  1479. /* Validate arguments. */
  1480. if ((ret = __db_removechk(dbp, flags)) != 0)
  1481. goto err_close;
  1483. /*
  1484.  * Subdatabases.
  1485.  */
  1486. if (subdb != NULL) {
  1487. /* Subdatabases must be created in named files. */
  1488. if (name == NULL) {
  1489. __db_err(dbenv,
  1490.     "multiple databases cannot be created in temporary files");
  1491. goto err_close;
  1492. }
  1493. return (__db_subdb_remove(dbp, name, subdb));
  1494. }
  1496. if ((ret = dbp->open(dbp,
  1497.     name, NULL, DB_UNKNOWN, DB_RDWRMASTER, 0)) != 0)
  1498. goto err_close;
  1500. if (LOGGING_ON(dbenv) && (ret = __log_file_lock(dbp)) != 0)
  1501. goto err_close;
  1503. if ((ret = dbp->sync(dbp, 0)) != 0)
  1504. goto err_close;
  1506. /* Start the transaction and log the delete. */
  1507. if (TXN_ON(dbenv) && (ret = __db_metabegin(dbp, &remove_lock)) != 0)
  1508. goto err_close;
  1510. if (LOGGING_ON(dbenv)) {
  1511. memset(&namedbt, 0, sizeof(namedbt));
  1512. namedbt.data = (char *)name;
  1513. namedbt.size = strlen(name) + 1;
  1515. if ((ret = __crdel_delete_log(dbenv,
  1516.     dbp->open_txn, &newlsn, DB_FLUSH,
  1517.     dbp->log_fileid, &namedbt)) != 0) {
  1518. __db_err(dbenv,
  1519.     "%s: %s", name, db_strerror(ret));
  1520. goto err;
  1521. }
  1522. }
  1524. /* Find the real name of the file. */
  1525. if ((ret = __db_appname(dbenv,
  1526.     DB_APP_DATA, NULL, name, 0, NULL, &real_name)) != 0)
  1527. goto err;
  1529. /*
  1530.  * XXX
  1531.  * We don't bother to open the file and call __memp_fremove on the mpf.
  1532.  * There is a potential race here.  It is at least possible that, if
  1533.  * the unique filesystem ID (dev/inode pair on UNIX) is reallocated
  1534.  * within a second (the granularity of the fileID timestamp), a new
  1535.  * file open will get the same fileID as the file being "removed".
  1536.  * We may actually want to open the file and call __memp_fremove on
  1537.  * the mpf to get around this.
  1538.  */
  1540. /* Create name for backup file. */
  1541. if (TXN_ON(dbenv)) {
  1542. if ((ret =
  1543.     __db_backup_name(dbenv, name, &backup, &newlsn)) != 0)
  1544. goto err;
  1545. if ((ret = __db_appname(dbenv,
  1546.     DB_APP_DATA, NULL, backup, 0, NULL, &real_back)) != 0)
  1547. goto err;
  1548. }
  1550. callback_func = __db_remove_callback;
  1551. cookie = real_back;
  1552. DB_TEST_RECOVERY(dbp, DB_TEST_PRERENAME, ret, name);
  1553. if (dbp->db_am_remove != NULL &&
  1554.     (ret = dbp->db_am_remove(dbp,
  1555.     name, subdb, &newlsn, &callback_func, &cookie)) != 0)
  1556. goto err;
  1557. /*
  1558.  * On Windows, the underlying file must be closed to perform a remove.
  1559.  * Nothing later in __db_remove requires that it be open, and the
  1560.  * dbp->close closes it anyway, so we just close it early.
  1561.  */
  1562. (void)__memp_fremove(dbp->mpf);
  1563. if ((ret = memp_fclose(dbp->mpf)) != 0)
  1564. goto err;
  1565. dbp->mpf = NULL;
  1567. if (TXN_ON(dbenv))
  1568. ret = __os_rename(dbenv, real_name, real_back);
  1569. else
  1570. ret = __os_unlink(dbenv, real_name);
  1572. DB_TEST_RECOVERY(dbp, DB_TEST_POSTRENAME, ret, name);
  1574. err:
  1575. DB_TEST_RECOVERY_LABEL
  1576. /*
  1577.  * End the transaction, committing the transaction if we were
  1578.  * successful, aborting otherwise.
  1579.  */
  1580. if (dbp->open_txn != NULL && (t_ret = __db_metaend(dbp, &remove_lock,
  1581.    ret == 0, callback_func, cookie)) != 0 && ret == 0)
  1582. ret = t_ret;
  1584. /* FALLTHROUGH */
  1586. err_close:
  1587. if (real_back != NULL)
  1588. __os_freestr(real_back);
  1589. if (real_name != NULL)
  1590. __os_freestr(real_name);
  1591. if (backup != NULL)
  1592. __os_freestr(backup);
  1594. /* We no longer have an mpool, so syncing would be disastrous. */
  1595. if ((t_ret = dbp->close(dbp, DB_NOSYNC)) != 0 && ret == 0)
  1596. ret = t_ret;
  1598. return (ret);
  1599. }
  1601. /*
  1602.  * __db_subdb_remove --
  1603.  * Remove a subdatabase.
  1604.  */
  1605. static int
  1606. __db_subdb_remove(dbp, name, subdb)
  1607. DB *dbp;
  1608. const char *name, *subdb;
  1609. {
  1610. DB *mdbp;
  1611. DBC *dbc;
  1612. DB_ENV *dbenv;
  1613. DB_LOCK remove_lock;
  1614. db_pgno_t meta_pgno;
  1615. int ret, t_ret;
  1617. mdbp = NULL;
  1618. dbc = NULL;
  1619. dbenv = dbp->dbenv;
  1621. /* Start the transaction. */
  1622. if (TXN_ON(dbenv) && (ret = __db_metabegin(dbp, &remove_lock)) != 0)
  1623. goto err_close;
  1625. /*
  1626.  * Open the subdatabase.  We can use the user's DB handle for this
  1627.  * purpose, I think.
  1628.  */
  1629. if ((ret = __db_open(dbp, name, subdb, DB_UNKNOWN, 0, 0)) != 0)
  1630. goto err;
  1632. /* Free up the pages in the subdatabase. */
  1633. switch (dbp->type) {
  1634. case DB_BTREE:
  1635. case DB_RECNO:
  1636. if ((ret = __bam_reclaim(dbp, dbp->open_txn)) != 0)
  1637. goto err;
  1638. break;
  1639. case DB_HASH:
  1640. if ((ret = __ham_reclaim(dbp, dbp->open_txn)) != 0)
  1641. goto err;
  1642. break;
  1643. default:
  1644. ret = __db_unknown_type(dbp->dbenv,
  1645.      "__db_subdb_remove", dbp->type);
  1646. goto err;
  1647. }
  1649. /*
  1650.  * Remove the entry from the main database and free the subdatabase
  1651.  * metadata page.
  1652.  */
  1653. if ((ret = __db_master_open(dbp, name, 0, 0, &mdbp)) != 0)
  1654. goto err;
  1656. if ((ret = __db_master_update(mdbp,
  1657.      subdb, dbp->type, &meta_pgno, MU_REMOVE, NULL, 0)) != 0)
  1658. goto err;
  1660. err: /*
  1661.  * End the transaction, committing the transaction if we were
  1662.  * successful, aborting otherwise.
  1663.  */
  1664. if (dbp->open_txn != NULL && (t_ret = __db_metaend(dbp,
  1665.     &remove_lock, ret == 0, NULL, NULL)) != 0 && ret == 0)
  1666. ret = t_ret;
  1668. err_close:
  1669. /*
  1670.  * Close the user's DB handle -- do this LAST to avoid smashing the
  1671.  * the transaction information.
  1672.  */
  1673. if ((t_ret = dbp->close(dbp, 0)) != 0 && ret == 0)
  1674. ret = t_ret;
  1676. if (mdbp != NULL && (t_ret = mdbp->close(mdbp, 0)) != 0 && ret == 0)
  1677. ret = t_ret;
  1679. return (ret);
  1680. }
  1682. /*
  1683.  * __db_rename
  1684.  * Rename method for DB.
  1685.  *
  1686.  * PUBLIC: int __db_rename __P((DB *,
  1687.  * PUBLIC:     const char *, const char *, const char *, u_int32_t));
  1688.  */
  1689. int
  1690. __db_rename(dbp, filename, subdb, newname, flags)
  1691. DB *dbp;
  1692. const char *filename, *subdb, *newname;
  1693. u_int32_t flags;
  1694. {
  1695. DBT namedbt, newnamedbt;
  1696. DB_ENV *dbenv;
  1697. DB_LOCK remove_lock;
  1698. DB_LSN newlsn;
  1699. char *real_name, *real_newname;
  1700. int ret, t_ret;
  1702. dbenv = dbp->dbenv;
  1703. ret = 0;
  1704. real_name = real_newname = NULL;
  1706. PANIC_CHECK(dbenv);
  1707. /*
  1708.  * Cannot use DB_ILLEGAL_AFTER_OPEN here because that returns
  1709.  * and we cannot return, but must deal with the error and destroy
  1710.  * the handle anyway.
  1711.  */
  1712. if (F_ISSET(dbp, DB_OPEN_CALLED)) {
  1713. ret = __db_mi_open(dbp->dbenv, "rename", 1);
  1714. goto err_close;
  1715. }
  1717. /* Validate arguments -- has same rules as remove. */
  1718. if ((ret = __db_removechk(dbp, flags)) != 0)
  1719. goto err_close;
  1721. /*
  1722.  * Subdatabases.
  1723.  */
  1724. if (subdb != NULL) {
  1725. if (filename == NULL) {
  1726. __db_err(dbenv,
  1727.     "multiple databases cannot be created in temporary files");
  1728. goto err_close;
  1729. }
  1730. return (__db_subdb_rename(dbp, filename, subdb, newname));
  1731. }
  1733. if ((ret = dbp->open(dbp,
  1734.     filename, NULL, DB_UNKNOWN, DB_RDWRMASTER, 0)) != 0)
  1735. goto err_close;
  1737. if (LOGGING_ON(dbenv) && (ret = __log_file_lock(dbp)) != 0)
  1738. goto err_close;
  1740. if ((ret = dbp->sync(dbp, 0)) != 0)
  1741. goto err_close;
  1743. /* Start the transaction and log the rename. */
  1744. if (TXN_ON(dbenv) && (ret = __db_metabegin(dbp, &remove_lock)) != 0)
  1745. goto err_close;
  1747. if (LOGGING_ON(dbenv)) {
  1748. memset(&namedbt, 0, sizeof(namedbt));
  1749. namedbt.data = (char *)filename;
  1750. namedbt.size = strlen(filename) + 1;
  1752. memset(&newnamedbt, 0, sizeof(namedbt));
  1753. newnamedbt.data = (char *)newname;
  1754. newnamedbt.size = strlen(newname) + 1;
  1756. if ((ret = __crdel_rename_log(dbenv, dbp->open_txn,
  1757.     &newlsn, 0, dbp->log_fileid, &namedbt, &newnamedbt)) != 0) {
  1758. __db_err(dbenv, "%s: %s", filename, db_strerror(ret));
  1759. goto err;
  1760. }
  1762. if ((ret = __log_filelist_update(dbenv, dbp,
  1763.     dbp->log_fileid, newname, NULL)) != 0)
  1764. goto err;
  1765. }
  1767. /* Find the real name of the file. */
  1768. if ((ret = __db_appname(dbenv,
  1769.     DB_APP_DATA, NULL, filename, 0, NULL, &real_name)) != 0)
  1770. goto err;
  1772. /* Find the real newname of the file. */
  1773. if ((ret = __db_appname(dbenv,
  1774.     DB_APP_DATA, NULL, newname, 0, NULL, &real_newname)) != 0)
  1775. goto err;
  1777. /*
  1778.  * It is an error to rename a file over one that already exists,
  1779.  * as that wouldn't be transaction-safe.
  1780.  */
  1781. if (__os_exists(real_newname, NULL) == 0) {
  1782. ret = EEXIST;
  1783. __db_err(dbenv, "rename: file %s exists", real_newname);
  1784. goto err;
  1785. }
  1787. DB_TEST_RECOVERY(dbp, DB_TEST_PRERENAME, ret, filename);
  1788. if (dbp->db_am_rename != NULL &&
  1789.     (ret = dbp->db_am_rename(dbp, filename, subdb, newname)) != 0)
  1790. goto err;
  1791. /*
  1792.  * We have to flush the cache for a couple of reasons.  First, the
  1793.  * underlying MPOOLFILE maintains a "name" that unrelated processes
  1794.  * can use to open the file in order to flush pages, and that name
  1795.  * is about to be wrong.  Second, on Windows the unique file ID is
  1796.  * generated from the file's name, not other file information as is
  1797.  * the case on UNIX, and so a subsequent open of the old file name
  1798.  * could conceivably result in a matching "unique" file ID.
  1799.  */
  1800. if ((ret = __memp_fremove(dbp->mpf)) != 0)
  1801. goto err;
  1803. /*
  1804.  * On Windows, the underlying file must be closed to perform a rename.
  1805.  * Nothing later in __db_rename requires that it be open, and the call
  1806.  * to dbp->close closes it anyway, so we just close it early.
  1807.  */
  1808. if ((ret = memp_fclose(dbp->mpf)) != 0)
  1809. goto err;
  1810. dbp->mpf = NULL;
  1812. ret = __os_rename(dbenv, real_name, real_newname);
  1813. DB_TEST_RECOVERY(dbp, DB_TEST_POSTRENAME, ret, newname);
  1815. DB_TEST_RECOVERY_LABEL
  1816. err: if (dbp->open_txn != NULL && (t_ret = __db_metaend(dbp,
  1817.     &remove_lock, ret == 0, NULL, NULL)) != 0 && ret == 0)
  1818. ret = t_ret;
  1820. err_close:
  1821. /* We no longer have an mpool, so syncing would be disastrous. */
  1822. dbp->close(dbp, DB_NOSYNC);
  1823. if (real_name != NULL)
  1824. __os_freestr(real_name);
  1825. if (real_newname != NULL)
  1826. __os_freestr(real_newname);
  1828. return (ret);
  1829. }
  1831. /*
  1832.  * __db_subdb_rename --
  1833.  * Rename a subdatabase.
  1834.  */
  1835. static int
  1836. __db_subdb_rename(dbp, name, subdb, newname)
  1837. DB *dbp;
  1838. const char *name, *subdb, *newname;
  1839. {
  1840. DB *mdbp;
  1841. DBC *dbc;
  1842. DB_ENV *dbenv;
  1843. DB_LOCK remove_lock;
  1844. int ret, t_ret;
  1846. mdbp = NULL;
  1847. dbc = NULL;
  1848. dbenv = dbp->dbenv;
  1850. /* Start the transaction. */
  1851. if (TXN_ON(dbenv) && (ret = __db_metabegin(dbp, &remove_lock)) != 0)
  1852. goto err_close;
  1854. /*
  1855.  * Open the subdatabase.  We can use the user's DB handle for this
  1856.  * purpose, I think.
  1857.  */
  1858. if ((ret = __db_open(dbp, name, subdb, DB_UNKNOWN, 0, 0)) != 0)
  1859. goto err;
  1861. /*
  1862.  * Rename the entry in the main database.
  1863.  */
  1864. if ((ret = __db_master_open(dbp, name, 0, 0, &mdbp)) != 0)
  1865. goto err;
  1867. if ((ret = __db_master_update(mdbp,
  1868.      subdb, dbp->type, NULL, MU_RENAME, newname, 0)) != 0)
  1869. goto err;
  1871. err: /*
  1872.  * End the transaction, committing the transaction if we were
  1873.  * successful, aborting otherwise.
  1874.  */
  1875. if (dbp->open_txn != NULL && (t_ret = __db_metaend(dbp,
  1876.     &remove_lock, ret == 0, NULL, NULL)) != 0 && ret == 0)
  1877. ret = t_ret;
  1879. err_close:
  1880. /*
  1881.  * Close the user's DB handle -- do this LAST to avoid smashing the
  1882.  * the transaction information.
  1883.  */
  1884. if ((t_ret = dbp->close(dbp, 0)) != 0 && ret == 0)
  1885. ret = t_ret;
  1887. if (mdbp != NULL && (t_ret = mdbp->close(mdbp, 0)) != 0 && ret == 0)
  1888. ret = t_ret;
  1890. return (ret);
  1891. }
  1893. /*
  1894.  * __db_metabegin --
  1895.  *
  1896.  * Begin a meta-data operation.  This involves doing any required locking,
  1897.  * potentially beginning a transaction and then telling the caller if you
  1898.  * did or did not begin the transaction.
  1899.  *
  1900.  * The writing flag indicates if the caller is actually allowing creates
  1901.  * or doing deletes (i.e., if the caller is opening and not creating, then
  1902.  * we don't need to do any of this).
  1903.  * PUBLIC: int __db_metabegin __P((DB *, DB_LOCK *));
  1904.  */
  1905. int
  1906. __db_metabegin(dbp, lockp)
  1907. DB *dbp;
  1908. DB_LOCK *lockp;
  1909. {
  1910. DB_ENV *dbenv;
  1911. DBT dbplock;
  1912. u_int32_t locker, lockval;
  1913. int ret;
  1915. dbenv = dbp->dbenv;
  1917. lockp->off = LOCK_INVALID;
  1919. /*
  1920.  * There is no single place where we can know that we are or are not
  1921.  * going to be creating any files and/or subdatabases, so we will
  1922.  * always begin a tranasaction when we start creating one.  If we later
  1923.  * discover that this was unnecessary, we will abort the transaction.
  1924.  * Recovery is written so that if we log a file create, but then
  1925.  * discover that we didn't have to do it, we recover correctly.  The
  1926.  * file recovery design document has details.
  1927.  *
  1928.  * We need to single thread all create and delete operations, so if we
  1929.  * are running with locking, we must obtain a lock. We use lock_id to
  1930.  * generate a unique locker id and use a handcrafted DBT as the object
  1931.  * on which we are locking.
  1932.  */
  1933. if (LOCKING_ON(dbenv)) {
  1934. if ((ret = lock_id(dbenv, &locker)) != 0)
  1935. return (ret);
  1936. lockval = 0;
  1937. dbplock.data = &lockval;
  1938. dbplock.size = sizeof(lockval);
  1939. if ((ret = lock_get(dbenv,
  1940.     locker, 0, &dbplock, DB_LOCK_WRITE, lockp)) != 0)
  1941. return (ret);
  1942. }
  1944. return (txn_begin(dbenv, NULL, &dbp->open_txn, 0));
  1945. }
  1947. /*
  1948.  * __db_metaend --
  1949.  * End a meta-data operation.
  1950.  * PUBLIC: int __db_metaend __P((DB *,
  1951.  * PUBLIC:       DB_LOCK *, int, int (*)(DB *, void *), void *));
  1952.  */
  1953. int
  1954. __db_metaend(dbp, lockp, commit, callback, cookie)
  1955. DB *dbp;
  1956. DB_LOCK *lockp;
  1957. int commit, (*callback) __P((DB *, void *));
  1958. void *cookie;
  1959. {
  1960. DB_ENV *dbenv;
  1961. int ret, t_ret;
  1963. ret = 0;
  1964. dbenv = dbp->dbenv;
  1966. /* End the transaction. */
  1967. if (commit) {
  1968. if ((ret = txn_commit(dbp->open_txn, DB_TXN_SYNC)) == 0) {
  1969. /*
  1970.  * Unlink any underlying file, we've committed the
  1971.  * transaction.
  1972.  */
  1973. if (callback != NULL)
  1974. ret = callback(dbp, cookie);
  1975. }
  1976. } else if ((t_ret = txn_abort(dbp->open_txn)) && ret == 0)
  1977. ret = t_ret;
  1979. /* Release our lock. */
  1980. if (lockp->off != LOCK_INVALID &&
  1981.     (t_ret = lock_put(dbenv, lockp)) != 0 && ret == 0)
  1982. ret = t_ret;
  1984. return (ret);
  1985. }
  1987. /*
  1988.  * __db_log_page
  1989.  * Log a meta-data or root page during a create operation.
  1990.  *
  1991.  * PUBLIC: int __db_log_page __P((DB *,
  1992.  * PUBLIC:     const char *, DB_LSN *, db_pgno_t, PAGE *));
  1993.  */
  1994. int
  1995. __db_log_page(dbp, name, lsn, pgno, page)
  1996. DB *dbp;
  1997. const char *name;
  1998. DB_LSN *lsn;
  1999. db_pgno_t pgno;
  2000. PAGE *page;
  2001. {
  2002. DBT name_dbt, page_dbt;
  2003. DB_LSN new_lsn;
  2004. int ret;
  2006. if (dbp->open_txn == NULL)
  2007. return (0);
  2009. memset(&page_dbt, 0, sizeof(page_dbt));
  2010. page_dbt.size = dbp->pgsize;
  2011. page_dbt.data = page;
  2012. if (pgno == PGNO_BASE_MD) {
  2013. /*
  2014.  * !!!
  2015.  * Make sure that we properly handle a null name.  The old
  2016.  * Tcl sent us pathnames of the form ""; it may be the case
  2017.  * that the new Tcl doesn't do that, so we can get rid of
  2018.  * the second check here.
  2019.  */
  2020. memset(&name_dbt, 0, sizeof(name_dbt));
  2021. name_dbt.data = (char *)name;
  2022. if (name == NULL || *name == '')
  2023. name_dbt.size = 0;
  2024. else
  2025. name_dbt.size = strlen(name) + 1;
  2027. ret = __crdel_metapage_log(dbp->dbenv,
  2028.     dbp->open_txn, &new_lsn, DB_FLUSH,
  2029.     dbp->log_fileid, &name_dbt, pgno, &page_dbt);
  2030. } else
  2031. ret = __crdel_metasub_log(dbp->dbenv, dbp->open_txn,
  2032.     &new_lsn, 0, dbp->log_fileid, pgno, &page_dbt, lsn);
  2034. if (ret == 0)
  2035. page->lsn = new_lsn;
  2036. return (ret);
  2037. }
  2039. /*
  2040.  * __db_backup_name
  2041.  * Create the backup file name for a given file.
  2042.  *
  2043.  * PUBLIC: int __db_backup_name __P((DB_ENV *,
  2044.  * PUBLIC:     const char *, char **, DB_LSN *));
  2045.  */
  2046. #undef BACKUP_PREFIX
  2047. #define BACKUP_PREFIX "__db."
  2049. #undef MAX_LSN_TO_TEXT
  2050. #define MAX_LSN_TO_TEXT 21
  2051. int
  2052. __db_backup_name(dbenv, name, backup, lsn)
  2053. DB_ENV *dbenv;
  2054. const char *name;
  2055. char **backup;
  2056. DB_LSN *lsn;
  2057. {
  2058. size_t len;
  2059. int plen, ret;
  2060. char *p, *retp;
  2062. len = strlen(name) + strlen(BACKUP_PREFIX) + MAX_LSN_TO_TEXT + 1;
  2064. if ((ret = __os_malloc(dbenv, len, NULL, &retp)) != 0)
  2065. return (ret);
  2067. /*
  2068.  * Create the name.  Backup file names are of the form:
  2069.  *
  2070.  * __db.name.0x[lsn-file].0x[lsn-offset]
  2071.  *
  2072.  * which guarantees uniqueness.
  2073.  *
  2074.  * However, name may contain an env-relative path in it.
  2075.  * In that case, put the __db. after the last portion of
  2076.  * the pathname.
  2077.  */
  2078. if ((p = __db_rpath(name)) == NULL)
  2079. snprintf(retp, len,
  2080.     "%s%s.0x%x0x%x", BACKUP_PREFIX, name,
  2081.     lsn->file, lsn->offset);
  2082. else {
  2083. plen = p - name + 1;
  2084. p++;
  2085. snprintf(retp, len,
  2086.     "%.*s%s%s.0x%x0x%x", plen, name, BACKUP_PREFIX, p,
  2087.     lsn->file, lsn->offset);
  2088. }
  2090. *backup = retp;
  2091. return (0);
  2092. }
  2094. /*
  2095.  * __db_remove_callback --
  2096.  * Callback function -- on file remove commit, it unlinks the backing
  2097.  * file.
  2098.  */
  2099. static int
  2100. __db_remove_callback(dbp, cookie)
  2101. DB *dbp;
  2102. void *cookie;
  2103. {
  2104. return (__os_unlink(dbp->dbenv, cookie));
  2105. }
  2107. /*
  2108.  * __dblist_get --
  2109.  * Get the first element of dbenv->dblist with
  2110.  * dbp->adj_fileid matching adjid.
  2111.  *
  2112.  * PUBLIC: DB *__dblist_get __P((DB_ENV *, u_int32_t));
  2113.  */
  2114. DB *
  2115. __dblist_get(dbenv, adjid)
  2116. DB_ENV *dbenv;
  2117. u_int32_t adjid;
  2118. {
  2119. DB *dbp;
  2121. for (dbp = LIST_FIRST(&dbenv->dblist);
  2122.     dbp != NULL && dbp->adj_fileid != adjid;
  2123.     dbp = LIST_NEXT(dbp, dblistlinks))
  2124. ;
  2126. return (dbp);
  2127. }
  2129. #if CONFIG_TEST
  2130. /*
  2131.  * __db_testcopy
  2132.  * Create a copy of all backup files and our "main" DB.
  2133.  *
  2134.  * PUBLIC: int __db_testcopy __P((DB *, const char *));
  2135.  */
  2136. int
  2137. __db_testcopy(dbp, name)
  2138. DB *dbp;
  2139. const char *name;
  2140. {
  2141. if (dbp->type == DB_QUEUE)
  2142. return (__qam_testdocopy(dbp, name));
  2143. else
  2144. return (__db_testdocopy(dbp, name));
  2145. }
  2147. static int
  2148. __qam_testdocopy(dbp, name)
  2149. DB *dbp;
  2150. const char *name;
  2151. {
  2152. QUEUE_FILELIST *filelist, *fp;
  2153. char buf[256], *dir;
  2154. int ret;
  2156. filelist = NULL;
  2157. if ((ret = __db_testdocopy(dbp, name)) != 0)
  2158. return (ret);
  2159. if (dbp->mpf != NULL &&
  2160.     (ret = __qam_gen_filelist(dbp, &filelist)) != 0)
  2161. return (ret);
  2163. if (filelist == NULL)
  2164. return (0);
  2165. dir = ((QUEUE *)dbp->q_internal)->dir;
  2166. for (fp = filelist; fp->mpf != NULL; fp++) {
  2167. snprintf(buf, sizeof(buf), QUEUE_EXTENT, dir, name, fp->id);
  2168. if ((ret = __db_testdocopy(dbp, buf)) != 0)
  2169. return (ret);
  2170. }
  2172. __os_free(filelist, 0);
  2173. return (0);
  2174. }
  2176. /*
  2177.  * __db_testdocopy
  2178.  * Create a copy of all backup files and our "main" DB.
  2179.  *
  2180.  */
  2181. static int
  2182. __db_testdocopy(dbp, name)
  2183. DB *dbp;
  2184. const char *name;
  2185. {
  2186. size_t len;
  2187. int dircnt, i, ret;
  2188. char **namesp, *backup, *copy, *dir, *p, *real_name;
  2189. real_name = NULL;
  2190. /* Get the real backing file name. */
  2191. if ((ret = __db_appname(dbp->dbenv,
  2192.     DB_APP_DATA, NULL, name, 0, NULL, &real_name)) != 0)
  2193. return (ret);
  2195. copy = backup = NULL;
  2196. namesp = NULL;
  2198. /*
  2199.  * Maximum size of file, including adding a ".afterop".
  2200.  */
  2201. len = strlen(real_name) + strlen(BACKUP_PREFIX) + MAX_LSN_TO_TEXT + 9;
  2203. if ((ret = __os_malloc(dbp->dbenv, len, NULL, &copy)) != 0)
  2204. goto out;
  2206. if ((ret = __os_malloc(dbp->dbenv, len, NULL, &backup)) != 0)
  2207. goto out;
  2209. /*
  2210.  * First copy the file itself.
  2211.  */
  2212. snprintf(copy, len, "%s.afterop", real_name);
  2213. __db_makecopy(real_name, copy);
  2215. if ((ret = __os_strdup(dbp->dbenv, real_name, &dir)) != 0)
  2216. goto out;
  2217. __os_freestr(real_name);
  2218. real_name = NULL;
  2219. /*
  2220.  * Create the name.  Backup file names are of the form:
  2221.  *
  2222.  * __db.name.0x[lsn-file].0x[lsn-offset]
  2223.  *
  2224.  * which guarantees uniqueness.  We want to look for the
  2225.  * backup name, followed by a '.0x' (so that if they have
  2226.  * files named, say, 'a' and 'abc' we won't match 'abc' when
  2227.  * looking for 'a'.
  2228.  */
  2229. snprintf(backup, len, "%s%s.0x", BACKUP_PREFIX, name);
  2231. /*
  2232.  * We need the directory path to do the __os_dirlist.
  2233.  */
  2234. p = __db_rpath(dir);
  2235. if (p != NULL)
  2236. *p = '';
  2237. ret = __os_dirlist(dbp->dbenv, dir, &namesp, &dircnt);
  2238. #if DIAGNOSTIC
  2239. /*
  2240.  * XXX
  2241.  * To get the memory guard code to work because it uses strlen and we
  2242.  * just moved the end of the string somewhere sooner.  This causes the
  2243.  * guard code to fail because it looks at one byte past the end of the
  2244.  * string.
  2245.  */
  2246. *p = '/';
  2247. #endif
  2248. __os_freestr(dir);
  2249. if (ret != 0)
  2250. goto out;
  2251. for (i = 0; i < dircnt; i++) {
  2252. /*
  2253.  * Need to check if it is a backup file for this.
  2254.  * No idea what namesp[i] may be or how long, so
  2255.  * must use strncmp and not memcmp.  We don't want
  2256.  * to use strcmp either because we are only matching
  2257.  * the first part of the real file's name.  We don't
  2258.  * know its LSN's.
  2259.  */
  2260. if (strncmp(namesp[i], backup, strlen(backup)) == 0) {
  2261. if ((ret = __db_appname(dbp->dbenv, DB_APP_DATA,
  2262.     NULL, namesp[i], 0, NULL, &real_name)) != 0)
  2263. goto out;
  2265. /*
  2266.  * This should not happen.  Check that old
  2267.  * .afterop files aren't around.
  2268.  * If so, just move on.
  2269.  */
  2270. if (strstr(real_name, ".afterop") != NULL) {
  2271. __os_freestr(real_name);
  2272. real_name = NULL;
  2273. continue;
  2274. }
  2275. snprintf(copy, len, "%s.afterop", real_name);
  2276. __db_makecopy(real_name, copy);
  2277. __os_freestr(real_name);
  2278. real_name = NULL;
  2279. }
  2280. }
  2281. out:
  2282. if (backup != NULL)
  2283. __os_freestr(backup);
  2284. if (copy != NULL)
  2285. __os_freestr(copy);
  2286. if (namesp != NULL)
  2287. __os_dirfree(namesp, dircnt);
  2288. if (real_name != NULL)
  2289. __os_freestr(real_name);
  2290. return (ret);
  2291. }
  2293. static void
  2294. __db_makecopy(src, dest)
  2295. const char *src, *dest;
  2296. {
  2297. DB_FH rfh, wfh;
  2298. size_t rcnt, wcnt;
  2299. char *buf;
  2301. memset(&rfh, 0, sizeof(rfh));
  2302. memset(&wfh, 0, sizeof(wfh));
  2304. if (__os_malloc(NULL, 1024, NULL, &buf) != 0)
  2305. return;
  2307. if (__os_open(NULL,
  2308.     src, DB_OSO_RDONLY, __db_omode("rw----"), &rfh) != 0)
  2309. goto err;
  2310. if (__os_open(NULL, dest,
  2311.     DB_OSO_CREATE | DB_OSO_TRUNC, __db_omode("rw----"), &wfh) != 0)
  2312. goto err;
  2314. for (;;)
  2315. if (__os_read(NULL, &rfh, buf, 1024, &rcnt) < 0 || rcnt == 0 ||
  2316.     __os_write(NULL, &wfh, buf, rcnt, &wcnt) < 0 || wcnt != rcnt)
  2317. break;
  2319. err: __os_free(buf, 1024);
  2320. if (F_ISSET(&rfh, DB_FH_VALID))
  2321. __os_closehandle(&rfh);
  2322. if (F_ISSET(&wfh, DB_FH_VALID))
  2323. __os_closehandle(&wfh);
  2324. }
  2325. #endif