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

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

MySQL数据库

开发平台：

Visual C++

mp_fopen.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. #include "db_config.h"
  9. #ifndef lint
  10. static const char revid[] = "$Id: mp_fopen.c,v 11.41 2001/01/10 04:50:53 ubell Exp $";
  11. #endif /* not lint */
  13. #ifndef NO_SYSTEM_INCLUDES
  14. #include <sys/types.h>
  16. #include <string.h>
  17. #endif
  19. #ifdef  HAVE_RPC
  20. #include "db_server.h"
  21. #endif
  23. #include "db_int.h"
  24. #include "db_shash.h"
  25. #include "mp.h"
  27. #ifdef HAVE_RPC
  28. #include "gen_client_ext.h"
  29. #include "rpc_client_ext.h"
  30. #endif
  32. static int __memp_mf_open __P((DB_MPOOL *, const char *,
  33.     size_t, db_pgno_t, DB_MPOOL_FINFO *, u_int32_t, MPOOLFILE **));
  35. /*
  36.  * MEMP_FREMOVE --
  37.  * Discard an MPOOLFILE and any buffers it references: update the flags
  38.  * so we never try to write buffers associated with the file, nor can we
  39.  * find it when looking for files to join.  In addition, clear the ftype
  40.  * field, there's no reason to post-process pages, they can be discarded
  41.  * by any thread.
  42.  */
  43. #define MEMP_FREMOVE(mfp) {
  44. mfp->ftype = 0;
  45. F_SET(mfp, MP_DEADFILE);
  46. }
  48. /*
  49.  * memp_fopen --
  50.  * Open a backing file for the memory pool.
  51.  */
  52. int
  53. memp_fopen(dbenv, path, flags, mode, pagesize, finfop, retp)
  54. DB_ENV *dbenv;
  55. const char *path;
  56. u_int32_t flags;
  57. int mode;
  58. size_t pagesize;
  59. DB_MPOOL_FINFO *finfop;
  60. DB_MPOOLFILE **retp;
  61. {
  62. DB_MPOOL *dbmp;
  63. int ret;
  65. #ifdef HAVE_RPC
  66. if (F_ISSET(dbenv, DB_ENV_RPCCLIENT))
  67. return (__dbcl_memp_fopen(dbenv, path, flags,
  68.     mode, pagesize, finfop, retp));
  69. #endif
  71. PANIC_CHECK(dbenv);
  72. ENV_REQUIRES_CONFIG(dbenv, dbenv->mp_handle, DB_INIT_MPOOL);
  74. dbmp = dbenv->mp_handle;
  76. /* Validate arguments. */
  77. if ((ret = __db_fchk(dbenv, "memp_fopen", flags,
  78.     DB_CREATE |
  79.     DB_NOMMAP | DB_ODDFILESIZE | DB_RDONLY | DB_TRUNCATE)) != 0)
  80. return (ret);
  82. /* Require a non-zero pagesize. */
  83. if (pagesize == 0 ||
  84.     (finfop != NULL && finfop->clear_len > pagesize)) {
  85. __db_err(dbenv, "memp_fopen: illegal page size.");
  86. return (EINVAL);
  87. }
  89. return (__memp_fopen(dbmp,
  90.     NULL, path, flags, mode, pagesize, 1, finfop, retp));
  91. }
  93. /*
  94.  * __memp_set_unlink -- set unlink on last close flag.
  95.  *
  96.  * PUBLIC: void __memp_set_unlink __P((DB_MPOOLFILE *));
  97.  */
  98. void
  99. __memp_set_unlink(dbmpf)
  100. DB_MPOOLFILE *dbmpf;
  101. {
  102. DB_MPOOL *dbmp;
  103. dbmp = dbmpf->dbmp;
  105. R_LOCK(dbmp->dbenv, dbmp->reginfo);
  106. F_SET(dbmpf->mfp, MP_UNLINK);
  107. R_UNLOCK(dbmp->dbenv, dbmp->reginfo);
  108. }
  110. /*
  111.  * __memp_clear_unlink -- clear unlink on last close flag.
  112.  *
  113.  * PUBLIC: void __memp_clear_unlink __P((DB_MPOOLFILE *));
  114.  */
  115. void
  116. __memp_clear_unlink(dbmpf)
  117. DB_MPOOLFILE *dbmpf;
  118. {
  119. DB_MPOOL *dbmp;
  120. dbmp = dbmpf->dbmp;
  122. /*
  123.  * This bit is protected in the queue code because the metapage
  124.  * is locked so we can avoid geting the region lock.
  125.  * If this gets used from other than the queue code, we cannot.
  126.  */
  127. if (!F_ISSET(dbmpf->mfp, MP_UNLINK))
  128. return;
  129. R_LOCK(dbmp->dbenv, dbmp->reginfo);
  130. F_CLR(dbmpf->mfp, MP_UNLINK);
  131. R_UNLOCK(dbmp->dbenv, dbmp->reginfo);
  132. }
  134. /*
  135.  * __memp_fopen --
  136.  * Open a backing file for the memory pool; internal version.
  137.  *
  138.  * PUBLIC: int __memp_fopen __P((DB_MPOOL *, MPOOLFILE *, const char *,
  139.  * PUBLIC:    u_int32_t, int, size_t, int, DB_MPOOL_FINFO *, DB_MPOOLFILE **));
  140.  */
  141. int
  142. __memp_fopen(dbmp, mfp, path, flags, mode, pagesize, needlock, finfop, retp)
  143. DB_MPOOL *dbmp;
  144. MPOOLFILE *mfp;
  145. const char *path;
  146. u_int32_t flags;
  147. int mode, needlock;
  148. size_t pagesize;
  149. DB_MPOOL_FINFO *finfop;
  150. DB_MPOOLFILE **retp;
  151. {
  152. DB_ENV *dbenv;
  153. DB_MPOOLFILE *dbmfp;
  154. DB_MPOOL_FINFO finfo;
  155. db_pgno_t last_pgno;
  156. size_t maxmap;
  157. u_int32_t mbytes, bytes, oflags;
  158. int ret;
  159. u_int8_t idbuf[DB_FILE_ID_LEN];
  160. char *rpath;
  162. dbenv = dbmp->dbenv;
  163. ret = 0;
  164. rpath = NULL;
  166. /*
  167.  * If mfp is provided, we take the DB_MPOOL_FINFO information from
  168.  * the mfp.  We don't bother initializing everything, because some
  169.  * of them are expensive to acquire.  If no mfp is provided and the
  170.  * finfop argument is NULL, we default the values.
  171.  */
  172. if (finfop == NULL) {
  173. memset(&finfo, 0, sizeof(finfo));
  174. if (mfp != NULL) {
  175. finfo.ftype = mfp->ftype;
  176. finfo.pgcookie = NULL;
  177. finfo.fileid = NULL;
  178. finfo.lsn_offset = mfp->lsn_off;
  179. finfo.clear_len = mfp->clear_len;
  180. } else {
  181. finfo.ftype = 0;
  182. finfo.pgcookie = NULL;
  183. finfo.fileid = NULL;
  184. finfo.lsn_offset = -1;
  185. finfo.clear_len = 0;
  186. }
  187. finfop = &finfo;
  188. }
  190. /* Allocate and initialize the per-process structure. */
  191. if ((ret = __os_calloc(dbenv, 1, sizeof(DB_MPOOLFILE), &dbmfp)) != 0)
  192. return (ret);
  193. dbmfp->dbmp = dbmp;
  194. dbmfp->ref = 1;
  195. if (LF_ISSET(DB_RDONLY))
  196. F_SET(dbmfp, MP_READONLY);
  198. if (path == NULL) {
  199. if (LF_ISSET(DB_RDONLY)) {
  200. __db_err(dbenv,
  201.     "memp_fopen: temporary files can't be readonly");
  202. ret = EINVAL;
  203. goto err;
  204. }
  205. last_pgno = 0;
  206. } else {
  207. /* Get the real name for this file and open it. */
  208. if ((ret = __db_appname(dbenv,
  209.     DB_APP_DATA, NULL, path, 0, NULL, &rpath)) != 0)
  210. goto err;
  211. oflags = 0;
  212. if (LF_ISSET(DB_CREATE))
  213. oflags |= DB_OSO_CREATE;
  214. if (LF_ISSET(DB_RDONLY))
  215. oflags |= DB_OSO_RDONLY;
  216. if ((ret =
  217.    __os_open(dbenv, rpath, oflags, mode, &dbmfp->fh)) != 0) {
  218. if (!LF_ISSET(DB_EXTENT))
  219. __db_err(dbenv,
  220.     "%s: %s", rpath, db_strerror(ret));
  221. goto err;
  222. }
  224. /*
  225.  * Don't permit files that aren't a multiple of the pagesize,
  226.  * and find the number of the last page in the file, all the
  227.  * time being careful not to overflow 32 bits.
  228.  *
  229.  * !!!
  230.  * We can't use off_t's here, or in any code in the mainline
  231.  * library for that matter.  (We have to use them in the os
  232.  * stubs, of course, as there are system calls that take them
  233.  * as arguments.)  The reason is that some customers build in
  234.  * environments where an off_t is 32-bits, but still run where
  235.  * offsets are 64-bits, and they pay us a lot of money.
  236.  */
  237. if ((ret = __os_ioinfo(dbenv, rpath,
  238.     &dbmfp->fh, &mbytes, &bytes, NULL)) != 0) {
  239. __db_err(dbenv, "%s: %s", rpath, db_strerror(ret));
  240. goto err;
  241. }
  243. /*
  244.  * If we're doing a verify, we might have to cope with
  245.  * a truncated file;  if the file size is not a multiple
  246.  * of the page size, round down to a page--we'll
  247.  * take care of the partial page outside the memp system.
  248.  */
  250. /* Page sizes have to be a power-of-two, ignore mbytes. */
  251. if (bytes % pagesize != 0) {
  252. if (LF_ISSET(DB_ODDFILESIZE))
  253. /*
  254.  * If we're doing a verify, we might
  255.  * have to cope with a truncated file;
  256.  * round down, we'll worry about the partial
  257.  * page outside the memp system.
  258.  */
  259. bytes -= (bytes % pagesize);
  260. else {
  261. __db_err(dbenv,
  262. "%s: file size not a multiple of the pagesize",
  263.     rpath);
  264. ret = EINVAL;
  265. goto err;
  266. }
  267. }
  269. last_pgno = mbytes * (MEGABYTE / pagesize);
  270. last_pgno += bytes / pagesize;
  272. /* Correction: page numbers are zero-based, not 1-based. */
  273. if (last_pgno != 0)
  274. --last_pgno;
  276. /*
  277.  * Get the file id if we weren't given one.  Generated file id's
  278.  * don't use timestamps, otherwise there'd be no chance of any
  279.  * other process joining the party.
  280.  */
  281. if (finfop->fileid == NULL) {
  282. if ((ret = __os_fileid(dbenv, rpath, 0, idbuf)) != 0)
  283. goto err;
  284. finfop->fileid = idbuf;
  285. }
  286. }
  288. /*
  289.  * If we weren't provided an underlying shared object to join with,
  290.  * find/allocate the shared file objects.  Also allocate space for
  291.  * for the per-process thread lock.
  292.  */
  293. if (needlock)
  294. R_LOCK(dbenv, dbmp->reginfo);
  295. if (mfp == NULL)
  296. ret = __memp_mf_open(
  297.     dbmp, path, pagesize, last_pgno, finfop, flags, &mfp);
  298. else {
  299. ++mfp->mpf_cnt;
  300. ret = 0;
  301. }
  302. if (needlock)
  303. R_UNLOCK(dbenv, dbmp->reginfo);
  304. if (ret != 0)
  305. goto err;
  307. if (F_ISSET(dbenv, DB_ENV_THREAD)) {
  308. if ((ret = __db_mutex_alloc(
  309.     dbenv, dbmp->reginfo, &dbmfp->mutexp)) != 0)
  310. goto err;
  311. if ((ret = __db_mutex_init(
  312.     dbenv, dbmfp->mutexp, 0, MUTEX_THREAD)) != 0)
  313. goto err;
  315. /* XXX: KEITH: CLOSE THE FILE ON FAILURE? */
  316. }
  318. dbmfp->mfp = mfp;
  320. /*
  321.  * If a file:
  322.  * + is read-only
  323.  * + isn't temporary
  324.  * + doesn't require any pgin/pgout support
  325.  * + the DB_NOMMAP flag wasn't set (in either the file open or
  326.  *   the environment in which it was opened)
  327.  * + and is less than mp_mmapsize bytes in size
  328.  *
  329.  * we can mmap it instead of reading/writing buffers.  Don't do error
  330.  * checking based on the mmap call failure.  We want to do normal I/O
  331.  * on the file if the reason we failed was because the file was on an
  332.  * NFS mounted partition, and we can fail in buffer I/O just as easily
  333.  * as here.
  334.  *
  335.  * XXX
  336.  * We'd like to test to see if the file is too big to mmap.  Since we
  337.  * don't know what size or type off_t's or size_t's are, or the largest
  338.  * unsigned integral type is, or what random insanity the local C
  339.  * compiler will perpetrate, doing the comparison in a portable way is
  340.  * flatly impossible.  Hope that mmap fails if the file is too large.
  341.  */
  342. #define DB_MAXMMAPSIZE (10 * 1024 * 1024) /* 10 Mb. */
  343. if (F_ISSET(mfp, MP_CAN_MMAP)) {
  344. if (!F_ISSET(dbmfp, MP_READONLY))
  345. F_CLR(mfp, MP_CAN_MMAP);
  346. if (path == NULL)
  347. F_CLR(mfp, MP_CAN_MMAP);
  348. if (finfop->ftype != 0)
  349. F_CLR(mfp, MP_CAN_MMAP);
  350. if (LF_ISSET(DB_NOMMAP) || F_ISSET(dbenv, DB_ENV_NOMMAP))
  351. F_CLR(mfp, MP_CAN_MMAP);
  352. maxmap = dbenv->mp_mmapsize == 0 ?
  353.     DB_MAXMMAPSIZE : dbenv->mp_mmapsize;
  354. if (mbytes > maxmap / MEGABYTE ||
  355.     (mbytes == maxmap / MEGABYTE && bytes >= maxmap % MEGABYTE))
  356. F_CLR(mfp, MP_CAN_MMAP);
  357. }
  358. dbmfp->addr = NULL;
  359. if (F_ISSET(mfp, MP_CAN_MMAP)) {
  360. dbmfp->len = (size_t)mbytes * MEGABYTE + bytes;
  361. if (__os_mapfile(dbenv, rpath,
  362.     &dbmfp->fh, dbmfp->len, 1, &dbmfp->addr) != 0) {
  363. dbmfp->addr = NULL;
  364. F_CLR(mfp, MP_CAN_MMAP);
  365. }
  366. }
  367. if (rpath != NULL)
  368. __os_freestr(rpath);
  370. MUTEX_THREAD_LOCK(dbenv, dbmp->mutexp);
  371. TAILQ_INSERT_TAIL(&dbmp->dbmfq, dbmfp, q);
  372. MUTEX_THREAD_UNLOCK(dbenv, dbmp->mutexp);
  374. *retp = dbmfp;
  375. return (0);
  377. err: /*
  378.  * Note that we do not have to free the thread mutex, because we
  379.  * never get to here after we have successfully allocated it.
  380.  */
  381. if (rpath != NULL)
  382. __os_freestr(rpath);
  383. if (F_ISSET(&dbmfp->fh, DB_FH_VALID))
  384. (void)__os_closehandle(&dbmfp->fh);
  385. if (dbmfp != NULL) {
  386. if (dbmfp->mutexp != NULL)
  387. __db_mutex_free(dbenv, dbmp->reginfo, dbmfp->mutexp);
  388. __os_free(dbmfp, sizeof(DB_MPOOLFILE));
  389. }
  390. return (ret);
  391. }
  393. /*
  394.  * __memp_mf_open --
  395.  * Open an MPOOLFILE.
  396.  */
  397. static int
  398. __memp_mf_open(dbmp, path, pagesize, last_pgno, finfop, flags, retp)
  399. DB_MPOOL *dbmp;
  400. const char *path;
  401. size_t pagesize;
  402. db_pgno_t last_pgno;
  403. DB_MPOOL_FINFO *finfop;
  404. u_int32_t flags;
  405. MPOOLFILE **retp;
  406. {
  407. MPOOL *mp;
  408. MPOOLFILE *mfp;
  409. int ret;
  410. void *p;
  412. #define ISTEMPORARY (path == NULL)
  414. /*
  415.  * If not creating a temporary file, walk the list of MPOOLFILE's,
  416.  * looking for a matching file.  Files backed by temporary files
  417.  * or previously removed files can't match.
  418.  *
  419.  * DB_TRUNCATE support.
  420.  *
  421.  * The fileID is a filesystem unique number (e.g., a UNIX dev/inode
  422.  * pair) plus a timestamp.  If files are removed and created in less
  423.  * than a second, the fileID can be repeated.  The problem with
  424.  * repetition happens when the file that previously had the fileID
  425.  * value still has pages in the pool, since we don't want to use them
  426.  * to satisfy requests for the new file.
  427.  *
  428.  * Because the DB_TRUNCATE flag reuses the dev/inode pair, repeated
  429.  * opens with that flag set guarantees matching fileIDs when the
  430.  * machine can open a file and then re-open with truncate within a
  431.  * second.  For this reason, we pass that flag down, and, if we find
  432.  * a matching entry, we ensure that it's never found again, and we
  433.  * create a new entry for the current request.
  434.  */
  435. if (!ISTEMPORARY) {
  436. mp = dbmp->reginfo[0].primary;
  437. for (mfp = SH_TAILQ_FIRST(&mp->mpfq, __mpoolfile);
  438.     mfp != NULL; mfp = SH_TAILQ_NEXT(mfp, q, __mpoolfile)) {
  439. if (F_ISSET(mfp, MP_DEADFILE | MP_TEMP))
  440. continue;
  441. if (memcmp(finfop->fileid, R_ADDR(dbmp->reginfo,
  442.     mfp->fileid_off), DB_FILE_ID_LEN) == 0) {
  443. if (LF_ISSET(DB_TRUNCATE)) {
  444. MEMP_FREMOVE(mfp);
  445. continue;
  446. }
  447. if (finfop->clear_len != mfp->clear_len ||
  448.     pagesize != mfp->stat.st_pagesize) {
  449. __db_err(dbmp->dbenv,
  450.     "%s: page size or clear length changed",
  451.     path);
  452. return (EINVAL);
  453. }
  455. /*
  456.  * It's possible that our needs for pre- and
  457.  * post-processing are changing.  For example,
  458.  * an application created a hash subdatabase
  459.  * in a database that was previously all btree.
  460.  */
  461. if (finfop->ftype != 0)
  462. mfp->ftype = finfop->ftype;
  464. ++mfp->mpf_cnt;
  466. *retp = mfp;
  467. return (0);
  468. }
  469. }
  470. }
  472. /* Allocate a new MPOOLFILE. */
  473. if ((ret = __memp_alloc(
  474.     dbmp, dbmp->reginfo, NULL, sizeof(MPOOLFILE), NULL, &mfp)) != 0)
  475. goto mem_err;
  476. *retp = mfp;
  478. /* Initialize the structure. */
  479. memset(mfp, 0, sizeof(MPOOLFILE));
  480. mfp->mpf_cnt = 1;
  481. mfp->ftype = finfop->ftype;
  482. mfp->lsn_off = finfop->lsn_offset;
  483. mfp->clear_len = finfop->clear_len;
  485. /*
  486.  * If the user specifies DB_MPOOL_LAST or DB_MPOOL_NEW on a memp_fget,
  487.  * we have to know the last page in the file.  Figure it out and save
  488.  * it away.
  489.  */
  490. mfp->stat.st_pagesize = pagesize;
  491. mfp->orig_last_pgno = mfp->last_pgno = last_pgno;
  493. if (ISTEMPORARY)
  494. F_SET(mfp, MP_TEMP);
  495. else {
  496. /* Copy the file path into shared memory. */
  497. if ((ret = __memp_alloc(dbmp, dbmp->reginfo,
  498.     NULL, strlen(path) + 1, &mfp->path_off, &p)) != 0)
  499. goto err;
  500. memcpy(p, path, strlen(path) + 1);
  502. /* Copy the file identification string into shared memory. */
  503. if ((ret = __memp_alloc(dbmp, dbmp->reginfo,
  504.     NULL, DB_FILE_ID_LEN, &mfp->fileid_off, &p)) != 0)
  505. goto err;
  506. memcpy(p, finfop->fileid, DB_FILE_ID_LEN);
  508. F_SET(mfp, MP_CAN_MMAP);
  509. }
  511. /* Copy the page cookie into shared memory. */
  512. if (finfop->pgcookie == NULL || finfop->pgcookie->size == 0) {
  513. mfp->pgcookie_len = 0;
  514. mfp->pgcookie_off = 0;
  515. } else {
  516. if ((ret = __memp_alloc(dbmp, dbmp->reginfo,
  517.     NULL, finfop->pgcookie->size, &mfp->pgcookie_off, &p)) != 0)
  518. goto err;
  519. memcpy(p, finfop->pgcookie->data, finfop->pgcookie->size);
  520. mfp->pgcookie_len = finfop->pgcookie->size;
  521. }
  523. /* Prepend the MPOOLFILE to the list of MPOOLFILE's. */
  524. mp = dbmp->reginfo[0].primary;
  525. SH_TAILQ_INSERT_HEAD(&mp->mpfq, mfp, q, __mpoolfile);
  527. if (0) {
  528. err: if (mfp->path_off != 0)
  529. __db_shalloc_free(dbmp->reginfo[0].addr,
  530.     R_ADDR(dbmp->reginfo, mfp->path_off));
  531. if (mfp->fileid_off != 0)
  532. __db_shalloc_free(dbmp->reginfo[0].addr,
  533.     R_ADDR(dbmp->reginfo, mfp->fileid_off));
  534. if (mfp != NULL)
  535. __db_shalloc_free(dbmp->reginfo[0].addr, mfp);
  536. mem_err: __db_err(dbmp->dbenv,
  537.     "Unable to allocate memory for mpool file");
  538. }
  539. return (ret);
  540. }
  542. /*
  543.  * memp_fclose --
  544.  * Close a backing file for the memory pool.
  545.  */
  546. int
  547. memp_fclose(dbmfp)
  548. DB_MPOOLFILE *dbmfp;
  549. {
  550. DB_ENV *dbenv;
  551. DB_MPOOL *dbmp;
  552. MPOOLFILE *mfp;
  553. char *rpath;
  554. int ret, t_ret;
  556. dbmp = dbmfp->dbmp;
  557. dbenv = dbmp->dbenv;
  558. ret = 0;
  560. PANIC_CHECK(dbenv);
  562. #ifdef HAVE_RPC
  563. if (F_ISSET(dbenv, DB_ENV_RPCCLIENT))
  564. return (__dbcl_memp_fclose(dbmfp));
  565. #endif
  567. /*
  568.  * Remove the DB_MPOOLFILE from the queue.  This has to happen before
  569.  * we perform any action that can fail, otherwise __memp_close may
  570.  * loop infinitely when calling us to discard all of the DB_MPOOLFILEs.
  571.  */
  572. for (;;) {
  573. MUTEX_THREAD_LOCK(dbenv, dbmp->mutexp);
  575. /*
  576.  * We have to reference count DB_MPOOLFILE structures as other
  577.  * threads may be using them.  The problem only happens if the
  578.  * application makes a bad design choice.  Here's the path:
  579.  *
  580.  * Thread A opens a database.
  581.  * Thread B uses thread A's DB_MPOOLFILE to write a buffer
  582.  *    in order to free up memory in the mpool cache.
  583.  * Thread A closes the database while thread B is using the
  584.  *    DB_MPOOLFILE structure.
  585.  *
  586.  * By opening all databases before creating the threads, and
  587.  * closing them after the threads have exited, applications
  588.  * get better performance and avoid the problem path entirely.
  589.  *
  590.  * Regardless, holding the DB_MPOOLFILE to flush a dirty buffer
  591.  * is a short-term lock, even in worst case, since we better be
  592.  * the only thread of control using the DB_MPOOLFILE structure
  593.  * to read pages *into* the cache.  Wait until we're the only
  594.  * reference holder and remove the DB_MPOOLFILE structure from
  595.  * the list, so nobody else can even find it.
  596.  */
  597. if (dbmfp->ref == 1) {
  598. TAILQ_REMOVE(&dbmp->dbmfq, dbmfp, q);
  599. break;
  600. }
  601. MUTEX_THREAD_UNLOCK(dbenv, dbmp->mutexp);
  603. (void)__os_sleep(dbenv, 1, 0);
  604. }
  605. MUTEX_THREAD_UNLOCK(dbenv, dbmp->mutexp);
  607. /* Complain if pinned blocks never returned. */
  608. if (dbmfp->pinref != 0)
  609. __db_err(dbenv, "%s: close: %lu blocks left pinned",
  610.     __memp_fn(dbmfp), (u_long)dbmfp->pinref);
  612. /* Discard any mmap information. */
  613. if (dbmfp->addr != NULL &&
  614.     (ret = __os_unmapfile(dbenv, dbmfp->addr, dbmfp->len)) != 0)
  615. __db_err(dbenv, "%s: %s", __memp_fn(dbmfp), db_strerror(ret));
  617. /* Close the file; temporary files may not yet have been created. */
  618. if (F_ISSET(&dbmfp->fh, DB_FH_VALID) &&
  619.     (t_ret = __os_closehandle(&dbmfp->fh)) != 0) {
  620. __db_err(dbenv, "%s: %s", __memp_fn(dbmfp), db_strerror(t_ret));
  621. if (ret != 0)
  622. t_ret = ret;
  623. }
  625. /* Discard the thread mutex. */
  626. if (dbmfp->mutexp != NULL)
  627. __db_mutex_free(dbenv, dbmp->reginfo, dbmfp->mutexp);
  629. /*
  630.  * Discard our reference on the the underlying MPOOLFILE, and close
  631.  * it if it's no longer useful to anyone.
  632.  *
  633.  * If we're not discarding it, and it's a temp file, this means
  634.  * all the outstanding references belong to unflushed buffers.
  635.  * (A temp file can only be referenced by one DB_MPOOLFILE).
  636.  * We don't care about preserving any of those buffers, so mark
  637.  * the MPOOLFILE as dead so that when we try to flush them,
  638.  * even the dirty ones just get discarded.
  639.  */
  640. R_LOCK(dbenv, dbmp->reginfo);
  641. mfp = dbmfp->mfp;
  642. if (--mfp->mpf_cnt == 0) {
  643. if (F_ISSET(mfp, MP_UNLINK)) {
  644. MEMP_FREMOVE(mfp);
  645. if ((t_ret = __db_appname(dbmp->dbenv,
  646.     DB_APP_DATA, NULL, R_ADDR(dbmp->reginfo,
  647.     mfp->path_off), 0, NULL, &rpath)) != 0 && ret == 0)
  648. ret = t_ret;
  649. if (t_ret == 0 && (t_ret =
  650.     __os_unlink(dbmp->dbenv, rpath) != 0 && ret == 0))
  651. ret = t_ret;
  652. __os_free(rpath, 0);
  653. }
  654. if (mfp->block_cnt == 0)
  655. __memp_mf_discard(dbmp, mfp);
  656. }
  657. else if (F_ISSET(mfp, MP_TEMP))
  658. MEMP_FREMOVE(mfp);
  659. R_UNLOCK(dbenv, dbmp->reginfo);
  661. /* Discard the DB_MPOOLFILE structure. */
  662. __os_free(dbmfp, sizeof(DB_MPOOLFILE));
  664. return (ret);
  665. }
  667. /*
  668.  * __memp_mf_discard --
  669.  * Discard an MPOOLFILE.
  670.  *
  671.  * PUBLIC: void __memp_mf_discard __P((DB_MPOOL *, MPOOLFILE *));
  672.  */
  673. void
  674. __memp_mf_discard(dbmp, mfp)
  675. DB_MPOOL *dbmp;
  676. MPOOLFILE *mfp;
  677. {
  678. MPOOL *mp;
  680. mp = dbmp->reginfo[0].primary;
  682. /* Delete from the list of MPOOLFILEs. */
  683. SH_TAILQ_REMOVE(&mp->mpfq, mfp, q, __mpoolfile);
  685. /* Free the space. */
  686. if (mfp->path_off != 0)
  687. __db_shalloc_free(dbmp->reginfo[0].addr,
  688.     R_ADDR(dbmp->reginfo, mfp->path_off));
  689. if (mfp->fileid_off != 0)
  690. __db_shalloc_free(dbmp->reginfo[0].addr,
  691.     R_ADDR(dbmp->reginfo, mfp->fileid_off));
  692. if (mfp->pgcookie_off != 0)
  693. __db_shalloc_free(dbmp->reginfo[0].addr,
  694.     R_ADDR(dbmp->reginfo, mfp->pgcookie_off));
  695. __db_shalloc_free(dbmp->reginfo[0].addr, mfp);
  696. }
  698. /*
  699.  * __memp_fremove --
  700.  * Remove an underlying file from the system.
  701.  *
  702.  * PUBLIC: int __memp_fremove __P((DB_MPOOLFILE *));
  703.  */
  704. int
  705. __memp_fremove(dbmfp)
  706. DB_MPOOLFILE *dbmfp;
  707. {
  708. DB_ENV *dbenv;
  709. DB_MPOOL *dbmp;
  710. MPOOLFILE *mfp;
  712. dbmp = dbmfp->dbmp;
  713. dbenv = dbmp->dbenv;
  714. mfp = dbmfp->mfp;
  716. PANIC_CHECK(dbenv);
  718. R_LOCK(dbenv, dbmp->reginfo);
  720. MEMP_FREMOVE(mfp);
  722. R_UNLOCK(dbenv, dbmp->reginfo);
  724. return (0);
  725. }
  727. /*
  728.  * __memp_fn --
  729.  * On errors we print whatever is available as the file name.
  730.  *
  731.  * PUBLIC: char * __memp_fn __P((DB_MPOOLFILE *));
  732.  */
  733. char *
  734. __memp_fn(dbmfp)
  735. DB_MPOOLFILE *dbmfp;
  736. {
  737. return (__memp_fns(dbmfp->dbmp, dbmfp->mfp));
  738. }
  740. /*
  741.  * __memp_fns --
  742.  * On errors we print whatever is available as the file name.
  743.  *
  744.  * PUBLIC: char * __memp_fns __P((DB_MPOOL *, MPOOLFILE *));
  745.  *
  746.  */
  747. char *
  748. __memp_fns(dbmp, mfp)
  749. DB_MPOOL *dbmp;
  750. MPOOLFILE *mfp;
  751. {
  752. if (mfp->path_off == 0)
  753. return ((char *)"temporary");
  755. return ((char *)R_ADDR(dbmp->reginfo, mfp->path_off));
  756. }