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

MySQL数据库

开发平台:

Visual C++

  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 1999-2002
  5.  * Sleepycat Software.  All rights reserved.
  6.  */
  7. #include "db_config.h"
  8. #ifndef lint
  9. static const char revid[] = "$Id: qam_open.c,v 11.55 2002/09/04 19:06:45 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/crypto.h"
  17. #include "dbinc/db_page.h"
  18. #include "dbinc/db_shash.h"
  19. #include "dbinc/db_swap.h"
  20. #include "dbinc/db_am.h"
  21. #include "dbinc/lock.h"
  22. #include "dbinc/qam.h"
  23. #include "dbinc/fop.h"
  24. static int __qam_init_meta __P((DB *, QMETA *));
  25. /*
  26.  * __qam_open
  27.  *
  28.  * PUBLIC: int __qam_open __P((DB *,
  29.  * PUBLIC:     DB_TXN *, const char *, db_pgno_t, int, u_int32_t));
  30.  */
  31. int
  32. __qam_open(dbp, txn, name, base_pgno, mode, flags)
  33. DB *dbp;
  34. DB_TXN *txn;
  35. const char *name;
  36. db_pgno_t base_pgno;
  37. int mode;
  38. u_int32_t flags;
  39. {
  40. DBC *dbc;
  41. DB_ENV *dbenv;
  42. DB_LOCK metalock;
  43. DB_MPOOLFILE *mpf;
  44. QMETA *qmeta;
  45. QUEUE *t;
  46. int ret, t_ret;
  47. dbenv = dbp->dbenv;
  48. mpf = dbp->mpf;
  49. t = dbp->q_internal;
  50. ret = 0;
  51. qmeta = NULL;
  52. /* Initialize the remaining fields/methods of the DB. */
  53. dbp->stat = __qam_stat;
  54. dbp->sync = __qam_sync;
  55. dbp->db_am_remove = __qam_remove;
  56. dbp->db_am_rename = __qam_rename;
  57. /*
  58.  * Get a cursor.  If DB_CREATE is specified, we may be creating
  59.  * pages, and to do that safely in CDB we need a write cursor.
  60.  * In STD_LOCKING mode, we'll synchronize using the meta page
  61.  * lock instead.
  62.  */
  63. if ((ret = dbp->cursor(dbp, txn, &dbc,
  64.     LF_ISSET(DB_CREATE) && CDB_LOCKING(dbenv) ?  DB_WRITECURSOR : 0))
  65.     != 0)
  66. return (ret);
  67. /*
  68.  * Get the meta data page.  It must exist, because creates of
  69.  * files/databases come in through the __qam_new_file interface
  70.  * and queue doesn't support subdatabases.
  71.  */
  72. if ((ret =
  73.     __db_lget(dbc, 0, base_pgno, DB_LOCK_READ, 0, &metalock)) != 0)
  74. goto err;
  75. if ((ret =
  76.     mpf->get(mpf, &base_pgno, 0, (PAGE **)&qmeta)) != 0)
  77. goto err;
  78. /* If the magic number is incorrect, that's a fatal error. */
  79. if (qmeta->dbmeta.magic != DB_QAMMAGIC) {
  80. __db_err(dbenv, "%s: unexpected file type or format", name);
  81. ret = EINVAL;
  82. goto err;
  83. }
  84. /* Setup information needed to open extents. */
  85. t->page_ext = qmeta->page_ext;
  86. if (t->page_ext != 0) {
  87. t->pginfo.db_pagesize = dbp->pgsize;
  88. t->pginfo.flags =
  89.     F_ISSET(dbp, (DB_AM_CHKSUM | DB_AM_ENCRYPT | DB_AM_SWAP));
  90. t->pginfo.type = dbp->type;
  91. t->pgcookie.data = &t->pginfo;
  92. t->pgcookie.size = sizeof(DB_PGINFO);
  93. if ((ret = __os_strdup(dbp->dbenv, name,  &t->path)) != 0)
  94. return (ret);
  95. t->dir = t->path;
  96. if ((t->name = __db_rpath(t->path)) == NULL) {
  97. t->name = t->path;
  98. t->dir = PATH_DOT;
  99. } else
  100. *t->name++ = '';
  101. if (mode == 0)
  102. mode = __db_omode("rwrw--");
  103. t->mode = mode;
  104. }
  105. if (name == NULL && t->page_ext != 0) {
  106. __db_err(dbenv,
  107. "Extent size may not be specified for in-memory queue database");
  108. return (EINVAL);
  109. }
  110. t->re_pad = qmeta->re_pad;
  111. t->re_len = qmeta->re_len;
  112. t->rec_page = qmeta->rec_page;
  113. t->q_meta = base_pgno;
  114. t->q_root = base_pgno + 1;
  115. err: if (qmeta != NULL && (t_ret = mpf->put(mpf, qmeta, 0)) != 0 && ret == 0)
  116. ret = t_ret;
  117. /* Don't hold the meta page long term. */
  118. (void)__LPUT(dbc, metalock);
  119. if ((t_ret = dbc->c_close(dbc)) != 0 && ret == 0)
  120. ret = t_ret;
  121. return (ret);
  122. }
  123. /*
  124.  * __qam_metachk --
  125.  *
  126.  * PUBLIC: int __qam_metachk __P((DB *, const char *, QMETA *));
  127.  */
  128. int
  129. __qam_metachk(dbp, name, qmeta)
  130. DB *dbp;
  131. const char *name;
  132. QMETA *qmeta;
  133. {
  134. DB_ENV *dbenv;
  135. u_int32_t vers;
  136. int ret;
  137. dbenv = dbp->dbenv;
  138. ret = 0;
  139. /*
  140.  * At this point, all we know is that the magic number is for a Queue.
  141.  * Check the version, the database may be out of date.
  142.  */
  143. vers = qmeta->dbmeta.version;
  144. if (F_ISSET(dbp, DB_AM_SWAP))
  145. M_32_SWAP(vers);
  146. switch (vers) {
  147. case 1:
  148. case 2:
  149. __db_err(dbenv,
  150.     "%s: queue version %lu requires a version upgrade",
  151.     name, (u_long)vers);
  152. return (DB_OLD_VERSION);
  153. case 3:
  154. case 4:
  155. break;
  156. default:
  157. __db_err(dbenv,
  158.     "%s: unsupported qam version: %lu", name, (u_long)vers);
  159. return (EINVAL);
  160. }
  161. /* Swap the page if we need to. */
  162. if (F_ISSET(dbp, DB_AM_SWAP) && (ret = __qam_mswap((PAGE *)qmeta)) != 0)
  163. return (ret);
  164. /* Check the type. */
  165. if (dbp->type != DB_QUEUE && dbp->type != DB_UNKNOWN)
  166. return (EINVAL);
  167. dbp->type = DB_QUEUE;
  168. DB_ILLEGAL_METHOD(dbp, DB_OK_QUEUE);
  169. /* Set the page size. */
  170. dbp->pgsize = qmeta->dbmeta.pagesize;
  171. /* Copy the file's ID. */
  172. memcpy(dbp->fileid, qmeta->dbmeta.uid, DB_FILE_ID_LEN);
  173. /* Set up AM-specific methods that do not require an open. */
  174. dbp->db_am_rename = __qam_rename;
  175. dbp->db_am_remove = __qam_remove;
  176. return (ret);
  177. }
  178. /*
  179.  * __qam_init_meta --
  180.  * Initialize the meta-data for a Queue database.
  181.  */
  182. static int
  183. __qam_init_meta(dbp, meta)
  184. DB *dbp;
  185. QMETA *meta;
  186. {
  187. QUEUE *t;
  188. t = dbp->q_internal;
  189. memset(meta, 0, sizeof(QMETA));
  190. LSN_NOT_LOGGED(meta->dbmeta.lsn);
  191. meta->dbmeta.pgno = PGNO_BASE_MD;
  192. meta->dbmeta.last_pgno = 0;
  193. meta->dbmeta.magic = DB_QAMMAGIC;
  194. meta->dbmeta.version = DB_QAMVERSION;
  195. meta->dbmeta.pagesize = dbp->pgsize;
  196. if (F_ISSET(dbp, DB_AM_CHKSUM))
  197. FLD_SET(meta->dbmeta.metaflags, DBMETA_CHKSUM);
  198. if (F_ISSET(dbp, DB_AM_ENCRYPT)) {
  199. meta->dbmeta.encrypt_alg =
  200.    ((DB_CIPHER *)dbp->dbenv->crypto_handle)->alg;
  201. DB_ASSERT(meta->dbmeta.encrypt_alg != 0);
  202. meta->crypto_magic = meta->dbmeta.magic;
  203. }
  204. meta->dbmeta.type = P_QAMMETA;
  205. meta->re_pad = t->re_pad;
  206. meta->re_len = t->re_len;
  207. meta->rec_page = CALC_QAM_RECNO_PER_PAGE(dbp);
  208. meta->cur_recno = 1;
  209. meta->first_recno = 1;
  210. meta->page_ext = t->page_ext;
  211. t->rec_page = meta->rec_page;
  212. memcpy(meta->dbmeta.uid, dbp->fileid, DB_FILE_ID_LEN);
  213. /* Verify that we can fit at least one record per page. */
  214. if (QAM_RECNO_PER_PAGE(dbp) < 1) {
  215. __db_err(dbp->dbenv,
  216.     "Record size of %lu too large for page size of %lu",
  217.     (u_long)t->re_len, (u_long)dbp->pgsize);
  218. return (EINVAL);
  219. }
  220. return (0);
  221. }
  222. /*
  223.  * __qam_new_file --
  224.  * Create the necessary pages to begin a new queue database file.
  225.  *
  226.  * This code appears more complex than it is because of the two cases (named
  227.  * and unnamed).  The way to read the code is that for each page being created,
  228.  * there are three parts: 1) a "get page" chunk (which either uses malloc'd
  229.  * memory or calls mpf->get), 2) the initialization, and 3) the "put page"
  230.  * chunk which either does a fop write or an mpf->put.
  231.  *
  232.  * PUBLIC: int __qam_new_file __P((DB *, DB_TXN *, DB_FH *, const char *));
  233.  */
  234. int
  235. __qam_new_file(dbp, txn, fhp, name)
  236. DB *dbp;
  237. DB_TXN *txn;
  238. DB_FH *fhp;
  239. const char *name;
  240. {
  241. QMETA *meta;
  242. DB_ENV *dbenv;
  243. DB_MPOOLFILE *mpf;
  244. DB_PGINFO pginfo;
  245. DBT pdbt;
  246. db_pgno_t pgno;
  247. int ret;
  248. void *buf;
  249. dbenv = dbp->dbenv;
  250. mpf = dbp->mpf;
  251. buf = NULL;
  252. meta = NULL;
  253. /* Build meta-data page. */
  254. if (name == NULL) {
  255. pgno = PGNO_BASE_MD;
  256. ret = mpf->get(mpf, &pgno, DB_MPOOL_CREATE, &meta);
  257. } else {
  258. ret = __os_calloc(dbp->dbenv, 1, dbp->pgsize, &buf);
  259. meta = (QMETA *)buf;
  260. }
  261. if (ret != 0)
  262. return (ret);
  263. if ((ret = __qam_init_meta(dbp, meta)) != 0)
  264. goto err;
  265. if (name == NULL)
  266. ret = mpf->put(mpf, meta, DB_MPOOL_DIRTY);
  267. else {
  268. pginfo.db_pagesize = dbp->pgsize;
  269. pginfo.flags =
  270.     F_ISSET(dbp, (DB_AM_CHKSUM | DB_AM_ENCRYPT | DB_AM_SWAP));
  271. pginfo.type = DB_QUEUE;
  272. pdbt.data = &pginfo;
  273. pdbt.size = sizeof(pginfo);
  274. if ((ret = __db_pgout(dbenv, PGNO_BASE_MD, meta, &pdbt)) != 0)
  275. goto err;
  276. ret = __fop_write(dbenv,
  277.     txn, name, DB_APP_DATA, fhp, 0, buf, dbp->pgsize, 1);
  278. }
  279. if (ret != 0)
  280. goto err;
  281. meta = NULL;
  282. err: if (name != NULL)
  283. __os_free(dbenv, buf);
  284. else if (meta != NULL)
  285. (void)mpf->put(mpf, meta, 0);
  286. return (ret);
  287. }