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

MySQL数据库

开发平台:

Visual C++

  1. /* DO NOT EDIT: automatically built by dist/s_win32. */
  2. /*-
  3.  * See the file LICENSE for redistribution information.
  4.  *
  5.  * Copyright (c) 1996-2002
  6.  * Sleepycat Software.  All rights reserved.
  7.  *
  8.  * $Id: db_int.in,v 11.106 2002/09/10 02:48:08 bostic Exp $
  9.  */
  10. #ifndef _DB_INTERNAL_H_
  11. #define _DB_INTERNAL_H_
  12. /*******************************************************
  13.  * System includes, db.h, a few general DB includes.  The DB includes are
  14.  * here because it's OK if db_int.h includes queue structure declarations.
  15.  *******************************************************/
  16. #ifndef NO_SYSTEM_INCLUDES
  17. #if defined(__STDC__) || defined(__cplusplus)
  18. #include <stdarg.h>
  19. #else
  20. #include <varargs.h>
  21. #endif
  22. #include <errno.h>
  23. #endif
  24. #include "db.h"
  25. #include "dbinc/queue.h"
  26. #include "dbinc/shqueue.h"
  27. #if defined(__cplusplus)
  28. extern "C" {
  29. #endif
  30. /*******************************************************
  31.  * General purpose constants and macros.
  32.  *******************************************************/
  33. #define UINT16_T_MAX     0xffff /* Maximum 16 bit unsigned. */
  34. #define UINT32_T_MAX 0xffffffff /* Maximum 32 bit unsigned. */
  35. #define MEGABYTE 1048576
  36. #define GIGABYTE 1073741824
  37. #define MS_PER_SEC 1000 /* Milliseconds in a second. */
  38. #define USEC_PER_MS 1000 /* Microseconds in a millisecond. */
  39. #define RECNO_OOB 0 /* Illegal record number. */
  40. /* Test for a power-of-two (tests true for zero, which doesn't matter here). */
  41. #define POWER_OF_TWO(x) (((x) & ((x) - 1)) == 0)
  42. /* Test for valid page sizes. */
  43. #define DB_MIN_PGSIZE 0x000200 /* Minimum page size (512). */
  44. #define DB_MAX_PGSIZE 0x010000 /* Maximum page size (65536). */
  45. #define IS_VALID_PAGESIZE(x)
  46. (POWER_OF_TWO(x) && (x) >= DB_MIN_PGSIZE && ((x) <= DB_MAX_PGSIZE))
  47. /* Minimum number of pages cached, by default. */
  48. #define DB_MINPAGECACHE 16
  49. /*
  50.  * If we are unable to determine the underlying filesystem block size, use
  51.  * 8K on the grounds that most OS's use less than 8K for a VM page size.
  52.  */
  53. #define DB_DEF_IOSIZE (8 * 1024)
  54. /*
  55.  * Aligning items to particular sizes or in pages or memory.
  56.  *
  57.  * db_align_t --
  58.  * Largest integral type, used to align structures in memory.  We don't store
  59.  * floating point types in structures, so integral types should be sufficient
  60.  * (and we don't have to worry about systems that store floats in other than
  61.  * power-of-2 numbers of bytes).  Additionally this fixes compiler that rewrite
  62.  * structure assignments and ANSI C memcpy calls to be in-line instructions
  63.  * that happen to require alignment.  Note: this alignment isn't sufficient for
  64.  * mutexes, which depend on things like cache line alignment.  Mutex alignment
  65.  * is handled separately, in mutex.h.
  66.  *
  67.  * db_alignp_t --
  68.  * Integral type that's the same size as a pointer.  There are places where
  69.  * DB modifies pointers by discarding the bottom bits to guarantee alignment.
  70.  * We can't use db_align_t, it may be larger than the pointer, and compilers
  71.  * get upset about that.  So far we haven't run on any machine where there
  72.  * isn't an integral type the same size as a pointer -- here's hoping.
  73.  */
  74. typedef unsigned long db_align_t;
  75. typedef unsigned long db_alignp_t;
  76. /* Align an integer to a specific boundary. */
  77. #undef ALIGN
  78. #define ALIGN(v, bound) (((v) + (bound) - 1) & ~(((db_align_t)bound) - 1))
  79. /*
  80.  * Print an address as a u_long (a u_long is the largest type we can print
  81.  * portably).  Most 64-bit systems have made longs 64-bits, so this should
  82.  * work.
  83.  */
  84. #define P_TO_ULONG(p) ((u_long)(db_alignp_t)(p))
  85. /*
  86.  * Convert a pointer to a small integral value.
  87.  *
  88.  * The (u_int16_t)(db_alignp_t) cast avoids warnings: the (db_alignp_t) cast
  89.  * converts the value to an integral type, and the (u_int16_t) cast converts
  90.  * it to a small integral type so we don't get complaints when we assign the
  91.  * final result to an integral type smaller than db_alignp_t.
  92.  */
  93. #define P_TO_UINT32(p) ((u_int32_t)(db_alignp_t)(p))
  94. #define P_TO_UINT16(p) ((u_int16_t)(db_alignp_t)(p))
  95. /*
  96.  * There are several on-page structures that are declared to have a number of
  97.  * fields followed by a variable length array of items.  The structure size
  98.  * without including the variable length array or the address of the first of
  99.  * those elements can be found using SSZ.
  100.  *
  101.  * This macro can also be used to find the offset of a structure element in a
  102.  * structure.  This is used in various places to copy structure elements from
  103.  * unaligned memory references, e.g., pointers into a packed page.
  104.  *
  105.  * There are two versions because compilers object if you take the address of
  106.  * an array.
  107.  */
  108. #undef SSZ
  109. #define SSZ(name, field)  P_TO_UINT16(&(((name *)0)->field))
  110. #undef SSZA
  111. #define SSZA(name, field) P_TO_UINT16(&(((name *)0)->field[0]))
  112. /* Structure used to print flag values. */
  113. typedef struct __fn {
  114. u_int32_t mask; /* Flag value. */
  115. const char *name; /* Flag name. */
  116. } FN;
  117. /* Set, clear and test flags. */
  118. #define FLD_CLR(fld, f) (fld) &= ~(f)
  119. #define FLD_ISSET(fld, f) ((fld) & (f))
  120. #define FLD_SET(fld, f) (fld) |= (f)
  121. #define F_CLR(p, f) (p)->flags &= ~(f)
  122. #define F_ISSET(p, f) ((p)->flags & (f))
  123. #define F_SET(p, f) (p)->flags |= (f)
  124. #define LF_CLR(f) ((flags) &= ~(f))
  125. #define LF_ISSET(f) ((flags) & (f))
  126. #define LF_SET(f) ((flags) |= (f))
  127. /* Display separator string. */
  128. #undef DB_LINE
  129. #define DB_LINE "=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-="
  130. /* Unused, or not-used-yet variable.  "Shut that bloody compiler up!" */
  131. #define COMPQUIET(n, v) (n) = (v)
  132. /*******************************************************
  133.  * API return values
  134.  *******************************************************/
  135.  /*
  136.   * Return values that are OK for each different call.  Most calls have
  137.   * a standard 'return of 0 is only OK value', but some, like db->get
  138.   * have DB_NOTFOUND as a return value, but it really isn't an error.
  139.   */
  140. #define DB_RETOK_STD(ret) ((ret) == 0)
  141. #define DB_RETOK_DBCDEL(ret) ((ret) == 0 || (ret) == DB_KEYEMPTY || 
  142.     (ret) == DB_NOTFOUND)
  143. #define DB_RETOK_DBCGET(ret) DB_RETOK_DBGET(ret)
  144. #define DB_RETOK_DBCPUT(ret) ((ret) == 0 || (ret) == DB_KEYEXIST || 
  145.     (ret) == DB_NOTFOUND)
  146. #define DB_RETOK_DBDEL(ret) ((ret) == 0 || (ret) == DB_NOTFOUND)
  147. #define DB_RETOK_DBGET(ret) ((ret) == 0 || (ret) == DB_KEYEMPTY || 
  148.     (ret) == DB_NOTFOUND)
  149. #define DB_RETOK_DBPUT(ret) ((ret) == 0 || (ret) == DB_KEYEXIST)
  150. #define DB_RETOK_LGGET(ret) ((ret) == 0 || (ret) == DB_NOTFOUND)
  151. #define DB_RETOK_MPGET(ret) ((ret) == 0 || (ret) == DB_PAGE_NOTFOUND)
  152. #define DB_RETOK_REPPMSG(ret) ((ret) == 0 || (ret) == DB_REP_NEWMASTER || 
  153.     (ret) == DB_REP_NEWSITE)
  154. /*******************************************************
  155.  * Files.
  156.  *******************************************************/
  157.  /*
  158.   * We use 1024 as the maximum path length.  It's too hard to figure out what
  159.   * the real path length is, as it was traditionally stored in <sys/param.h>,
  160.   * and that file isn't always available.
  161.   */
  162. #undef MAXPATHLEN
  163. #define MAXPATHLEN 1024
  164. #define PATH_DOT "." /* Current working directory. */
  165. #define PATH_SEPARATOR "\/:" /* Path separator character(s). */
  166. /*
  167.  * Flags understood by __os_open.
  168.  */
  169. #define DB_OSO_CREATE 0x0001 /* POSIX: O_CREAT */
  170. #define DB_OSO_DIRECT 0x0002 /* Don't buffer the file in the OS. */
  171. #define DB_OSO_EXCL 0x0004 /* POSIX: O_EXCL */
  172. #define DB_OSO_LOG 0x0008 /* Opening a log file. */
  173. #define DB_OSO_RDONLY 0x0010 /* POSIX: O_RDONLY */
  174. #define DB_OSO_REGION 0x0020 /* Opening a region file. */
  175. #define DB_OSO_SEQ 0x0040 /* Expected sequential access. */
  176. #define DB_OSO_TEMP 0x0080 /* Remove after last close. */
  177. #define DB_OSO_TRUNC 0x0100 /* POSIX: O_TRUNC */
  178. /*
  179.  * Seek options understood by __os_seek.
  180.  */
  181. typedef enum {
  182. DB_OS_SEEK_CUR, /* POSIX: SEEK_CUR */
  183. DB_OS_SEEK_END, /* POSIX: SEEK_END */
  184. DB_OS_SEEK_SET /* POSIX: SEEK_SET */
  185. } DB_OS_SEEK;
  186. /*******************************************************
  187.  * Environment.
  188.  *******************************************************/
  189. /* Type passed to __db_appname(). */
  190. typedef enum {
  191. DB_APP_NONE=0, /* No type (region). */
  192. DB_APP_DATA, /* Data file. */
  193. DB_APP_LOG, /* Log file. */
  194. DB_APP_TMP /* Temporary file. */
  195. } APPNAME;
  196. /*
  197.  * CDB_LOCKING CDB product locking.
  198.  * CRYPTO_ON Security has been configured.
  199.  * LOCKING_ON Locking has been configured.
  200.  * LOGGING_ON Logging has been configured.
  201.  * MPOOL_ON Memory pool has been configured.
  202.  * RPC_ON RPC has been configured.
  203.  * TXN_ON Transactions have been configured.
  204.  */
  205. #define CDB_LOCKING(dbenv) F_ISSET(dbenv, DB_ENV_CDB)
  206. #define CRYPTO_ON(dbenv) ((dbenv)->crypto_handle != NULL)
  207. #define LOCKING_ON(dbenv) ((dbenv)->lk_handle != NULL)
  208. #define LOGGING_ON(dbenv) ((dbenv)->lg_handle != NULL)
  209. #define MPOOL_ON(dbenv) ((dbenv)->mp_handle != NULL)
  210. #define RPC_ON(dbenv) ((dbenv)->cl_handle != NULL)
  211. #define TXN_ON(dbenv) ((dbenv)->tx_handle != NULL)
  212. /*
  213.  * STD_LOCKING Standard locking, that is, locking was configured and CDB
  214.  * was not.  We do not do locking in off-page duplicate trees,
  215.  * so we check for that in the cursor first.
  216.  */
  217. #define STD_LOCKING(dbc)
  218. (!F_ISSET(dbc, DBC_OPD) &&
  219.     !CDB_LOCKING((dbc)->dbp->dbenv) && LOCKING_ON((dbc)->dbp->dbenv))
  220. /*
  221.  * IS_RECOVERING: The system is running recovery.
  222.  */
  223. #define IS_RECOVERING(dbenv)
  224. (LOGGING_ON(dbenv) &&
  225.     F_ISSET((DB_LOG *)(dbenv)->lg_handle, DBLOG_RECOVER))
  226. /* Initialization methods are often illegal before/after open is called. */
  227. #define ENV_ILLEGAL_AFTER_OPEN(dbenv, name)
  228. if (F_ISSET((dbenv), DB_ENV_OPEN_CALLED))
  229. return (__db_mi_open(dbenv, name, 1));
  230. #define ENV_ILLEGAL_BEFORE_OPEN(dbenv, name)
  231. if (!F_ISSET((dbenv), DB_ENV_OPEN_CALLED))
  232. return (__db_mi_open(dbenv, name, 0));
  233. /* We're not actually user hostile, honest. */
  234. #define ENV_REQUIRES_CONFIG(dbenv, handle, i, flags)
  235. if (handle == NULL)
  236. return (__db_env_config(dbenv, i, flags));
  237. /*******************************************************
  238.  * Database Access Methods.
  239.  *******************************************************/
  240. /*
  241.  * DB_IS_THREADED --
  242.  * The database handle is free-threaded (was opened with DB_THREAD).
  243.  */
  244. #define DB_IS_THREADED(dbp)
  245. ((dbp)->mutexp != NULL)
  246. /* Initialization methods are often illegal before/after open is called. */
  247. #define DB_ILLEGAL_AFTER_OPEN(dbp, name)
  248. if (F_ISSET((dbp), DB_AM_OPEN_CALLED))
  249. return (__db_mi_open((dbp)->dbenv, name, 1));
  250. #define DB_ILLEGAL_BEFORE_OPEN(dbp, name)
  251. if (!F_ISSET((dbp), DB_AM_OPEN_CALLED))
  252. return (__db_mi_open((dbp)->dbenv, name, 0));
  253. /* Some initialization methods are illegal if environment isn't local. */
  254. #define DB_ILLEGAL_IN_ENV(dbp, name)
  255. if (!F_ISSET((dbp)->dbenv, DB_ENV_DBLOCAL))
  256. return (__db_mi_env((dbp)->dbenv, name));
  257. #define DB_ILLEGAL_METHOD(dbp, flags) {
  258. int __ret;
  259. if ((__ret = __dbh_am_chk(dbp, flags)) != 0)
  260. return (__ret);
  261. }
  262. /*
  263.  * Common DBC->internal fields.  Each access method adds additional fields
  264.  * to this list, but the initial fields are common.
  265.  */
  266. #define __DBC_INTERNAL
  267. DBC  *opd; /* Off-page duplicate cursor. */
  268. void  *page; /* Referenced page. */
  269. db_pgno_t root; /* Tree root. */
  270. db_pgno_t pgno; /* Referenced page number. */
  271. db_indx_t indx; /* Referenced key item index. */
  272. DB_LOCK lock; /* Cursor lock. */
  273. db_lockmode_t lock_mode; /* Lock mode. */
  274. struct __dbc_internal {
  275. __DBC_INTERNAL
  276. };
  277. /* Actions that __db_master_update can take. */
  278. typedef enum { MU_REMOVE, MU_RENAME, MU_OPEN } mu_action;
  279. /*
  280.  * Access-method-common macro for determining whether a cursor
  281.  * has been initialized.
  282.  */
  283. #define IS_INITIALIZED(dbc) ((dbc)->internal->pgno != PGNO_INVALID)
  284. /* Free the callback-allocated buffer, if necessary, hanging off of a DBT. */
  285. #define FREE_IF_NEEDED(sdbp, dbt)
  286. if (F_ISSET((dbt), DB_DBT_APPMALLOC)) {
  287. __os_ufree((sdbp)->dbenv, (dbt)->data);
  288. F_CLR((dbt), DB_DBT_APPMALLOC);
  289. }
  290. /*
  291.  * Use memory belonging to object "owner" to return the results of
  292.  * any no-DBT-flag get ops on cursor "dbc".
  293.  */
  294. #define SET_RET_MEM(dbc, owner)
  295. do {
  296. (dbc)->rskey = &(owner)->my_rskey;
  297. (dbc)->rkey = &(owner)->my_rkey;
  298. (dbc)->rdata = &(owner)->my_rdata;
  299. } while (0)
  300. /* Use the return-data memory src is currently set to use in dest as well. */
  301. #define COPY_RET_MEM(src, dest)
  302. do {
  303. (dest)->rskey = (src)->rskey;
  304. (dest)->rkey = (src)->rkey;
  305. (dest)->rdata = (src)->rdata;
  306. } while (0)
  307. /* Reset the returned-memory pointers to their defaults. */
  308. #define RESET_RET_MEM(dbc)
  309. do {
  310. (dbc)->rskey = &(dbc)->my_rskey;
  311. (dbc)->rkey = &(dbc)->my_rkey;
  312. (dbc)->rdata = &(dbc)->my_rdata;
  313. } while (0)
  314. /*******************************************************
  315.  * Mpool.
  316.  *******************************************************/
  317. /*
  318.  * File types for DB access methods.  Negative numbers are reserved to DB.
  319.  */
  320. #define DB_FTYPE_SET -1 /* Call pgin/pgout functions. */
  321. #define DB_FTYPE_NOTSET  0 /* Don't call... */
  322. /* Structure used as the DB pgin/pgout pgcookie. */
  323. typedef struct __dbpginfo {
  324. size_t db_pagesize; /* Underlying page size. */
  325. u_int32_t flags; /* Some DB_AM flags needed. */
  326. DBTYPE  type; /* DB type */
  327. } DB_PGINFO;
  328. /*******************************************************
  329.  * Log.
  330.  *******************************************************/
  331. /* Initialize an LSN to 'zero'. */
  332. #define ZERO_LSN(LSN) do {
  333. (LSN).file = 0;
  334. (LSN).offset = 0;
  335. } while (0)
  336. #define IS_ZERO_LSN(LSN) ((LSN).file == 0)
  337. #define IS_INIT_LSN(LSN) ((LSN).file == 1 && (LSN).offset == 0)
  338. #define INIT_LSN(LSN) do {
  339. (LSN).file = 1;
  340. (LSN).offset = 0;
  341. } while (0)
  342. #define MAX_LSN(LSN) do {
  343. (LSN).file = UINT32_T_MAX;
  344. (LSN).offset = UINT32_T_MAX;
  345. } while (0)
  346. #define IS_MAX_LSN(LSN) 
  347. ((LSN).file == UINT32_T_MAX && (LSN).offset == UINT32_T_MAX)
  348. /* If logging is turned off, smash the lsn. */
  349. #define LSN_NOT_LOGGED(LSN) do {
  350. (LSN).file = 0;
  351. (LSN).offset = 1;
  352. } while (0)
  353. #define IS_NOT_LOGGED_LSN(LSN) 
  354. ((LSN).file == 0 && (LSN).offset == 1)
  355. /*
  356.  * Test if the environment is currently logging changes.  If we're in
  357.  * recovery or we're a replication client, we don't need to log changes
  358.  * because they're already in the log, even though we have a fully functional
  359.  * log system.
  360.  */
  361. #define DBENV_LOGGING(dbenv)
  362. (LOGGING_ON(dbenv) && !F_ISSET((dbenv), DB_ENV_REP_CLIENT) &&
  363.     (!IS_RECOVERING(dbenv)))
  364. /*
  365.  * Test if we need to log a change.  Note that the DBC_RECOVER flag is set
  366.  * when we're in abort, as well as during recovery;  thus DBC_LOGGING may be
  367.  * false for a particular dbc even when DBENV_LOGGING is true.
  368.  *
  369.  * We explicitly use LOGGING_ON/DB_ENV_REP_CLIENT here because we don't
  370.  * want to have to pull in the log headers, which IS_RECOVERING (and thus
  371.  * DBENV_LOGGING) rely on, and because DBC_RECOVER should be set anytime
  372.  * IS_RECOVERING would be true.
  373.  */
  374. #define DBC_LOGGING(dbc)
  375. (LOGGING_ON((dbc)->dbp->dbenv) && !F_ISSET((dbc), DBC_RECOVER) && 
  376.  !F_ISSET((dbc)->dbp->dbenv, DB_ENV_REP_CLIENT))
  377. /*******************************************************
  378.  * Txn.
  379.  *******************************************************/
  380. #define DB_NONBLOCK(C) ((C)->txn != NULL && F_ISSET((C)->txn, TXN_NOWAIT))
  381. #define IS_SUBTRANSACTION(txn)
  382. ((txn) != NULL && (txn)->parent != NULL)
  383. /*******************************************************
  384.  * Crypto.
  385.  *******************************************************/
  386. #define DB_IV_BYTES     16 /* Bytes per IV */
  387. #define DB_MAC_KEY 20 /* Bytes per MAC checksum */
  388. /*******************************************************
  389.  * Forward structure declarations.
  390.  *******************************************************/
  391. struct __db_reginfo_t; typedef struct __db_reginfo_t REGINFO;
  392. struct __db_txnhead; typedef struct __db_txnhead DB_TXNHEAD;
  393. struct __db_txnlist; typedef struct __db_txnlist DB_TXNLIST;
  394. struct __vrfy_childinfo; typedef struct __vrfy_childinfo VRFY_CHILDINFO;
  395. struct __vrfy_dbinfo;   typedef struct __vrfy_dbinfo VRFY_DBINFO;
  396. struct __vrfy_pageinfo; typedef struct __vrfy_pageinfo VRFY_PAGEINFO;
  397. #if defined(__cplusplus)
  398. }
  399. #endif
  400. /*******************************************************
  401.  * Remaining general DB includes.
  402.  *******************************************************/
  403. #include "dbinc/globals.h"
  404. #include "dbinc/debug.h"
  405. #include "dbinc/mutex.h"
  406. #include "dbinc/region.h"
  407. #include "dbinc_auto/mutex_ext.h" /* XXX: Include after region.h. */
  408. #include "dbinc_auto/env_ext.h"
  409. #include "dbinc/os.h"
  410. #include "dbinc_auto/clib_ext.h"
  411. #include "dbinc_auto/common_ext.h"
  412. #endif /* !_DB_INTERNAL_H_ */