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

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

MySQL数据库

开发平台：

Visual C++

db_server_util.c：源码内容
  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 2000
  5.  *      Sleepycat Software.  All rights reserved.
  6.  */
  8. #include "db_config.h"
  10. #ifndef lint
  11. static const char revid[] = "$Id: db_server_util.c,v 1.32 2001/01/18 18:36:59 bostic Exp $";
  12. #endif /* not lint */
  14. #ifndef NO_SYSTEM_INCLUDES
  15. #include <sys/types.h>
  17. #if TIME_WITH_SYS_TIME
  18. #include <sys/time.h>
  19. #include <time.h>
  20. #else
  21. #if HAVE_SYS_TIME_H
  22. #include <sys/time.h>
  23. #else
  24. #include <time.h>
  25. #endif
  26. #endif
  28. #include <rpc/rpc.h>
  30. #include <limits.h>
  31. #include <signal.h>
  32. #include <stdio.h>
  33. #include <stdlib.h>
  34. #include <string.h>
  35. #include <unistd.h>
  36. #endif
  37. #include "db_server.h"
  39. #include "db_int.h"
  40. #include "clib_ext.h"
  41. #include "db_server_int.h"
  42. #include "rpc_server_ext.h"
  43. #include "common_ext.h"
  45. extern int __dbsrv_main  __P((void));
  46. static int add_home __P((char *));
  47. static int env_recover __P((char *));
  48. static void __dbclear_child __P((ct_entry *));
  50. static LIST_HEAD(cthead, ct_entry) __dbsrv_head;
  51. static LIST_HEAD(homehead, home_entry) __dbsrv_home;
  52. static long __dbsrv_defto = DB_SERVER_TIMEOUT;
  53. static long __dbsrv_maxto = DB_SERVER_MAXTIMEOUT;
  54. static long __dbsrv_idleto = DB_SERVER_IDLETIMEOUT;
  55. static char *logfile = NULL;
  56. static char *prog;
  58. static void usage __P((char *));
  59. static void version_check __P((void));
  61. int __dbsrv_verbose = 0;
  63. int
  64. main(argc, argv)
  65. int argc;
  66. char **argv;
  67. {
  68. extern char *optarg;
  69. extern int optind;
  70. CLIENT *cl;
  71. int ch, ret;
  73. prog = argv[0];
  75. version_check();
  77. /*
  78.  * Check whether another server is running or not.  There
  79.  * is a race condition where two servers could be racing to
  80.  * register with the portmapper.  The goal of this check is to
  81.  * forbid running additional servers (like those started from
  82.  * the test suite) if the user is already running one.
  83.  *
  84.  * XXX
  85.  * This does not solve nor prevent two servers from being
  86.  * started at the same time and running recovery at the same
  87.  * time on the same environments.
  88.  */
  89. if ((cl = clnt_create("localhost",
  90.     DB_SERVERPROG, DB_SERVERVERS, "tcp")) != NULL) {
  91. fprintf(stderr,
  92.     "%s: Berkeley DB RPC server already running.n", prog);
  93. clnt_destroy(cl);
  94. exit(1);
  95. }
  97. LIST_INIT(&__dbsrv_home);
  98. while ((ch = getopt(argc, argv, "h:I:L:t:T:Vv")) != EOF)
  99. switch (ch) {
  100. case 'h':
  101. (void)add_home(optarg);
  102. break;
  103. case 'I':
  104. (void)__db_getlong(NULL, prog, optarg, 1,
  105.     LONG_MAX, &__dbsrv_idleto);
  106. break;
  107. case 'L':
  108. logfile = optarg;
  109. break;
  110. case 't':
  111. (void)__db_getlong(NULL, prog, optarg, 1,
  112.     LONG_MAX, &__dbsrv_defto);
  113. break;
  114. case 'T':
  115. (void)__db_getlong(NULL, prog, optarg, 1,
  116.     LONG_MAX, &__dbsrv_maxto);
  117. break;
  118. case 'V':
  119. printf("%sn", db_version(NULL, NULL, NULL));
  120. exit(0);
  121. case 'v':
  122. __dbsrv_verbose = 1;
  123. break;
  124. default:
  125. usage(prog);
  126. }
  127. /*
  128.  * Check default timeout against maximum timeout
  129.  */
  130. if (__dbsrv_defto > __dbsrv_maxto)
  131. __dbsrv_defto = __dbsrv_maxto;
  133. /*
  134.  * Check default timeout against idle timeout
  135.  * It would be bad to timeout environments sooner than txns.
  136.  */
  137. if (__dbsrv_defto > __dbsrv_idleto)
  138. printf("%s:  WARNING: Idle timeout %ld is less than resource timeout %ldn",
  139.     prog, __dbsrv_idleto, __dbsrv_defto);
  141. LIST_INIT(&__dbsrv_head);
  143. /*
  144.  * If a client crashes during an RPC, our reply to it
  145.  * generates a SIGPIPE.  Ignore SIGPIPE so we don't exit unnecessarily.
  146.  */
  147. #ifdef SIGPIPE
  148. signal(SIGPIPE, SIG_IGN);
  149. #endif
  151. if (logfile != NULL && __db_util_logset("berkeley_db_svc", logfile))
  152. exit(1);
  154. /*
  155.  * Now that we are ready to start, run recovery on all the
  156.  * environments specified.
  157.  */
  158. if ((ret = env_recover(prog)) != 0)
  159. exit(1);
  161. /*
  162.  * We've done our setup, now call the generated server loop
  163.  */
  164. if (__dbsrv_verbose)
  165. printf("%s:  Ready to receive requestsn", prog);
  166. __dbsrv_main();
  168. /* NOTREACHED */
  169. abort();
  170. }
  172. static void
  173. usage(prog)
  174. char *prog;
  175. {
  176. fprintf(stderr, "usage: %s %snt%sn", prog,
  177.     "[-Vv] [-h home]",
  178.     "[-I idletimeout] [-L logfile] [-t def_timeout] [-T maxtimeout]");
  179. exit(1);
  180. }
  182. static void
  183. version_check()
  184. {
  185. int v_major, v_minor, v_patch;
  187. /* Make sure we're loaded with the right version of the DB library. */
  188. (void)db_version(&v_major, &v_minor, &v_patch);
  189. if (v_major != DB_VERSION_MAJOR ||
  190.     v_minor != DB_VERSION_MINOR || v_patch != DB_VERSION_PATCH) {
  191. fprintf(stderr,
  192. "%s: version %d.%d.%d doesn't match library version %d.%d.%dn",
  193.     prog, DB_VERSION_MAJOR, DB_VERSION_MINOR,
  194.     DB_VERSION_PATCH, v_major, v_minor, v_patch);
  195. exit (1);
  196. }
  197. }
  199. /*
  200.  * PUBLIC: void __dbsrv_settimeout __P((ct_entry *, u_int32_t));
  201.  */
  202. void
  203. __dbsrv_settimeout(ctp, to)
  204. ct_entry *ctp;
  205. u_int32_t to;
  206. {
  207. if (to > (u_int32_t)__dbsrv_maxto)
  208. ctp->ct_timeout = __dbsrv_maxto;
  209. else if (to <= 0)
  210. ctp->ct_timeout = __dbsrv_defto;
  211. else
  212. ctp->ct_timeout = to;
  213. }
  215. /*
  216.  * PUBLIC: void __dbsrv_timeout __P((int));
  217.  */
  218. void
  219. __dbsrv_timeout(force)
  220. int force;
  221. {
  222. static long to_hint = -1;
  223. DBC *dbcp;
  224. time_t t;
  225. long to;
  226. ct_entry *ctp, *nextctp;
  228. if ((t = time(NULL)) == -1)
  229. return;
  231. /*
  232.  * Check hint.  If hint is further in the future
  233.  * than now, no work to do.
  234.  */
  235. if (!force && to_hint > 0 && t < to_hint)
  236. return;
  237. to_hint = -1;
  238. /*
  239.  * Timeout transactions or cursors holding DB resources.
  240.  * Do this before timing out envs to properly release resources.
  241.  *
  242.  * !!!
  243.  * We can just loop through this list looking for cursors and txns.
  244.  * We do not need to verify txn and cursor relationships at this
  245.  * point because we maintain the list in LIFO order *and* we
  246.  * maintain activity in the ultimate txn parent of any cursor
  247.  * so either everything in a txn is timing out, or nothing.
  248.  * So, since we are LIFO, we will correctly close/abort all the
  249.  * appropriate handles, in the correct order.
  250.  */
  251. for (ctp = LIST_FIRST(&__dbsrv_head); ctp != NULL; ctp = nextctp) {
  252. nextctp = LIST_NEXT(ctp, entries);
  253. switch (ctp->ct_type) {
  254. case CT_TXN:
  255. to = *(ctp->ct_activep) + ctp->ct_timeout;
  256. /* TIMEOUT */
  257. if (to < t) {
  258. if (__dbsrv_verbose)
  259. printf("Timing out txn id %ldn",
  260.     ctp->ct_id);
  261. (void)txn_abort((DB_TXN *)ctp->ct_anyp);
  262. __dbdel_ctp(ctp);
  263. /*
  264.  * If we timed out an txn, we may have closed
  265.  * all sorts of ctp's.
  266.  * So start over with a guaranteed good ctp.
  267.  */
  268. nextctp = LIST_FIRST(&__dbsrv_head);
  269. } else if ((to_hint > 0 && to_hint > to) ||
  270.     to_hint == -1)
  271. to_hint = to;
  272. break;
  273. case CT_CURSOR:
  274. case (CT_JOINCUR | CT_CURSOR):
  275. to = *(ctp->ct_activep) + ctp->ct_timeout;
  276. /* TIMEOUT */
  277. if (to < t) {
  278. if (__dbsrv_verbose)
  279. printf("Timing out cursor %ldn",
  280.     ctp->ct_id);
  281. dbcp = (DBC *)ctp->ct_anyp;
  282. (void)__dbc_close_int(ctp);
  283. /*
  284.  * Start over with a guaranteed good ctp.
  285.  */
  286. nextctp = LIST_FIRST(&__dbsrv_head);
  287. } else if ((to_hint > 0 && to_hint > to) ||
  288.     to_hint == -1)
  289. to_hint = to;
  290. break;
  291. default:
  292. break;
  293. }
  294. }
  295. /*
  296.  * Timeout idle handles.
  297.  * If we are forcing a timeout, we'll close all env handles.
  298.  */
  299. for (ctp = LIST_FIRST(&__dbsrv_head); ctp != NULL; ctp = nextctp) {
  300. nextctp = LIST_NEXT(ctp, entries);
  301. if (ctp->ct_type != CT_ENV)
  302. continue;
  303. to = *(ctp->ct_activep) + ctp->ct_idle;
  304. /* TIMEOUT */
  305. if (to < t || force) {
  306. if (__dbsrv_verbose)
  307. printf("Timing out env id %ldn", ctp->ct_id);
  308. (void)__dbenv_close_int(ctp->ct_id, 0);
  309. /*
  310.  * If we timed out an env, we may have closed
  311.  * all sorts of ctp's (maybe even all of them.
  312.  * So start over with a guaranteed good ctp.
  313.  */
  314. nextctp = LIST_FIRST(&__dbsrv_head);
  315. }
  316. }
  317. }
  319. /*
  320.  * RECURSIVE FUNCTION.  We need to clear/free any number of levels of nested
  321.  * layers.
  322.  */
  323. static void
  324. __dbclear_child(parent)
  325. ct_entry *parent;
  326. {
  327. ct_entry *ctp, *nextctp;
  329. for (ctp = LIST_FIRST(&__dbsrv_head); ctp != NULL;
  330.     ctp = nextctp) {
  331. nextctp = LIST_NEXT(ctp, entries);
  332. if (ctp->ct_type == 0)
  333. continue;
  334. if (ctp->ct_parent == parent) {
  335. __dbclear_child(ctp);
  336. /*
  337.  * Need to do this here because le_next may
  338.  * have changed with the recursive call and we
  339.  * don't want to point to a removed entry.
  340.  */
  341. nextctp = LIST_NEXT(ctp, entries);
  342. __dbclear_ctp(ctp);
  343. }
  344. }
  345. }
  347. /*
  348.  * PUBLIC: void __dbclear_ctp __P((ct_entry *));
  349.  */
  350. void
  351. __dbclear_ctp(ctp)
  352. ct_entry *ctp;
  353. {
  354. LIST_REMOVE(ctp, entries);
  355. __os_free(ctp, sizeof(ct_entry));
  356. }
  358. /*
  359.  * PUBLIC: void __dbdel_ctp __P((ct_entry *));
  360.  */
  361. void
  362. __dbdel_ctp(parent)
  363. ct_entry *parent;
  364. {
  365. __dbclear_child(parent);
  366. __dbclear_ctp(parent);
  367. }
  369. /*
  370.  * PUBLIC: ct_entry *new_ct_ent __P((u_int32_t *));
  371.  */
  372. ct_entry *
  373. new_ct_ent(errp)
  374. u_int32_t *errp;
  375. {
  376. time_t t;
  377. ct_entry *ctp, *octp;
  378. int ret;
  380. if ((ret = __os_malloc(NULL, sizeof(ct_entry), NULL, &ctp)) != 0) {
  381. *errp = ret;
  382. return (NULL);
  383. }
  384. /*
  385.  * Get the time as ID.  We may service more than one request per
  386.  * second however.  If we are, then increment id value until we
  387.  * find an unused one.  We insert entries in LRU fashion at the
  388.  * head of the list.  So, if the first entry doesn't match, then
  389.  * we know for certain that we can use our entry.
  390.  */
  391. if ((t = time(NULL)) == -1) {
  392. *errp = t;
  393. __os_free(ctp, sizeof(ct_entry));
  394. return (NULL);
  395. }
  396. octp = LIST_FIRST(&__dbsrv_head);
  397. if (octp != NULL && octp->ct_id >= t)
  398. t = octp->ct_id + 1;
  399. ctp->ct_id = t;
  400. ctp->ct_idle = __dbsrv_idleto;
  401. ctp->ct_activep = &ctp->ct_active;
  402. ctp->ct_origp = NULL;
  404. LIST_INSERT_HEAD(&__dbsrv_head, ctp, entries);
  405. return (ctp);
  406. }
  408. /*
  409.  * PUBLIC: ct_entry *get_tableent __P((long));
  410.  */
  411. ct_entry *
  412. get_tableent(id)
  413. long id;
  414. {
  415. ct_entry *ctp;
  417. for (ctp = LIST_FIRST(&__dbsrv_head); ctp != NULL;
  418.     ctp = LIST_NEXT(ctp, entries))
  419. if (ctp->ct_id == id)
  420. return (ctp);
  421. return (NULL);
  422. }
  424. /*
  425.  * PUBLIC: void __dbsrv_active __P((ct_entry *));
  426.  */
  427. void
  428. __dbsrv_active(ctp)
  429. ct_entry *ctp;
  430. {
  431. time_t t;
  432. ct_entry *envctp;
  434. if (ctp == NULL)
  435. return;
  436. if ((t = time(NULL)) == -1)
  437. return;
  438. *(ctp->ct_activep) = t;
  439. if ((envctp = ctp->ct_envparent) == NULL)
  440. return;
  441. *(envctp->ct_activep) = t;
  442. return;
  443. }
  445. /*
  446.  * PUBLIC: int __dbc_close_int __P((ct_entry *));
  447.  */
  448. int
  449. __dbc_close_int(dbc_ctp)
  450. ct_entry *dbc_ctp;
  451. {
  452. DBC *dbc;
  453. int ret;
  454. ct_entry *ctp;
  456. dbc = (DBC *)dbc_ctp->ct_anyp;
  458. ret = dbc->c_close(dbc);
  459. /*
  460.  * If this cursor is a join cursor then we need to fix up the
  461.  * cursors that it was joined from so that they are independent again.
  462.  */
  463. if (dbc_ctp->ct_type & CT_JOINCUR)
  464. for (ctp = LIST_FIRST(&__dbsrv_head); ctp != NULL;
  465.     ctp = LIST_NEXT(ctp, entries)) {
  466. /*
  467.  * Test if it is a join cursor, and if it is part
  468.  * of this one.
  469.  */
  470. if ((ctp->ct_type & CT_JOIN) &&
  471.     ctp->ct_activep == &dbc_ctp->ct_active) {
  472. ctp->ct_type &= ~CT_JOIN;
  473. ctp->ct_activep = ctp->ct_origp;
  474. __dbsrv_active(ctp);
  475. }
  476. }
  477. __dbclear_ctp(dbc_ctp);
  478. return (ret);
  480. }
  482. /*
  483.  * PUBLIC: int __dbenv_close_int __P((long, int));
  484.  */
  485. int
  486. __dbenv_close_int(id, flags)
  487. long id;
  488. int flags;
  489. {
  490. DB_ENV *dbenv;
  491. int ret;
  492. ct_entry *ctp;
  494. ctp = get_tableent(id);
  495. if (ctp == NULL)
  496. return (DB_NOSERVER_ID);
  497. DB_ASSERT(ctp->ct_type == CT_ENV);
  498. dbenv = ctp->ct_envp;
  500. ret = dbenv->close(dbenv, flags);
  501. __dbdel_ctp(ctp);
  502. return (ret);
  503. }
  505. static int
  506. add_home(home)
  507. char *home;
  508. {
  509. home_entry *hp, *homep;
  510. int ret;
  512. if ((ret = __os_malloc(NULL, sizeof(home_entry), NULL, &hp)) != 0)
  513. return (ret);
  514. if ((ret = __os_malloc(NULL, strlen(home)+1, NULL, &hp->home)) != 0)
  515. return (ret);
  516. memcpy(hp->home, home, strlen(home)+1);
  517. hp->dir = home;
  518. /*
  519.  * This loop is to remove any trailing path separators,
  520.  * to assure hp->name points to the last component.
  521.  */
  522. hp->name = __db_rpath(home);
  523. *(hp->name) = '';
  524. hp->name++;
  525. while (*(hp->name) == '') {
  526. hp->name = __db_rpath(home);
  527. *(hp->name) = '';
  528. hp->name++;
  529. }
  530. /*
  531.  * Now we have successfully added it.  Make sure there are no
  532.  * identical names.
  533.  */
  534. for (homep = LIST_FIRST(&__dbsrv_home); homep != NULL;
  535.     homep = LIST_NEXT(homep, entries))
  536. if (strcmp(homep->name, hp->name) == 0) {
  537. printf("Already added home name %s, at directory %sn",
  538.     hp->name, homep->dir);
  539. return (-1);
  540. }
  541. LIST_INSERT_HEAD(&__dbsrv_home, hp, entries);
  542. if (__dbsrv_verbose)
  543. printf("Added home %s in dir %sn", hp->name, hp->dir);
  544. return (0);
  545. }
  547. /*
  548.  * PUBLIC: char *get_home __P((char *));
  549.  */
  550. char *
  551. get_home(name)
  552. char *name;
  553. {
  554. home_entry *hp;
  556. for (hp = LIST_FIRST(&__dbsrv_home); hp != NULL;
  557.     hp = LIST_NEXT(hp, entries))
  558. if (strcmp(name, hp->name) == 0)
  559. return (hp->home);
  560. return (NULL);
  561. }
  563. static int
  564. env_recover(progname)
  565. char *progname;
  566. {
  567. DB_ENV *dbenv;
  568. home_entry *hp;
  569. u_int32_t flags;
  570. int exitval, ret;
  572. for (hp = LIST_FIRST(&__dbsrv_home); hp != NULL;
  573.     hp = LIST_NEXT(hp, entries)) {
  574. exitval = 0;
  575. if ((ret = db_env_create(&dbenv, 0)) != 0) {
  576. fprintf(stderr, "%s: db_env_create: %sn",
  577.     progname, db_strerror(ret));
  578. exit(1);
  579. }
  580. if (__dbsrv_verbose == 1) {
  581. (void)dbenv->set_verbose(dbenv, DB_VERB_RECOVERY, 1);
  582. (void)dbenv->set_verbose(dbenv, DB_VERB_CHKPOINT, 1);
  583. }
  584. dbenv->set_errfile(dbenv, stderr);
  585. dbenv->set_errpfx(dbenv, progname);
  587. /*
  588.  * Initialize the env with DB_RECOVER.  That is all we
  589.  * have to do to run recovery.
  590.  */
  591. if (__dbsrv_verbose)
  592. printf("Running recovery on %sn", hp->home);
  593. flags = DB_CREATE | DB_INIT_LOCK | DB_INIT_LOG | DB_INIT_MPOOL |
  594.     DB_INIT_TXN | DB_PRIVATE | DB_USE_ENVIRON | DB_RECOVER;
  595. if ((ret = dbenv->open(dbenv, hp->home, flags, 0)) != 0) {
  596. dbenv->err(dbenv, ret, "DBENV->open");
  597. goto error;
  598. }
  600. if (0) {
  601. error: exitval = 1;
  602. }
  603. if ((ret = dbenv->close(dbenv, 0)) != 0) {
  604. exitval = 1;
  605. fprintf(stderr, "%s: dbenv->close: %sn",
  606.     progname, db_strerror(ret));
  607. }
  608. if (exitval)
  609. return (exitval);
  610. }
  611. return (0);
  612. }