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

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

MySQL数据库

开发平台：

Visual C++

mp_fopen.c：源码内容
  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 1996-2002
  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.90 2002/08/26 15:22:01 bostic Exp $";
  11. #endif /* not lint */
  13. #ifndef NO_SYSTEM_INCLUDES
  14. #include <sys/types.h>
  16. #include <string.h>
  17. #endif
  19. #include "db_int.h"
  20. #include "dbinc/db_shash.h"
  21. #include "dbinc/mp.h"
  23. static int  __memp_fclose __P((DB_MPOOLFILE *, u_int32_t));
  24. static int  __memp_fopen __P((DB_MPOOLFILE *,
  25. const char *, u_int32_t, int, size_t));
  26. static void __memp_get_fileid __P((DB_MPOOLFILE *, u_int8_t *));
  27. static void __memp_last_pgno __P((DB_MPOOLFILE *, db_pgno_t *));
  28. static void __memp_refcnt __P((DB_MPOOLFILE *, db_pgno_t *));
  29. static int  __memp_set_clear_len __P((DB_MPOOLFILE *, u_int32_t));
  30. static int  __memp_set_fileid __P((DB_MPOOLFILE *, u_int8_t *));
  31. static int  __memp_set_ftype __P((DB_MPOOLFILE *, int));
  32. static int  __memp_set_lsn_offset __P((DB_MPOOLFILE *, int32_t));
  33. static int  __memp_set_pgcookie __P((DB_MPOOLFILE *, DBT *));
  34. static int  __memp_set_priority __P((DB_MPOOLFILE *, DB_CACHE_PRIORITY));
  35. static void __memp_set_unlink __P((DB_MPOOLFILE *, int));
  37. /* Initialization methods cannot be called after open is called. */
  38. #define MPF_ILLEGAL_AFTER_OPEN(dbmfp, name)
  39. if (F_ISSET(dbmfp, MP_OPEN_CALLED))
  40. return (__db_mi_open((dbmfp)->dbmp->dbenv, name, 1));
  42. /*
  43.  * __memp_fcreate --
  44.  * Create a DB_MPOOLFILE handle.
  45.  *
  46.  * PUBLIC: int __memp_fcreate __P((DB_ENV *, DB_MPOOLFILE **, u_int32_t));
  47.  */
  48. int
  49. __memp_fcreate(dbenv, retp, flags)
  50. DB_ENV *dbenv;
  51. DB_MPOOLFILE **retp;
  52. u_int32_t flags;
  53. {
  54. DB_MPOOL *dbmp;
  55. DB_MPOOLFILE *dbmfp;
  56. int ret;
  58. PANIC_CHECK(dbenv);
  59. ENV_REQUIRES_CONFIG(dbenv,
  60.     dbenv->mp_handle, "memp_fcreate", DB_INIT_MPOOL);
  62. dbmp = dbenv->mp_handle;
  64. /* Validate arguments. */
  65. if ((ret = __db_fchk(dbenv, "memp_fcreate", flags, 0)) != 0)
  66. return (ret);
  68. /* Allocate and initialize the per-process structure. */
  69. if ((ret = __os_calloc(dbenv, 1, sizeof(DB_MPOOLFILE), &dbmfp)) != 0)
  70. return (ret);
  71. if ((ret = __os_calloc(dbenv, 1, sizeof(DB_FH), &dbmfp->fhp)) != 0)
  72. goto err;
  74. /* Allocate and initialize a mutex if necessary. */
  75. if (F_ISSET(dbenv, DB_ENV_THREAD) &&
  76.     (ret = __db_mutex_setup(dbenv, dbmp->reginfo, &dbmfp->mutexp,
  77.     MUTEX_ALLOC | MUTEX_THREAD)) != 0)
  78. goto err;
  80. dbmfp->ref = 1;
  81. dbmfp->lsn_offset = -1;
  82. dbmfp->dbmp = dbmp;
  83. dbmfp->mfp = INVALID_ROFF;
  85. dbmfp->close = __memp_fclose;
  86. dbmfp->get = __memp_fget;
  87. dbmfp->get_fileid = __memp_get_fileid;
  88. dbmfp->last_pgno = __memp_last_pgno;
  89. dbmfp->open = __memp_fopen;
  90. dbmfp->put = __memp_fput;
  91. dbmfp->refcnt = __memp_refcnt;
  92. dbmfp->set = __memp_fset;
  93. dbmfp->set_clear_len = __memp_set_clear_len;
  94. dbmfp->set_fileid = __memp_set_fileid;
  95. dbmfp->set_ftype = __memp_set_ftype;
  96. dbmfp->set_lsn_offset = __memp_set_lsn_offset;
  97. dbmfp->set_pgcookie = __memp_set_pgcookie;
  98. dbmfp->set_priority = __memp_set_priority;
  99. dbmfp->set_unlink = __memp_set_unlink;
  100. dbmfp->sync = __memp_fsync;
  102. *retp = dbmfp;
  103. return (0);
  105. err: if (dbmfp != NULL) {
  106. if (dbmfp->fhp != NULL)
  107. (void)__os_free(dbenv, dbmfp->fhp);
  108. (void)__os_free(dbenv, dbmfp);
  109. }
  110. return (ret);
  111. }
  113. /*
  114.  * __memp_set_clear_len --
  115.  * Set the clear length.
  116.  */
  117. static int
  118. __memp_set_clear_len(dbmfp, clear_len)
  119. DB_MPOOLFILE *dbmfp;
  120. u_int32_t clear_len;
  121. {
  122. MPF_ILLEGAL_AFTER_OPEN(dbmfp, "set_clear_len");
  124. dbmfp->clear_len = clear_len;
  125. return (0);
  126. }
  128. /*
  129.  * __memp_set_fileid --
  130.  * Set the file ID.
  131.  */
  132. static int
  133. __memp_set_fileid(dbmfp, fileid)
  134. DB_MPOOLFILE *dbmfp;
  135. u_int8_t *fileid;
  136. {
  137. MPF_ILLEGAL_AFTER_OPEN(dbmfp, "set_fileid");
  139. /*
  140.  * XXX
  141.  * This is dangerous -- we're saving the caller's pointer instead
  142.  * of allocating memory and copying the contents.
  143.  */
  144. dbmfp->fileid = fileid;
  145. return (0);
  146. }
  148. /*
  149.  * __memp_set_ftype --
  150.  * Set the file type (as registered).
  151.  */
  152. static int
  153. __memp_set_ftype(dbmfp, ftype)
  154. DB_MPOOLFILE *dbmfp;
  155. int ftype;
  156. {
  157. MPF_ILLEGAL_AFTER_OPEN(dbmfp, "set_ftype");
  159. dbmfp->ftype = ftype;
  160. return (0);
  161. }
  163. /*
  164.  * __memp_set_lsn_offset --
  165.  * Set the page's LSN offset.
  166.  */
  167. static int
  168. __memp_set_lsn_offset(dbmfp, lsn_offset)
  169. DB_MPOOLFILE *dbmfp;
  170. int32_t lsn_offset;
  171. {
  172. MPF_ILLEGAL_AFTER_OPEN(dbmfp, "set_lsn_offset");
  174. dbmfp->lsn_offset = lsn_offset;
  175. return (0);
  176. }
  178. /*
  179.  * __memp_set_pgcookie --
  180.  * Set the pgin/pgout cookie.
  181.  */
  182. static int
  183. __memp_set_pgcookie(dbmfp, pgcookie)
  184. DB_MPOOLFILE *dbmfp;
  185. DBT *pgcookie;
  186. {
  187. MPF_ILLEGAL_AFTER_OPEN(dbmfp, "set_pgcookie");
  189. dbmfp->pgcookie = pgcookie;
  190. return (0);
  191. }
  193. /*
  194.  * __memp_set_priority --
  195.  * Set the cache priority for pages from this file.
  196.  */
  197. static int
  198. __memp_set_priority(dbmfp, priority)
  199. DB_MPOOLFILE *dbmfp;
  200. DB_CACHE_PRIORITY priority;
  201. {
  202. switch (priority) {
  203. case DB_PRIORITY_VERY_LOW:
  204. dbmfp->mfp->priority = MPOOL_PRI_VERY_LOW;
  205. break;
  206. case DB_PRIORITY_LOW:
  207. dbmfp->mfp->priority = MPOOL_PRI_LOW;
  208. break;
  209. case DB_PRIORITY_DEFAULT:
  210. dbmfp->mfp->priority = MPOOL_PRI_DEFAULT;
  211. break;
  212. case DB_PRIORITY_HIGH:
  213. dbmfp->mfp->priority = MPOOL_PRI_HIGH;
  214. break;
  215. case DB_PRIORITY_VERY_HIGH:
  216. dbmfp->mfp->priority = MPOOL_PRI_VERY_HIGH;
  217. break;
  218. default:
  219. __db_err(dbmfp->dbmp->dbenv,
  220.     "Unknown priority value: %d", priority);
  221. return (EINVAL);
  222. }
  224. return (0);
  225. }
  227. /*
  228.  * __memp_fopen --
  229.  * Open a backing file for the memory pool.
  230.  */
  231. static int
  232. __memp_fopen(dbmfp, path, flags, mode, pagesize)
  233. DB_MPOOLFILE *dbmfp;
  234. const char *path;
  235. u_int32_t flags;
  236. int mode;
  237. size_t pagesize;
  238. {
  239. DB_ENV *dbenv;
  240. DB_MPOOL *dbmp;
  241. int ret;
  243. dbmp = dbmfp->dbmp;
  244. dbenv = dbmp->dbenv;
  246. PANIC_CHECK(dbenv);
  248. /* Validate arguments. */
  249. if ((ret = __db_fchk(dbenv, "memp_fopen", flags,
  250.     DB_CREATE | DB_DIRECT | DB_EXTENT |
  251.     DB_NOMMAP | DB_ODDFILESIZE | DB_RDONLY | DB_TRUNCATE)) != 0)
  252. return (ret);
  254. /*
  255.  * Require a non-zero, power-of-two pagesize, smaller than the
  256.  * clear length.
  257.  */
  258. if (pagesize == 0 || !POWER_OF_TWO(pagesize)) {
  259. __db_err(dbenv,
  260.     "memp_fopen: page sizes must be a power-of-2");
  261. return (EINVAL);
  262. }
  263. if (dbmfp->clear_len > pagesize) {
  264. __db_err(dbenv,
  265.     "memp_fopen: clear length larger than page size");
  266. return (EINVAL);
  267. }
  269. /* Read-only checks, and local flag. */
  270. if (LF_ISSET(DB_RDONLY) && path == NULL) {
  271. __db_err(dbenv,
  272.     "memp_fopen: temporary files can't be readonly");
  273. return (EINVAL);
  274. }
  276. return (__memp_fopen_int(dbmfp, NULL, path, flags, mode, pagesize));
  277. }
  279. /*
  280.  * __memp_fopen_int --
  281.  * Open a backing file for the memory pool; internal version.
  282.  *
  283.  * PUBLIC: int __memp_fopen_int __P((DB_MPOOLFILE *,
  284.  * PUBLIC:     MPOOLFILE *, const char *, u_int32_t, int, size_t));
  285.  */
  286. int
  287. __memp_fopen_int(dbmfp, mfp, path, flags, mode, pagesize)
  288. DB_MPOOLFILE *dbmfp;
  289. MPOOLFILE *mfp;
  290. const char *path;
  291. u_int32_t flags;
  292. int mode;
  293. size_t pagesize;
  294. {
  295. DB_ENV *dbenv;
  296. DB_MPOOL *dbmp;
  297. MPOOL *mp;
  298. db_pgno_t last_pgno;
  299. size_t maxmap;
  300. u_int32_t mbytes, bytes, oflags;
  301. int mfp_alloc, ret;
  302. u_int8_t idbuf[DB_FILE_ID_LEN];
  303. char *rpath;
  304. void *p;
  306. dbmp = dbmfp->dbmp;
  307. dbenv = dbmp->dbenv;
  308. mp = dbmp->reginfo[0].primary;
  309. mfp_alloc = ret = 0;
  310. rpath = NULL;
  312. /*
  313.  * Set the page size so os_open can decide whether to turn buffering
  314.  * off if the DB_DIRECT_DB flag is set.
  315.  */
  316. dbmfp->fhp->pagesize = (u_int32_t)pagesize;
  318. /*
  319.  * If it's a temporary file, delay the open until we actually need
  320.  * to write the file, and we know we can't join any existing files.
  321.  */
  322. if (path == NULL)
  323. goto alloc;
  325. /*
  326.  * Get the real name for this file and open it.  If it's a Queue extent
  327.  * file, it may not exist, and that's OK.
  328.  */
  329. oflags = 0;
  330. if (LF_ISSET(DB_CREATE))
  331. oflags |= DB_OSO_CREATE;
  332. if (LF_ISSET(DB_DIRECT))
  333. oflags |= DB_OSO_DIRECT;
  334. if (LF_ISSET(DB_RDONLY)) {
  335. F_SET(dbmfp, MP_READONLY);
  336. oflags |= DB_OSO_RDONLY;
  337. }
  338. if ((ret =
  339.     __db_appname(dbenv, DB_APP_DATA, path, 0, NULL, &rpath)) != 0)
  340. goto err;
  341. if ((ret = __os_open(dbenv, rpath, oflags, mode, dbmfp->fhp)) != 0) {
  342. if (!LF_ISSET(DB_EXTENT))
  343. __db_err(dbenv, "%s: %s", rpath, db_strerror(ret));
  344. goto err;
  345. }
  347. /*
  348.  * Figure out the file's size.
  349.  *
  350.  * !!!
  351.  * We can't use off_t's here, or in any code in the mainline library
  352.  * for that matter.  (We have to use them in the os stubs, of course,
  353.  * as there are system calls that take them as arguments.)  The reason
  354.  * is some customers build in environments where an off_t is 32-bits,
  355.  * but still run where offsets are 64-bits, and they pay us a lot of
  356.  * money.
  357.  */
  358. if ((ret = __os_ioinfo(
  359.     dbenv, rpath, dbmfp->fhp, &mbytes, &bytes, NULL)) != 0) {
  360. __db_err(dbenv, "%s: %s", rpath, db_strerror(ret));
  361. goto err;
  362. }
  364. /*
  365.  * Get the file id if we weren't given one.  Generated file id's
  366.  * don't use timestamps, otherwise there'd be no chance of any
  367.  * other process joining the party.
  368.  */
  369. if (dbmfp->fileid == NULL) {
  370. if ((ret = __os_fileid(dbenv, rpath, 0, idbuf)) != 0)
  371. goto err;
  372. dbmfp->fileid = idbuf;
  373. }
  375. /*
  376.  * If our caller knows what mfp we're using, increment the ref count,
  377.  * no need to search.
  378.  *
  379.  * We don't need to acquire a lock other than the mfp itself, because
  380.  * we know there's another reference and it's not going away.
  381.  */
  382. if (mfp != NULL) {
  383. MUTEX_LOCK(dbenv, &mfp->mutex);
  384. ++mfp->mpf_cnt;
  385. MUTEX_UNLOCK(dbenv, &mfp->mutex);
  386. goto check_map;
  387. }
  389. /*
  390.  * If not creating a temporary file, walk the list of MPOOLFILE's,
  391.  * looking for a matching file.  Files backed by temporary files
  392.  * or previously removed files can't match.
  393.  *
  394.  * DB_TRUNCATE support.
  395.  *
  396.  * The fileID is a filesystem unique number (e.g., a UNIX dev/inode
  397.  * pair) plus a timestamp.  If files are removed and created in less
  398.  * than a second, the fileID can be repeated.  The problem with
  399.  * repetition happens when the file that previously had the fileID
  400.  * value still has pages in the pool, since we don't want to use them
  401.  * to satisfy requests for the new file.
  402.  *
  403.  * Because the DB_TRUNCATE flag reuses the dev/inode pair, repeated
  404.  * opens with that flag set guarantees matching fileIDs when the
  405.  * machine can open a file and then re-open with truncate within a
  406.  * second.  For this reason, we pass that flag down, and, if we find
  407.  * a matching entry, we ensure that it's never found again, and we
  408.  * create a new entry for the current request.
  409.  */
  410. R_LOCK(dbenv, dbmp->reginfo);
  411. for (mfp = SH_TAILQ_FIRST(&mp->mpfq, __mpoolfile);
  412.     mfp != NULL; mfp = SH_TAILQ_NEXT(mfp, q, __mpoolfile)) {
  413. /* Skip dead files and temporary files. */
  414. if (F_ISSET(mfp, MP_DEADFILE | MP_TEMP))
  415. continue;
  417. /* Skip non-matching files. */
  418. if (memcmp(dbmfp->fileid, R_ADDR(dbmp->reginfo,
  419.     mfp->fileid_off), DB_FILE_ID_LEN) != 0)
  420. continue;
  422. /*
  423.  * If the file is being truncated, remove it from the system
  424.  * and create a new entry.
  425.  *
  426.  * !!!
  427.  * We should be able to set mfp to NULL and break out of the
  428.  * loop, but I like the idea of checking all the entries.
  429.  */
  430. if (LF_ISSET(DB_TRUNCATE)) {
  431. MUTEX_LOCK(dbenv, &mfp->mutex);
  432. MPOOLFILE_IGNORE(mfp);
  433. MUTEX_UNLOCK(dbenv, &mfp->mutex);
  434. continue;
  435. }
  437. /*
  438.  * Some things about a file cannot be changed: the clear length,
  439.  * page size, or lSN location.
  440.  *
  441.  * The file type can change if the application's pre- and post-
  442.  * processing needs change.  For example, an application that
  443.  * created a hash subdatabase in a database that was previously
  444.  * all btree.
  445.  *
  446.  * XXX
  447.  * We do not check to see if the pgcookie information changed,
  448.  * or update it if it is, this might be a bug.
  449.  */
  450. if (dbmfp->clear_len != mfp->clear_len ||
  451.     pagesize != mfp->stat.st_pagesize ||
  452.     dbmfp->lsn_offset != mfp->lsn_off) {
  453. __db_err(dbenv,
  454.     "%s: clear length, page size or LSN location changed",
  455.     path);
  456. R_UNLOCK(dbenv, dbmp->reginfo);
  457. ret = EINVAL;
  458. goto err;
  459. }
  461. if (dbmfp->ftype != 0)
  462. mfp->ftype = dbmfp->ftype;
  464. MUTEX_LOCK(dbenv, &mfp->mutex);
  465. ++mfp->mpf_cnt;
  466. MUTEX_UNLOCK(dbenv, &mfp->mutex);
  467. break;
  468. }
  469. R_UNLOCK(dbenv, dbmp->reginfo);
  471. if (mfp != NULL)
  472. goto check_map;
  474. alloc: /* Allocate and initialize a new MPOOLFILE. */
  475. if ((ret = __memp_alloc(
  476.     dbmp, dbmp->reginfo, NULL, sizeof(MPOOLFILE), NULL, &mfp)) != 0)
  477. goto err;
  478. mfp_alloc = 1;
  479. memset(mfp, 0, sizeof(MPOOLFILE));
  480. mfp->mpf_cnt = 1;
  481. mfp->ftype = dbmfp->ftype;
  482. mfp->stat.st_pagesize = pagesize;
  483. mfp->lsn_off = dbmfp->lsn_offset;
  484. mfp->clear_len = dbmfp->clear_len;
  486. if (LF_ISSET(DB_DIRECT))
  487. F_SET(mfp, MP_DIRECT);
  488. if (LF_ISSET(DB_EXTENT))
  489. F_SET(mfp, MP_EXTENT);
  490. F_SET(mfp, MP_CAN_MMAP);
  492. if (path == NULL)
  493. F_SET(mfp, MP_TEMP);
  494. else {
  495. /*
  496.  * Don't permit files that aren't a multiple of the pagesize,
  497.  * and find the number of the last page in the file, all the
  498.  * time being careful not to overflow 32 bits.
  499.  *
  500.  * During verify or recovery, we might have to cope with a
  501.  * truncated file; if the file size is not a multiple of the
  502.  * page size, round down to a page, we'll take care of the
  503.  * partial page outside the mpool system.
  504.  */
  505. if (bytes % pagesize != 0) {
  506. if (LF_ISSET(DB_ODDFILESIZE))
  507. bytes -= (u_int32_t)(bytes % pagesize);
  508. else {
  509. __db_err(dbenv,
  510.     "%s: file size not a multiple of the pagesize", rpath);
  511. ret = EINVAL;
  512. goto err;
  513. }
  514. }
  516. /*
  517.  * If the user specifies DB_MPOOL_LAST or DB_MPOOL_NEW on a
  518.  * page get, we have to increment the last page in the file.
  519.  * Figure it out and save it away.
  520.  *
  521.  * Note correction: page numbers are zero-based, not 1-based.
  522.  */
  523. last_pgno = (db_pgno_t)(mbytes * (MEGABYTE / pagesize));
  524. last_pgno += (db_pgno_t)(bytes / pagesize);
  525. if (last_pgno != 0)
  526. --last_pgno;
  527. mfp->orig_last_pgno = mfp->last_pgno = last_pgno;
  529. /* Copy the file path into shared memory. */
  530. if ((ret = __memp_alloc(dbmp, dbmp->reginfo,
  531.     NULL, strlen(path) + 1, &mfp->path_off, &p)) != 0)
  532. goto err;
  533. memcpy(p, path, strlen(path) + 1);
  535. /* Copy the file identification string into shared memory. */
  536. if ((ret = __memp_alloc(dbmp, dbmp->reginfo,
  537.     NULL, DB_FILE_ID_LEN, &mfp->fileid_off, &p)) != 0)
  538. goto err;
  539. memcpy(p, dbmfp->fileid, DB_FILE_ID_LEN);
  540. }
  542. /* Copy the page cookie into shared memory. */
  543. if (dbmfp->pgcookie == NULL || dbmfp->pgcookie->size == 0) {
  544. mfp->pgcookie_len = 0;
  545. mfp->pgcookie_off = 0;
  546. } else {
  547. if ((ret = __memp_alloc(dbmp, dbmp->reginfo,
  548.     NULL, dbmfp->pgcookie->size, &mfp->pgcookie_off, &p)) != 0)
  549. goto err;
  550. memcpy(p, dbmfp->pgcookie->data, dbmfp->pgcookie->size);
  551. mfp->pgcookie_len = dbmfp->pgcookie->size;
  552. }
  554. /*
  555.  * Prepend the MPOOLFILE to the list of MPOOLFILE's.
  556.  */
  557. R_LOCK(dbenv, dbmp->reginfo);
  558. ret = __db_mutex_setup(dbenv, dbmp->reginfo, &mfp->mutex,
  559.     MUTEX_NO_RLOCK);
  560. if (ret == 0)
  561. SH_TAILQ_INSERT_HEAD(&mp->mpfq, mfp, q, __mpoolfile);
  562. R_UNLOCK(dbenv, dbmp->reginfo);
  563. if (ret != 0)
  564. goto err;
  566. check_map:
  567. /*
  568.  * If a file:
  569.  * + isn't temporary
  570.  * + is read-only
  571.  * + doesn't require any pgin/pgout support
  572.  * + the DB_NOMMAP flag wasn't set (in either the file open or
  573.  *   the environment in which it was opened)
  574.  * + and is less than mp_mmapsize bytes in size
  575.  *
  576.  * we can mmap it instead of reading/writing buffers.  Don't do error
  577.  * checking based on the mmap call failure.  We want to do normal I/O
  578.  * on the file if the reason we failed was because the file was on an
  579.  * NFS mounted partition, and we can fail in buffer I/O just as easily
  580.  * as here.
  581.  *
  582.  * We'd like to test to see if the file is too big to mmap.  Since we
  583.  * don't know what size or type off_t's or size_t's are, or the largest
  584.  * unsigned integral type is, or what random insanity the local C
  585.  * compiler will perpetrate, doing the comparison in a portable way is
  586.  * flatly impossible.  Hope that mmap fails if the file is too large.
  587.  */
  588. #define DB_MAXMMAPSIZE (10 * 1024 * 1024) /* 10 MB. */
  589. if (F_ISSET(mfp, MP_CAN_MMAP)) {
  590. if (path == NULL)
  591. F_CLR(mfp, MP_CAN_MMAP);
  592. if (!F_ISSET(dbmfp, MP_READONLY))
  593. F_CLR(mfp, MP_CAN_MMAP);
  594. if (dbmfp->ftype != 0)
  595. F_CLR(mfp, MP_CAN_MMAP);
  596. if (LF_ISSET(DB_NOMMAP) || F_ISSET(dbenv, DB_ENV_NOMMAP))
  597. F_CLR(mfp, MP_CAN_MMAP);
  598. maxmap = dbenv->mp_mmapsize == 0 ?
  599.     DB_MAXMMAPSIZE : dbenv->mp_mmapsize;
  600. if (mbytes > maxmap / MEGABYTE ||
  601.     (mbytes == maxmap / MEGABYTE && bytes >= maxmap % MEGABYTE))
  602. F_CLR(mfp, MP_CAN_MMAP);
  604. dbmfp->addr = NULL;
  605. if (F_ISSET(mfp, MP_CAN_MMAP)) {
  606. dbmfp->len = (size_t)mbytes * MEGABYTE + bytes;
  607. if (__os_mapfile(dbenv, rpath,
  608.     dbmfp->fhp, dbmfp->len, 1, &dbmfp->addr) != 0) {
  609. dbmfp->addr = NULL;
  610. F_CLR(mfp, MP_CAN_MMAP);
  611. }
  612. }
  613. }
  615. dbmfp->mfp = mfp;
  617. F_SET(dbmfp, MP_OPEN_CALLED);
  619. /* Add the file to the process' list of DB_MPOOLFILEs. */
  620. MUTEX_THREAD_LOCK(dbenv, dbmp->mutexp);
  621. TAILQ_INSERT_TAIL(&dbmp->dbmfq, dbmfp, q);
  622. MUTEX_THREAD_UNLOCK(dbenv, dbmp->mutexp);
  624. if (0) {
  625. err: if (F_ISSET(dbmfp->fhp, DB_FH_VALID))
  626. (void)__os_closehandle(dbenv, dbmfp->fhp);
  628. if (mfp_alloc) {
  629. R_LOCK(dbenv, dbmp->reginfo);
  630. if (mfp->path_off != 0)
  631. __db_shalloc_free(dbmp->reginfo[0].addr,
  632.     R_ADDR(dbmp->reginfo, mfp->path_off));
  633. if (mfp->fileid_off != 0)
  634. __db_shalloc_free(dbmp->reginfo[0].addr,
  635.     R_ADDR(dbmp->reginfo, mfp->fileid_off));
  636. __db_shalloc_free(dbmp->reginfo[0].addr, mfp);
  637. R_UNLOCK(dbenv, dbmp->reginfo);
  638. }
  640. }
  641. if (rpath != NULL)
  642. __os_free(dbenv, rpath);
  643. return (ret);
  644. }
  646. /*
  647.  * __memp_get_fileid --
  648.  * Return the file ID.
  649.  *
  650.  * XXX
  651.  * Undocumented interface: DB private.
  652.  */
  653. static void
  654. __memp_get_fileid(dbmfp, fidp)
  655. DB_MPOOLFILE *dbmfp;
  656. u_int8_t *fidp;
  657. {
  658. /*
  659.  * No lock needed -- we're using the handle, it had better not
  660.  * be going away.
  661.  *
  662.  * !!!
  663.  * Get the fileID out of the region, not out of the DB_MPOOLFILE
  664.  * structure because the DB_MPOOLFILE reference is possibly short
  665.  * lived, and isn't to be trusted.
  666.  */
  667. memcpy(fidp, R_ADDR(
  668.     dbmfp->dbmp->reginfo, dbmfp->mfp->fileid_off), DB_FILE_ID_LEN);
  669. }
  671. /*
  672.  * __memp_last_pgno --
  673.  * Return the page number of the last page in the file.
  674.  *
  675.  * XXX
  676.  * Undocumented interface: DB private.
  677.  */
  678. static void
  679. __memp_last_pgno(dbmfp, pgnoaddr)
  680. DB_MPOOLFILE *dbmfp;
  681. db_pgno_t *pgnoaddr;
  682. {
  683. DB_ENV *dbenv;
  684. DB_MPOOL *dbmp;
  686. dbmp = dbmfp->dbmp;
  687. dbenv = dbmp->dbenv;
  689. R_LOCK(dbenv, dbmp->reginfo);
  690. *pgnoaddr = dbmfp->mfp->last_pgno;
  691. R_UNLOCK(dbenv, dbmp->reginfo);
  692. }
  694. /*
  695.  * __memp_refcnt --
  696.  * Return the current reference count.
  697.  *
  698.  * XXX
  699.  * Undocumented interface: DB private.
  700.  */
  701. static void
  702. __memp_refcnt(dbmfp, cntp)
  703. DB_MPOOLFILE *dbmfp;
  704. db_pgno_t *cntp;
  705. {
  706. DB_ENV *dbenv;
  708. dbenv = dbmfp->dbmp->dbenv;
  710. MUTEX_LOCK(dbenv, &dbmfp->mfp->mutex);
  711. *cntp = dbmfp->mfp->mpf_cnt;
  712. MUTEX_UNLOCK(dbenv, &dbmfp->mfp->mutex);
  713. }
  715. /*
  716.  * __memp_set_unlink --
  717.  * Set unlink on last close flag.
  718.  *
  719.  * XXX
  720.  * Undocumented interface: DB private.
  721.  */
  722. static void
  723. __memp_set_unlink(dbmpf, set)
  724. DB_MPOOLFILE *dbmpf;
  725. int set;
  726. {
  727. DB_ENV *dbenv;
  729. dbenv = dbmpf->dbmp->dbenv;
  731. MUTEX_LOCK(dbenv, &dbmpf->mfp->mutex);
  732. if (set)
  733. F_SET(dbmpf->mfp, MP_UNLINK);
  734. else
  735. F_CLR(dbmpf->mfp, MP_UNLINK);
  736. MUTEX_UNLOCK(dbenv, &dbmpf->mfp->mutex);
  737. }
  739. /*
  740.  * memp_fclose --
  741.  * Close a backing file for the memory pool.
  742.  */
  743. static int
  744. __memp_fclose(dbmfp, flags)
  745. DB_MPOOLFILE *dbmfp;
  746. u_int32_t flags;
  747. {
  748. DB_ENV *dbenv;
  749. int ret, t_ret;
  751. dbenv = dbmfp->dbmp->dbenv;
  753. PANIC_CHECK(dbenv);
  755. /*
  756.  * XXX
  757.  * DB_MPOOL_DISCARD: Undocumented flag: DB private.
  758.  */
  759. ret = __db_fchk(dbenv, "DB_MPOOLFILE->close", flags, DB_MPOOL_DISCARD);
  761. if ((t_ret = __memp_fclose_int(dbmfp, flags)) != 0 && ret == 0)
  762. ret = t_ret;
  764. return (ret);
  765. }
  767. /*
  768.  * __memp_fclose_int --
  769.  * Internal version of __memp_fclose.
  770.  *
  771.  * PUBLIC: int __memp_fclose_int __P((DB_MPOOLFILE *, u_int32_t));
  772.  */
  773. int
  774. __memp_fclose_int(dbmfp, flags)
  775. DB_MPOOLFILE *dbmfp;
  776. u_int32_t flags;
  777. {
  778. DB_ENV *dbenv;
  779. DB_MPOOL *dbmp;
  780. MPOOLFILE *mfp;
  781. char *rpath;
  782. int deleted, ret, t_ret;
  784. dbmp = dbmfp->dbmp;
  785. dbenv = dbmp->dbenv;
  786. ret = 0;
  788. /*
  789.  * We have to reference count DB_MPOOLFILE structures as other threads
  790.  * in the process may be using them.  Here's the problem:
  791.  *
  792.  * Thread A opens a database.
  793.  * Thread B uses thread A's DB_MPOOLFILE to write a buffer
  794.  *    in order to free up memory in the mpool cache.
  795.  * Thread A closes the database while thread B is using the
  796.  *    DB_MPOOLFILE structure.
  797.  *
  798.  * By opening all databases before creating any threads, and closing
  799.  * the databases after all the threads have exited, applications get
  800.  * better performance and avoid the problem path entirely.
  801.  *
  802.  * Regardless, holding the DB_MPOOLFILE to flush a dirty buffer is a
  803.  * short-term lock, even in worst case, since we better be the only
  804.  * thread of control using the DB_MPOOLFILE structure to read pages
  805.  * *into* the cache.  Wait until we're the only reference holder and
  806.  * remove the DB_MPOOLFILE structure from the list, so nobody else can
  807.  * find it.  We do this, rather than have the last reference holder
  808.  * (whoever that might be) discard the DB_MPOOLFILE structure, because
  809.  * we'd rather write error messages to the application in the close
  810.  * routine, not in the checkpoint/sync routine.
  811.  *
  812.  * !!!
  813.  * It's possible the DB_MPOOLFILE was never added to the DB_MPOOLFILE
  814.  * file list, check the DB_OPEN_CALLED flag to be sure.
  815.  */
  816. for (deleted = 0;;) {
  817. MUTEX_THREAD_LOCK(dbenv, dbmp->mutexp);
  818. if (dbmfp->ref == 1) {
  819. if (F_ISSET(dbmfp, MP_OPEN_CALLED))
  820. TAILQ_REMOVE(&dbmp->dbmfq, dbmfp, q);
  821. deleted = 1;
  822. }
  823. MUTEX_THREAD_UNLOCK(dbenv, dbmp->mutexp);
  825. if (deleted)
  826. break;
  827. __os_sleep(dbenv, 1, 0);
  828. }
  830. /* Complain if pinned blocks never returned. */
  831. if (dbmfp->pinref != 0) {
  832. __db_err(dbenv, "%s: close: %lu blocks left pinned",
  833.     __memp_fn(dbmfp), (u_long)dbmfp->pinref);
  834. ret = __db_panic(dbenv, DB_RUNRECOVERY);
  835. }
  837. /* Discard any mmap information. */
  838. if (dbmfp->addr != NULL &&
  839.     (ret = __os_unmapfile(dbenv, dbmfp->addr, dbmfp->len)) != 0)
  840. __db_err(dbenv, "%s: %s", __memp_fn(dbmfp), db_strerror(ret));
  842. /* Close the file; temporary files may not yet have been created. */
  843. if (F_ISSET(dbmfp->fhp, DB_FH_VALID) &&
  844.     (t_ret = __os_closehandle(dbenv, dbmfp->fhp)) != 0) {
  845. __db_err(dbenv, "%s: %s", __memp_fn(dbmfp), db_strerror(t_ret));
  846. if (ret == 0)
  847. ret = t_ret;
  848. }
  850. /* Discard the thread mutex. */
  851. if (dbmfp->mutexp != NULL)
  852. __db_mutex_free(dbenv, dbmp->reginfo, dbmfp->mutexp);
  854. /*
  855.  * Discard our reference on the the underlying MPOOLFILE, and close
  856.  * it if it's no longer useful to anyone.  It possible the open of
  857.  * the file never happened or wasn't successful, in which case, mpf
  858.  * will be NULL;
  859.  */
  860. if ((mfp = dbmfp->mfp) == NULL)
  861. goto done;
  863. /*
  864.  * If it's a temp file, all outstanding references belong to unflushed
  865.  * buffers.  (A temp file can only be referenced by one DB_MPOOLFILE).
  866.  * We don't care about preserving any of those buffers, so mark the
  867.  * MPOOLFILE as dead so that even the dirty ones just get discarded
  868.  * when we try to flush them.
  869.  */
  870. deleted = 0;
  871. MUTEX_LOCK(dbenv, &mfp->mutex);
  872. if (--mfp->mpf_cnt == 0 || LF_ISSET(DB_MPOOL_DISCARD)) {
  873. if (LF_ISSET(DB_MPOOL_DISCARD) ||
  874.     F_ISSET(mfp, MP_TEMP | MP_UNLINK))
  875. MPOOLFILE_IGNORE(mfp);
  876. if (F_ISSET(mfp, MP_UNLINK)) {
  877. if ((t_ret = __db_appname(dbmp->dbenv,
  878.     DB_APP_DATA, R_ADDR(dbmp->reginfo,
  879.     mfp->path_off), 0, NULL, &rpath)) != 0 && ret == 0)
  880. ret = t_ret;
  881. if (t_ret == 0) {
  882. if ((t_ret = __os_unlink(
  883.     dbmp->dbenv, rpath) != 0) && ret == 0)
  884. ret = t_ret;
  885. __os_free(dbenv, rpath);
  886. }
  887. }
  888. if (mfp->block_cnt == 0) {
  889. if ((t_ret =
  890.     __memp_mf_discard(dbmp, mfp)) != 0 && ret == 0)
  891. ret = t_ret;
  892. deleted = 1;
  893. }
  894. }
  895. if (deleted == 0)
  896. MUTEX_UNLOCK(dbenv, &mfp->mutex);
  898. /* Discard the DB_MPOOLFILE structure. */
  899. done: __os_free(dbenv, dbmfp->fhp);
  900. __os_free(dbenv, dbmfp);
  902. return (ret);
  903. }
  905. /*
  906.  * __memp_mf_discard --
  907.  * Discard an MPOOLFILE.
  908.  *
  909.  * PUBLIC: int __memp_mf_discard __P((DB_MPOOL *, MPOOLFILE *));
  910.  */
  911. int
  912. __memp_mf_discard(dbmp, mfp)
  913. DB_MPOOL *dbmp;
  914. MPOOLFILE *mfp;
  915. {
  916. DB_ENV *dbenv;
  917. DB_FH fh;
  918. DB_MPOOL_STAT *sp;
  919. MPOOL *mp;
  920. char *rpath;
  921. int ret;
  923. dbenv = dbmp->dbenv;
  924. mp = dbmp->reginfo[0].primary;
  925. ret = 0;
  927. /*
  928.  * Expects caller to be holding the MPOOLFILE mutex.
  929.  *
  930.  * When discarding a file, we have to flush writes from it to disk.
  931.  * The scenario is that dirty buffers from this file need to be
  932.  * flushed to satisfy a future checkpoint, but when the checkpoint
  933.  * calls mpool sync, the sync code won't know anything about them.
  934.  */
  935. if (!F_ISSET(mfp, MP_DEADFILE) &&
  936.     (ret = __db_appname(dbenv, DB_APP_DATA,
  937.     R_ADDR(dbmp->reginfo, mfp->path_off), 0, NULL, &rpath)) == 0) {
  938. if ((ret = __os_open(dbenv, rpath, 0, 0, &fh)) == 0) {
  939. ret = __os_fsync(dbenv, &fh);
  940. (void)__os_closehandle(dbenv, &fh);
  941. }
  942. __os_free(dbenv, rpath);
  943. }
  945. /*
  946.  * We have to release the MPOOLFILE lock before acquiring the region
  947.  * lock so that we don't deadlock.  Make sure nobody ever looks at
  948.  * this structure again.
  949.  */
  950. MPOOLFILE_IGNORE(mfp);
  952. /* Discard the mutex we're holding. */
  953. MUTEX_UNLOCK(dbenv, &mfp->mutex);
  955. /* Delete from the list of MPOOLFILEs. */
  956. R_LOCK(dbenv, dbmp->reginfo);
  957. SH_TAILQ_REMOVE(&mp->mpfq, mfp, q, __mpoolfile);
  959. /* Copy the statistics into the region. */
  960. sp = &mp->stat;
  961. sp->st_cache_hit += mfp->stat.st_cache_hit;
  962. sp->st_cache_miss += mfp->stat.st_cache_miss;
  963. sp->st_map += mfp->stat.st_map;
  964. sp->st_page_create += mfp->stat.st_page_create;
  965. sp->st_page_in += mfp->stat.st_page_in;
  966. sp->st_page_out += mfp->stat.st_page_out;
  968. /* Clear the mutex this MPOOLFILE recorded. */
  969. __db_shlocks_clear(&mfp->mutex, dbmp->reginfo,
  970.     (REGMAINT *)R_ADDR(dbmp->reginfo, mp->maint_off));
  972. /* Free the space. */
  973. if (mfp->path_off != 0)
  974. __db_shalloc_free(dbmp->reginfo[0].addr,
  975.     R_ADDR(dbmp->reginfo, mfp->path_off));
  976. if (mfp->fileid_off != 0)
  977. __db_shalloc_free(dbmp->reginfo[0].addr,
  978.     R_ADDR(dbmp->reginfo, mfp->fileid_off));
  979. if (mfp->pgcookie_off != 0)
  980. __db_shalloc_free(dbmp->reginfo[0].addr,
  981.     R_ADDR(dbmp->reginfo, mfp->pgcookie_off));
  982. __db_shalloc_free(dbmp->reginfo[0].addr, mfp);
  984. R_UNLOCK(dbenv, dbmp->reginfo);
  986. return (ret);
  987. }
  989. /*
  990.  * __memp_fn --
  991.  * On errors we print whatever is available as the file name.
  992.  *
  993.  * PUBLIC: char * __memp_fn __P((DB_MPOOLFILE *));
  994.  */
  995. char *
  996. __memp_fn(dbmfp)
  997. DB_MPOOLFILE *dbmfp;
  998. {
  999. return (__memp_fns(dbmfp->dbmp, dbmfp->mfp));
  1000. }
  1002. /*
  1003.  * __memp_fns --
  1004.  * On errors we print whatever is available as the file name.
  1005.  *
  1006.  * PUBLIC: char * __memp_fns __P((DB_MPOOL *, MPOOLFILE *));
  1007.  *
  1008.  */
  1009. char *
  1010. __memp_fns(dbmp, mfp)
  1011. DB_MPOOL *dbmp;
  1012. MPOOLFILE *mfp;
  1013. {
  1014. if (mfp->path_off == 0)
  1015. return ((char *)"temporary");
  1017. return ((char *)R_ADDR(dbmp->reginfo, mfp->path_off));
  1018. }