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

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

MySQL数据库

开发平台：

Visual C++

qam_files.c：源码内容
  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 1999, 2000
  5.  * Sleepycat Software.  All rights reserved.
  6.  */
  8. #include "db_config.h"
  10. #ifndef lint
  11. static const char revid[] = "$Id: qam_files.c,v 1.16 2001/01/19 18:01:59 bostic Exp $";
  12. #endif /* not lint */
  14. #ifndef NO_SYSTEM_INCLUDES
  15. #include <sys/types.h>
  17. #include <string.h>
  18. #endif
  20. #include "db_int.h"
  21. #include "db_page.h"
  22. #include "db_shash.h"
  23. #include "db_am.h"
  24. #include "lock.h"
  25. #include "btree.h"
  26. #include "qam.h"
  27. #include "mp.h"
  29. /*
  30.  * __qam_fprobe -- calcluate and open extent
  31.  *
  32.  * Calculate which extent the page is in, open and create
  33.  * if necessary.
  34.  *
  35.  * PUBLIC: int __qam_fprobe __P((DB *, db_pgno_t, void *, qam_probe_mode, int));
  36.  */
  38. int
  39. __qam_fprobe(dbp, pgno, addrp, mode, flags)
  40. DB *dbp;
  41. db_pgno_t pgno;
  42. void *addrp;
  43. qam_probe_mode mode;
  44. int flags;
  45. {
  46. DB_ENV *dbenv;
  47. DB_MPOOLFILE *mpf;
  48. MPFARRAY *array;
  49. QUEUE *qp;
  50. u_int32_t extid, maxext;
  51. char buf[256];
  52. int numext, offset, oldext, openflags, ret;
  54. qp = (QUEUE *)dbp->q_internal;
  55. if (qp->page_ext == 0) {
  56. mpf = dbp->mpf;
  57. if (mode == QAM_PROBE_GET)
  58. return (memp_fget(mpf, &pgno, flags, addrp));
  59. return (memp_fput(mpf, addrp, flags));
  60. }
  62. dbenv = dbp->dbenv;
  63. mpf = NULL;
  64. ret = 0;
  66. /*
  67.  * Need to lock long enough to find the mpf or create the file.
  68.  * The file cannot go away because we must have a record locked
  69.  * in that file.
  70.  */
  71. MUTEX_THREAD_LOCK(dbenv, dbp->mutexp);
  72. extid = (pgno - 1) / qp->page_ext;
  74. /* Array1 will always be in use if array2 is in use. */
  75. array = &qp->array1;
  76. if (array->n_extent == 0) {
  77. /* Start with 4 extents */
  78. oldext = 0;
  79. array->n_extent = 4;
  80. array->low_extent = extid;
  81. offset = 0;
  82. numext = 0;
  83. goto alloc;
  84. }
  86. offset = extid - qp->array1.low_extent;
  87. if (qp->array2.n_extent != 0 &&
  88.     abs(offset) > abs(extid - qp->array2.low_extent)) {
  89. array = &qp->array2;
  90. offset = extid - array->low_extent;
  91. }
  93. /*
  94.  * Check to see if the requested extent is outside the range of
  95.  * extents in the array.  This is true by defualt if there are
  96.  * no extents here yet.
  97.  */
  98. if (offset < 0 || (unsigned) offset >= array->n_extent) {
  99. oldext = array->n_extent;
  100. numext =  array->hi_extent - array->low_extent  + 1;
  101. if (offset < 0
  102.     && (unsigned) -offset + numext <= array->n_extent) {
  103. /* If we can fit this one in, move the array up */
  104. memmove(&array->mpfarray[-offset],
  105.     array->mpfarray, numext
  106.     * sizeof(array->mpfarray[0]));
  107. memset(array->mpfarray, 0, -offset
  108.      * sizeof(array->mpfarray[0]));
  109. offset = 0;
  110. } else if ((u_int32_t)offset == array->n_extent &&
  111.     mode != QAM_PROBE_MPF && array->mpfarray[0].pinref == 0) {
  112. /* We can close the bottom extent. */
  113. mpf = array->mpfarray[0].mpf;
  114. if (mpf != NULL && (ret = memp_fclose(mpf)) != 0)
  115. goto err;
  116. memmove(&array->mpfarray[0], &array->mpfarray[1],
  117.     (array->n_extent - 1) * sizeof (array->mpfarray[0]));
  118. array->low_extent++;
  119. array->hi_extent++;
  120. offset--;
  121. array->mpfarray[offset].mpf = NULL;
  122. array->mpfarray[offset].pinref = 0;
  123. } else {
  124. /* See if we have wrapped around the queue. */
  125. maxext = (u_int32_t) UINT32_T_MAX
  126.     / (qp->page_ext * qp->rec_page);
  127. if ((u_int32_t) abs(offset) >= maxext/2) {
  128. array = &qp->array2;
  129. DB_ASSERT(array->n_extent == 0);
  130. oldext = 0;
  131. array->n_extent = 4;
  132. array->low_extent = extid;
  133. offset = 0;
  134. numext = 0;
  135. } else {
  136. /*
  137.  * Increase the size to at least include
  138.  * the new one and double it.
  139.  */
  140. array->n_extent += abs(offset);
  141. array->n_extent <<= 2;
  142. }
  143. alloc:
  144. if ((ret = __os_realloc(dbenv,
  145.     array->n_extent * sizeof(struct __qmpf),
  146.     NULL, &array->mpfarray)) != 0)
  147. goto err;
  149. if (offset < 0) {
  150. offset = -offset;
  151. memmove(&array->mpfarray[offset], array->mpfarray,
  152.     numext * sizeof(array->mpfarray[0]));
  153. memset(array->mpfarray, 0,
  154.     offset * sizeof(array->mpfarray[0]));
  155. memset(&array->mpfarray[numext + offset], 0,
  156.      (array->n_extent - (numext + offset))
  157.      * sizeof(array->mpfarray[0]));
  158. offset = 0;
  159. }
  160. else
  161. memset(&array->mpfarray[oldext], 0,
  162.     (array->n_extent - oldext) *
  163.     sizeof(array->mpfarray[0]));
  164. }
  165. }
  167. if (extid < array->low_extent)
  168. array->low_extent = extid;
  169. if (extid > array->hi_extent)
  170. array->hi_extent = extid;
  171. if (array->mpfarray[offset].mpf == NULL) {
  172. snprintf(buf,
  173.     sizeof(buf), QUEUE_EXTENT, qp->dir, qp->name, extid);
  174. openflags = DB_EXTENT;
  175. if (LF_ISSET(DB_MPOOL_CREATE))
  176. openflags |= DB_CREATE;
  177. if (F_ISSET(dbp, DB_AM_RDONLY))
  178. openflags |= DB_RDONLY;
  179. qp->finfo.fileid = NULL;
  180. if ((ret = __memp_fopen(dbenv->mp_handle,
  181.     NULL, buf, openflags, qp->mode, dbp->pgsize,
  182.     1, &qp->finfo, &array->mpfarray[offset].mpf)) != 0)
  183. goto err;
  184. }
  186. mpf = array->mpfarray[offset].mpf;
  187. if (mode == QAM_PROBE_GET)
  188. array->mpfarray[offset].pinref++;
  189. if (LF_ISSET(DB_MPOOL_CREATE))
  190. __memp_clear_unlink(mpf);
  192. err:
  193. MUTEX_THREAD_UNLOCK(dbenv, dbp->mutexp);
  195. if (ret == 0) {
  196. if (mode == QAM_PROBE_MPF) {
  197. *(DB_MPOOLFILE **)addrp = mpf;
  198. return (0);
  199. }
  200. pgno--;
  201. pgno %= qp->page_ext;
  202. if (mode == QAM_PROBE_GET)
  203. return (memp_fget(mpf,
  204.     &pgno, flags | DB_MPOOL_EXTENT, addrp));
  205. ret = memp_fput(mpf, addrp, flags);
  206. MUTEX_THREAD_LOCK(dbenv, dbp->mutexp);
  207. array->mpfarray[offset].pinref--;
  208. MUTEX_THREAD_UNLOCK(dbenv, dbp->mutexp);
  209. }
  210. return (ret);
  211. }
  213. /*
  214.  * __qam_fclose -- close an extent.
  215.  *
  216.  * Calculate which extent the page is in and close it.
  217.  * We assume the mpf entry is present.
  218.  *
  219.  * PUBLIC: int __qam_fclose __P((DB *, db_pgno_t));
  220.  */
  222. int
  223. __qam_fclose(dbp, pgnoaddr)
  224. DB *dbp;
  225. db_pgno_t pgnoaddr;
  226. {
  227. DB_ENV *dbenv;
  228. DB_MPOOLFILE *mpf;
  229. MPFARRAY *array;
  230. QUEUE *qp;
  231. u_int32_t extid;
  232. int offset, ret;
  234. ret = 0;
  235. dbenv = dbp->dbenv;
  236. qp = (QUEUE *)dbp->q_internal;
  238. MUTEX_THREAD_LOCK(dbenv, dbp->mutexp);
  240. extid = (pgnoaddr - 1) / qp->page_ext;
  241. array = &qp->array1;
  242. if (array->low_extent > extid || array->hi_extent < extid)
  243. array = &qp->array2;
  244. offset = extid - array->low_extent;
  246. DB_ASSERT(offset >= 0 && (unsigned) offset < array->n_extent);
  248. /* If other threads are still using this file, leave it. */
  249. if (array->mpfarray[offset].pinref != 0)
  250. goto done;
  252. mpf = array->mpfarray[offset].mpf;
  253. array->mpfarray[offset].mpf = NULL;
  254. ret = memp_fclose(mpf);
  256. done:
  257. MUTEX_THREAD_UNLOCK(dbenv, dbp->mutexp);
  258. return (ret);
  259. }
  260. /*
  261.  * __qam_fremove -- remove an extent.
  262.  *
  263.  * Calculate which extent the page is in and remove it.  There is no way
  264.  * to remove an extent without probing it first and seeing that is is empty
  265.  * so we assume the mpf entry is present.
  266.  *
  267.  * PUBLIC: int __qam_fremove __P((DB *, db_pgno_t));
  268.  */
  270. int
  271. __qam_fremove(dbp, pgnoaddr)
  272. DB *dbp;
  273. db_pgno_t pgnoaddr;
  274. {
  275. DB_ENV *dbenv;
  276. DB_MPOOLFILE *mpf;
  277. MPFARRAY *array;
  278. QUEUE *qp;
  279. u_int32_t extid;
  280. #if CONFIG_TEST
  281. char buf[256], *real_name;
  282. #endif
  283. int offset, ret;
  285. qp = (QUEUE *)dbp->q_internal;
  286. dbenv = dbp->dbenv;
  287. ret = 0;
  289. MUTEX_THREAD_LOCK(dbenv, dbp->mutexp);
  291. extid = (pgnoaddr - 1) / qp->page_ext;
  292. array = &qp->array1;
  293. if (array->low_extent > extid || array->hi_extent < extid)
  294. array = &qp->array2;
  295. offset = extid - array->low_extent;
  297. DB_ASSERT(offset >= 0 && (unsigned) offset < array->n_extent);
  299. #if CONFIG_TEST
  300. real_name = NULL;
  301. /* Find the real name of the file. */
  302. snprintf(buf, sizeof(buf),
  303.     QUEUE_EXTENT, qp->dir, qp->name, extid);
  304. if ((ret = __db_appname(dbenv,
  305.     DB_APP_DATA, NULL, buf, 0, NULL, &real_name)) != 0)
  306. goto err;
  307. #endif
  308. mpf = array->mpfarray[offset].mpf;
  309. array->mpfarray[offset].mpf = NULL;
  310. __memp_set_unlink(mpf);
  311. if ((ret = memp_fclose(mpf)) != 0)
  312. goto err;
  314. if (offset == 0) {
  315. memmove(array->mpfarray, &array->mpfarray[1],
  316.     (array->hi_extent - array->low_extent)
  317.     * sizeof(array->mpfarray[0]));
  318. array->mpfarray[array->hi_extent - array->low_extent].mpf = NULL;
  319. if (array->low_extent != array->hi_extent)
  320. array->low_extent++;
  321. } else {
  322. if (extid == array->hi_extent)
  323. array->hi_extent--;
  324. }
  326. err:
  327. MUTEX_THREAD_UNLOCK(dbenv, dbp->mutexp);
  328. #if CONFIG_TEST
  329. if (real_name != NULL)
  330. __os_freestr(real_name);
  331. #endif
  332. return (ret);
  333. }
  335. /*
  336.  * __qam_sync --
  337.  * Flush the database cache.
  338.  *
  339.  * PUBLIC: int __qam_sync __P((DB *, u_int32_t));
  340.  */
  341. int
  342. __qam_sync(dbp, flags)
  343. DB *dbp;
  344. u_int32_t flags;
  345. {
  346. DB_ENV *dbenv;
  347. DB_MPOOLFILE *mpf;
  348. MPFARRAY *array;
  349. QUEUE *qp;
  350. QUEUE_FILELIST *filelist;
  351. struct __qmpf *mpfp;
  352. u_int32_t i;
  353. int done, ret;
  355. dbenv = dbp->dbenv;
  357. PANIC_CHECK(dbenv);
  358. DB_ILLEGAL_BEFORE_OPEN(dbp, "DB->sync");
  360. if ((ret = __db_syncchk(dbp, flags)) != 0)
  361. return (ret);
  363. /* Read-only trees never need to be sync'd. */
  364. if (F_ISSET(dbp, DB_AM_RDONLY))
  365. return (0);
  367. /* If the tree was never backed by a database file, we're done. */
  368. if (F_ISSET(dbp, DB_AM_INMEM))
  369. return (0);
  371. /* Flush any dirty pages from the cache to the backing file. */
  372. if ((ret = memp_fsync(dbp->mpf)) != 0)
  373. return (ret);
  375. qp = (QUEUE *)dbp->q_internal;
  376. if (qp->page_ext == 0)
  377. return (0);
  379. /* We do this for the side effect of opening all active extents. */
  380. if ((ret = __qam_gen_filelist(dbp, &filelist)) != 0)
  381. return (ret);
  383. if (filelist == NULL)
  384. return (0);
  386. __os_free(filelist, 0);
  388. done = 0;
  389. qp = (QUEUE *)dbp->q_internal;
  390. array = &qp->array1;
  392. MUTEX_THREAD_LOCK(dbenv, dbp->mutexp);
  393. again:
  394. mpfp = array->mpfarray;
  395. for (i = array->low_extent; i <= array->hi_extent; i++, mpfp++)
  396. if ((mpf = mpfp->mpf) != NULL) {
  397. if ((ret = memp_fsync(mpf)) != 0)
  398. goto err;
  399. /*
  400.  * If we are the only ones with this file open
  401.  * then close it so it might be removed.
  402.  */
  403. if (mpfp->pinref == 0) {
  404. mpfp->mpf = NULL;
  405. if ((ret = memp_fclose(mpf)) != 0)
  406. goto err;
  407. }
  408. }
  410. if (done == 0 && qp->array2.n_extent != 0) {
  411. array = &qp->array2;
  412. done = 1;
  413. goto again;
  414. }
  416. err:
  417. MUTEX_THREAD_UNLOCK(dbenv, dbp->mutexp);
  418. return (ret);
  419. }
  421. /*
  422.  * __qam_gen_filelist -- generate a list of extent files.
  423.  * Another thread may close the handle so this should only
  424.  * be used single threaded or with care.
  425.  *
  426.  * PUBLIC: int __qam_gen_filelist __P(( DB *, QUEUE_FILELIST **));
  427.  */
  428. int
  429. __qam_gen_filelist(dbp, filelistp)
  430. DB *dbp;
  431. QUEUE_FILELIST **filelistp;
  432. {
  433. DB_ENV *dbenv;
  434. QUEUE *qp;
  435. QMETA *meta;
  436. db_pgno_t i, last, start, stop;
  437. db_recno_t current, first;
  438. QUEUE_FILELIST *fp;
  439. int ret;
  441. dbenv = dbp->dbenv;
  442. qp = (QUEUE *)dbp->q_internal;
  443. *filelistp = NULL;
  444. if (qp->page_ext == 0)
  445. return (0);
  447. /* This may happen during metapage recovery. */
  448. if (qp->name == NULL)
  449. return (0);
  451. /* Find out the page number of the last page in the database. */
  452. i = PGNO_BASE_MD;
  453. if ((ret = memp_fget(dbp->mpf, &i, 0, &meta)) != 0) {
  454. (void)dbp->close(dbp, 0);
  455. return (ret);
  456. }
  458. current = meta->cur_recno;
  459. first = meta->first_recno;
  461. if ((ret = memp_fput(dbp->mpf, meta, 0)) != 0) {
  462. (void)dbp->close(dbp, 0);
  463. return (ret);
  464. }
  466. last = QAM_RECNO_PAGE(dbp, current);
  467. start = QAM_RECNO_PAGE(dbp, first);
  469. /* Allocate the worst case plus 1 for null termination. */
  470. if (last >= start)
  471. ret = last - start + 2;
  472. else
  473. ret = last + (QAM_RECNO_PAGE(dbp, UINT32_T_MAX) - start) + 1;
  474. if ((ret = __os_calloc(dbenv,
  475.     ret, sizeof(QUEUE_FILELIST), filelistp)) != 0)
  476. return (ret);
  477. fp = *filelistp;
  478. i = start;
  479. if (last >= start)
  480. stop = last;
  481. else
  482. stop = QAM_RECNO_PAGE(dbp, UINT32_T_MAX);
  483. again:
  484. for (; i <= last; i += qp->page_ext) {
  485. if ((ret = __qam_fprobe(dbp,
  486.     i, &fp->mpf, QAM_PROBE_MPF, 0)) != 0) {
  487. if (ret == ENOENT)
  488. continue;
  489. return (ret);
  490. }
  491. fp->id = (i - 1) / qp->page_ext;
  492. fp++;
  493. }
  495. if (last < start) {
  496. i = 1;
  497. stop = last;
  498. start = 0;
  499. goto again;
  500. }
  502. return (0);
  503. }