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

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

MySQL数据库

开发平台：

Visual C++

log_rec.c：源码内容
  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 1996, 1997, 1998, 1999, 2000
  5.  * Sleepycat Software.  All rights reserved.
  6.  */
  7. /*
  8.  * Copyright (c) 1995, 1996
  9.  * The President and Fellows of Harvard University.  All rights reserved.
  10.  *
  11.  * Redistribution and use in source and binary forms, with or without
  12.  * modification, are permitted provided that the following conditions
  13.  * are met:
  14.  * 1. Redistributions of source code must retain the above copyright
  15.  *    notice, this list of conditions and the following disclaimer.
  16.  * 2. Redistributions in binary form must reproduce the above copyright
  17.  *    notice, this list of conditions and the following disclaimer in the
  18.  *    documentation and/or other materials provided with the distribution.
  19.  * 3. Neither the name of the University nor the names of its contributors
  20.  *    may be used to endorse or promote products derived from this software
  21.  *    without specific prior written permission.
  22.  *
  23.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  24.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  27.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33.  * SUCH DAMAGE.
  34.  */
  36. #include "db_config.h"
  38. #ifndef lint
  39. static const char revid[] = "$Id: log_rec.c,v 11.48 2001/01/11 18:19:53 bostic Exp $";
  40. #endif /* not lint */
  42. #ifndef NO_SYSTEM_INCLUDES
  43. #include <sys/types.h>
  45. #include <string.h>
  46. #endif
  48. #include "db_int.h"
  49. #include "db_page.h"
  50. #include "db_am.h"
  51. #include "log.h"
  53. static int __log_check_master __P((DB_ENV *, u_int8_t *, char *));
  54. static int __log_do_open __P((DB_ENV *, DB_LOG *,
  55.     u_int8_t *, char *, DBTYPE, int32_t, db_pgno_t));
  56. static int __log_open_file __P((DB_ENV *, DB_LOG *, __log_register_args *));
  58. /*
  59.  * PUBLIC: int __log_register_recover
  60.  * PUBLIC:     __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  61.  */
  62. int
  63. __log_register_recover(dbenv, dbtp, lsnp, op, info)
  64. DB_ENV *dbenv;
  65. DBT *dbtp;
  66. DB_LSN *lsnp;
  67. db_recops op;
  68. void *info;
  69. {
  70. DB_ENTRY *dbe;
  71. DB_LOG *logp;
  72. DB *dbp;
  73. __log_register_args *argp;
  74. int do_rem, ret, t_ret;
  76. logp = dbenv->lg_handle;
  77. dbp = NULL;
  79. #ifdef DEBUG_RECOVER
  80. REC_PRINT(__log_register_print);
  81. #endif
  82. COMPQUIET(lsnp, NULL);
  84. if ((ret = __log_register_read(dbenv, dbtp->data, &argp)) != 0)
  85. goto out;
  87. if ((argp->opcode == LOG_OPEN &&
  88.     (DB_REDO(op) || op == DB_TXN_OPENFILES)) ||
  89.     (argp->opcode == LOG_CLOSE && DB_UNDO(op))) {
  90. /*
  91.  * If we are redoing an open or undoing a close, then we need
  92.  * to open a file.  We must open the file even if
  93.  * the meta page is not yet written as we may be creating it.
  94.  */
  95. if (op == DB_TXN_OPENFILES)
  96. F_SET(logp, DBLOG_FORCE_OPEN);
  97. ret = __log_open_file(dbenv, logp, argp);
  98. F_CLR(logp, DBLOG_FORCE_OPEN);
  99. if (ret == ENOENT || ret == EINVAL) {
  100. if (op == DB_TXN_OPENFILES && argp->name.size != 0 &&
  101.     (ret = __db_txnlist_delete(dbenv, info,
  102. argp->name.data, argp->fileid, 0)) != 0)
  103. goto out;
  104. ret = 0;
  105. }
  106. } else if (argp->opcode != LOG_CHECKPOINT) {
  107. /*
  108.  * If we are undoing an open, then we need to close the file.
  109.  *
  110.  * If the file is deleted, then we can just ignore this close.
  111.  * Otherwise, we should usually have a valid dbp we should
  112.  * close or whose reference count should be decremented.
  113.  * However, if we shut down without closing a file, we may, in
  114.  * fact, not have the file open, and that's OK.
  115.  */
  116. do_rem = 0;
  117. MUTEX_THREAD_LOCK(dbenv, logp->mutexp);
  118. if (argp->fileid < logp->dbentry_cnt) {
  119. dbe = &logp->dbentry[argp->fileid];
  121. DB_ASSERT(dbe->refcount == 1);
  123. ret = __db_txnlist_close(info,
  124.     argp->fileid, dbe->count);
  125. if ((dbp = TAILQ_FIRST(&dbe->dblist)) != NULL)
  126. (void)log_unregister(dbenv, dbp);
  127. do_rem = 1;
  128. }
  129. MUTEX_THREAD_UNLOCK(dbenv, logp->mutexp);
  130. if (do_rem) {
  131. (void)__log_rem_logid(logp, dbp, argp->fileid);
  132. /*
  133.  * If remove or rename has closed the file, don't
  134.  * sync.
  135.  */
  136. if (dbp != NULL &&
  137.     (t_ret = dbp->close(dbp,
  138.     dbp->mpf == NULL ? DB_NOSYNC : 0)) != 0 && ret == 0)
  139. ret = t_ret;
  140. }
  141. } else if (DB_UNDO(op) || op == DB_TXN_OPENFILES) {
  142. /*
  143.  * It's a checkpoint and we are rolling backward.  It
  144.  * is possible that the system was shut down and thus
  145.  * ended with a stable checkpoint; this file was never
  146.  * closed and has therefore not been reopened yet.  If
  147.  * so, we need to try to open it.
  148.  */
  149. ret = __log_open_file(dbenv, logp, argp);
  150. if (ret == ENOENT || ret == EINVAL) {
  151. if (argp->name.size != 0 && (ret =
  152.     __db_txnlist_delete(dbenv, info,
  153. argp->name.data, argp->fileid, 0)) != 0)
  154. goto out;
  155. ret = 0;
  156. }
  157. }
  159. out: if (argp != NULL)
  160. __os_free(argp, 0);
  161. return (ret);
  162. }
  164. /*
  165.  * __log_open_file --
  166.  * Called during log_register recovery.  Make sure that we have an
  167.  * entry in the dbentry table for this ndx.  Returns 0 on success,
  168.  * non-zero on error.
  169.  */
  170. static int
  171. __log_open_file(dbenv, lp, argp)
  172. DB_ENV *dbenv;
  173. DB_LOG *lp;
  174. __log_register_args *argp;
  175. {
  176. DB_ENTRY *dbe;
  177. DB *dbp;
  179. /*
  180.  * We never re-open temporary files.  Temp files are only
  181.  * useful during aborts in which case the dbp was entered
  182.  * when the file was registered.  During recovery, we treat
  183.  * temp files as properly deleted files, allowing the open to
  184.  * fail and not reporting any errors when recovery fails to
  185.  * get a valid dbp from db_fileid_to_db.
  186.  */
  187. if (argp->name.size == 0) {
  188. (void)__log_add_logid(dbenv, lp, NULL, argp->fileid);
  189. return (ENOENT);
  190. }
  192. /*
  193.  * Because of reference counting, we cannot automatically close files
  194.  * during recovery, so when we're opening, we have to check that the
  195.  * name we are opening is what we expect.  If it's not, then we close
  196.  * the old file and open the new one.
  197.  */
  198. MUTEX_THREAD_LOCK(dbenv, lp->mutexp);
  199. if (argp->fileid < lp->dbentry_cnt)
  200. dbe = &lp->dbentry[argp->fileid];
  201. else
  202. dbe = NULL;
  204. if (dbe != NULL) {
  205. dbe->deleted = 0;
  206. if ((dbp = TAILQ_FIRST(&dbe->dblist)) != NULL) {
  207. if (dbp->meta_pgno != argp->meta_pgno ||
  208.     memcmp(dbp->fileid,
  209.     argp->uid.data, DB_FILE_ID_LEN) != 0) {
  210. MUTEX_THREAD_UNLOCK(dbenv, lp->mutexp);
  211. goto reopen;
  212. }
  213. if (!F_ISSET(lp, DBLOG_RECOVER))
  214. dbe->refcount++;
  215. MUTEX_THREAD_UNLOCK(dbenv, lp->mutexp);
  216. return (0);
  217. }
  218. }
  220. MUTEX_THREAD_UNLOCK(dbenv, lp->mutexp);
  221. if (0) {
  222. reopen: (void)log_unregister(dbp->dbenv, dbp);
  223. (void)__log_rem_logid(lp, dbp, argp->fileid);
  224. dbp->close(dbp, 0);
  225. }
  227. return (__log_do_open(dbenv, lp,
  228.     argp->uid.data, argp->name.data,
  229.     argp->ftype, argp->fileid, argp->meta_pgno));
  230. }
  232. /*
  233.  * log_reopen_file -- close and reopen a db file.
  234.  * Must be called when a metadata page changes.
  235.  *
  236.  * PUBLIC: int __log_reopen_file __P((DB_ENV *,
  237.  * PUBLIC:     char *, int32_t, u_int8_t *, db_pgno_t));
  238.  *
  239.  */
  240. int
  241. __log_reopen_file(dbenv, name, ndx, fileid, meta_pgno)
  242. DB_ENV *dbenv;
  243. char *name;
  244. int32_t ndx;
  245. u_int8_t *fileid;
  246. db_pgno_t meta_pgno;
  247. {
  248. DB *dbp;
  249. DB_LOG *logp;
  250. DBTYPE ftype;
  251. FNAME *fnp;
  252. LOG *lp;
  253. char *tmp_name;
  254. int ret;
  256. logp = dbenv->lg_handle;
  258. if (name == NULL) {
  259. R_LOCK(dbenv, &logp->reginfo);
  261. lp = logp->reginfo.primary;
  263. for (fnp = SH_TAILQ_FIRST(&lp->fq, __fname);
  264.     fnp != NULL; fnp = SH_TAILQ_NEXT(fnp, q, __fname)) {
  265. if (fnp->ref == 0)      /* Entry not in use. */
  266. continue;
  267. if (memcmp(fnp->ufid, fileid, DB_FILE_ID_LEN) == 0)
  268. break;
  269. }
  271. if (fnp == 0 || fnp->name_off == INVALID_ROFF) {
  272. __db_err(dbenv,
  273.     "metasub recover: non-existent file id");
  274. return (EINVAL);
  275. }
  277. name = R_ADDR(&logp->reginfo, fnp->name_off);
  278. ret = __os_strdup(dbenv, name, &tmp_name);
  279. R_UNLOCK(dbenv, &logp->reginfo);
  280. if (ret != 0)
  281. goto out;
  282. name = tmp_name;
  283. } else
  284. tmp_name = NULL;
  286. if ((ret = __db_fileid_to_db(dbenv, &dbp, ndx, 0)) != 0)
  287. goto out;
  288. ftype = dbp->type;
  289. (void)log_unregister(dbenv, dbp);
  290. (void)__log_rem_logid(logp, dbp, ndx);
  291. (void)dbp->close(dbp, 0);
  293. ret = __log_do_open(dbenv, logp, fileid, name, ftype, ndx, meta_pgno);
  295. if (tmp_name != NULL)
  296. __os_free(tmp_name, 0);
  298. out: return (ret);
  299. }
  301. /*
  302.  * __log_do_open --
  303.  * Open files referenced in the log.  This is the part of the open that
  304.  * is not protected by the thread mutex.
  305.  */
  306. static int
  307. __log_do_open(dbenv, lp, uid, name, ftype, ndx, meta_pgno)
  308. DB_ENV *dbenv;
  309. DB_LOG *lp;
  310. u_int8_t *uid;
  311. char *name;
  312. DBTYPE ftype;
  313. int32_t ndx;
  314. db_pgno_t meta_pgno;
  315. {
  316. DB *dbp;
  317. int ret;
  318. u_int8_t zeroid[DB_FILE_ID_LEN];
  320. if ((ret = db_create(&dbp, lp->dbenv, 0)) != 0)
  321. return (ret);
  323. dbp->log_fileid = ndx;
  325. /*
  326.  * This is needed to signal to the locking routines called while
  327.  * opening databases that we are potentially undoing a transaction
  328.  * from an XA process.  Since the XA process does not share
  329.  * locks with the aborting transaction this prevents us from
  330.  * deadlocking during the open during rollback.
  331.  * Because this routine is called either during recovery or during an
  332.  * XA_ABORT, we can safely set DB_AM_RECOVER in the dbp since it
  333.  * will not be shared with other threads.
  334.  */
  335. F_SET(dbp, DB_AM_RECOVER);
  336. if (meta_pgno != PGNO_BASE_MD)
  337. memcpy(dbp->fileid, uid, DB_FILE_ID_LEN);
  338. dbp->type = ftype;
  339. if ((ret =
  340.     __db_dbopen(dbp, name, 0, __db_omode("rw----"), meta_pgno)) == 0) {
  341. /*
  342.  * Verify that we are opening the same file that we were
  343.  * referring to when we wrote this log record.
  344.  */
  345. if (meta_pgno != PGNO_BASE_MD &&
  346.     __log_check_master(dbenv, uid, name) != 0)
  347. goto not_right;
  348. if (memcmp(uid, dbp->fileid, DB_FILE_ID_LEN) != 0) {
  349. memset(zeroid, 0, DB_FILE_ID_LEN);
  350. if (memcmp(dbp->fileid, zeroid, DB_FILE_ID_LEN) != 0)
  351. goto not_right;
  352. memcpy(dbp->fileid, uid, DB_FILE_ID_LEN);
  353. }
  354. if (IS_RECOVERING(dbenv)) {
  355. (void)log_register(dbp->dbenv, dbp, name);
  356. (void)__log_add_logid(dbenv, lp, dbp, ndx);
  357. }
  358. return (0);
  359. }
  361. not_right:
  362. (void)dbp->close(dbp, 0);
  363. (void)__log_add_logid(dbenv, lp, NULL, ndx);
  365. return (ENOENT);
  366. }
  368. static int
  369. __log_check_master(dbenv, uid, name)
  370. DB_ENV *dbenv;
  371. u_int8_t *uid;
  372. char *name;
  373. {
  374. DB *dbp;
  375. int ret;
  377. ret = 0;
  378. if ((ret = db_create(&dbp, dbenv, 0)) != 0)
  379. return (ret);
  380. dbp->type = DB_BTREE;
  381. ret = __db_dbopen(dbp, name, 0, __db_omode("rw----"), PGNO_BASE_MD);
  383. if (ret == 0 && memcmp(uid, dbp->fileid, DB_FILE_ID_LEN) != 0) 
  384. ret = EINVAL;
  386. (void) dbp->close(dbp, 0);
  387. return (ret);
  388. }
  390. /*
  391.  * __log_add_logid --
  392.  * Adds a DB entry to the log's DB entry table.
  393.  *
  394.  * PUBLIC: int __log_add_logid __P((DB_ENV *, DB_LOG *, DB *, int32_t));
  395.  */
  396. int
  397. __log_add_logid(dbenv, logp, dbp, ndx)
  398. DB_ENV *dbenv;
  399. DB_LOG *logp;
  400. DB *dbp;
  401. int32_t ndx;
  402. {
  403. DB *dbtmp;
  404. int32_t i;
  405. int ret;
  407. ret = 0;
  409. MUTEX_THREAD_LOCK(dbenv, logp->mutexp);
  411. /*
  412.  * Check if we need to grow the table.  Note, ndx is 0-based (the
  413.  * index into the DB entry table) an dbentry_cnt is 1-based, the
  414.  * number of available slots.
  415.  */
  416. if (logp->dbentry_cnt <= ndx) {
  417. if ((ret = __os_realloc(dbenv,
  418.     (ndx + DB_GROW_SIZE) * sizeof(DB_ENTRY),
  419.     NULL, &logp->dbentry)) != 0)
  420. goto err;
  422. /*
  423.  * We have moved the head of the queue.
  424.  * Fix up the queue header of an empty queue or the previous
  425.  * pointer of the first element.
  426.  */
  427. for (i = 0; i < logp->dbentry_cnt; i++) {
  428. if ((dbtmp =
  429.     TAILQ_FIRST(&logp->dbentry[i].dblist)) == NULL)
  430. TAILQ_INIT(&logp->dbentry[i].dblist);
  431. else
  432. TAILQ_REINSERT_HEAD(
  433.     &logp->dbentry[i].dblist, dbp, links);
  434. }
  436. /* Initialize the new entries. */
  437. for (i = logp->dbentry_cnt; i < ndx + DB_GROW_SIZE; i++) {
  438. logp->dbentry[i].count = 0;
  439. TAILQ_INIT(&logp->dbentry[i].dblist);
  440. logp->dbentry[i].deleted = 0;
  441. logp->dbentry[i].refcount = 0;
  442. }
  444. logp->dbentry_cnt = i;
  445. }
  447. if (logp->dbentry[ndx].deleted == 0 &&
  448.     TAILQ_FIRST(&logp->dbentry[ndx].dblist) == NULL) {
  449. logp->dbentry[ndx].count = 0;
  450. if (dbp != NULL)
  451. TAILQ_INSERT_HEAD(&logp->dbentry[ndx].dblist,
  452.     dbp, links);
  453. logp->dbentry[ndx].deleted = dbp == NULL;
  454. logp->dbentry[ndx].refcount = 1;
  455. } else if (!F_ISSET(logp, DBLOG_RECOVER)) {
  456. if (dbp != NULL)
  457. TAILQ_INSERT_HEAD(&logp->dbentry[ndx].dblist,
  458.     dbp, links);
  459. logp->dbentry[ndx].refcount++;
  460. }
  462. err: MUTEX_THREAD_UNLOCK(dbenv, logp->mutexp);
  463. return (ret);
  464. }
  466. /*
  467.  * __db_fileid_to_db --
  468.  * Return the DB corresponding to the specified fileid.
  469.  *
  470.  * PUBLIC: int __db_fileid_to_db __P((DB_ENV *, DB **, int32_t, int));
  471.  */
  472. int
  473. __db_fileid_to_db(dbenv, dbpp, ndx, inc)
  474. DB_ENV *dbenv;
  475. DB **dbpp;
  476. int32_t ndx;
  477. int inc;
  478. {
  479. DB_LOG *logp;
  480. DB *dbp;
  481. FNAME *fname;
  482. int ret;
  483. char *name;
  485. ret = 0;
  486. logp = dbenv->lg_handle;
  488. MUTEX_THREAD_LOCK(dbenv, logp->mutexp);
  490. /*
  491.  * Under XA, a process different than the one issuing DB operations
  492.  * may abort a transaction.  In this case, recovery routines are run
  493.  * by a process that does not necessarily have the file open, so we
  494.  * we must open the file explicitly.
  495.  */
  496. if (ndx >= logp->dbentry_cnt ||
  497.     (!logp->dbentry[ndx].deleted &&
  498.     (dbp = TAILQ_FIRST(&logp->dbentry[ndx].dblist)) == NULL)) {
  499. if (F_ISSET(logp, DBLOG_RECOVER)) {
  500. ret = ENOENT;
  501. goto err;
  502. }
  503. if (__log_lid_to_fname(logp, ndx, &fname) != 0) {
  504. /* Couldn't find entry; this is a fatal error. */
  505. __db_err(dbenv, "Missing log fileid entry");
  506. ret = EINVAL;
  507. goto err;
  508. }
  509. name = R_ADDR(&logp->reginfo, fname->name_off);
  511. /*
  512.  * __log_do_open is called without protection of the
  513.  * log thread lock.
  514.  */
  515. MUTEX_THREAD_UNLOCK(dbenv, logp->mutexp);
  517. /*
  518.  * At this point, we are not holding the thread lock, so exit
  519.  * directly instead of going through the exit code at the
  520.  * bottom.  If the __log_do_open succeeded, then we don't need
  521.  * to do any of the remaining error checking at the end of this
  522.  * routine.
  523.  */
  524. if ((ret = __log_do_open(dbenv, logp,
  525.     fname->ufid, name, fname->s_type,
  526.     ndx, fname->meta_pgno)) != 0)
  527. return (ret);
  529. *dbpp = TAILQ_FIRST(&logp->dbentry[ndx].dblist);
  530. return (0);
  531. }
  533. /*
  534.  * Return DB_DELETED if the file has been deleted (it's not an error).
  535.  */
  536. if (logp->dbentry[ndx].deleted) {
  537. ret = DB_DELETED;
  538. if (inc)
  539. logp->dbentry[ndx].count++;
  540. goto err;
  541. }
  543. /*
  544.  * Otherwise return 0, but if we don't have a corresponding DB, it's
  545.  * an error.
  546.  */
  547. if ((*dbpp = TAILQ_FIRST(&logp->dbentry[ndx].dblist)) == NULL)
  548. ret = ENOENT;
  550. err: MUTEX_THREAD_UNLOCK(dbenv, logp->mutexp);
  551. return (ret);
  552. }
  554. /*
  555.  * __log_close_files --
  556.  * Close files that were opened by the recovery daemon.  We sync the
  557.  * file, unless its mpf pointer has been NULLed by a db_remove or
  558.  * db_rename.  We may not have flushed the log_register record that
  559.  * closes the file.
  560.  *
  561.  * PUBLIC: void __log_close_files __P((DB_ENV *));
  562.  */
  563. void
  564. __log_close_files(dbenv)
  565. DB_ENV *dbenv;
  566. {
  567. DB_ENTRY *dbe;
  568. DB_LOG *logp;
  569. DB *dbp;
  570. int32_t i;
  572. logp = dbenv->lg_handle;
  573. MUTEX_THREAD_LOCK(dbenv, logp->mutexp);
  574. for (i = 0; i < logp->dbentry_cnt; i++) {
  575. dbe = &logp->dbentry[i];
  576. while ((dbp = TAILQ_FIRST(&dbe->dblist)) != NULL) {
  577. (void)log_unregister(dbenv, dbp);
  578. TAILQ_REMOVE(&dbe->dblist, dbp, links);
  579. (void)dbp->close(dbp, dbp->mpf == NULL ? DB_NOSYNC : 0);
  580. }
  581. dbe->deleted = 0;
  582. dbe->refcount = 0;
  583. }
  584. MUTEX_THREAD_UNLOCK(dbenv, logp->mutexp);
  585. }
  587. /*
  588.  * __log_rem_logid
  589.  * Remove an entry from the log table.  Find the appropriate DB and
  590.  * unlink it from the linked list off the table.  If the DB is NULL, treat
  591.  * this as a simple refcount decrement.
  592.  *
  593.  * PUBLIC: void __log_rem_logid __P((DB_LOG *, DB *, int32_t));
  594.  */
  595. void
  596. __log_rem_logid(logp, dbp, ndx)
  597. DB_LOG *logp;
  598. DB *dbp;
  599. int32_t ndx;
  600. {
  601. DB *xdbp;
  603. MUTEX_THREAD_LOCK(logp->dbenv, logp->mutexp);
  604. if (--logp->dbentry[ndx].refcount == 0) {
  605. TAILQ_INIT(&logp->dbentry[ndx].dblist);
  606. logp->dbentry[ndx].deleted = 0;
  607. } else if (dbp != NULL)
  608. for (xdbp = TAILQ_FIRST(&logp->dbentry[ndx].dblist);
  609.     xdbp != NULL;
  610.     xdbp = TAILQ_NEXT(xdbp, links))
  611. if (xdbp == dbp) {
  612. TAILQ_REMOVE(&logp->dbentry[ndx].dblist,
  613.     xdbp, links);
  614. break;
  615. }
  617. MUTEX_THREAD_UNLOCK(logp->dbenv, logp->mutexp);
  618. }
  620. /*
  621.  * __log_lid_to_fname --
  622.  * Traverse the shared-memory region looking for the entry that
  623.  * matches the passed log fileid.  Returns 0 on success; -1 on error.
  624.  * PUBLIC: int __log_lid_to_fname __P((DB_LOG *, int32_t, FNAME **));
  625.  */
  626. int
  627. __log_lid_to_fname(dblp, lid, fnamep)
  628. DB_LOG *dblp;
  629. int32_t lid;
  630. FNAME **fnamep;
  631. {
  632. FNAME *fnp;
  633. LOG *lp;
  635. lp = dblp->reginfo.primary;
  637. for (fnp = SH_TAILQ_FIRST(&lp->fq, __fname);
  638.     fnp != NULL; fnp = SH_TAILQ_NEXT(fnp, q, __fname)) {
  639. if (fnp->ref == 0) /* Entry not in use. */
  640. continue;
  641. if (fnp->id == lid) {
  642. *fnamep = fnp;
  643. return (0);
  644. }
  645. }
  646. return (-1);
  647. }