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

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

MySQL数据库

开发平台：

Visual C++

env_method.c：源码内容
  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 1999, 2000
  5.  * Sleepycat Software.  All rights reserved.
  6.  */
  8. #include "db_config.h"
  10. #ifndef lint
  11. static const char revid[] = "$Id: env_method.c,v 11.31 2000/11/30 00:58:35 ubell Exp $";
  12. #endif /* not lint */
  14. #ifndef NO_SYSTEM_INCLUDES
  15. #include <sys/types.h>
  17. #include <string.h>
  18. #endif
  20. #ifdef HAVE_RPC
  21. #include "db_server.h"
  22. #endif
  24. /*
  25.  * This is the file that initializes the global array.  Do it this way because
  26.  * people keep changing one without changing the other.  Having declaration and
  27.  * initialization in one file will hopefully fix that.
  28.  */
  29. #define DB_INITIALIZE_DB_GLOBALS 1
  31. #include "db_int.h"
  32. #include "db_shash.h"
  33. #include "db_page.h"
  34. #include "db_am.h"
  35. #include "lock.h"
  36. #include "log.h"
  37. #include "mp.h"
  38. #include "txn.h"
  40. #ifdef HAVE_RPC
  41. #include "gen_client_ext.h"
  42. #include "rpc_client_ext.h"
  43. #endif
  45. static void __dbenv_err __P((const DB_ENV *, int, const char *, ...));
  46. static void __dbenv_errx __P((const DB_ENV *, const char *, ...));
  47. static int  __dbenv_set_data_dir __P((DB_ENV *, const char *));
  48. static void __dbenv_set_errcall __P((DB_ENV *, void (*)(const char *, char *)));
  49. static void __dbenv_set_errfile __P((DB_ENV *, FILE *));
  50. static void __dbenv_set_errpfx __P((DB_ENV *, const char *));
  51. static int  __dbenv_set_feedback __P((DB_ENV *, void (*)(DB_ENV *, int, int)));
  52. static int  __dbenv_set_flags __P((DB_ENV *, u_int32_t, int));
  53. static int  __dbenv_set_mutexlocks __P((DB_ENV *, int));
  54. static void __dbenv_set_noticecall
  55.     __P((DB_ENV *, void (*)(DB_ENV *, db_notices)));
  56. static int  __dbenv_set_paniccall __P((DB_ENV *, void (*)(DB_ENV *, int)));
  57. static int  __dbenv_set_recovery_init __P((DB_ENV *, int (*)(DB_ENV *)));
  58. static int  __dbenv_set_server_noclnt
  59.     __P((DB_ENV *, char *, long, long, u_int32_t));
  60. static int  __dbenv_set_shm_key __P((DB_ENV *, long));
  61. static int  __dbenv_set_tmp_dir __P((DB_ENV *, const char *));
  62. static int  __dbenv_set_verbose __P((DB_ENV *, u_int32_t, int));
  64. /*
  65.  * db_env_create --
  66.  * DB_ENV constructor.
  67.  */
  68. int
  69. db_env_create(dbenvpp, flags)
  70. DB_ENV **dbenvpp;
  71. u_int32_t flags;
  72. {
  73. DB_ENV *dbenv;
  74. int ret;
  76. /*
  77.  * !!!
  78.  * We can't call the flags-checking routines, we don't have an
  79.  * environment yet.
  80.  */
  81. if (flags != 0 && flags != DB_CLIENT)
  82. return (EINVAL);
  84. if ((ret = __os_calloc(NULL, 1, sizeof(*dbenv), &dbenv)) != 0)
  85. return (ret);
  87. #ifdef HAVE_RPC
  88. if (LF_ISSET(DB_CLIENT))
  89. F_SET(dbenv, DB_ENV_RPCCLIENT);
  90. #endif
  91. ret = __dbenv_init(dbenv);
  93. if (ret != 0) {
  94. __os_free(dbenv, sizeof(*dbenv));
  95. return (ret);
  96. }
  98. *dbenvpp = dbenv;
  99. return (0);
  100. }
  102. /*
  103.  * __dbenv_init --
  104.  * Initialize a DB_ENV structure.
  105.  *
  106.  * PUBLIC: int  __dbenv_init __P((DB_ENV *));
  107.  */
  108. int
  109. __dbenv_init(dbenv)
  110. DB_ENV *dbenv;
  111. {
  112. /*
  113.  * Set up methods that are the same in both normal and RPC
  114.  */
  115. dbenv->err = __dbenv_err;
  116. dbenv->errx = __dbenv_errx;
  117. dbenv->set_errcall = __dbenv_set_errcall;
  118. dbenv->set_errfile = __dbenv_set_errfile;
  119. dbenv->set_errpfx = __dbenv_set_errpfx;
  121. #ifdef HAVE_RPC
  122. if (F_ISSET(dbenv, DB_ENV_RPCCLIENT)) {
  123. dbenv->close = __dbcl_env_close;
  124. dbenv->open = __dbcl_env_open;
  125. dbenv->remove = __dbcl_env_remove;
  126. dbenv->set_data_dir = __dbcl_set_data_dir;
  127. dbenv->set_feedback = __dbcl_env_set_feedback;
  128. dbenv->set_flags = __dbcl_env_flags;
  129. dbenv->set_mutexlocks = __dbcl_set_mutex_locks;
  130. dbenv->set_noticecall = __dbcl_env_noticecall;
  131. dbenv->set_paniccall = __dbcl_env_paniccall;
  132. dbenv->set_recovery_init = __dbcl_set_recovery_init;
  133. dbenv->set_server = __dbcl_envserver;
  134. dbenv->set_shm_key = __dbcl_set_shm_key;
  135. dbenv->set_tmp_dir = __dbcl_set_tmp_dir;
  136. dbenv->set_verbose = __dbcl_set_verbose;
  137. } else {
  138. #endif
  139. dbenv->close = __dbenv_close;
  140. dbenv->open = __dbenv_open;
  141. dbenv->remove = __dbenv_remove;
  142. dbenv->set_data_dir = __dbenv_set_data_dir;
  143. dbenv->set_feedback = __dbenv_set_feedback;
  144. dbenv->set_flags = __dbenv_set_flags;
  145. dbenv->set_mutexlocks = __dbenv_set_mutexlocks;
  146. dbenv->set_noticecall = __dbenv_set_noticecall;
  147. dbenv->set_paniccall = __dbenv_set_paniccall;
  148. dbenv->set_recovery_init = __dbenv_set_recovery_init;
  149. dbenv->set_server = __dbenv_set_server_noclnt;
  150. dbenv->set_shm_key = __dbenv_set_shm_key;
  151. dbenv->set_tmp_dir = __dbenv_set_tmp_dir;
  152. dbenv->set_verbose = __dbenv_set_verbose;
  153. #ifdef HAVE_RPC
  154. }
  155. #endif
  156. dbenv->shm_key = INVALID_REGION_SEGID;
  157. dbenv->db_mutexlocks = 1;
  159. __log_dbenv_create(dbenv); /* Subsystem specific. */
  160. __lock_dbenv_create(dbenv);
  161. __memp_dbenv_create(dbenv);
  162. __txn_dbenv_create(dbenv);
  164. return (0);
  165. }
  167. /*
  168.  * __dbenv_err --
  169.  * Error message, including the standard error string.
  170.  */
  171. static void
  172. #ifdef __STDC__
  173. __dbenv_err(const DB_ENV *dbenv, int error, const char *fmt, ...)
  174. #else
  175. __dbenv_err(dbenv, error, fmt, va_alist)
  176. const DB_ENV *dbenv;
  177. int error;
  178. const char *fmt;
  179. va_dcl
  180. #endif
  181. {
  182. va_list ap;
  184. #ifdef __STDC__
  185. va_start(ap, fmt);
  186. #else
  187. va_start(ap);
  188. #endif
  189. __db_real_err(dbenv, error, 1, 1, fmt, ap);
  191. va_end(ap);
  192. }
  194. /*
  195.  * __dbenv_errx --
  196.  * Error message.
  197.  */
  198. static void
  199. #ifdef __STDC__
  200. __dbenv_errx(const DB_ENV *dbenv, const char *fmt, ...)
  201. #else
  202. __dbenv_errx(dbenv, fmt, va_alist)
  203. const DB_ENV *dbenv;
  204. const char *fmt;
  205. va_dcl
  206. #endif
  207. {
  208. va_list ap;
  210. #ifdef __STDC__
  211. va_start(ap, fmt);
  212. #else
  213. va_start(ap);
  214. #endif
  215. __db_real_err(dbenv, 0, 0, 1, fmt, ap);
  217. va_end(ap);
  218. }
  220. static int
  221. __dbenv_set_flags(dbenv, flags, onoff)
  222. DB_ENV *dbenv;
  223. u_int32_t flags;
  224. int onoff;
  225. {
  226. #define OK_FLAGS (DB_CDB_ALLDB | DB_NOMMAP | DB_TXN_NOSYNC)
  228. if (LF_ISSET(~OK_FLAGS))
  229. return (__db_ferr(dbenv, "DBENV->set_flags", 0));
  231. if (LF_ISSET(DB_CDB_ALLDB)) {
  232. ENV_ILLEGAL_AFTER_OPEN(dbenv, "set_flags: DB_CDB_ALLDB");
  233. if (onoff)
  234. F_SET(dbenv, DB_ENV_CDB_ALLDB);
  235. else
  236. F_CLR(dbenv, DB_ENV_CDB_ALLDB);
  237. }
  238. if (LF_ISSET(DB_NOMMAP)) {
  239. if (onoff)
  240. F_SET(dbenv, DB_ENV_NOMMAP);
  241. else
  242. F_CLR(dbenv, DB_ENV_NOMMAP);
  243. }
  244. if (LF_ISSET(DB_TXN_NOSYNC)) {
  245. if (onoff)
  246. F_SET(dbenv, DB_ENV_TXN_NOSYNC);
  247. else
  248. F_CLR(dbenv, DB_ENV_TXN_NOSYNC);
  249. }
  250. return (0);
  251. }
  253. static int
  254. __dbenv_set_data_dir(dbenv, dir)
  255. DB_ENV *dbenv;
  256. const char *dir;
  257. {
  258. int ret;
  260. #define DATA_INIT_CNT 20 /* Start with 20 data slots. */
  261. if (dbenv->db_data_dir == NULL) {
  262. if ((ret = __os_calloc(dbenv, DATA_INIT_CNT,
  263.     sizeof(char **), &dbenv->db_data_dir)) != 0)
  264. return (ret);
  265. dbenv->data_cnt = DATA_INIT_CNT;
  266. } else if (dbenv->data_next == dbenv->data_cnt - 1) {
  267. dbenv->data_cnt *= 2;
  268. if ((ret = __os_realloc(dbenv,
  269.     dbenv->data_cnt * sizeof(char **),
  270.     NULL, &dbenv->db_data_dir)) != 0)
  271. return (ret);
  272. }
  273. return (__os_strdup(dbenv,
  274.     dir, &dbenv->db_data_dir[dbenv->data_next++]));
  275. }
  277. static void
  278. __dbenv_set_errcall(dbenv, errcall)
  279. DB_ENV *dbenv;
  280. void (*errcall) __P((const char *, char *));
  281. {
  282. dbenv->db_errcall = errcall;
  283. }
  285. static void
  286. __dbenv_set_errfile(dbenv, errfile)
  287. DB_ENV *dbenv;
  288. FILE *errfile;
  289. {
  290. dbenv->db_errfile = errfile;
  291. }
  293. static void
  294. __dbenv_set_errpfx(dbenv, errpfx)
  295. DB_ENV *dbenv;
  296. const char *errpfx;
  297. {
  298. dbenv->db_errpfx = errpfx;
  299. }
  301. static int
  302. __dbenv_set_feedback(dbenv, feedback)
  303. DB_ENV *dbenv;
  304. void (*feedback) __P((DB_ENV *, int, int));
  305. {
  306. dbenv->db_feedback = feedback;
  307. return (0);
  308. }
  310. static void
  311. __dbenv_set_noticecall(dbenv, noticecall)
  312. DB_ENV *dbenv;
  313. void (*noticecall) __P((DB_ENV *, db_notices));
  314. {
  315. dbenv->db_noticecall = noticecall;
  316. }
  318. static int
  319. __dbenv_set_mutexlocks(dbenv, onoff)
  320. DB_ENV *dbenv;
  321. int onoff;
  322. {
  323. dbenv->db_mutexlocks = onoff;
  324. return (0);
  325. }
  327. static int
  328. __dbenv_set_paniccall(dbenv, paniccall)
  329. DB_ENV *dbenv;
  330. void (*paniccall) __P((DB_ENV *, int));
  331. {
  332. dbenv->db_paniccall = paniccall;
  333. return (0);
  334. }
  336. static int
  337. __dbenv_set_recovery_init(dbenv, recovery_init)
  338. DB_ENV *dbenv;
  339. int (*recovery_init) __P((DB_ENV *));
  340. {
  341. ENV_ILLEGAL_AFTER_OPEN(dbenv, "set_recovery_init");
  343. dbenv->db_recovery_init = recovery_init;
  345. return (0);
  346. }
  348. static int
  349. __dbenv_set_shm_key(dbenv, shm_key)
  350. DB_ENV *dbenv;
  351. long shm_key; /* !!!: really a key_t. */
  352. {
  353. ENV_ILLEGAL_AFTER_OPEN(dbenv, "set_shm_key");
  355. dbenv->shm_key = shm_key;
  356. return (0);
  357. }
  359. static int
  360. __dbenv_set_tmp_dir(dbenv, dir)
  361. DB_ENV *dbenv;
  362. const char *dir;
  363. {
  364. if (dbenv->db_tmp_dir != NULL)
  365. __os_freestr(dbenv->db_tmp_dir);
  366. return (__os_strdup(dbenv, dir, &dbenv->db_tmp_dir));
  367. }
  369. static int
  370. __dbenv_set_verbose(dbenv, which, onoff)
  371. DB_ENV *dbenv;
  372. u_int32_t which;
  373. int onoff;
  374. {
  375. switch (which) {
  376. case DB_VERB_CHKPOINT:
  377. case DB_VERB_DEADLOCK:
  378. case DB_VERB_RECOVERY:
  379. case DB_VERB_WAITSFOR:
  380. if (onoff)
  381. FLD_SET(dbenv->verbose, which);
  382. else
  383. FLD_CLR(dbenv->verbose, which);
  384. break;
  385. default:
  386. return (EINVAL);
  387. }
  388. return (0);
  389. }
  391. /*
  392.  * __db_mi_env --
  393.  * Method illegally called with public environment.
  394.  *
  395.  * PUBLIC: int __db_mi_env __P((DB_ENV *, const char *));
  396.  */
  397. int
  398. __db_mi_env(dbenv, name)
  399. DB_ENV *dbenv;
  400. const char *name;
  401. {
  402. __db_err(dbenv, "%s: method meaningless in shared environment", name);
  403. return (EINVAL);
  404. }
  406. /*
  407.  * __db_mi_open --
  408.  * Method illegally called after open.
  409.  *
  410.  * PUBLIC: int __db_mi_open __P((DB_ENV *, const char *, int));
  411.  */
  412. int
  413. __db_mi_open(dbenv, name, after)
  414. DB_ENV *dbenv;
  415. const char *name;
  416. int after;
  417. {
  418. __db_err(dbenv,
  419.     "%s: method meaningless %s open", name, after ? "after" : "before");
  420. return (EINVAL);
  421. }
  423. /*
  424.  * __db_env_config --
  425.  * Method or function called without subsystem being configured.
  426.  *
  427.  * PUBLIC: int __db_env_config __P((DB_ENV *, int));
  428.  */
  429. int
  430. __db_env_config(dbenv, subsystem)
  431. DB_ENV *dbenv;
  432. int subsystem;
  433. {
  434. const char *name;
  436. switch (subsystem) {
  437. case DB_INIT_LOCK:
  438. name = "lock";
  439. break;
  440. case DB_INIT_LOG:
  441. name = "log";
  442. break;
  443. case DB_INIT_MPOOL:
  444. name = "mpool";
  445. break;
  446. case DB_INIT_TXN:
  447. name = "txn";
  448. break;
  449. default:
  450. name = "unknown";
  451. break;
  452. }
  453. __db_err(dbenv,
  454.     "%s interface called with environment not configured for that subsystem",
  455.     name);
  456. return (EINVAL);
  457. }
  459. static int
  460. __dbenv_set_server_noclnt(dbenv, host, tsec, ssec, flags)
  461. DB_ENV *dbenv;
  462. char *host;
  463. long tsec, ssec;
  464. u_int32_t flags;
  465. {
  466. COMPQUIET(host, NULL);
  467. COMPQUIET(tsec, 0);
  468. COMPQUIET(ssec, 0);
  469. COMPQUIET(flags, 0);
  471. __db_err(dbenv, "set_server method meaningless in non-RPC enviroment");
  472. return (__db_eopnotsup(dbenv));
  473. }