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

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

MySQL数据库

开发平台：

Visual C++

db_dispatch.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.  * This code is derived from software contributed to Berkeley by
  12.  * Margo Seltzer.
  13.  *
  14.  * Redistribution and use in source and binary forms, with or without
  15.  * modification, are permitted provided that the following conditions
  16.  * are met:
  17.  * 1. Redistributions of source code must retain the above copyright
  18.  *    notice, this list of conditions and the following disclaimer.
  19.  * 2. Redistributions in binary form must reproduce the above copyright
  20.  *    notice, this list of conditions and the following disclaimer in the
  21.  *    documentation and/or other materials provided with the distribution.
  22.  * 3. Neither the name of the University nor the names of its contributors
  23.  *    may be used to endorse or promote products derived from this software
  24.  *    without specific prior written permission.
  25.  *
  26.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  27.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  28.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  29.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  30.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  31.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  32.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  33.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  34.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  35.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  36.  * SUCH DAMAGE.
  37.  */
  39. #include "db_config.h"
  41. #ifndef lint
  42. static const char revid[] = "$Id: db_dispatch.c,v 11.41 2001/01/11 18:19:50 bostic Exp $";
  43. #endif /* not lint */
  45. #ifndef NO_SYSTEM_INCLUDES
  46. #include <sys/types.h>
  48. #include <stddef.h>
  49. #include <stdlib.h>
  50. #include <string.h>
  51. #endif
  53. #include "db_int.h"
  54. #include "db_page.h"
  55. #include "db_dispatch.h"
  56. #include "db_am.h"
  57. #include "log_auto.h"
  58. #include "txn.h"
  59. #include "txn_auto.h"
  60. #include "log.h"
  62. static int __db_txnlist_find_internal __P((void *, db_txnlist_type,
  63.      u_int32_t, u_int8_t [DB_FILE_ID_LEN], DB_TXNLIST **, int));
  65. /*
  66.  * __db_dispatch --
  67.  *
  68.  * This is the transaction dispatch function used by the db access methods.
  69.  * It is designed to handle the record format used by all the access
  70.  * methods (the one automatically generated by the db_{h,log,read}.sh
  71.  * scripts in the tools directory).  An application using a different
  72.  * recovery paradigm will supply a different dispatch function to txn_open.
  73.  *
  74.  * PUBLIC: int __db_dispatch __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  75.  */
  76. int
  77. __db_dispatch(dbenv, db, lsnp, redo, info)
  78. DB_ENV *dbenv; /* The environment. */
  79. DBT *db; /* The log record upon which to dispatch. */
  80. DB_LSN *lsnp; /* The lsn of the record being dispatched. */
  81. db_recops redo; /* Redo this op (or undo it). */
  82. void *info;
  83. {
  84. u_int32_t rectype, txnid;
  85. int make_call, ret;
  87. memcpy(&rectype, db->data, sizeof(rectype));
  88. memcpy(&txnid, (u_int8_t *)db->data + sizeof(rectype), sizeof(txnid));
  89. make_call = ret = 0;
  91. /*
  92.  * If we find a record that is in the user's number space and they
  93.  * have specified a recovery routine, let them handle it.  If they
  94.  * didn't specify a recovery routine, then we expect that they've
  95.  * followed all our rules and registered new recovery functions.
  96.  */
  97. switch (redo) {
  98. case DB_TXN_ABORT:
  99. /*
  100.  * XXX
  101.  * db_printlog depends on DB_TXN_ABORT not examining the TXN
  102.  * list.  If that ever changes, fix db_printlog too.
  103.  */
  104. make_call = 1;
  105. break;
  106. case DB_TXN_OPENFILES:
  107. if (rectype == DB_log_register)
  108. return (dbenv->dtab[rectype](dbenv,
  109.     db, lsnp, redo, info));
  110. break;
  111. case DB_TXN_BACKWARD_ROLL:
  112. /*
  113.  * Running full recovery in the backward pass.  If we've
  114.  * seen this txnid before and added to it our commit list,
  115.  * then we do nothing during this pass, unless this is a child
  116.  * commit record, in which case we need to process it.  If
  117.  * we've never seen it, then we call the appropriate recovery
  118.  * routine.
  119.  *
  120.  * We need to always undo DB_db_noop records, so that we
  121.  * properly handle any aborts before the file was closed.
  122.  */
  123. if (rectype == DB_log_register ||
  124.     rectype == DB_txn_ckp || rectype == DB_db_noop
  125.     || rectype == DB_txn_child || (txnid != 0 &&
  126.     (ret = __db_txnlist_find(info, txnid)) != 0)) {
  127. make_call = 1;
  128. if (ret == DB_NOTFOUND && rectype != DB_txn_regop &&
  129.     rectype != DB_txn_xa_regop && (ret =
  130.     __db_txnlist_add(dbenv, info, txnid, 1)) != 0)
  131. return (ret);
  132. }
  133. break;
  134. case DB_TXN_FORWARD_ROLL:
  135. /*
  136.  * In the forward pass, if we haven't seen the transaction,
  137.  * do nothing, else recovery it.
  138.  *
  139.  * We need to always redo DB_db_noop records, so that we
  140.  * properly handle any commits after the file was closed.
  141.  */
  142. if (rectype == DB_log_register ||
  143.     rectype == DB_txn_ckp ||
  144.     rectype == DB_db_noop ||
  145.     __db_txnlist_find(info, txnid) == 0)
  146. make_call = 1;
  147. break;
  148. default:
  149. return (__db_unknown_flag(dbenv, "__db_dispatch", redo));
  150. }
  152. if (make_call) {
  153. if (rectype >= DB_user_BEGIN && dbenv->tx_recover != NULL)
  154. return (dbenv->tx_recover(dbenv, db, lsnp, redo));
  155. else
  156. return (dbenv->dtab[rectype](dbenv, db, lsnp, redo, info));
  157. }
  159. return (0);
  160. }
  162. /*
  163.  * __db_add_recovery --
  164.  *
  165.  * PUBLIC: int __db_add_recovery __P((DB_ENV *,
  166.  * PUBLIC:    int (*)(DB_ENV *, DBT *, DB_LSN *, db_recops, void *), u_int32_t));
  167.  */
  168. int
  169. __db_add_recovery(dbenv, func, ndx)
  170. DB_ENV *dbenv;
  171. int (*func) __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  172. u_int32_t ndx;
  173. {
  174. u_int32_t i, nsize;
  175. int ret;
  177. /* Check if we have to grow the table. */
  178. if (ndx >= dbenv->dtab_size) {
  179. nsize = ndx + 40;
  180. if ((ret = __os_realloc(dbenv,
  181.     nsize * sizeof(dbenv->dtab[0]), NULL, &dbenv->dtab)) != 0)
  182. return (ret);
  183. for (i = dbenv->dtab_size; i < nsize; ++i)
  184. dbenv->dtab[i] = NULL;
  185. dbenv->dtab_size = nsize;
  186. }
  188. dbenv->dtab[ndx] = func;
  189. return (0);
  190. }
  192. /*
  193.  * __deprecated_recover --
  194.  * Stub routine for deprecated recovery functions.
  195.  *
  196.  * PUBLIC: int __deprecated_recover
  197.  * PUBLIC:     __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  198.  */
  199. int
  200. __deprecated_recover(dbenv, dbtp, lsnp, op, info)
  201. DB_ENV *dbenv;
  202. DBT *dbtp;
  203. DB_LSN *lsnp;
  204. db_recops op;
  205. void *info;
  206. {
  207. COMPQUIET(dbenv, NULL);
  208. COMPQUIET(dbtp, NULL);
  209. COMPQUIET(lsnp, NULL);
  210. COMPQUIET(op, 0);
  211. COMPQUIET(info, NULL);
  212. return (EINVAL);
  213. }
  215. /*
  216.  * __db_txnlist_init --
  217.  * Initialize transaction linked list.
  218.  *
  219.  * PUBLIC: int __db_txnlist_init __P((DB_ENV *, void *));
  220.  */
  221. int
  222. __db_txnlist_init(dbenv, retp)
  223. DB_ENV *dbenv;
  224. void *retp;
  225. {
  226. DB_TXNHEAD *headp;
  227. int ret;
  229. if ((ret = __os_malloc(dbenv, sizeof(DB_TXNHEAD), NULL, &headp)) != 0)
  230. return (ret);
  232. LIST_INIT(&headp->head);
  233. headp->maxid = 0;
  234. headp->generation = 1;
  236. *(void **)retp = headp;
  237. return (0);
  238. }
  240. /*
  241.  * __db_txnlist_add --
  242.  * Add an element to our transaction linked list.
  243.  *
  244.  * PUBLIC: int __db_txnlist_add __P((DB_ENV *, void *, u_int32_t, int32_t));
  245.  */
  246. int
  247. __db_txnlist_add(dbenv, listp, txnid, aborted)
  248. DB_ENV *dbenv;
  249. void *listp;
  250. u_int32_t txnid;
  251. int32_t aborted;
  252. {
  253. DB_TXNHEAD *hp;
  254. DB_TXNLIST *elp;
  255. int ret;
  257. if ((ret = __os_malloc(dbenv, sizeof(DB_TXNLIST), NULL, &elp)) != 0)
  258. return (ret);
  260. hp = (DB_TXNHEAD *)listp;
  261. LIST_INSERT_HEAD(&hp->head, elp, links);
  263. elp->type = TXNLIST_TXNID;
  264. elp->u.t.txnid = txnid;
  265. elp->u.t.aborted = aborted;
  266. if (txnid > hp->maxid)
  267. hp->maxid = txnid;
  268. elp->u.t.generation = hp->generation;
  270. return (0);
  271. }
  272. /*
  273.  * __db_txnlist_remove --
  274.  * Remove an element from our transaction linked list.
  275.  *
  276.  * PUBLIC: int __db_txnlist_remove __P((void *, u_int32_t));
  277.  */
  278. int
  279. __db_txnlist_remove(listp, txnid)
  280. void *listp;
  281. u_int32_t txnid;
  282. {
  283. DB_TXNLIST *entry;
  285. return (__db_txnlist_find_internal(listp,
  286.      TXNLIST_TXNID, txnid, NULL, &entry, 1));
  287. }
  289. /* __db_txnlist_close --
  290.  *
  291.  * Call this when we close a file.  It allows us to reconcile whether
  292.  * we have done any operations on this file with whether the file appears
  293.  * to have been deleted.  If you never do any operations on a file, then
  294.  * we assume it's OK to appear deleted.
  295.  *
  296.  * PUBLIC: int __db_txnlist_close __P((void *, int32_t, u_int32_t));
  297.  */
  299. int
  300. __db_txnlist_close(listp, lid, count)
  301. void *listp;
  302. int32_t lid;
  303. u_int32_t count;
  304. {
  305. DB_TXNHEAD *hp;
  306. DB_TXNLIST *p;
  308. hp = (DB_TXNHEAD *)listp;
  309. for (p = LIST_FIRST(&hp->head); p != NULL; p = LIST_NEXT(p, links)) {
  310. if (p->type == TXNLIST_DELETE)
  311. if (lid == p->u.d.fileid &&
  312.     !F_ISSET(&p->u.d, TXNLIST_FLAG_CLOSED)) {
  313. p->u.d.count += count;
  314. return (0);
  315. }
  316. }
  318. return (0);
  319. }
  321. /*
  322.  * __db_txnlist_delete --
  323.  *
  324.  * Record that a file was missing or deleted.  If the deleted
  325.  * flag is set, then we've encountered a delete of a file, else we've
  326.  * just encountered a file that is missing.  The lid is the log fileid
  327.  * and is only meaningful if deleted is not equal to 0.
  328.  *
  329.  * PUBLIC: int __db_txnlist_delete __P((DB_ENV *,
  330.  * PUBLIC:     void *, char *, u_int32_t, int));
  331.  */
  332. int
  333. __db_txnlist_delete(dbenv, listp, name, lid, deleted)
  334. DB_ENV *dbenv;
  335. void *listp;
  336. char *name;
  337. u_int32_t lid;
  338. int deleted;
  339. {
  340. DB_TXNHEAD *hp;
  341. DB_TXNLIST *p;
  342. int ret;
  344. hp = (DB_TXNHEAD *)listp;
  345. for (p = LIST_FIRST(&hp->head); p != NULL; p = LIST_NEXT(p, links)) {
  346. if (p->type == TXNLIST_DELETE)
  347. if (strcmp(name, p->u.d.fname) == 0) {
  348. if (deleted)
  349. F_SET(&p->u.d, TXNLIST_FLAG_DELETED);
  350. else
  351. F_CLR(&p->u.d, TXNLIST_FLAG_CLOSED);
  352. return (0);
  353. }
  354. }
  356. /* Need to add it. */
  357. if ((ret = __os_malloc(dbenv, sizeof(DB_TXNLIST), NULL, &p)) != 0)
  358. return (ret);
  359. LIST_INSERT_HEAD(&hp->head, p, links);
  361. p->type = TXNLIST_DELETE;
  362. p->u.d.flags = 0;
  363. if (deleted)
  364. F_SET(&p->u.d, TXNLIST_FLAG_DELETED);
  365. p->u.d.fileid = lid;
  366. p->u.d.count = 0;
  367. ret = __os_strdup(dbenv, name, &p->u.d.fname);
  369. return (ret);
  370. }
  372. /*
  373.  * __db_txnlist_end --
  374.  * Discard transaction linked list. Print out any error messages
  375.  * for deleted files.
  376.  *
  377.  * PUBLIC: void __db_txnlist_end __P((DB_ENV *, void *));
  378.  */
  379. void
  380. __db_txnlist_end(dbenv, listp)
  381. DB_ENV *dbenv;
  382. void *listp;
  383. {
  384. DB_TXNHEAD *hp;
  385. DB_TXNLIST *p;
  386. DB_LOG *lp;
  388. hp = (DB_TXNHEAD *)listp;
  389. lp = (DB_LOG *)dbenv->lg_handle;
  390. while (hp != NULL && (p = LIST_FIRST(&hp->head)) != NULL) {
  391. LIST_REMOVE(p, links);
  392. switch (p->type) {
  393. case TXNLIST_DELETE:
  394. /*
  395.  * If we have a file that is not deleted and has
  396.  * some operations, we flag the warning.  Since
  397.  * the file could still be open, we need to check
  398.  * the actual log table as well.
  399.  */
  400. if ((!F_ISSET(&p->u.d, TXNLIST_FLAG_DELETED) &&
  401.     p->u.d.count != 0) ||
  402.     (!F_ISSET(&p->u.d, TXNLIST_FLAG_CLOSED) &&
  403.     p->u.d.fileid != (int32_t) TXNLIST_INVALID_ID &&
  404.     p->u.d.fileid < lp->dbentry_cnt &&
  405.     lp->dbentry[p->u.d.fileid].count != 0))
  406. __db_err(dbenv, "warning: %s: %s",
  407.     p->u.d.fname, db_strerror(ENOENT));
  408. __os_freestr(p->u.d.fname);
  409. break;
  410. case TXNLIST_LSN:
  411. __os_free(p->u.l.lsn_array,
  412.     p->u.l.maxn * sizeof(DB_LSN));
  413. break;
  414. default:
  415. /* Possibly an incomplete DB_TXNLIST;  just free it. */
  416. break;
  417. }
  418. __os_free(p, sizeof(DB_TXNLIST));
  419. }
  420. __os_free(listp, sizeof(DB_TXNHEAD));
  421. }
  423. /*
  424.  * __db_txnlist_find --
  425.  * Checks to see if a txnid with the current generation is in the
  426.  * txnid list.  This returns DB_NOTFOUND if the item isn't in the
  427.  * list otherwise it returns (like __db_txnlist_find_internal) a
  428.  * 1 or 0 indicating if the transaction is aborted or not.  A txnid
  429.  * of 0 means the record was generated while not in a transaction.
  430.  *
  431.  * PUBLIC: int __db_txnlist_find __P((void *, u_int32_t));
  432.  */
  433. int
  434. __db_txnlist_find(listp, txnid)
  435. void *listp;
  436. u_int32_t txnid;
  437. {
  438. DB_TXNLIST *entry;
  440. if (txnid == 0)
  441. return (DB_NOTFOUND);
  442. return (__db_txnlist_find_internal(listp,
  443.      TXNLIST_TXNID, txnid, NULL, &entry, 0));
  444. }
  446. /*
  447.  * __db_txnlist_find_internal --
  448.  * Find an entry on the transaction list.
  449.  * If the entry is not there or the list pointeris not initialized
  450.  * we return DB_NOTFOUND.  If the item is found, we return the aborted
  451.  * status (1 for aborted, 0 for not aborted).  Currently we always call
  452.  * this with an initialized list pointer but checking for NULL keeps it general.
  453.  */
  454. static int
  455. __db_txnlist_find_internal(listp, type, txnid, uid, txnlistp, delete)
  456. void *listp;
  457. db_txnlist_type type;
  458. u_int32_t txnid;
  459. u_int8_t uid[DB_FILE_ID_LEN];
  460. DB_TXNLIST **txnlistp;
  461. int delete;
  462. {
  463. DB_TXNHEAD *hp;
  464. DB_TXNLIST *p;
  465. int ret;
  467. if ((hp = (DB_TXNHEAD *)listp) == NULL)
  468. return (DB_NOTFOUND);
  470. for (p = LIST_FIRST(&hp->head); p != NULL; p = LIST_NEXT(p, links)) {
  471. if (p->type != type)
  472. continue;
  473. switch (type) {
  474. case TXNLIST_TXNID:
  475. if (p->u.t.txnid != txnid ||
  476.     hp->generation != p->u.t.generation)
  477. continue;
  478. ret = p->u.t.aborted;
  479. break;
  481. case TXNLIST_PGNO:
  482. if (memcmp(uid, p->u.p.uid, DB_FILE_ID_LEN) != 0)
  483. continue;
  485. ret = 0;
  486. break;
  487. default:
  488. DB_ASSERT(0);
  489. ret = EINVAL;
  490. }
  491. if (delete == 1) {
  492. LIST_REMOVE(p, links);
  493. __os_free(p, sizeof(DB_TXNLIST));
  494. } else if (p != LIST_FIRST(&hp->head)) {
  495. /* Move it to head of list. */
  496. LIST_REMOVE(p, links);
  497. LIST_INSERT_HEAD(&hp->head, p, links);
  498. }
  499. *txnlistp = p;
  500. return (ret);
  501. }
  503. return (DB_NOTFOUND);
  504. }
  506. /*
  507.  * __db_txnlist_gen --
  508.  * Change the current generation number.
  509.  *
  510.  * PUBLIC: void __db_txnlist_gen __P((void *, int));
  511.  */
  512. void
  513. __db_txnlist_gen(listp, incr)
  514. void *listp;
  515. int incr;
  516. {
  517. DB_TXNHEAD *hp;
  519. /*
  520.  * During recovery generation numbers keep track of how many "restart"
  521.  * checkpoints we've seen.  Restart checkpoints occur whenever we take
  522.  * a checkpoint and there are no outstanding transactions.  When that
  523.  * happens, we can reset transaction IDs back to 1.  It always happens
  524.  * at recovery and it prevents us from exhausting the transaction IDs
  525.  * name space.
  526.  */
  527. hp = (DB_TXNHEAD *)listp;
  528. hp->generation += incr;
  529. }
  531. #define TXN_BUBBLE(AP, MAX) {
  532. int __j;
  533. DB_LSN __tmp;
  535. for (__j = 0; __j < MAX - 1; __j++)
  536. if (log_compare(&AP[__j], &AP[__j + 1]) < 0) {
  537. __tmp = AP[__j];
  538. AP[__j] = AP[__j + 1];
  539. AP[__j + 1] = __tmp;
  540. }
  541. }
  543. /*
  544.  * __db_txnlist_lsnadd --
  545.  * Add to or re-sort the transaction list lsn entry.
  546.  * Note that since this is used during an abort, the __txn_undo
  547.  * code calls into the "recovery" subsystem explicitly, and there
  548.  * is only a single TXNLIST_LSN entry on the list.
  549.  *
  550.  * PUBLIC: int __db_txnlist_lsnadd __P((DB_ENV *, void *, DB_LSN *, u_int32_t));
  551.  */
  552. int
  553. __db_txnlist_lsnadd(dbenv, listp, lsnp, flags)
  554. DB_ENV *dbenv;
  555. void *listp;
  556. DB_LSN *lsnp;
  557. u_int32_t flags;
  558. {
  559. DB_TXNHEAD *hp;
  560. DB_TXNLIST *elp;
  561. int i, ret;
  563. hp = (DB_TXNHEAD *)listp;
  565. for (elp = LIST_FIRST(&hp->head);
  566.     elp != NULL; elp = LIST_NEXT(elp, links))
  567. if (elp->type == TXNLIST_LSN)
  568. break;
  570. if (elp == NULL)
  571. return (EINVAL);
  573. if (LF_ISSET(TXNLIST_NEW)) {
  574. if (elp->u.l.ntxns >= elp->u.l.maxn) {
  575. if ((ret = __os_realloc(dbenv,
  576.     2 * elp->u.l.maxn * sizeof(DB_LSN),
  577.     NULL, &elp->u.l.lsn_array)) != 0)
  578. return (ret);
  579. elp->u.l.maxn *= 2;
  580. }
  581. elp->u.l.lsn_array[elp->u.l.ntxns++] = *lsnp;
  582. } else
  583. /* Simply replace the 0th element. */
  584. elp->u.l.lsn_array[0] = *lsnp;
  586. /*
  587.  * If we just added a new entry and there may be NULL
  588.  * entries, so we have to do a complete bubble sort,
  589.  * not just trickle a changed entry around.
  590.  */
  591. for (i = 0; i < (!LF_ISSET(TXNLIST_NEW) ? 1 : elp->u.l.ntxns); i++)
  592. TXN_BUBBLE(elp->u.l.lsn_array, elp->u.l.ntxns);
  594. *lsnp = elp->u.l.lsn_array[0];
  596. return (0);
  597. }
  599. /*
  600.  * __db_txnlist_lsnhead --
  601.  * Return a pointer to the beginning of the lsn_array.
  602.  *
  603.  * PUBLIC: int __db_txnlist_lsnhead __P((void *, DB_LSN **));
  604.  */
  605. int
  606. __db_txnlist_lsnhead(listp, lsnpp)
  607. void *listp;
  608. DB_LSN **lsnpp;
  609. {
  610. DB_TXNHEAD *hp;
  611. DB_TXNLIST *elp;
  613. hp = (DB_TXNHEAD *)listp;
  615. for (elp = LIST_FIRST(&hp->head);
  616.     elp != NULL; elp = LIST_NEXT(elp, links))
  617. if (elp->type == TXNLIST_LSN)
  618. break;
  620. if (elp == NULL)
  621. return (EINVAL);
  623. *lsnpp = &elp->u.l.lsn_array[0];
  625. return (0);
  626. }
  628. /*
  629.  * __db_txnlist_lsninit --
  630.  * Initialize a transaction list with an lsn array entry.
  631.  *
  632.  * PUBLIC: int __db_txnlist_lsninit __P((DB_ENV *, DB_TXNHEAD *, DB_LSN *));
  633.  */
  634. int
  635. __db_txnlist_lsninit(dbenv, hp, lsnp)
  636. DB_ENV *dbenv;
  637. DB_TXNHEAD *hp;
  638. DB_LSN *lsnp;
  639. {
  640. DB_TXNLIST *elp;
  641. int ret;
  643. elp = NULL;
  645. if ((ret = __os_malloc(dbenv, sizeof(DB_TXNLIST), NULL, &elp)) != 0)
  646. goto err;
  647. LIST_INSERT_HEAD(&hp->head, elp, links);
  649. if ((ret = __os_malloc(dbenv,
  650.     12 * sizeof(DB_LSN), NULL, &elp->u.l.lsn_array)) != 0)
  651. goto err;
  652. elp->type = TXNLIST_LSN;
  653. elp->u.l.maxn = 12;
  654. elp->u.l.ntxns = 1;
  655. elp->u.l.lsn_array[0] = *lsnp;
  657. return (0);
  659. err: __db_txnlist_end(dbenv, hp);
  660. return (ret);
  661. }
  663. /*
  664.  * __db_add_limbo -- add pages to the limbo list.
  665.  * Get the file information and call pgnoadd
  666.  * for each page.
  667.  *
  668.  * PUBLIC: int __db_add_limbo __P((DB_ENV *,
  669.  * PUBLIC:      void *, int32_t, db_pgno_t, int32_t));
  670.  */
  671. int
  672. __db_add_limbo(dbenv, info, fileid, pgno, count)
  673. DB_ENV *dbenv;
  674. void *info;
  675. int32_t fileid;
  676. db_pgno_t pgno;
  677. int32_t count;
  678. {
  679. DB_LOG *dblp;
  680. FNAME *fnp;
  681. int ret;
  683. dblp = dbenv->lg_handle;
  684. if ((ret = __log_lid_to_fname(dblp, fileid, &fnp)) != 0)
  685. return (ret);
  687. do {
  688. if ((ret =
  689.     __db_txnlist_pgnoadd(dbenv, info, fileid, fnp->ufid,
  690.     R_ADDR(&dblp->reginfo, fnp->name_off), pgno)) != 0)
  691. return (ret);
  692. pgno++;
  693. } while (--count != 0);
  695. return (0);
  696. }
  698. /*
  699.  * __db_do_the_limbo -- move pages from limbo to free.
  700.  *
  701.  * If we are in recovery we add things to the free list without
  702.  * logging becasue we want to incrementaly apply logs that
  703.  * may be generated on another copy of this environment.
  704.  * Otherwise we just call __db_free to put the pages on
  705.  * the free list and log the activity.
  706.  *
  707.  * PUBLIC: int __db_do_the_limbo __P((DB_ENV *, DB_TXNHEAD *));
  708.  */
  709. int
  710. __db_do_the_limbo(dbenv, hp)
  711. DB_ENV *dbenv;
  712. DB_TXNHEAD *hp;
  713. {
  714. DB *dbp;
  715. DBC *dbc;
  716. DBMETA *meta;
  717. DB_TXN *txn;
  718. DB_TXNLIST *elp;
  719. PAGE *pagep;
  720. db_pgno_t last_pgno, pgno;
  721. int i, in_recover, put_page, ret, t_ret;
  723. dbp = NULL;
  724. dbc = NULL;
  725. txn = NULL;
  726. ret = 0;
  728. /* Are we in recovery? */
  729. in_recover = F_ISSET((DB_LOG *)dbenv->lg_handle, DBLOG_RECOVER);
  731. for (elp = LIST_FIRST(&hp->head);
  732.     elp != NULL; elp = LIST_NEXT(elp, links)) {
  733. if (elp->type != TXNLIST_PGNO)
  734. continue;
  736. if (in_recover) {
  737. if ((ret = db_create(&dbp, dbenv, 0)) != 0)
  738. goto err;
  740. /*
  741.  * It is ok if the file is nolonger there.
  742.  */
  743. dbp->type = DB_UNKNOWN;
  744. ret = __db_dbopen(dbp,
  745.     elp->u.p.fname, 0, __db_omode("rw----"), 0);
  746. } else {
  747. /*
  748.  * If we are in transaction undo, then we know
  749.  * the fileid is still correct.
  750.  */
  751. if ((ret =
  752.     __db_fileid_to_db(dbenv, &dbp,
  753.     elp->u.p.fileid, 0)) != 0 && ret != DB_DELETED)
  754. goto err;
  755. /* File is being destroyed. */
  756. if (F_ISSET(dbp, DB_AM_DISCARD))
  757. ret = DB_DELETED;
  758. }
  759. /*
  760.  * Verify that we are opening the same file that we were
  761.  * referring to when we wrote this log record.
  762.  */
  763. if (ret == 0 &&
  764.     memcmp(elp->u.p.uid, dbp->fileid, DB_FILE_ID_LEN) == 0) {
  765. last_pgno = PGNO_INVALID;
  766. if (in_recover) {
  767. pgno = PGNO_BASE_MD;
  768. if ((ret = memp_fget(dbp->mpf,
  769.     &pgno, 0, (PAGE **)&meta)) != 0)
  770. goto err;
  771. last_pgno = meta->free;
  772. /*
  773.  * Check to see if the head of the free
  774.  * list is any of the pages we are about
  775.  * to link in.  We could have crashed
  776.  * after linking them in and before writing
  777.  * a checkpoint.
  778.  * It may not be the last one since
  779.  * any page may get reallocated before here.
  780.  */
  781. if (last_pgno != PGNO_INVALID)
  782. for (i = 0; i < elp->u.p.nentries; i++)
  783. if (last_pgno
  784.      == elp->u.p.pgno_array[i])
  785. goto done_it;
  786. }
  788. for (i = 0; i < elp->u.p.nentries; i++) {
  789. pgno = elp->u.p.pgno_array[i];
  790. if ((ret = memp_fget(dbp->mpf,
  791.     &pgno, DB_MPOOL_CREATE, &pagep)) != 0)
  792. goto err;
  794. put_page = 1;
  795. if (IS_ZERO_LSN(LSN(pagep))) {
  796. P_INIT(pagep, dbp->pgsize,
  797.     pgno, PGNO_INVALID,
  798.     last_pgno, 0, P_INVALID);
  800. if (in_recover) {
  801. LSN(pagep) = LSN(meta);
  802. last_pgno = pgno;
  803. } else {
  804. /*
  805.  * Starting the transaction
  806.  * is postponed until we know
  807.  * we have something to do.
  808.  */
  809. if (txn == NULL &&
  810.     (ret = txn_begin(dbenv,
  811.     NULL, &txn, 0)) != 0)
  812. goto err;
  814. if (dbc == NULL &&
  815.     (ret = dbp->cursor(dbp,
  816.     txn, &dbc, 0)) != 0)
  817. goto err;
  818. /* Turn off locking. */
  819. F_SET(dbc, DBC_COMPENSATE);
  821. /* __db_free puts the page. */
  822. if ((ret =
  823.     __db_free(dbc, pagep)) != 0)
  824. goto err;
  825. put_page = 0;
  826. }
  827. }
  829. if (put_page == 1 &&
  830.     (ret = memp_fput(dbp->mpf,
  831.     pagep, DB_MPOOL_DIRTY)) != 0)
  832. goto err;
  833. }
  834. if (in_recover) {
  835. if (last_pgno == meta->free) {
  836. done_it:
  837. if ((ret =
  838.     memp_fput(dbp->mpf, meta, 0)) != 0)
  839. goto err;
  840. } else {
  841. /*
  842.  * Flush the new free list then
  843.  * update the metapage.  This is
  844.  * unlogged so we cannot have the
  845.  * metapage pointing at pages that
  846.  * are not on disk.
  847.  */
  848. dbp->sync(dbp, 0);
  849. meta->free = last_pgno;
  850. if ((ret = memp_fput(dbp->mpf,
  851.     meta, DB_MPOOL_DIRTY)) != 0)
  852. goto err;
  853. }
  854. }
  855. if (dbc != NULL && (ret = dbc->c_close(dbc)) != 0)
  856. goto err;
  857. dbc = NULL;
  858. }
  859. if (in_recover && (t_ret = dbp->close(dbp, 0)) != 0 && ret == 0)
  860. ret = t_ret;
  861. dbp = NULL;
  862. __os_free(elp->u.p.fname, 0);
  863. __os_free(elp->u.p.pgno_array, 0);
  864. if (ret == ENOENT)
  865. ret = 0;
  866. else if (ret != 0)
  867. goto err;
  868. }
  870. if (txn != NULL) {
  871. ret = txn_commit(txn, 0);
  872. txn = NULL;
  873. }
  874. err:
  875. if (dbc != NULL)
  876. (void)dbc->c_close(dbc);
  877. if (in_recover && dbp != NULL)
  878. (void)dbp->close(dbp, 0);
  879. if (txn != NULL)
  880. (void)txn_abort(txn);
  881. return (ret);
  883. }
  885. #define DB_TXNLIST_MAX_PGNO 8 /* A nice even number. */
  887. /*
  888.  * __db_txnlist_pgnoadd --
  889.  * Find the txnlist entry for a file and add this pgno,
  890.  * or add the list entry for the file and then add the pgno.
  891.  *
  892.  * PUBLIC: int __db_txnlist_pgnoadd __P((DB_ENV *, DB_TXNHEAD *,
  893.  * PUBLIC:      int32_t, u_int8_t [DB_FILE_ID_LEN], char *, db_pgno_t));
  894.  */
  895. int
  896. __db_txnlist_pgnoadd(dbenv, hp, fileid, uid, fname, pgno)
  897. DB_ENV *dbenv;
  898. DB_TXNHEAD *hp;
  899. int32_t fileid;
  900. u_int8_t uid[DB_FILE_ID_LEN];
  901. char *fname;
  902. db_pgno_t pgno;
  903. {
  904. DB_TXNLIST *elp;
  905. int len, ret;
  907. elp = NULL;
  909. if (__db_txnlist_find_internal(hp, TXNLIST_PGNO, 0, uid, &elp, 0) != 0) {
  910. if ((ret =
  911.     __os_malloc(dbenv, sizeof(DB_TXNLIST), NULL, &elp)) != 0)
  912. goto err;
  913. LIST_INSERT_HEAD(&hp->head, elp, links);
  914. elp->u.p.fileid = fileid;
  915. memcpy(elp->u.p.uid, uid, DB_FILE_ID_LEN);
  917. len = strlen(fname) + 1;
  918. if ((ret = __os_malloc(dbenv, len, NULL, &elp->u.p.fname)) != 0)
  919. goto err;
  920. memcpy(elp->u.p.fname, fname, len);
  922. elp->u.p.maxentry = 0;
  923. elp->type = TXNLIST_PGNO;
  924. if ((ret = __os_malloc(dbenv,
  925.     8 * sizeof(db_pgno_t), NULL, &elp->u.p.pgno_array)) != 0)
  926. goto err;
  927. elp->u.p.maxentry = DB_TXNLIST_MAX_PGNO;
  928. elp->u.p.nentries = 0;
  929. } else if (elp->u.p.nentries == elp->u.p.maxentry) {
  930. elp->u.p.maxentry <<= 1;
  931. if ((ret = __os_realloc(dbenv, elp->u.p.maxentry *
  932.     sizeof(db_pgno_t), NULL, &elp->u.p.pgno_array)) != 0)
  933. goto err;
  934. }
  936. elp->u.p.pgno_array[elp->u.p.nentries++] = pgno;
  938. return (0);
  940. err: __db_txnlist_end(dbenv, hp);
  941. return (ret);
  942. }
  944. #ifdef DEBUG
  945. /*
  946.  * __db_txnlist_print --
  947.  * Print out the transaction list.
  948.  *
  949.  * PUBLIC: void __db_txnlist_print __P((void *));
  950.  */
  951. void
  952. __db_txnlist_print(listp)
  953. void *listp;
  954. {
  955. DB_TXNHEAD *hp;
  956. DB_TXNLIST *p;
  958. hp = (DB_TXNHEAD *)listp;
  960. printf("Maxid: %lu Generation: %lun",
  961.     (u_long)hp->maxid, (u_long)hp->generation);
  962. for (p = LIST_FIRST(&hp->head); p != NULL; p = LIST_NEXT(p, links)) {
  963. switch (p->type) {
  964. case TXNLIST_TXNID:
  965. printf("TXNID: %lu(%lu)n",
  966.     (u_long)p->u.t.txnid, (u_long)p->u.t.generation);
  967. break;
  968. case TXNLIST_DELETE:
  969. printf("FILE: %s id=%d ops=%d %s %sn",
  970.     p->u.d.fname, p->u.d.fileid, p->u.d.count,
  971.     F_ISSET(&p->u.d, TXNLIST_FLAG_DELETED) ?
  972.     "(deleted)" : "(missing)",
  973.     F_ISSET(&p->u.d, TXNLIST_FLAG_CLOSED) ?
  974.     "(closed)" : "(open)");
  976. break;
  977. default:
  978. printf("Unrecognized type: %dn", p->type);
  979. break;
  980. }
  981. }
  982. }
  983. #endif