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

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

MySQL数据库

开发平台：

Visual C++

db.c：源码内容
  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 1996-2002
  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.246 2002/08/20 14:40:00 margo 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 "dbinc/db_page.h"
  56. #include "dbinc/db_shash.h"
  57. #include "dbinc/db_swap.h"
  58. #include "dbinc/btree.h"
  59. #include "dbinc/hash.h"
  60. #include "dbinc/lock.h"
  61. #include "dbinc/log.h"
  62. #include "dbinc/log.h"
  63. #include "dbinc/mp.h"
  64. #include "dbinc/qam.h"
  65. #include "dbinc/txn.h"
  67. static int __db_disassociate __P((DB *));
  68. #if CONFIG_TEST
  69. static void __db_makecopy __P((const char *, const char *));
  70. static int  __db_testdocopy __P((DB_ENV *, const char *));
  71. static int  __qam_testdocopy __P((DB *, const char *));
  72. #endif
  74. /*
  75.  * DB.C --
  76.  * This file contains the utility functions for the DBP layer.
  77.  */
  79. /*
  80.  * __db_master_open --
  81.  * Open up a handle on a master database.
  82.  *
  83.  * PUBLIC: int __db_master_open __P((DB *,
  84.  * PUBLIC:     DB_TXN *, const char *, u_int32_t, int, DB **));
  85.  */
  86. int
  87. __db_master_open(subdbp, txn, name, flags, mode, dbpp)
  88. DB *subdbp;
  89. DB_TXN *txn;
  90. const char *name;
  91. u_int32_t flags;
  92. int mode;
  93. DB **dbpp;
  94. {
  95. DB *dbp;
  96. int ret;
  98. /* Open up a handle on the main database. */
  99. if ((ret = db_create(&dbp, subdbp->dbenv, 0)) != 0)
  100. return (ret);
  102. /*
  103.  * It's always a btree.
  104.  * Run in the transaction we've created.
  105.  * Set the pagesize in case we're creating a new database.
  106.  * Flag that we're creating a database with subdatabases.
  107.  */
  108. dbp->type = DB_BTREE;
  109. dbp->pgsize = subdbp->pgsize;
  110. F_SET(dbp, DB_AM_SUBDB);
  111. F_SET(dbp, F_ISSET(subdbp,
  112.     DB_AM_RECOVER | DB_AM_SWAP | DB_AM_ENCRYPT | DB_AM_CHKSUM));
  114. /*
  115.  * If there was a subdb specified, then we only want to apply
  116.  * DB_EXCL to the subdb, not the actual file.  We only got here
  117.  * because there was a subdb specified.
  118.  */
  119. LF_CLR(DB_EXCL);
  120. LF_SET(DB_RDWRMASTER);
  121. if ((ret = __db_dbopen(dbp, txn, name, NULL, flags, mode, PGNO_BASE_MD))
  122.     != 0)
  123. goto err;
  125. /*
  126.  * Verify that pagesize is the same on both.
  127.  * The items in dbp were now initialized from the meta
  128.  * page.  The items in dbp were set in __db_dbopen
  129.  * when we either read or created the master file.
  130.  * Other items such as checksum and encryption are
  131.  * checked when we read the meta-page.  So we do not
  132.  * check those here.  However, if the meta-page caused
  133.  * chksumming to be turned on and it wasn't already, set
  134.  * it here.
  135.  */
  136. if (F_ISSET(dbp, DB_AM_CHKSUM))
  137. F_SET(subdbp, DB_AM_CHKSUM);
  138. if (subdbp->pgsize != 0 && dbp->pgsize != subdbp->pgsize) {
  139. ret = EINVAL;
  140. __db_err(dbp->dbenv,
  141.     "Different pagesize specified on existent file");
  142. goto err;
  143. }
  144. err:
  145. if (ret != 0 && !F_ISSET(dbp, DB_AM_DISCARD))
  146. __db_close_i(dbp, txn, 0);
  147. else
  148. *dbpp = dbp;
  149. return (ret);
  150. }
  152. /*
  153.  * __db_master_update --
  154.  * Add/Open/Remove a subdatabase from a master database.
  155.  *
  156.  * PUBLIC: int __db_master_update __P((DB *, DB *, DB_TXN *, const char *,
  157.  * PUBLIC:     DBTYPE, mu_action, const char *, u_int32_t));
  158.  */
  159. int
  160. __db_master_update(mdbp, sdbp, txn, subdb, type, action, newname, flags)
  161. DB *mdbp, *sdbp;
  162. DB_TXN *txn;
  163. const char *subdb;
  164. DBTYPE type;
  165. mu_action action;
  166. const char *newname;
  167. u_int32_t flags;
  168. {
  169. DB_ENV *dbenv;
  170. DBC *dbc, *ndbc;
  171. DBT key, data, ndata;
  172. PAGE *p;
  173. db_pgno_t t_pgno;
  174. int modify, ret, t_ret;
  176. dbenv = mdbp->dbenv;
  177. dbc = ndbc = NULL;
  178. p = NULL;
  180. memset(&key, 0, sizeof(key));
  181. memset(&data, 0, sizeof(data));
  183. /* Might we modify the master database?  If so, we'll need to lock. */
  184. modify = (action != MU_OPEN || LF_ISSET(DB_CREATE)) ? 1 : 0;
  186. /*
  187.  * Open up a cursor.  If this is CDB and we're creating the database,
  188.  * make it an update cursor.
  189.  */
  190. if ((ret = mdbp->cursor(mdbp, txn, &dbc,
  191.     (CDB_LOCKING(dbenv) && modify) ? DB_WRITECURSOR : 0)) != 0)
  192. goto err;
  194. /*
  195.  * Point the cursor at the record.
  196.  *
  197.  * If we're removing or potentially creating an entry, lock the page
  198.  * with DB_RMW.
  199.  *
  200.  * We do multiple cursor operations with the cursor in some cases and
  201.  * subsequently access the data DBT information.  Set DB_DBT_MALLOC so
  202.  * we don't risk modification of the data between our uses of it.
  203.  *
  204.  * !!!
  205.  * We don't include the name's nul termination in the database.
  206.  */
  207. key.data = (void *)subdb;
  208. key.size = (u_int32_t)strlen(subdb);
  209. F_SET(&data, DB_DBT_MALLOC);
  211. ret = dbc->c_get(dbc, &key, &data,
  212.     DB_SET | ((STD_LOCKING(dbc) && modify) ? DB_RMW : 0));
  214. /*
  215.  * What we do next--whether or not we found a record for the
  216.  * specified subdatabase--depends on what the specified action is.
  217.  * Handle ret appropriately as the first statement of each case.
  218.  */
  219. switch (action) {
  220. case MU_REMOVE:
  221. /*
  222.  * We should have found something if we're removing it.  Note
  223.  * that in the common case where the DB we're asking to remove
  224.  * doesn't exist, we won't get this far;  __db_subdb_remove
  225.  * will already have returned an error from __db_open.
  226.  */
  227. if (ret != 0)
  228. goto err;
  230. /*
  231.  * Delete the subdatabase entry first;  if this fails,
  232.  * we don't want to touch the actual subdb pages.
  233.  */
  234. if ((ret = dbc->c_del(dbc, 0)) != 0)
  235. goto err;
  237. /*
  238.  * We're handling actual data, not on-page meta-data,
  239.  * so it hasn't been converted to/from opposite
  240.  * endian architectures.  Do it explicitly, now.
  241.  */
  242. memcpy(&sdbp->meta_pgno, data.data, sizeof(db_pgno_t));
  243. DB_NTOHL(&sdbp->meta_pgno);
  244. if ((ret =
  245.     mdbp->mpf->get(mdbp->mpf, &sdbp->meta_pgno, 0, &p)) != 0)
  246. goto err;
  248. /* Free and put the page. */
  249. if ((ret = __db_free(dbc, p)) != 0) {
  250. p = NULL;
  251. goto err;
  252. }
  253. p = NULL;
  254. break;
  255. case MU_RENAME:
  256. /* We should have found something if we're renaming it. */
  257. if (ret != 0)
  258. goto err;
  260. /*
  261.  * Before we rename, we need to make sure we're not
  262.  * overwriting another subdatabase, or else this operation
  263.  * won't be undoable.  Open a second cursor and check
  264.  * for the existence of newname;  it shouldn't appear under
  265.  * us since we hold the metadata lock.
  266.  */
  267. if ((ret = mdbp->cursor(mdbp, txn, &ndbc, 0)) != 0)
  268. goto err;
  269. DB_ASSERT(newname != NULL);
  270. key.data = (void *)newname;
  271. key.size = (u_int32_t)strlen(newname);
  273. /*
  274.  * We don't actually care what the meta page of the potentially-
  275.  * overwritten DB is;  we just care about existence.
  276.  */
  277. memset(&ndata, 0, sizeof(ndata));
  278. F_SET(&ndata, DB_DBT_USERMEM | DB_DBT_PARTIAL);
  280. if ((ret = ndbc->c_get(ndbc, &key, &ndata, DB_SET)) == 0) {
  281. /* A subdb called newname exists.  Bail. */
  282. ret = EEXIST;
  283. __db_err(dbenv, "rename: database %s exists", newname);
  284. goto err;
  285. } else if (ret != DB_NOTFOUND)
  286. goto err;
  288. /*
  289.  * Now do the put first;  we don't want to lose our
  290.  * sole reference to the subdb.  Use the second cursor
  291.  * so that the first one continues to point to the old record.
  292.  */
  293. if ((ret = ndbc->c_put(ndbc, &key, &data, DB_KEYFIRST)) != 0)
  294. goto err;
  295. if ((ret = dbc->c_del(dbc, 0)) != 0) {
  296. /*
  297.  * If the delete fails, try to delete the record
  298.  * we just put, in case we're not txn-protected.
  299.  */
  300. (void)ndbc->c_del(ndbc, 0);
  301. goto err;
  302. }
  304. break;
  305. case MU_OPEN:
  306. /*
  307.  * Get the subdatabase information.  If it already exists,
  308.  * copy out the page number and we're done.
  309.  */
  310. switch (ret) {
  311. case 0:
  312. if (LF_ISSET(DB_CREATE) && LF_ISSET(DB_EXCL)) {
  313. ret = EEXIST;
  314. goto err;
  315. }
  316. memcpy(&sdbp->meta_pgno, data.data, sizeof(db_pgno_t));
  317. DB_NTOHL(&sdbp->meta_pgno);
  318. goto done;
  319. case DB_NOTFOUND:
  320. if (LF_ISSET(DB_CREATE))
  321. break;
  322. /*
  323.  * No db_err, it is reasonable to remove a
  324.  * nonexistent db.
  325.  */
  326. ret = ENOENT;
  327. goto err;
  328. default:
  329. goto err;
  330. }
  332. /*
  333.  * We need to check against the master lorder here because
  334.  * we only want to check this if we are creating.  In the
  335.  * case where we don't create we just want to inherit.
  336.  */
  337. if (F_ISSET(mdbp, DB_AM_SWAP) != F_ISSET(sdbp, DB_AM_SWAP)) {
  338.  ret = EINVAL;
  339.  __db_err(mdbp->dbenv,
  340.     "Different lorder specified on existent file");
  341. goto err;
  342. }
  343. /* Create a subdatabase. */
  344. if ((ret = __db_new(dbc,
  345.     type == DB_HASH ? P_HASHMETA : P_BTREEMETA, &p)) != 0)
  346. goto err;
  347. sdbp->meta_pgno = PGNO(p);
  349. /*
  350.  * XXX
  351.  * We're handling actual data, not on-page meta-data, so it
  352.  * hasn't been converted to/from opposite endian architectures.
  353.  * Do it explicitly, now.
  354.  */
  355. t_pgno = PGNO(p);
  356. DB_HTONL(&t_pgno);
  357. memset(&ndata, 0, sizeof(ndata));
  358. ndata.data = &t_pgno;
  359. ndata.size = sizeof(db_pgno_t);
  360. if ((ret = dbc->c_put(dbc, &key, &ndata, DB_KEYLAST)) != 0)
  361. goto err;
  362. F_SET(sdbp, DB_AM_CREATED);
  363. break;
  364. }
  366. err:
  367. done: /*
  368.  * If we allocated a page: if we're successful, mark the page dirty
  369.  * and return it to the cache, otherwise, discard/free it.
  370.  */
  371. if (p != NULL) {
  372. if (ret == 0) {
  373. if ((t_ret =
  374.     mdbp->mpf->put(mdbp->mpf, p, DB_MPOOL_DIRTY)) != 0)
  375. ret = t_ret;
  376. /*
  377.  * Since we cannot close this file until after
  378.  * transaction commit, we need to sync the dirty
  379.  * pages, because we'll read these directly from
  380.  * disk to open.
  381.  */
  382. if ((t_ret = mdbp->sync(mdbp, 0)) != 0 && ret == 0)
  383. ret = t_ret;
  384. } else
  385. (void)mdbp->mpf->put(mdbp->mpf, p, 0);
  386. }
  388. /* Discard the cursor(s) and data. */
  389. if (data.data != NULL)
  390. __os_ufree(dbenv, data.data);
  391. if (dbc != NULL && (t_ret = dbc->c_close(dbc)) != 0 && ret == 0)
  392. ret = t_ret;
  393. if (ndbc != NULL && (t_ret = ndbc->c_close(ndbc)) != 0 && ret == 0)
  394. ret = t_ret;
  396. return (ret);
  397. }
  399. /*
  400.  * __db_dbenv_setup --
  401.  * Set up the underlying environment during a db_open.
  402.  *
  403.  * PUBLIC: int __db_dbenv_setup __P((DB *,
  404.  * PUBLIC:     DB_TXN *, const char *, u_int32_t, u_int32_t));
  405.  */
  406. int
  407. __db_dbenv_setup(dbp, txn, name, id, flags)
  408. DB *dbp;
  409. DB_TXN *txn;
  410. const char *name;
  411. u_int32_t id;
  412. u_int32_t flags;
  413. {
  414. DB *ldbp;
  415. DBT pgcookie;
  416. DB_ENV *dbenv;
  417. DB_MPOOL *dbmp;
  418. DB_MPOOLFILE *mpf;
  419. DB_PGINFO pginfo;
  420. u_int32_t maxid;
  421. int ftype, ret;
  423. dbenv = dbp->dbenv;
  425. /* If we don't yet have an environment, it's time to create it. */
  426. if (!F_ISSET(dbenv, DB_ENV_OPEN_CALLED)) {
  427. /* Make sure we have at least DB_MINCACHE pages in our cache. */
  428. if (dbenv->mp_gbytes == 0 &&
  429.     dbenv->mp_bytes < dbp->pgsize * DB_MINPAGECACHE &&
  430.     (ret = dbenv->set_cachesize(
  431.     dbenv, 0, dbp->pgsize * DB_MINPAGECACHE, 0)) != 0)
  432. return (ret);
  434. if ((ret = dbenv->open(dbenv, NULL, DB_CREATE |
  435.     DB_INIT_MPOOL | DB_PRIVATE | LF_ISSET(DB_THREAD), 0)) != 0)
  436. return (ret);
  437. }
  439. /* Register DB's pgin/pgout functions. */
  440. if ((ret = dbenv->memp_register(
  441.     dbenv, DB_FTYPE_SET, __db_pgin, __db_pgout)) != 0)
  442. return (ret);
  444. /* Create the DB_MPOOLFILE structure. */
  445. if ((ret = dbenv->memp_fcreate(dbenv, &dbp->mpf, 0)) != 0)
  446. return (ret);
  447. mpf = dbp->mpf;
  449. /* Set the database's cache priority if we've been given one. */
  450. if (dbp->priority != 0 &&
  451.     (ret = mpf->set_priority(mpf, dbp->priority)) != 0)
  452. return (ret);
  454. /*
  455.  * Open a backing file in the memory pool.
  456.  *
  457.  * If we need to pre- or post-process a file's pages on I/O, set the
  458.  * file type.  If it's a hash file, always call the pgin and pgout
  459.  * routines.  This means that hash files can never be mapped into
  460.  * process memory.  If it's a btree file and requires swapping, we
  461.  * need to page the file in and out.  This has to be right -- we can't
  462.  * mmap files that are being paged in and out.
  463.  */
  464. switch (dbp->type) {
  465. case DB_BTREE:
  466. case DB_RECNO:
  467. ftype = F_ISSET(dbp, DB_AM_SWAP | DB_AM_ENCRYPT | DB_AM_CHKSUM)
  468.     ? DB_FTYPE_SET : DB_FTYPE_NOTSET;
  469. (void)mpf->set_ftype(mpf, ftype);
  470. (void)mpf->set_clear_len(mpf, (CRYPTO_ON(dbenv) ?
  471.     dbp->pgsize : DB_PAGE_DB_LEN));
  472. break;
  473. case DB_HASH:
  474. (void)mpf->set_ftype(mpf, DB_FTYPE_SET);
  475. (void)mpf->set_clear_len(mpf, (CRYPTO_ON(dbenv) ?
  476.     dbp->pgsize : DB_PAGE_DB_LEN));
  477. break;
  478. case DB_QUEUE:
  479. ftype = F_ISSET(dbp, DB_AM_SWAP | DB_AM_ENCRYPT | DB_AM_CHKSUM)
  480.     ? DB_FTYPE_SET : DB_FTYPE_NOTSET;
  481. (void)mpf->set_ftype(mpf, ftype);
  482. (void)mpf->set_clear_len(mpf, (CRYPTO_ON(dbenv) ?
  483.     dbp->pgsize : DB_PAGE_QUEUE_LEN));
  484. break;
  485. case DB_UNKNOWN:
  486. /*
  487.  * If we're running in the verifier, our database might
  488.  * be corrupt and we might not know its type--but we may
  489.  * still want to be able to verify and salvage.
  490.  *
  491.  * If we can't identify the type, it's not going to be safe
  492.  * to call __db_pgin--we pretty much have to give up all
  493.  * hope of salvaging cross-endianness.  Proceed anyway;
  494.  * at worst, the database will just appear more corrupt
  495.  * than it actually is, but at best, we may be able
  496.  * to salvage some data even with no metadata page.
  497.  */
  498. if (F_ISSET(dbp, DB_AM_VERIFYING)) {
  499. (void)mpf->set_ftype(mpf, DB_FTYPE_NOTSET);
  500. (void)mpf->set_clear_len(mpf, DB_PAGE_DB_LEN);
  501. break;
  502. }
  503. /* FALLTHROUGH */
  504. default:
  505. return (
  506.     __db_unknown_type(dbenv, "__db_dbenv_setup", dbp->type));
  507. }
  509. (void)mpf->set_fileid(mpf, dbp->fileid);
  510. (void)mpf->set_lsn_offset(mpf, 0);
  512. pginfo.db_pagesize = dbp->pgsize;
  513. pginfo.flags =
  514.     F_ISSET(dbp, (DB_AM_CHKSUM | DB_AM_ENCRYPT | DB_AM_SWAP));
  515. pginfo.type = dbp->type;
  516. pgcookie.data = &pginfo;
  517. pgcookie.size = sizeof(DB_PGINFO);
  518. (void)mpf->set_pgcookie(mpf, &pgcookie);
  520. if ((ret = mpf->open(mpf, name,
  521.     LF_ISSET(DB_RDONLY | DB_NOMMAP | DB_ODDFILESIZE | DB_TRUNCATE) |
  522.     (F_ISSET(dbenv, DB_ENV_DIRECT_DB) ? DB_DIRECT : 0),
  523.     0, dbp->pgsize)) != 0)
  524. return (ret);
  526. /*
  527.  * We may need a per-thread mutex.  Allocate it from the mpool
  528.  * region, there's supposed to be extra space there for that purpose.
  529.  */
  530. if (LF_ISSET(DB_THREAD)) {
  531. dbmp = dbenv->mp_handle;
  532. if ((ret = __db_mutex_setup(dbenv, dbmp->reginfo, &dbp->mutexp,
  533.     MUTEX_ALLOC | MUTEX_THREAD)) != 0)
  534. return (ret);
  535. }
  537. /*
  538.  * Set up a bookkeeping entry for this database in the log region,
  539.  * if such a region exists.  Note that even if we're in recovery
  540.  * or a replication client, where we won't log registries, we'll
  541.  * still need an FNAME struct, so LOGGING_ON is the correct macro.
  542.  */
  543. if (LOGGING_ON(dbenv) &&
  544.     (ret = __dbreg_setup(dbp, name, id)) != 0)
  545. return (ret);
  547. /*
  548.  * If we're actively logging and our caller isn't a recovery function
  549.  * that already did so, assign this dbp a log fileid.
  550.  */
  551. if (DBENV_LOGGING(dbenv) && !F_ISSET(dbp, DB_AM_RECOVER) &&
  552. #if !defined(DEBUG_ROP)
  553.     !F_ISSET(dbp, DB_AM_RDONLY) &&
  554. #endif
  555.     (ret = __dbreg_new_id(dbp, txn)) != 0)
  556. return (ret);
  558. /*
  559.  * Insert ourselves into the DB_ENV's dblist.  We allocate a
  560.  * unique ID to each {fileid, meta page number} pair, and to
  561.  * each temporary file (since they all have a zero fileid).
  562.  * This ID gives us something to use to tell which DB handles
  563.  * go with which databases in all the cursor adjustment
  564.  * routines, where we don't want to do a lot of ugly and
  565.  * expensive memcmps.
  566.  */
  567. MUTEX_THREAD_LOCK(dbenv, dbenv->dblist_mutexp);
  568. for (maxid = 0, ldbp = LIST_FIRST(&dbenv->dblist);
  569.     ldbp != NULL; ldbp = LIST_NEXT(dbp, dblistlinks)) {
  570. if (name != NULL &&
  571.     memcmp(ldbp->fileid, dbp->fileid, DB_FILE_ID_LEN) == 0 &&
  572.     ldbp->meta_pgno == dbp->meta_pgno)
  573. break;
  574. if (ldbp->adj_fileid > maxid)
  575. maxid = ldbp->adj_fileid;
  576. }
  578. /*
  579.  * If ldbp is NULL, we didn't find a match, or we weren't
  580.  * really looking because name is NULL.  Assign the dbp an
  581.  * adj_fileid one higher than the largest we found, and
  582.  * insert it at the head of the master dbp list.
  583.  *
  584.  * If ldbp is not NULL, it is a match for our dbp.  Give dbp
  585.  * the same ID that ldbp has, and add it after ldbp so they're
  586.  * together in the list.
  587.  */
  588. if (ldbp == NULL) {
  589. dbp->adj_fileid = maxid + 1;
  590. LIST_INSERT_HEAD(&dbenv->dblist, dbp, dblistlinks);
  591. } else {
  592. dbp->adj_fileid = ldbp->adj_fileid;
  593. LIST_INSERT_AFTER(ldbp, dbp, dblistlinks);
  594. }
  595. MUTEX_THREAD_UNLOCK(dbenv, dbenv->dblist_mutexp);
  597. return (0);
  598. }
  600. /*
  601.  * __db_close --
  602.  * DB destructor.
  603.  *
  604.  * PUBLIC: int __db_close __P((DB *, u_int32_t));
  605.  */
  606. int
  607. __db_close(dbp, flags)
  608. DB *dbp;
  609. u_int32_t flags;
  610. {
  611. DB_ENV *dbenv;
  613. dbenv = dbp->dbenv;
  615. PANIC_CHECK(dbenv);
  617. /* Validate arguments, but as a DB handle destructor, we can't fail. */
  618. if (flags != 0 && flags != DB_NOSYNC)
  619. (void)__db_ferr(dbenv, "DB->close", 0);
  621. return (__db_close_i(dbp, NULL, flags));
  622. }
  624. /*
  625.  * __db_close_i --
  626.  * Internal DB destructor.
  627.  *
  628.  * PUBLIC: int __db_close_i __P((DB *, DB_TXN *, u_int32_t));
  629.  */
  630. int
  631. __db_close_i(dbp, txn, flags)
  632. DB *dbp;
  633. DB_TXN *txn;
  634. u_int32_t flags;
  635. {
  636. DB_ENV *dbenv;
  637. int ret, t_ret;
  639. dbenv = dbp->dbenv;
  640. ret = 0;
  642. /*
  643.  * Validate arguments, but as a DB handle destructor, we can't fail.
  644.  *
  645.  * Check for consistent transaction usage -- ignore errors.  Only
  646.  * internal callers specify transactions, so it's a serious problem
  647.  * if we get error messages.
  648.  */
  649. if (txn != NULL)
  650. (void)__db_check_txn(dbp, txn, DB_LOCK_INVALIDID, 0);
  652. /* Refresh the structure and close any local environment. */
  653. if ((t_ret = __db_refresh(dbp, txn, flags)) != 0 && ret == 0)
  654. ret = t_ret;
  656. /*
  657.  * Call the access specific close function.
  658.  *
  659.  * !!!
  660.  * Because of where these functions are called in the DB handle close
  661.  * process, these routines can't do anything that would dirty pages or
  662.  * otherwise affect closing down the database.  Specifically, we can't
  663.  * abort and recover any of the information they control.
  664.  */
  665. if ((t_ret = __ham_db_close(dbp)) != 0 && ret == 0)
  666. ret = t_ret;
  667. if ((t_ret = __bam_db_close(dbp)) != 0 && ret == 0)
  668. ret = t_ret;
  669. if ((t_ret = __qam_db_close(dbp)) != 0 && ret == 0)
  670. ret = t_ret;
  672. --dbenv->db_ref;
  673. if (F_ISSET(dbenv, DB_ENV_DBLOCAL) && dbenv->db_ref == 0 &&
  674.     (t_ret = dbenv->close(dbenv, 0)) != 0 && ret == 0)
  675. ret = t_ret;
  677. /* Free the database handle. */
  678. memset(dbp, CLEAR_BYTE, sizeof(*dbp));
  679. __os_free(dbenv, dbp);
  681. return (ret);
  682. }
  684. /*
  685.  * __db_refresh --
  686.  * Refresh the DB structure, releasing any allocated resources.
  687.  * This does most of the work of closing files now because refresh
  688.  * is what is used during abort processing (since we can't destroy
  689.  * the actual handle) and during abort processing, we may have a
  690.  * fully opened handle.
  691.  *
  692.  * PUBLIC: int __db_refresh __P((DB *, DB_TXN *, u_int32_t));
  693.  */
  694. int
  695. __db_refresh(dbp, txn, flags)
  696. DB *dbp;
  697. DB_TXN *txn;
  698. u_int32_t flags;
  699. {
  700. DB *sdbp;
  701. DBC *dbc;
  702. DB_ENV *dbenv;
  703. DB_LOCKREQ lreq;
  704. DB_MPOOL *dbmp;
  705. int ret, t_ret;
  707. ret = 0;
  709. dbenv = dbp->dbenv;
  711. /* If never opened, or not currently open, it's easy. */
  712. if (!F_ISSET(dbp, DB_AM_OPEN_CALLED))
  713. goto never_opened;
  715. /*
  716.  * If we have any secondary indices, disassociate them from us.
  717.  * We don't bother with the mutex here;  it only protects some
  718.  * of the ops that will make us core-dump mid-close anyway, and
  719.  * if you're trying to do something with a secondary *while* you're
  720.  * closing the primary, you deserve what you get.  The disassociation
  721.  * is mostly done just so we can close primaries and secondaries in
  722.  * any order--but within one thread of control.
  723.  */
  724. for (sdbp = LIST_FIRST(&dbp->s_secondaries);
  725.     sdbp != NULL; sdbp = LIST_NEXT(sdbp, s_links)) {
  726. LIST_REMOVE(sdbp, s_links);
  727. if ((t_ret = __db_disassociate(sdbp)) != 0 && ret == 0)
  728. ret = t_ret;
  729. }
  731. /*
  732.  * Sync the underlying access method.  Do before closing the cursors
  733.  * because DB->sync allocates cursors in order to write Recno backing
  734.  * source text files.
  735.  */
  736. if (!LF_ISSET(DB_NOSYNC) && !F_ISSET(dbp, DB_AM_DISCARD) &&
  737.     (t_ret = dbp->sync(dbp, 0)) != 0 && ret == 0)
  738. ret = t_ret;
  740. /*
  741.  * Go through the active cursors and call the cursor recycle routine,
  742.  * which resolves pending operations and moves the cursors onto the
  743.  * free list.  Then, walk the free list and call the cursor destroy
  744.  * routine.  Note that any failure on a close is considered "really
  745.  * bad" and we just break out of the loop and force forward.
  746.  */
  747. while ((dbc = TAILQ_FIRST(&dbp->active_queue)) != NULL)
  748. if ((t_ret = dbc->c_close(dbc)) != 0) {
  749. if (ret == 0)
  750. ret = t_ret;
  751. break;
  752. }
  754. while ((dbc = TAILQ_FIRST(&dbp->free_queue)) != NULL)
  755. if ((t_ret = __db_c_destroy(dbc)) != 0) {
  756. if (ret == 0)
  757. ret = t_ret;
  758. break;
  759. }
  761. /*
  762.  * Close any outstanding join cursors.  Join cursors destroy
  763.  * themselves on close and have no separate destroy routine.
  764.  */
  765. while ((dbc = TAILQ_FIRST(&dbp->join_queue)) != NULL)
  766. if ((t_ret = dbc->c_close(dbc)) != 0) {
  767. if (ret == 0)
  768. ret = t_ret;
  769. break;
  770. }
  772. /*
  773.  * Sync the memory pool, even though we've already called DB->sync,
  774.  * because closing cursors can dirty pages by deleting items they
  775.  * referenced.
  776.  */
  777. if (!LF_ISSET(DB_NOSYNC) && !F_ISSET(dbp, DB_AM_DISCARD) &&
  778.     (t_ret = dbp->mpf->sync(dbp->mpf)) != 0 && ret == 0)
  779. ret = t_ret;
  781. /* Close any handle we've been holding since the open.  */
  782. if (dbp->saved_open_fhp != NULL &&
  783.     F_ISSET(dbp->saved_open_fhp, DB_FH_VALID) &&
  784.     (t_ret = __os_closehandle(dbenv, dbp->saved_open_fhp)) != 0 &&
  785.     ret == 0)
  786. ret = t_ret;
  788. never_opened:
  789. /*
  790.  * We are not releasing the handle lock here because we're about
  791.  * to release all locks held by dbp->lid below.  There are two
  792.  * ways that we can get in here with a handle_lock, but not a
  793.  * dbp->lid.  The first is when our lid has been hijacked by a
  794.  * subdb.  The second is when we are a Queue database in the midst
  795.  * of a rename.  If the queue file hasn't actually been opened, we
  796.  * hijack the main dbp's locker id to do the open so we can get the
  797.  * extent files.  In both cases, we needn't free the handle lock
  798.  * because it will be freed when the hijacked locker-id is freed.
  799.  */
  800. DB_ASSERT(!LOCK_ISSET(dbp->handle_lock) ||
  801.     dbp->lid != DB_LOCK_INVALIDID ||
  802.     dbp->type == DB_QUEUE ||
  803.     F_ISSET(dbp, DB_AM_SUBDB));
  805. if (dbp->lid != DB_LOCK_INVALIDID) {
  806. /* We may have pending trade operations on this dbp. */
  807. if (txn != NULL)
  808. __txn_remlock(dbenv, txn, &dbp->handle_lock, dbp->lid);
  810. /* We may be holding the handle lock; release it. */
  811. lreq.op = DB_LOCK_PUT_ALL;
  812. if ((t_ret = __lock_vec(dbenv,
  813.     dbp->lid, 0, &lreq, 1, NULL)) != 0 && ret == 0)
  814. ret = t_ret;
  816. if ((t_ret =
  817.     dbenv->lock_id_free(dbenv, dbp->lid)) != 0 && ret == 0)
  818. ret = t_ret;
  819. dbp->lid = DB_LOCK_INVALIDID;
  820. LOCK_INIT(dbp->handle_lock);
  821. }
  823. /* Discard the locker ID allocated as the fileid. */
  824. if (F_ISSET(dbp, DB_AM_INMEM) &&
  825.     LOCKING_ON(dbenv) && (t_ret = dbenv->lock_id_free(
  826.     dbenv, *(u_int32_t *)dbp->fileid)) != 0 && ret == 0)
  827. ret = t_ret;
  829. dbp->type = DB_UNKNOWN;
  831. /* Discard the thread mutex. */
  832. if (dbp->mutexp != NULL) {
  833. dbmp = dbenv->mp_handle;
  834. __db_mutex_free(dbenv, dbmp->reginfo, dbp->mutexp);
  835. dbp->mutexp = NULL;
  836. }
  838. /* Discard any memory used to store returned data. */
  839. if (dbp->my_rskey.data != NULL)
  840. __os_free(dbp->dbenv, dbp->my_rskey.data);
  841. if (dbp->my_rkey.data != NULL)
  842. __os_free(dbp->dbenv, dbp->my_rkey.data);
  843. if (dbp->my_rdata.data != NULL)
  844. __os_free(dbp->dbenv, dbp->my_rdata.data);
  846. /* For safety's sake;  we may refresh twice. */
  847. memset(&dbp->my_rskey, 0, sizeof(DBT));
  848. memset(&dbp->my_rkey, 0, sizeof(DBT));
  849. memset(&dbp->my_rdata, 0, sizeof(DBT));
  851. /*
  852.  * Remove this DB handle from the DB_ENV's dblist, if it's been added.
  853.  */
  854. MUTEX_THREAD_LOCK(dbenv, dbenv->dblist_mutexp);
  855. if (dbp->dblistlinks.le_prev != NULL)
  856. LIST_REMOVE(dbp, dblistlinks);
  857. MUTEX_THREAD_UNLOCK(dbenv, dbenv->dblist_mutexp);
  858. dbp->dblistlinks.le_prev = NULL;
  860. /* Close the memory pool file handle. */
  861. if (dbp->mpf != NULL) {
  862. if ((t_ret = dbp->mpf->close(dbp->mpf,
  863.     F_ISSET(dbp, DB_AM_DISCARD) ? DB_MPOOL_DISCARD : 0)) != 0 &&
  864.     ret == 0)
  865. ret = t_ret;
  866. dbp->mpf = NULL;
  867. }
  869. if (LOGGING_ON(dbp->dbenv)) {
  870. /*
  871.  * Discard the log file id, if any.  We want to log the close
  872.  * if and only if this is not a recovery dbp.
  873.  */
  874. if (F_ISSET(dbp, DB_AM_RECOVER))
  875. (void)__dbreg_revoke_id(dbp, 0);
  876. else
  877. (void)__dbreg_close_id(dbp, txn);
  879. /* Discard the log FNAME. */
  880. (void)__dbreg_teardown(dbp);
  881. }
  883. /* Clear out fields that normally get set during open. */
  884. memset(dbp->fileid, 0, sizeof(dbp->fileid));
  885. dbp->adj_fileid = 0;
  886. dbp->meta_pgno = 0;
  887. dbp->cur_lid = DB_LOCK_INVALIDID;
  888. dbp->associate_lid = DB_LOCK_INVALIDID;
  889. dbp->cl_id = 0;
  891. /*
  892.  * If we are being refreshed with a txn specified, then we need
  893.  * to make sure that we clear out the lock handle field, because
  894.  * releasing all the locks for this transaction will release this
  895.  * lock and we don't want close to stumble upon this handle and
  896.  * try to close it.
  897.  */
  898. if (txn != NULL)
  899. LOCK_INIT(dbp->handle_lock);
  901. F_CLR(dbp, DB_AM_DBM_ERROR);
  902. F_CLR(dbp, DB_AM_DISCARD);
  903. F_CLR(dbp, DB_AM_INMEM);
  904. F_CLR(dbp, DB_AM_RECOVER);
  905. F_CLR(dbp, DB_AM_OPEN_CALLED);
  906. F_CLR(dbp, DB_AM_RDONLY);
  907. F_CLR(dbp, DB_AM_SWAP);
  909. return (ret);
  910. }
  912. /*
  913.  * __db_log_page
  914.  * Log a meta-data or root page during a subdatabase create operation.
  915.  *
  916.  * PUBLIC: int __db_log_page __P((DB *, DB_TXN *, DB_LSN *, db_pgno_t, PAGE *));
  917.  */
  918. int
  919. __db_log_page(dbp, txn, lsn, pgno, page)
  920. DB *dbp;
  921. DB_TXN *txn;
  922. DB_LSN *lsn;
  923. db_pgno_t pgno;
  924. PAGE *page;
  925. {
  926. DBT page_dbt;
  927. DB_LSN new_lsn;
  928. int ret;
  930. if (!LOGGING_ON(dbp->dbenv) || txn == NULL)
  931. return (0);
  933. memset(&page_dbt, 0, sizeof(page_dbt));
  934. page_dbt.size = dbp->pgsize;
  935. page_dbt.data = page;
  937. ret = __crdel_metasub_log(dbp, txn, &new_lsn, 0, pgno, &page_dbt, lsn);
  939. if (ret == 0)
  940. page->lsn = new_lsn;
  941. return (ret);
  942. }
  944. /*
  945.  * __db_backup_name
  946.  * Create the backup file name for a given file.
  947.  *
  948.  * PUBLIC: int __db_backup_name __P((DB_ENV *,
  949.  * PUBLIC:     const char *, DB_TXN *, char **));
  950.  */
  951. #undef BACKUP_PREFIX
  952. #define BACKUP_PREFIX "__db."
  954. #undef MAX_LSN_TO_TEXT
  955. #define MAX_LSN_TO_TEXT 17
  957. int
  958. __db_backup_name(dbenv, name, txn, backup)
  959. DB_ENV *dbenv;
  960. const char *name;
  961. DB_TXN *txn;
  962. char **backup;
  963. {
  964. DB_LSN lsn;
  965. size_t len;
  966. int plen, ret;
  967. char *p, *retp;
  969. /*
  970.  * Create the name.  Backup file names are in one of two forms:
  971.  *
  972.  * In a transactional env: __db.LSN(8).LSN(8)
  973.  * and
  974.  * in a non-transactional env: __db.FILENAME.
  975.  *
  976.  * If the transaction doesn't have a current LSN, we write
  977.  * a dummy log record to force it, so that we ensure that
  978.  * all tmp names are unique.
  979.  *
  980.  * In addition, the name passed may contain an env-relative path.
  981.  * In that case, put the __db. in the right place (in the last
  982.  * component of the pathname).
  983.  */
  984. if (txn != NULL) {
  985. if (IS_ZERO_LSN(txn->last_lsn)) {
  986. /*
  987.  * Write dummy log record.   The two choices for
  988.  * dummy log records are __db_noop_log and
  989.  * __db_debug_log; unfortunately __db_noop_log requires
  990.  * a valid dbp, and we aren't guaranteed to be able
  991.  * to pass one in here.
  992.  */
  993. if ((ret = __db_debug_log(dbenv, txn, &lsn, 0,
  994.     NULL, 0, NULL, NULL, 0)) != 0)
  995. return (ret);
  996. } else
  997. lsn = txn->last_lsn;
  998. }
  1000. /*
  1001.  * Part of the name may be a full path, so we need to make sure that
  1002.  * we allocate enough space for it, even in the case where we don't
  1003.  * use the entire filename for the backup name.
  1004.  */
  1005. len = strlen(name) + strlen(BACKUP_PREFIX) + MAX_LSN_TO_TEXT;
  1006.     
  1007. if ((ret = __os_malloc(dbenv, len, &retp)) != 0)
  1008. return (ret);
  1010. /*
  1011.  * There are four cases here:
  1012.  * 1. simple path w/out transaction
  1013.  * 2. simple path + transaction
  1014.  * 3. multi-component path w/out transaction
  1015.  * 4. multi-component path + transaction
  1016.  */
  1017. if ((p = __db_rpath(name)) == NULL) {
  1018. if (txn == NULL) /* case 1 */
  1019. snprintf(retp, len, "%s%s.", BACKUP_PREFIX, name);
  1020. else /* case 2 */
  1021. snprintf(retp, len,
  1022.     "%s%x.%x", BACKUP_PREFIX, lsn.file, lsn.offset);
  1023. } else {
  1024. plen = (int)(p - name) + 1;
  1025. p++;
  1026. if (txn == NULL) /* case 3 */
  1027. snprintf(retp, len,
  1028.     "%.*s%s%s.", plen, name, BACKUP_PREFIX, p);
  1029. else  /* case 4 */
  1030. snprintf(retp, len,
  1031.     "%.*s%x.%x.", plen, name, lsn.file, lsn.offset);
  1032. }
  1034. *backup = retp;
  1035. return (0);
  1036. }
  1038. /*
  1039.  * __dblist_get --
  1040.  * Get the first element of dbenv->dblist with
  1041.  * dbp->adj_fileid matching adjid.
  1042.  *
  1043.  * PUBLIC: DB *__dblist_get __P((DB_ENV *, u_int32_t));
  1044.  */
  1045. DB *
  1046. __dblist_get(dbenv, adjid)
  1047. DB_ENV *dbenv;
  1048. u_int32_t adjid;
  1049. {
  1050. DB *dbp;
  1052. for (dbp = LIST_FIRST(&dbenv->dblist);
  1053.     dbp != NULL && dbp->adj_fileid != adjid;
  1054.     dbp = LIST_NEXT(dbp, dblistlinks))
  1055. ;
  1057. return (dbp);
  1058. }
  1060. /*
  1061.  * __db_disassociate --
  1062.  * Destroy the association between a given secondary and its primary.
  1063.  */
  1064. static int
  1065. __db_disassociate(sdbp)
  1066. DB *sdbp;
  1067. {
  1068. DBC *dbc;
  1069. int ret, t_ret;
  1071. ret = 0;
  1073. sdbp->s_callback = NULL;
  1074. sdbp->s_primary = NULL;
  1075. sdbp->get = sdbp->stored_get;
  1076. sdbp->close = sdbp->stored_close;
  1078. /*
  1079.  * Complain, but proceed, if we have any active cursors.  (We're in
  1080.  * the middle of a close, so there's really no turning back.)
  1081.  */
  1082. if (sdbp->s_refcnt != 1 ||
  1083.     TAILQ_FIRST(&sdbp->active_queue) != NULL ||
  1084.     TAILQ_FIRST(&sdbp->join_queue) != NULL) {
  1085. __db_err(sdbp->dbenv,
  1086.     "Closing a primary DB while a secondary DB has active cursors is unsafe");
  1087. ret = EINVAL;
  1088. }
  1089. sdbp->s_refcnt = 0;
  1091. while ((dbc = TAILQ_FIRST(&sdbp->free_queue)) != NULL)
  1092. if ((t_ret = __db_c_destroy(dbc)) != 0 && ret == 0)
  1093. ret = t_ret;
  1095. F_CLR(sdbp, DB_AM_SECONDARY);
  1096. return (ret);
  1097. }
  1099. #if CONFIG_TEST
  1100. /*
  1101.  * __db_testcopy
  1102.  * Create a copy of all backup files and our "main" DB.
  1103.  *
  1104.  * PUBLIC: #if CONFIG_TEST
  1105.  * PUBLIC: int __db_testcopy __P((DB_ENV *, DB *, const char *));
  1106.  * PUBLIC: #endif
  1107.  */
  1108. int
  1109. __db_testcopy(dbenv, dbp, name)
  1110. DB_ENV *dbenv;
  1111. DB *dbp;
  1112. const char *name;
  1113. {
  1114. DB_MPOOLFILE *mpf;
  1116. DB_ASSERT(dbp != NULL || name != NULL);
  1118. if (name == NULL) {
  1119. mpf = dbp->mpf;
  1120. name = R_ADDR(mpf->dbmp->reginfo, mpf->mfp->path_off);
  1121. }
  1123. if (dbp != NULL && dbp->type == DB_QUEUE)
  1124. return (__qam_testdocopy(dbp, name));
  1125. else
  1126. return (__db_testdocopy(dbenv, name));
  1127. }
  1129. static int
  1130. __qam_testdocopy(dbp, name)
  1131. DB *dbp;
  1132. const char *name;
  1133. {
  1134. QUEUE_FILELIST *filelist, *fp;
  1135. char buf[256], *dir;
  1136. int ret;
  1138. filelist = NULL;
  1139. if ((ret = __db_testdocopy(dbp->dbenv, name)) != 0)
  1140. return (ret);
  1141. if (dbp->mpf != NULL &&
  1142.     (ret = __qam_gen_filelist(dbp, &filelist)) != 0)
  1143. return (ret);
  1145. if (filelist == NULL)
  1146. return (0);
  1147. dir = ((QUEUE *)dbp->q_internal)->dir;
  1148. for (fp = filelist; fp->mpf != NULL; fp++) {
  1149. snprintf(buf, sizeof(buf),
  1150.     QUEUE_EXTENT, dir, PATH_SEPARATOR[0], name, fp->id);
  1151. if ((ret = __db_testdocopy(dbp->dbenv, buf)) != 0)
  1152. return (ret);
  1153. }
  1155. __os_free(dbp->dbenv, filelist);
  1156. return (0);
  1157. }
  1159. /*
  1160.  * __db_testdocopy
  1161.  * Create a copy of all backup files and our "main" DB.
  1162.  *
  1163.  */
  1164. static int
  1165. __db_testdocopy(dbenv, name)
  1166. DB_ENV *dbenv;
  1167. const char *name;
  1168. {
  1169. size_t len;
  1170. int dircnt, i, ret;
  1171. char **namesp, *backup, *copy, *dir, *p, *real_name;
  1172. real_name = NULL;
  1173. /* Get the real backing file name. */
  1174. if ((ret = __db_appname(dbenv,
  1175.     DB_APP_DATA, name, 0, NULL, &real_name)) != 0)
  1176. return (ret);
  1178. copy = backup = NULL;
  1179. namesp = NULL;
  1181. /*
  1182.  * Maximum size of file, including adding a ".afterop".
  1183.  */
  1184. len = strlen(real_name) + strlen(BACKUP_PREFIX) + MAX_LSN_TO_TEXT + 9;
  1186. if ((ret = __os_malloc(dbenv, len, &copy)) != 0)
  1187. goto out;
  1189. if ((ret = __os_malloc(dbenv, len, &backup)) != 0)
  1190. goto out;
  1192. /*
  1193.  * First copy the file itself.
  1194.  */
  1195. snprintf(copy, len, "%s.afterop", real_name);
  1196. __db_makecopy(real_name, copy);
  1198. if ((ret = __os_strdup(dbenv, real_name, &dir)) != 0)
  1199. goto out;
  1200. __os_free(dbenv, real_name);
  1201. real_name = NULL;
  1202. /*
  1203.  * Create the name.  Backup file names are of the form:
  1204.  *
  1205.  * __db.name.0x[lsn-file].0x[lsn-offset]
  1206.  *
  1207.  * which guarantees uniqueness.  We want to look for the
  1208.  * backup name, followed by a '.0x' (so that if they have
  1209.  * files named, say, 'a' and 'abc' we won't match 'abc' when
  1210.  * looking for 'a'.
  1211.  */
  1212. snprintf(backup, len, "%s%s.0x", BACKUP_PREFIX, name);
  1214. /*
  1215.  * We need the directory path to do the __os_dirlist.
  1216.  */
  1217. p = __db_rpath(dir);
  1218. if (p != NULL)
  1219. *p = '';
  1220. ret = __os_dirlist(dbenv, dir, &namesp, &dircnt);
  1221. #if DIAGNOSTIC
  1222. /*
  1223.  * XXX
  1224.  * To get the memory guard code to work because it uses strlen and we
  1225.  * just moved the end of the string somewhere sooner.  This causes the
  1226.  * guard code to fail because it looks at one byte past the end of the
  1227.  * string.
  1228.  */
  1229. *p = '/';
  1230. #endif
  1231. __os_free(dbenv, dir);
  1232. if (ret != 0)
  1233. goto out;
  1234. for (i = 0; i < dircnt; i++) {
  1235. /*
  1236.  * Need to check if it is a backup file for this.
  1237.  * No idea what namesp[i] may be or how long, so
  1238.  * must use strncmp and not memcmp.  We don't want
  1239.  * to use strcmp either because we are only matching
  1240.  * the first part of the real file's name.  We don't
  1241.  * know its LSN's.
  1242.  */
  1243. if (strncmp(namesp[i], backup, strlen(backup)) == 0) {
  1244. if ((ret = __db_appname(dbenv, DB_APP_DATA,
  1245.     namesp[i], 0, NULL, &real_name)) != 0)
  1246. goto out;
  1248. /*
  1249.  * This should not happen.  Check that old
  1250.  * .afterop files aren't around.
  1251.  * If so, just move on.
  1252.  */
  1253. if (strstr(real_name, ".afterop") != NULL) {
  1254. __os_free(dbenv, real_name);
  1255. real_name = NULL;
  1256. continue;
  1257. }
  1258. snprintf(copy, len, "%s.afterop", real_name);
  1259. __db_makecopy(real_name, copy);
  1260. __os_free(dbenv, real_name);
  1261. real_name = NULL;
  1262. }
  1263. }
  1264. out:
  1265. if (backup != NULL)
  1266. __os_free(dbenv, backup);
  1267. if (copy != NULL)
  1268. __os_free(dbenv, copy);
  1269. if (namesp != NULL)
  1270. __os_dirfree(dbenv, namesp, dircnt);
  1271. if (real_name != NULL)
  1272. __os_free(dbenv, real_name);
  1273. return (ret);
  1274. }
  1276. static void
  1277. __db_makecopy(src, dest)
  1278. const char *src, *dest;
  1279. {
  1280. DB_FH rfh, wfh;
  1281. size_t rcnt, wcnt;
  1282. char *buf;
  1284. memset(&rfh, 0, sizeof(rfh));
  1285. memset(&wfh, 0, sizeof(wfh));
  1287. if (__os_malloc(NULL, 1024, &buf) != 0)
  1288. return;
  1290. if (__os_open(NULL,
  1291.     src, DB_OSO_RDONLY, __db_omode("rw----"), &rfh) != 0)
  1292. goto err;
  1293. if (__os_open(NULL, dest,
  1294.     DB_OSO_CREATE | DB_OSO_TRUNC, __db_omode("rw----"), &wfh) != 0)
  1295. goto err;
  1297. for (;;)
  1298. if (__os_read(NULL, &rfh, buf, 1024, &rcnt) < 0 || rcnt == 0 ||
  1299.     __os_write(NULL, &wfh, buf, rcnt, &wcnt) < 0)
  1300. break;
  1302. err: __os_free(NULL, buf);
  1303. if (F_ISSET(&rfh, DB_FH_VALID))
  1304. __os_closehandle(NULL, &rfh);
  1305. if (F_ISSET(&wfh, DB_FH_VALID))
  1306. __os_closehandle(NULL, &wfh);
  1307. }
  1308. #endif