dbreg.c
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:11k
源码类别:

MySQL数据库

开发平台:

Visual 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"
  8. #ifndef lint
  9. static const char revid[] = "$Id: dbreg.c,v 11.68 2002/08/28 19:05:27 margo Exp $";
  10. #endif /* not lint */
  11. #ifndef NO_SYSTEM_INCLUDES
  12. #include <sys/types.h>
  13. #include <string.h>
  14. #endif
  15. #include "db_int.h"
  16. #include "dbinc/log.h"
  17. #include "dbinc/txn.h"
  18. /*
  19.  * The dbreg subsystem, as its name implies, registers database handles so
  20.  * that we can associate log messages with them without logging a filename
  21.  * or a full, unique DB ID.  Instead, we assign each dbp an int32_t which is
  22.  * easy and cheap to log, and use this subsystem to map back and forth.
  23.  *
  24.  * Overview of how dbreg ids are managed:
  25.  *
  26.  * OPEN
  27.  * dbreg_setup (Creates FNAME struct.)
  28.  * dbreg_new_id (Assigns new ID to dbp and logs it.  May be postponed
  29.  * until we attempt to log something else using that dbp, if the dbp
  30.  * was opened on a replication client.)
  31.  *
  32.  * CLOSE
  33.  * dbreg_close_id  (Logs closure of dbp/revocation of ID.)
  34.  * dbreg_revoke_id (As name implies, revokes ID.)
  35.  * dbreg_teardown (Destroys FNAME.)
  36.  *
  37.  * RECOVERY
  38.  * dbreg_setup
  39.  * dbreg_assign_id (Assigns a particular ID we have in the log to a dbp.)
  40.  *
  41.  * sometimes: dbreg_revoke_id; dbreg_teardown
  42.  * other times: normal close path
  43.  *
  44.  * A note about locking:
  45.  *
  46.  * FNAME structures are referenced only by their corresponding dbp's
  47.  * until they have a valid id.
  48.  *
  49.  * Once they have a valid id, they must get linked into the log
  50.  * region list so they can get logged on checkpoints.
  51.  *
  52.  * An FNAME that may/does have a valid id must be accessed under
  53.  * protection of the fq_mutex, with the following exception:
  54.  *
  55.  * We don't want to have to grab the fq_mutex on every log
  56.  * record, and it should be safe not to do so when we're just
  57.  * looking at the id, because once allocated, the id should
  58.  * not change under a handle until the handle is closed.
  59.  *
  60.  * If a handle is closed during an attempt by another thread to
  61.  * log with it, well, the application doing the close deserves to
  62.  * go down in flames and a lot else is about to fail anyway.
  63.  *
  64.  * When in the course of logging we encounter an invalid id
  65.  * and go to allocate it lazily, we *do* need to check again
  66.  * after grabbing the mutex, because it's possible to race with
  67.  * another thread that has also decided that it needs to allocate
  68.  * a id lazily.
  69.  *
  70.  * See SR #5623 for further discussion of the new dbreg design.
  71.  */
  72. /*
  73.  * __dbreg_setup --
  74.  * Allocate and initialize an FNAME structure.  The FNAME structures
  75.  * live in the log shared region and map one-to-one with open database handles.
  76.  * When the handle needs to be logged, the FNAME should have a valid fid
  77.  * allocated.  If the handle currently isn't logged, it still has an FNAME
  78.  * entry.  If we later discover that the handle needs to be logged, we can
  79.  * allocate a id for it later.  (This happens when the handle is on a
  80.  * replication client that later becomes a master.)
  81.  *
  82.  * PUBLIC: int __dbreg_setup __P((DB *, const char *, u_int32_t));
  83.  */
  84. int
  85. __dbreg_setup(dbp, name, create_txnid)
  86. DB *dbp;
  87. const char *name;
  88. u_int32_t create_txnid;
  89. {
  90. DB_ENV *dbenv;
  91. DB_LOG *dblp;
  92. FNAME *fnp;
  93. int ret;
  94. size_t len;
  95. void *namep;
  96. dbenv = dbp->dbenv;
  97. dblp = dbenv->lg_handle;
  98. fnp = NULL;
  99. namep = NULL;
  100. /* Allocate an FNAME and, if necessary, a buffer for the name itself. */
  101. R_LOCK(dbenv, &dblp->reginfo);
  102. if ((ret =
  103.     __db_shalloc(dblp->reginfo.addr, sizeof(FNAME), 0, &fnp)) != 0) {
  104. R_UNLOCK(dbenv, &dblp->reginfo);
  105. return (ret);
  106. }
  107. memset(fnp, 0, sizeof(FNAME));
  108. if (name != NULL) {
  109. len = strlen(name) + 1;
  110. if ((ret = __db_shalloc(dblp->reginfo.addr,
  111.     len, 0, &namep)) != 0) {
  112. R_UNLOCK(dbenv, &dblp->reginfo);
  113. return (ret);
  114. }
  115. fnp->name_off = R_OFFSET(&dblp->reginfo, namep);
  116. memcpy(namep, name, len);
  117. } else
  118. fnp->name_off = INVALID_ROFF;
  119. R_UNLOCK(dbenv, &dblp->reginfo);
  120. /*
  121.  * Fill in all the remaining info that we'll need later to register
  122.  * the file, if we use it for logging.
  123.  */
  124. fnp->id = DB_LOGFILEID_INVALID;
  125. fnp->s_type = dbp->type;
  126. memcpy(fnp->ufid, dbp->fileid, DB_FILE_ID_LEN);
  127. fnp->meta_pgno = dbp->meta_pgno;
  128. fnp->create_txnid = create_txnid;
  129. dbp->log_filename = fnp;
  130. return (0);
  131. }
  132. /*
  133.  * __dbreg_teardown --
  134.  * Destroy a DB handle's FNAME struct.
  135.  *
  136.  * PUBLIC: int __dbreg_teardown __P((DB *));
  137.  */
  138. int
  139. __dbreg_teardown(dbp)
  140. DB *dbp;
  141. {
  142. DB_ENV *dbenv;
  143. DB_LOG *dblp;
  144. FNAME *fnp;
  145. dbenv = dbp->dbenv;
  146. dblp = dbenv->lg_handle;
  147. fnp = dbp->log_filename;
  148. /*
  149.  * We may not have an FNAME if we were never opened.  This is not an
  150.  * error.
  151.  */
  152. if (fnp == NULL)
  153. return (0);
  154. DB_ASSERT(fnp->id == DB_LOGFILEID_INVALID);
  155. R_LOCK(dbenv, &dblp->reginfo);
  156. if (fnp->name_off != INVALID_ROFF)
  157. __db_shalloc_free(dblp->reginfo.addr,
  158.     R_ADDR(&dblp->reginfo, fnp->name_off));
  159. __db_shalloc_free(dblp->reginfo.addr, fnp);
  160. R_UNLOCK(dbenv, &dblp->reginfo);
  161. dbp->log_filename = NULL;
  162. return (0);
  163. }
  164. /*
  165.  * __dbreg_new_id --
  166.  * Assign an unused dbreg id to this database handle.
  167.  *
  168.  * PUBLIC: int __dbreg_new_id __P((DB *, DB_TXN *));
  169.  */
  170. int
  171. __dbreg_new_id(dbp, txn)
  172. DB *dbp;
  173. DB_TXN *txn;
  174. {
  175. DBT fid_dbt, r_name;
  176. DB_ENV *dbenv;
  177. DB_LOG *dblp;
  178. DB_LSN unused;
  179. FNAME *fnp;
  180. LOG *lp;
  181. int32_t id;
  182. int ret;
  183. dbenv = dbp->dbenv;
  184. dblp = dbenv->lg_handle;
  185. lp = dblp->reginfo.primary;
  186. fnp = dbp->log_filename;
  187. /* The fq_mutex protects the FNAME list and id management. */
  188. MUTEX_LOCK(dbenv, &lp->fq_mutex);
  189. /*
  190.  * It's possible that after deciding we needed to call this function,
  191.  * someone else allocated an ID before we grabbed the lock.  Check
  192.  * to make sure there was no race and we have something useful to do.
  193.  */
  194. if (fnp->id != DB_LOGFILEID_INVALID) {
  195. MUTEX_UNLOCK(dbenv, &lp->fq_mutex);
  196. return (0);
  197. }
  198. /* Get an unused ID from the free list. */
  199. if ((ret = __dbreg_pop_id(dbenv, &id)) != 0)
  200. goto err;
  201. /* If no ID was found, allocate a new one. */
  202. if (id == DB_LOGFILEID_INVALID)
  203. id = lp->fid_max++;
  204. fnp->id = id;
  205. /* Hook the FNAME into the list of open files. */
  206. SH_TAILQ_INSERT_HEAD(&lp->fq, fnp, q, __fname);
  207. /*
  208.  * Log the registry.  We should only request a new ID in situations
  209.  * where logging is reasonable.
  210.  */
  211. DB_ASSERT(!F_ISSET(dbp, DB_AM_RECOVER));
  212. memset(&fid_dbt, 0, sizeof(fid_dbt));
  213. memset(&r_name, 0, sizeof(r_name));
  214. if (fnp->name_off != INVALID_ROFF) {
  215. r_name.data = R_ADDR(&dblp->reginfo, fnp->name_off);
  216. r_name.size = (u_int32_t)strlen((char *)r_name.data) + 1;
  217. }
  218. fid_dbt.data = dbp->fileid;
  219. fid_dbt.size = DB_FILE_ID_LEN;
  220. if ((ret = __dbreg_register_log(dbenv, txn, &unused, 0, LOG_OPEN,
  221.     r_name.size == 0 ? NULL : &r_name, &fid_dbt, id, fnp->s_type,
  222.     fnp->meta_pgno, fnp->create_txnid)) != 0)
  223. goto err;
  224. DB_ASSERT(dbp->type == fnp->s_type);
  225. DB_ASSERT(dbp->meta_pgno == fnp->meta_pgno);
  226. if ((ret = __dbreg_add_dbentry(dbenv, dblp, dbp, id)) != 0)
  227. goto err;
  228. err: MUTEX_UNLOCK(dbenv, &lp->fq_mutex);
  229. return (ret);
  230. }
  231. /*
  232.  * __dbreg_assign_id --
  233.  * Assign a particular dbreg id to this database handle.
  234.  *
  235.  * PUBLIC: int __dbreg_assign_id __P((DB *, int32_t));
  236.  */
  237. int
  238. __dbreg_assign_id(dbp, id)
  239. DB *dbp;
  240. int32_t id;
  241. {
  242. DB *close_dbp;
  243. DB_ENV *dbenv;
  244. DB_LOG *dblp;
  245. FNAME *close_fnp, *fnp;
  246. LOG *lp;
  247. int ret;
  248. dbenv = dbp->dbenv;
  249. dblp = dbenv->lg_handle;
  250. lp = dblp->reginfo.primary;
  251. fnp = dbp->log_filename;
  252. close_dbp = NULL;
  253. close_fnp = NULL;
  254. /* The fq_mutex protects the FNAME list and id management. */
  255. MUTEX_LOCK(dbenv, &lp->fq_mutex);
  256. /* We should only call this on DB handles that have no ID. */
  257. DB_ASSERT(fnp->id == DB_LOGFILEID_INVALID);
  258. /*
  259.  * Make sure there isn't already a file open with this ID. There can
  260.  * be in recovery, if we're recovering across a point where an ID got
  261.  * reused.
  262.  */
  263. if (__dbreg_id_to_fname(dblp, id, 1, &close_fnp) == 0) {
  264. /*
  265.  * We want to save off any dbp we have open with this id.
  266.  * We can't safely close it now, because we hold the fq_mutex,
  267.  * but we should be able to rely on it being open in this
  268.  * process, and we're running recovery, so no other thread
  269.  * should muck with it if we just put off closing it until
  270.  * we're ready to return.
  271.  *
  272.  * Once we have the dbp, revoke its id;  we're about to
  273.  * reuse it.
  274.  */
  275. ret = __dbreg_id_to_db_int(dbenv, NULL, &close_dbp, id, 0, 0);
  276. if (ret == ENOENT) {
  277. ret = 0;
  278. goto cont;
  279. } else if (ret != 0)
  280. goto err;
  281. if ((ret = __dbreg_revoke_id(close_dbp, 1)) != 0)
  282. goto err;
  283. }
  284. /*
  285.  * Remove this ID from the free list, if it's there, and make sure
  286.  * we don't allocate it anew.
  287.  */
  288. cont: if ((ret = __dbreg_pluck_id(dbenv, id)) != 0)
  289. goto err;
  290. if (id >= lp->fid_max)
  291. lp->fid_max = id + 1;
  292. /* Now go ahead and assign the id to our dbp. */
  293. fnp->id = id;
  294. SH_TAILQ_INSERT_HEAD(&lp->fq, fnp, q, __fname);
  295. if ((ret = __dbreg_add_dbentry(dbenv, dblp, dbp, id)) != 0)
  296. goto err;
  297. err: MUTEX_UNLOCK(dbenv, &lp->fq_mutex);
  298. /* There's nothing useful that our caller can do if this close fails. */
  299. if (close_dbp != NULL)
  300. (void)close_dbp->close(close_dbp, DB_NOSYNC);
  301. return (ret);
  302. }
  303. /*
  304.  * __dbreg_revoke_id --
  305.  * Take a log id away from a dbp, in preparation for closing it,
  306.  * but without logging the close.
  307.  *
  308.  * PUBLIC: int __dbreg_revoke_id __P((DB *, int));
  309.  */
  310. int
  311. __dbreg_revoke_id(dbp, have_lock)
  312. DB *dbp;
  313. int have_lock;
  314. {
  315. DB_ENV *dbenv;
  316. DB_LOG *dblp;
  317. FNAME *fnp;
  318. LOG *lp;
  319. int32_t id;
  320. int ret;
  321. dbenv = dbp->dbenv;
  322. dblp = dbenv->lg_handle;
  323. lp = dblp->reginfo.primary;
  324. fnp = dbp->log_filename;
  325. /* If we lack an ID, this is a null-op. */
  326. if (fnp == NULL || fnp->id == DB_LOGFILEID_INVALID)
  327. return (0);
  328. if (!have_lock)
  329. MUTEX_LOCK(dbenv, &lp->fq_mutex);
  330. id = fnp->id;
  331. fnp->id = DB_LOGFILEID_INVALID;
  332. /* Remove the FNAME from the list of open files. */
  333. SH_TAILQ_REMOVE(&lp->fq, fnp, q, __fname);
  334. /* Remove this id from the dbentry table. */
  335. __dbreg_rem_dbentry(dblp, id);
  336. /* Push this id onto the free list. */
  337. ret = __dbreg_push_id(dbenv, id);
  338. if (!have_lock)
  339. MUTEX_UNLOCK(dbenv, &lp->fq_mutex);
  340. return (ret);
  341. }
  342. /*
  343.  * __dbreg_close_id --
  344.  * Take a dbreg id away from a dbp that we're closing, and log
  345.  * the unregistry.
  346.  *
  347.  * PUBLIC: int __dbreg_close_id __P((DB *, DB_TXN *));
  348.  */
  349. int
  350. __dbreg_close_id(dbp, txn)
  351. DB *dbp;
  352. DB_TXN *txn;
  353. {
  354. DBT fid_dbt, r_name, *dbtp;
  355. DB_ENV *dbenv;
  356. DB_LOG *dblp;
  357. DB_LSN r_unused;
  358. FNAME *fnp;
  359. LOG *lp;
  360. int ret;
  361. dbenv = dbp->dbenv;
  362. dblp = dbenv->lg_handle;
  363. lp = dblp->reginfo.primary;
  364. fnp = dbp->log_filename;
  365. /* If we lack an ID, this is a null-op. */
  366. if (fnp == NULL || fnp->id == DB_LOGFILEID_INVALID)
  367. return (0);
  368. MUTEX_LOCK(dbenv, &lp->fq_mutex);
  369. if (fnp->name_off == INVALID_ROFF)
  370. dbtp = NULL;
  371. else {
  372. memset(&r_name, 0, sizeof(r_name));
  373. r_name.data = R_ADDR(&dblp->reginfo, fnp->name_off);
  374. r_name.size =
  375.     (u_int32_t)strlen((char *)r_name.data) + 1;
  376. dbtp = &r_name;
  377. }
  378. memset(&fid_dbt, 0, sizeof(fid_dbt));
  379. fid_dbt.data = fnp->ufid;
  380. fid_dbt.size = DB_FILE_ID_LEN;
  381. if ((ret = __dbreg_register_log(dbenv, txn,
  382.     &r_unused, 0, LOG_CLOSE, dbtp, &fid_dbt, fnp->id,
  383.     fnp->s_type, fnp->meta_pgno, TXN_INVALID)) != 0)
  384. goto err;
  385. ret = __dbreg_revoke_id(dbp, 1);
  386. err: MUTEX_UNLOCK(dbenv, &lp->fq_mutex);
  387. return (ret);
  388. }