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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
db_stat.c
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：33k
源码类别：

MySQL数据库

开发平台：

Visual C++

db_stat.c：源码内容
  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 1996-2002
  5.  * Sleepycat Software.  All rights reserved.
  6.  */
  8. #include "db_config.h"
  10. #ifndef lint
  11. static const char copyright[] =
  12.     "Copyright (c) 1996-2002nSleepycat Software Inc.  All rights reserved.n";
  13. static const char revid[] =
  14.     "$Id: db_stat.c,v 11.125 2002/08/08 15:26:15 bostic Exp $";
  15. #endif
  17. #ifndef NO_SYSTEM_INCLUDES
  18. #include <sys/types.h>
  20. #if TIME_WITH_SYS_TIME
  21. #include <sys/time.h>
  22. #include <time.h>
  23. #else
  24. #if HAVE_SYS_TIME_H
  25. #include <sys/time.h>
  26. #else
  27. #include <time.h>
  28. #endif
  29. #endif
  31. #include <ctype.h>
  32. #include <stdlib.h>
  33. #include <string.h>
  34. #include <unistd.h>
  35. #endif
  37. #include "db_int.h"
  38. #include "dbinc/db_page.h"
  40. #define PCT(f, t, pgsize)
  41.     ((t) == 0 ? 0 :
  42.     (((double)(((t) * (pgsize)) - (f)) / ((t) * (pgsize))) * 100))
  44. typedef enum { T_NOTSET,
  45.     T_DB, T_ENV, T_LOCK, T_LOG, T_MPOOL, T_REP, T_TXN } test_t;
  47. int  argcheck __P((char *, const char *));
  48. int  btree_stats __P((DB_ENV *, DB *, DB_BTREE_STAT *, int));
  49. int  db_init __P((DB_ENV *, char *, test_t, u_int32_t, int *));
  50. void  dl __P((const char *, u_long));
  51. void  dl_bytes __P((const char *, u_long, u_long, u_long));
  52. int  env_stats __P((DB_ENV *, u_int32_t));
  53. int  hash_stats __P((DB_ENV *, DB *, int));
  54. int  lock_stats __P((DB_ENV *, char *, u_int32_t));
  55. int  log_stats __P((DB_ENV *, u_int32_t));
  56. int  main __P((int, char *[]));
  57. int  mpool_stats __P((DB_ENV *, char *, u_int32_t));
  58. void  prflags __P((u_int32_t, const FN *));
  59. int  queue_stats __P((DB_ENV *, DB *, int));
  60. int  rep_stats __P((DB_ENV *, u_int32_t));
  61. int  txn_compare __P((const void *, const void *));
  62. int  txn_stats __P((DB_ENV *, u_int32_t));
  63. int  usage __P((void));
  64. int  version_check __P((const char *));
  66. int
  67. main(argc, argv)
  68. int argc;
  69. char *argv[];
  70. {
  71. extern char *optarg;
  72. extern int optind;
  73. const char *progname = "db_stat";
  74. DB_ENV *dbenv;
  75. DB_BTREE_STAT *sp;
  76. DB *alt_dbp, *dbp;
  77. test_t ttype;
  78. u_int32_t cache;
  79. int ch, checked, d_close, e_close, exitval, fast, flags;
  80. int nflag, private, resize, ret;
  81. char *db, *home, *internal, *passwd, *subdb;
  83. if ((ret = version_check(progname)) != 0)
  84. return (ret);
  86. dbp = NULL;
  87. ttype = T_NOTSET;
  88. cache = MEGABYTE;
  89. d_close = e_close = exitval = fast = flags = nflag = private = 0;
  90. db = home = internal = passwd = subdb = NULL;
  92. while ((ch = getopt(argc, argv, "C:cd:efh:lM:mNP:rs:tVZ")) != EOF)
  93. switch (ch) {
  94. case 'C':
  95. if (ttype != T_NOTSET)
  96. goto argcombo;
  97. ttype = T_LOCK;
  98. if (!argcheck(internal = optarg, "Aclmop"))
  99. return (usage());
  100. break;
  101. case 'c':
  102. if (ttype != T_NOTSET)
  103. goto argcombo;
  104. ttype = T_LOCK;
  105. break;
  106. case 'd':
  107. if (ttype != T_DB && ttype != T_NOTSET)
  108. goto argcombo;
  109. ttype = T_DB;
  110. db = optarg;
  111. break;
  112. case 'e':
  113. if (ttype != T_NOTSET)
  114. goto argcombo;
  115. ttype = T_ENV;
  116. break;
  117. case 'f':
  118. fast = DB_FAST_STAT;
  119. break;
  120. case 'h':
  121. home = optarg;
  122. break;
  123. case 'l':
  124. if (ttype != T_NOTSET)
  125. goto argcombo;
  126. ttype = T_LOG;
  127. break;
  128. case 'M':
  129. if (ttype != T_NOTSET)
  130. goto argcombo;
  131. ttype = T_MPOOL;
  132. if (!argcheck(internal = optarg, "Ahm"))
  133. return (usage());
  134. break;
  135. case 'm':
  136. if (ttype != T_NOTSET)
  137. goto argcombo;
  138. ttype = T_MPOOL;
  139. break;
  140. case 'N':
  141. nflag = 1;
  142. break;
  143. case 'P':
  144. passwd = strdup(optarg);
  145. memset(optarg, 0, strlen(optarg));
  146. if (passwd == NULL) {
  147. fprintf(stderr, "%s: strdup: %sn",
  148.     progname, strerror(errno));
  149. return (EXIT_FAILURE);
  150. }
  151. break;
  152. case 'r':
  153. if (ttype != T_NOTSET)
  154. goto argcombo;
  155. ttype = T_REP;
  156. break;
  157. case 's':
  158. if (ttype != T_DB && ttype != T_NOTSET)
  159. goto argcombo;
  160. ttype = T_DB;
  161. subdb = optarg;
  162. break;
  163. case 't':
  164. if (ttype != T_NOTSET) {
  165. argcombo: fprintf(stderr,
  166.     "%s: illegal option combinationn",
  167.     progname);
  168. return (EXIT_FAILURE);
  169. }
  170. ttype = T_TXN;
  171. break;
  172. case 'V':
  173. printf("%sn", db_version(NULL, NULL, NULL));
  174. return (EXIT_SUCCESS);
  175. case 'Z':
  176. flags |= DB_STAT_CLEAR;
  177. break;
  178. case '?':
  179. default:
  180. return (usage());
  181. }
  182. argc -= optind;
  183. argv += optind;
  185. switch (ttype) {
  186. case T_DB:
  187. if (db == NULL)
  188. return (usage());
  189. break;
  190. case T_NOTSET:
  191. return (usage());
  192. /* NOTREACHED */
  193. default:
  194. if (fast != 0)
  195. return (usage());
  196. break;
  197. }
  199. /* Handle possible interruptions. */
  200. __db_util_siginit();
  202. /*
  203.  * Create an environment object and initialize it for error
  204.  * reporting.
  205.  */
  206. retry: if ((ret = db_env_create(&dbenv, 0)) != 0) {
  207. fprintf(stderr,
  208.     "%s: db_env_create: %sn", progname, db_strerror(ret));
  209. goto shutdown;
  210. }
  211. e_close = 1;
  213. dbenv->set_errfile(dbenv, stderr);
  214. dbenv->set_errpfx(dbenv, progname);
  216. if (nflag) {
  217. if ((ret = dbenv->set_flags(dbenv, DB_NOLOCKING, 1)) != 0) {
  218. dbenv->err(dbenv, ret, "set_flags: DB_NOLOCKING");
  219. goto shutdown;
  220. }
  221. if ((ret = dbenv->set_flags(dbenv, DB_NOPANIC, 1)) != 0) {
  222. dbenv->err(dbenv, ret, "set_flags: DB_NOPANIC");
  223. goto shutdown;
  224. }
  225. }
  227. if (passwd != NULL &&
  228.     (ret = dbenv->set_encrypt(dbenv, passwd, DB_ENCRYPT_AES)) != 0) {
  229. dbenv->err(dbenv, ret, "set_passwd");
  230. goto shutdown;
  231. }
  233. /* Initialize the environment. */
  234. if (db_init(dbenv, home, ttype, cache, &private) != 0)
  235. goto shutdown;
  237. switch (ttype) {
  238. case T_DB:
  239. /* Create the DB object and open the file. */
  240. if (flags != 0)
  241. return (usage());
  242. if ((ret = db_create(&dbp, dbenv, 0)) != 0) {
  243. dbenv->err(dbenv, ret, "db_create");
  244. goto shutdown;
  245. }
  246. d_close = 1;
  248. if ((ret = dbp->open(dbp,
  249.     NULL, db, subdb, DB_UNKNOWN, DB_RDONLY, 0)) != 0) {
  250. dbp->err(dbp, ret, "DB->open: %s", db);
  251. goto shutdown;
  252. }
  254. /* Check if cache is too small for this DB's pagesize. */
  255. if (private) {
  256. if ((ret =
  257.     __db_util_cache(dbenv, dbp, &cache, &resize)) != 0)
  258. goto shutdown;
  259. if (resize) {
  260. (void)dbp->close(dbp, 0);
  261. d_close = 0;
  263. (void)dbenv->close(dbenv, 0);
  264. e_close = 0;
  265. goto retry;
  266. }
  267. }
  269. /*
  270.  * See if we can open this db read/write to update counts.
  271.  * If its a master-db then we cannot.  So check to see,
  272.  * if its btree then it might be.
  273.  */
  274. checked = 0;
  275. if (subdb == NULL && dbp->type == DB_BTREE) {
  276. if ((ret = dbp->stat(dbp, &sp, DB_FAST_STAT)) != 0) {
  277. dbp->err(dbp, ret, "DB->stat");
  278. goto shutdown;
  279. }
  280. checked = 1;
  281. }
  283. if (subdb != NULL ||
  284.     dbp->type != DB_BTREE ||
  285.     (sp->bt_metaflags & BTM_SUBDB) == 0) {
  286. if ((ret = db_create(&alt_dbp, dbenv, 0)) != 0) {
  287. dbenv->err(dbenv, ret, "db_create");
  288. goto shutdown;
  289. }
  290. if ((ret = dbp->open(alt_dbp, NULL,
  291.     db, subdb, DB_UNKNOWN, 0, 0)) != 0) {
  292. dbenv->err(dbenv,
  293.    ret, "DB->open: %s:%s", db, subdb);
  294. (void)alt_dbp->close(alt_dbp, 0);
  295. goto shutdown;
  296. }
  298. (void)dbp->close(dbp, 0);
  299. dbp = alt_dbp;
  301. /* Need to run again to update counts */
  302. checked = 0;
  303. }
  305. switch (dbp->type) {
  306. case DB_BTREE:
  307. case DB_RECNO:
  308. if (btree_stats(
  309.     dbenv, dbp, checked == 1 ? sp : NULL, fast))
  310. goto shutdown;
  311. break;
  312. case DB_HASH:
  313. if (hash_stats(dbenv, dbp, fast))
  314. goto shutdown;
  315. break;
  316. case DB_QUEUE:
  317. if (queue_stats(dbenv, dbp, fast))
  318. goto shutdown;
  319. break;
  320. case DB_UNKNOWN:
  321. dbenv->errx(dbenv, "Unknown database type.");
  322. goto shutdown;
  323. }
  324. break;
  325. case T_ENV:
  326. if (env_stats(dbenv, flags))
  327. goto shutdown;
  328. break;
  329. case T_LOCK:
  330. if (lock_stats(dbenv, internal, flags))
  331. goto shutdown;
  332. break;
  333. case T_LOG:
  334. if (log_stats(dbenv, flags))
  335. goto shutdown;
  336. break;
  337. case T_MPOOL:
  338. if (mpool_stats(dbenv, internal, flags))
  339. goto shutdown;
  340. break;
  341. case T_REP:
  342. if (rep_stats(dbenv, flags))
  343. goto shutdown;
  344. break;
  345. case T_TXN:
  346. if (txn_stats(dbenv, flags))
  347. goto shutdown;
  348. break;
  349. case T_NOTSET:
  350. dbenv->errx(dbenv, "Unknown statistics flag.");
  351. goto shutdown;
  352. }
  354. if (0) {
  355. shutdown: exitval = 1;
  356. }
  357. if (d_close && (ret = dbp->close(dbp, 0)) != 0) {
  358. exitval = 1;
  359. dbenv->err(dbenv, ret, "close");
  360. }
  361. if (e_close && (ret = dbenv->close(dbenv, 0)) != 0) {
  362. exitval = 1;
  363. fprintf(stderr,
  364.     "%s: dbenv->close: %sn", progname, db_strerror(ret));
  365. }
  367. /* Resend any caught signal. */
  368. __db_util_sigresend();
  370. return (exitval == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
  371. }
  373. /*
  374.  * env_stats --
  375.  * Display environment statistics.
  376.  */
  377. int
  378. env_stats(dbenv, flags)
  379. DB_ENV *dbenv;
  380. u_int32_t flags;
  381. {
  382. REGENV renv;
  383. REGION *rp, regs[1024];
  384. int n, ret;
  385. const char *lable;
  387. n = sizeof(regs) / sizeof(regs[0]);
  388. if ((ret = __db_e_stat(dbenv, &renv, regs, &n, flags)) != 0)  {
  389. dbenv->err(dbenv, ret, "__db_e_stat");
  390. return (1);
  391. }
  393. printf("%d.%d.%dtEnvironment version.n",
  394.     renv.majver, renv.minver, renv.patch);
  395. printf("%lxtMagic number.n", (u_long)renv.magic);
  396. printf("%dtPanic value.n", renv.envpanic);
  398. /* Adjust the reference count for us... */
  399. printf("%dtReferences.n", renv.refcnt - 1);
  401. dl("Locks granted without waiting.n",
  402.     (u_long)renv.mutex.mutex_set_nowait);
  403. dl("Locks granted after waiting.n",
  404.     (u_long)renv.mutex.mutex_set_wait);
  406. while (n > 0) {
  407. printf("%sn", DB_LINE);
  408. rp = &regs[--n];
  409. switch (rp->type) {
  410. case REGION_TYPE_ENV:
  411. lable = "Environment";
  412. break;
  413. case REGION_TYPE_LOCK:
  414. lable = "Lock";
  415. break;
  416. case REGION_TYPE_LOG:
  417. lable = "Log";
  418. break;
  419. case REGION_TYPE_MPOOL:
  420. lable = "Mpool";
  421. break;
  422. case REGION_TYPE_MUTEX:
  423. lable = "Mutex";
  424. break;
  425. case REGION_TYPE_TXN:
  426. lable = "Txn";
  427. break;
  428. case INVALID_REGION_TYPE:
  429. default:
  430. lable = "Invalid";
  431. break;
  432. }
  433. printf("%s Region: %d.n", lable, rp->id);
  434. dl_bytes("Size", (u_long)0, (u_long)0, (u_long)rp->size);
  435. printf("%ldtSegment ID.n", rp->segid);
  436. dl("Locks granted without waiting.n",
  437.     (u_long)rp->mutex.mutex_set_nowait);
  438. dl("Locks granted after waiting.n",
  439.     (u_long)rp->mutex.mutex_set_wait);
  440. }
  442. return (0);
  443. }
  445. /*
  446.  * btree_stats --
  447.  * Display btree/recno statistics.
  448.  */
  449. int
  450. btree_stats(dbenv, dbp, msp, fast)
  451. DB_ENV *dbenv;
  452. DB *dbp;
  453. DB_BTREE_STAT *msp;
  454. int fast;
  455. {
  456. static const FN fn[] = {
  457. { BTM_DUP, "duplicates" },
  458. { BTM_FIXEDLEN, "fixed-length" },
  459. { BTM_RECNO, "recno" },
  460. { BTM_RECNUM, "record-numbers" },
  461. { BTM_RENUMBER, "renumber" },
  462. { BTM_SUBDB, "multiple-databases" },
  463. { 0, NULL }
  464. };
  465. DB_BTREE_STAT *sp;
  466. int ret;
  468. COMPQUIET(dbenv, NULL);
  470. if (msp != NULL)
  471. sp = msp;
  472. else if ((ret = dbp->stat(dbp, &sp, fast)) != 0) {
  473. dbp->err(dbp, ret, "DB->stat");
  474. return (1);
  475. }
  477. printf("%lxtBtree magic number.n", (u_long)sp->bt_magic);
  478. printf("%lutBtree version number.n", (u_long)sp->bt_version);
  479. prflags(sp->bt_metaflags, fn);
  480. if (dbp->type == DB_BTREE) {
  481. #ifdef NOT_IMPLEMENTED
  482. dl("Maximum keys per-page.n", (u_long)sp->bt_maxkey);
  483. #endif
  484. dl("Minimum keys per-page.n", (u_long)sp->bt_minkey);
  485. }
  486. if (dbp->type == DB_RECNO) {
  487. dl("Fixed-length record size.n", (u_long)sp->bt_re_len);
  488. if (isprint(sp->bt_re_pad) && !isspace(sp->bt_re_pad))
  489. printf("%ctFixed-length record pad.n",
  490.     (int)sp->bt_re_pad);
  491. else
  492. printf("0x%xtFixed-length record pad.n",
  493.     (int)sp->bt_re_pad);
  494. }
  495. dl("Underlying database page size.n", (u_long)sp->bt_pagesize);
  496. dl("Number of levels in the tree.n", (u_long)sp->bt_levels);
  497. dl(dbp->type == DB_BTREE ?
  498.     "Number of unique keys in the tree.n" :
  499.     "Number of records in the tree.n", (u_long)sp->bt_nkeys);
  500. dl("Number of data items in the tree.n", (u_long)sp->bt_ndata);
  502. dl("Number of tree internal pages.n", (u_long)sp->bt_int_pg);
  503. dl("Number of bytes free in tree internal pages",
  504.     (u_long)sp->bt_int_pgfree);
  505. printf(" (%.0f%% ff).n",
  506.     PCT(sp->bt_int_pgfree, sp->bt_int_pg, sp->bt_pagesize));
  508. dl("Number of tree leaf pages.n", (u_long)sp->bt_leaf_pg);
  509. dl("Number of bytes free in tree leaf pages",
  510.     (u_long)sp->bt_leaf_pgfree);
  511. printf(" (%.0f%% ff).n",
  512.     PCT(sp->bt_leaf_pgfree, sp->bt_leaf_pg, sp->bt_pagesize));
  514. dl("Number of tree duplicate pages.n", (u_long)sp->bt_dup_pg);
  515. dl("Number of bytes free in tree duplicate pages",
  516.     (u_long)sp->bt_dup_pgfree);
  517. printf(" (%.0f%% ff).n",
  518.     PCT(sp->bt_dup_pgfree, sp->bt_dup_pg, sp->bt_pagesize));
  520. dl("Number of tree overflow pages.n", (u_long)sp->bt_over_pg);
  521. dl("Number of bytes free in tree overflow pages",
  522.     (u_long)sp->bt_over_pgfree);
  523. printf(" (%.0f%% ff).n",
  524.     PCT(sp->bt_over_pgfree, sp->bt_over_pg, sp->bt_pagesize));
  526. dl("Number of pages on the free list.n", (u_long)sp->bt_free);
  528. free(sp);
  530. return (0);
  531. }
  533. /*
  534.  * hash_stats --
  535.  * Display hash statistics.
  536.  */
  537. int
  538. hash_stats(dbenv, dbp, fast)
  539. DB_ENV *dbenv;
  540. DB *dbp;
  541. int fast;
  542. {
  543. static const FN fn[] = {
  544. { DB_HASH_DUP, "duplicates" },
  545. { DB_HASH_SUBDB,"multiple-databases" },
  546. { 0, NULL }
  547. };
  548. DB_HASH_STAT *sp;
  549. int ret;
  551. COMPQUIET(dbenv, NULL);
  553. if ((ret = dbp->stat(dbp, &sp, fast)) != 0) {
  554. dbp->err(dbp, ret, "DB->stat");
  555. return (1);
  556. }
  558. printf("%lxtHash magic number.n", (u_long)sp->hash_magic);
  559. printf("%lutHash version number.n", (u_long)sp->hash_version);
  560. prflags(sp->hash_metaflags, fn);
  561. dl("Underlying database page size.n", (u_long)sp->hash_pagesize);
  562. dl("Specified fill factor.n", (u_long)sp->hash_ffactor);
  563. dl("Number of keys in the database.n", (u_long)sp->hash_nkeys);
  564. dl("Number of data items in the database.n", (u_long)sp->hash_ndata);
  566. dl("Number of hash buckets.n", (u_long)sp->hash_buckets);
  567. dl("Number of bytes free on bucket pages", (u_long)sp->hash_bfree);
  568. printf(" (%.0f%% ff).n",
  569.     PCT(sp->hash_bfree, sp->hash_buckets, sp->hash_pagesize));
  571. dl("Number of overflow pages.n", (u_long)sp->hash_bigpages);
  572. dl("Number of bytes free in overflow pages",
  573.     (u_long)sp->hash_big_bfree);
  574. printf(" (%.0f%% ff).n",
  575.     PCT(sp->hash_big_bfree, sp->hash_bigpages, sp->hash_pagesize));
  577. dl("Number of bucket overflow pages.n", (u_long)sp->hash_overflows);
  578. dl("Number of bytes free in bucket overflow pages",
  579.     (u_long)sp->hash_ovfl_free);
  580. printf(" (%.0f%% ff).n",
  581.     PCT(sp->hash_ovfl_free, sp->hash_overflows, sp->hash_pagesize));
  583. dl("Number of duplicate pages.n", (u_long)sp->hash_dup);
  584. dl("Number of bytes free in duplicate pages",
  585.     (u_long)sp->hash_dup_free);
  586. printf(" (%.0f%% ff).n",
  587.     PCT(sp->hash_dup_free, sp->hash_dup, sp->hash_pagesize));
  589. dl("Number of pages on the free list.n", (u_long)sp->hash_free);
  591. free(sp);
  593. return (0);
  594. }
  596. /*
  597.  * queue_stats --
  598.  * Display queue statistics.
  599.  */
  600. int
  601. queue_stats(dbenv, dbp, fast)
  602. DB_ENV *dbenv;
  603. DB *dbp;
  604. int fast;
  605. {
  606. DB_QUEUE_STAT *sp;
  607. int ret;
  609. COMPQUIET(dbenv, NULL);
  611. if ((ret = dbp->stat(dbp, &sp, fast)) != 0) {
  612. dbp->err(dbp, ret, "DB->stat");
  613. return (1);
  614. }
  616. printf("%lxtQueue magic number.n", (u_long)sp->qs_magic);
  617. printf("%lutQueue version number.n", (u_long)sp->qs_version);
  618. dl("Fixed-length record size.n", (u_long)sp->qs_re_len);
  619. if (isprint(sp->qs_re_pad) && !isspace(sp->qs_re_pad))
  620. printf("%ctFixed-length record pad.n", (int)sp->qs_re_pad);
  621. else
  622. printf("0x%xtFixed-length record pad.n", (int)sp->qs_re_pad);
  623. dl("Underlying database page size.n", (u_long)sp->qs_pagesize);
  624. if (sp->qs_extentsize != 0)
  625. dl("Underlying database extent size.n",
  626.     (u_long)sp->qs_extentsize);
  627. dl("Number of records in the database.n", (u_long)sp->qs_nkeys);
  628. dl("Number of database pages.n", (u_long)sp->qs_pages);
  629. dl("Number of bytes free in database pages", (u_long)sp->qs_pgfree);
  630. printf(" (%.0f%% ff).n",
  631.     PCT(sp->qs_pgfree, sp->qs_pages, sp->qs_pagesize));
  632. printf("%lutFirst undeleted record.n", (u_long)sp->qs_first_recno);
  633. printf(
  634.     "%lutNext available record number.n", (u_long)sp->qs_cur_recno);
  636. free(sp);
  638. return (0);
  639. }
  641. /*
  642.  * lock_stats --
  643.  * Display lock statistics.
  644.  */
  645. int
  646. lock_stats(dbenv, internal, flags)
  647. DB_ENV *dbenv;
  648. char *internal;
  649. u_int32_t flags;
  650. {
  651. DB_LOCK_STAT *sp;
  652. int ret;
  654. if (internal != NULL) {
  655. if ((ret =
  656.     dbenv->lock_dump_region(dbenv, internal, stdout)) != 0) {
  657. dbenv->err(dbenv, ret, NULL);
  658. return (1);
  659. }
  660. return (0);
  661. }
  663. if ((ret = dbenv->lock_stat(dbenv, &sp, flags)) != 0) {
  664. dbenv->err(dbenv, ret, NULL);
  665. return (1);
  666. }
  668. dl("Last allocated locker ID.n", (u_long)sp->st_id);
  669. dl("Current maximum unused locker ID.n", (u_long)sp->st_cur_maxid);
  670. dl("Number of lock modes.n", (u_long)sp->st_nmodes);
  671. dl("Maximum number of locks possible.n", (u_long)sp->st_maxlocks);
  672. dl("Maximum number of lockers possible.n", (u_long)sp->st_maxlockers);
  673. dl("Maximum number of lock objects possible.n",
  674.     (u_long)sp->st_maxobjects);
  675. dl("Number of current locks.n", (u_long)sp->st_nlocks);
  676. dl("Maximum number of locks at any one time.n",
  677.     (u_long)sp->st_maxnlocks);
  678. dl("Number of current lockers.n", (u_long)sp->st_nlockers);
  679. dl("Maximum number of lockers at any one time.n",
  680.     (u_long)sp->st_maxnlockers);
  681. dl("Number of current lock objects.n", (u_long)sp->st_nobjects);
  682. dl("Maximum number of lock objects at any one time.n",
  683.     (u_long)sp->st_maxnobjects);
  684. dl("Total number of locks requested.n", (u_long)sp->st_nrequests);
  685. dl("Total number of locks released.n", (u_long)sp->st_nreleases);
  686. dl(
  687.   "Total number of lock requests failing because DB_LOCK_NOWAIT was set.n",
  688.     (u_long)sp->st_nnowaits);
  689. dl(
  690.   "Total number of locks not immediately available due to conflicts.n",
  691.     (u_long)sp->st_nconflicts);
  692. dl("Number of deadlocks.n", (u_long)sp->st_ndeadlocks);
  693. dl("Lock timeout value.n", (u_long)sp->st_locktimeout);
  694. dl("Number of locks that have timed out.n",
  695.     (u_long)sp->st_nlocktimeouts);
  696. dl("Transaction timeout value.n", (u_long)sp->st_txntimeout);
  697. dl("Number of transactions that have timed out.n",
  698.     (u_long)sp->st_ntxntimeouts);
  700. dl_bytes("The size of the lock region.",
  701.     (u_long)0, (u_long)0, (u_long)sp->st_regsize);
  702. dl("The number of region locks granted after waiting.n",
  703.     (u_long)sp->st_region_wait);
  704. dl("The number of region locks granted without waiting.n",
  705.     (u_long)sp->st_region_nowait);
  707. free(sp);
  709. return (0);
  710. }
  712. /*
  713.  * log_stats --
  714.  * Display log statistics.
  715.  */
  716. int
  717. log_stats(dbenv, flags)
  718. DB_ENV *dbenv;
  719. u_int32_t flags;
  720. {
  721. DB_LOG_STAT *sp;
  722. int ret;
  724. if ((ret = dbenv->log_stat(dbenv, &sp, flags)) != 0) {
  725. dbenv->err(dbenv, ret, NULL);
  726. return (1);
  727. }
  729. printf("%lxtLog magic number.n", (u_long)sp->st_magic);
  730. printf("%lutLog version number.n", (u_long)sp->st_version);
  731. dl_bytes("Log record cache size",
  732.     (u_long)0, (u_long)0, (u_long)sp->st_lg_bsize);
  733. printf("%#otLog file mode.n", sp->st_mode);
  734. if (sp->st_lg_size % MEGABYTE == 0)
  735. printf("%luMbtCurrent log file size.n",
  736.     (u_long)sp->st_lg_size / MEGABYTE);
  737. else if (sp->st_lg_size % 1024 == 0)
  738. printf("%luKbtCurrent log file size.n",
  739.     (u_long)sp->st_lg_size / 1024);
  740. else
  741. printf("%lutCurrent log file size.n",
  742.     (u_long)sp->st_lg_size);
  743. dl_bytes("Log bytes written",
  744.     (u_long)0, (u_long)sp->st_w_mbytes, (u_long)sp->st_w_bytes);
  745. dl_bytes("Log bytes written since last checkpoint",
  746.     (u_long)0, (u_long)sp->st_wc_mbytes, (u_long)sp->st_wc_bytes);
  747. dl("Total log file writes.n", (u_long)sp->st_wcount);
  748. dl("Total log file write due to overflow.n",
  749.     (u_long)sp->st_wcount_fill);
  750. dl("Total log file flushes.n", (u_long)sp->st_scount);
  751. printf("%lutCurrent log file number.n", (u_long)sp->st_cur_file);
  752. printf("%lutCurrent log file offset.n", (u_long)sp->st_cur_offset);
  753. printf("%lutOn-disk log file number.n", (u_long)sp->st_disk_file);
  754. printf("%lutOn-disk log file offset.n", (u_long)sp->st_disk_offset);
  756. dl("Max commits in a log flush.n", (u_long)sp->st_maxcommitperflush);
  757. dl("Min commits in a log flush.n", (u_long)sp->st_mincommitperflush);
  759. dl_bytes("Log region size",
  760.     (u_long)0, (u_long)0, (u_long)sp->st_regsize);
  761. dl("The number of region locks granted after waiting.n",
  762.     (u_long)sp->st_region_wait);
  763. dl("The number of region locks granted without waiting.n",
  764.     (u_long)sp->st_region_nowait);
  766. free(sp);
  768. return (0);
  769. }
  771. /*
  772.  * mpool_stats --
  773.  * Display mpool statistics.
  774.  */
  775. int
  776. mpool_stats(dbenv, internal, flags)
  777. DB_ENV *dbenv;
  778. char *internal;
  779. u_int32_t flags;
  780. {
  781. DB_MPOOL_FSTAT **fsp;
  782. DB_MPOOL_STAT *gsp;
  783. int ret;
  785. if (internal != NULL) {
  786. if ((ret =
  787.     dbenv->memp_dump_region(dbenv, internal, stdout)) != 0) {
  788. dbenv->err(dbenv, ret, NULL);
  789. return (1);
  790. }
  791. return (0);
  792. }
  794. if ((ret = dbenv->memp_stat(dbenv, &gsp, &fsp, flags)) != 0) {
  795. dbenv->err(dbenv, ret, NULL);
  796. return (1);
  797. }
  799. dl_bytes("Total cache size",
  800.     (u_long)gsp->st_gbytes, (u_long)0, (u_long)gsp->st_bytes);
  801. dl("Number of caches.n", (u_long)gsp->st_ncache);
  802. dl_bytes("Pool individual cache size",
  803.     (u_long)0, (u_long)0, (u_long)gsp->st_regsize);
  804. dl("Requested pages mapped into the process' address space.n",
  805.     (u_long)gsp->st_map);
  806. dl("Requested pages found in the cache", (u_long)gsp->st_cache_hit);
  807. if (gsp->st_cache_hit + gsp->st_cache_miss != 0)
  808. printf(" (%.0f%%)", ((double)gsp->st_cache_hit /
  809.     (gsp->st_cache_hit + gsp->st_cache_miss)) * 100);
  810. printf(".n");
  811. dl("Requested pages not found in the cache.n",
  812.     (u_long)gsp->st_cache_miss);
  813. dl("Pages created in the cache.n", (u_long)gsp->st_page_create);
  814. dl("Pages read into the cache.n", (u_long)gsp->st_page_in);
  815. dl("Pages written from the cache to the backing file.n",
  816.     (u_long)gsp->st_page_out);
  817. dl("Clean pages forced from the cache.n",
  818.     (u_long)gsp->st_ro_evict);
  819. dl("Dirty pages forced from the cache.n",
  820.     (u_long)gsp->st_rw_evict);
  821. dl("Dirty pages written by trickle-sync thread.n",
  822.     (u_long)gsp->st_page_trickle);
  823. dl("Current total page count.n",
  824.     (u_long)gsp->st_pages);
  825. dl("Current clean page count.n",
  826.     (u_long)gsp->st_page_clean);
  827. dl("Current dirty page count.n",
  828.     (u_long)gsp->st_page_dirty);
  829. dl("Number of hash buckets used for page location.n",
  830.     (u_long)gsp->st_hash_buckets);
  831. dl("Total number of times hash chains searched for a page.n",
  832.     (u_long)gsp->st_hash_searches);
  833. dl("The longest hash chain searched for a page.n",
  834.     (u_long)gsp->st_hash_longest);
  835. dl("Total number of hash buckets examined for page location.n",
  836.     (u_long)gsp->st_hash_examined);
  837. dl("The number of hash bucket locks granted without waiting.n",
  838.     (u_long)gsp->st_hash_nowait);
  839. dl("The number of hash bucket locks granted after waiting.n",
  840.     (u_long)gsp->st_hash_wait);
  841. dl("The maximum number of times any hash bucket lock was waited for.n",
  842.     (u_long)gsp->st_hash_max_wait);
  843. dl("The number of region locks granted without waiting.n",
  844.     (u_long)gsp->st_region_nowait);
  845. dl("The number of region locks granted after waiting.n",
  846.     (u_long)gsp->st_region_wait);
  847. dl("The number of page allocations.n",
  848.     (u_long)gsp->st_alloc);
  849. dl("The number of hash buckets examined during allocationsn",
  850.     (u_long)gsp->st_alloc_buckets);
  851. dl("The max number of hash buckets examined for an allocationn",
  852.     (u_long)gsp->st_alloc_max_buckets);
  853. dl("The number of pages examined during allocationsn",
  854.     (u_long)gsp->st_alloc_pages);
  855. dl("The max number of pages examined for an allocationn",
  856.     (u_long)gsp->st_alloc_max_pages);
  858. for (; fsp != NULL && *fsp != NULL; ++fsp) {
  859. printf("%sn", DB_LINE);
  860. printf("Pool File: %sn", (*fsp)->file_name);
  861. dl("Page size.n", (u_long)(*fsp)->st_pagesize);
  862. dl("Requested pages mapped into the process' address space.n",
  863.     (u_long)(*fsp)->st_map);
  864. dl("Requested pages found in the cache",
  865.     (u_long)(*fsp)->st_cache_hit);
  866. if ((*fsp)->st_cache_hit + (*fsp)->st_cache_miss != 0)
  867. printf(" (%.0f%%)", ((double)(*fsp)->st_cache_hit /
  868.     ((*fsp)->st_cache_hit + (*fsp)->st_cache_miss)) *
  869.     100);
  870. printf(".n");
  871. dl("Requested pages not found in the cache.n",
  872.     (u_long)(*fsp)->st_cache_miss);
  873. dl("Pages created in the cache.n",
  874.     (u_long)(*fsp)->st_page_create);
  875. dl("Pages read into the cache.n",
  876.     (u_long)(*fsp)->st_page_in);
  877. dl("Pages written from the cache to the backing file.n",
  878.     (u_long)(*fsp)->st_page_out);
  879. }
  881. free(gsp);
  883. return (0);
  884. }
  886. /*
  887.  * rep_stats --
  888.  * Display replication statistics.
  889.  */
  890. int
  891. rep_stats(dbenv, flags)
  892. DB_ENV *dbenv;
  893. u_int32_t flags;
  894. {
  895. DB_REP_STAT *sp;
  896. int is_client, ret;
  897. const char *p;
  899. if ((ret = dbenv->rep_stat(dbenv, &sp, flags)) != 0) {
  900. dbenv->err(dbenv, ret, NULL);
  901. return (1);
  902. }
  904. is_client = 0;
  905. switch (sp->st_status) {
  906. case DB_REP_MASTER:
  907. printf("Environment configured as a replication master.n");
  908. break;
  909. case DB_REP_CLIENT:
  910. printf("Environment configured as a replication client.n");
  911. is_client = 1;
  912. break;
  913. case DB_REP_LOGSONLY:
  914. printf("Environment configured as a logs-only replica.n");
  915. is_client = 1;
  916. break;
  917. default:
  918. printf("Environment not configured for replication.n");
  919. break;
  920. }
  922. printf("%lu/%lut%sn",
  923.     (u_long)sp->st_next_lsn.file, (u_long)sp->st_next_lsn.offset,
  924.     is_client ? "Next LSN expected." : "Next LSN to be used.");
  925. p = sp->st_waiting_lsn.file == 0 ?
  926.     "Not waiting for any missed log records." :
  927.     "LSN of first missed log record being waited for.";
  928. printf("%lu/%lut%sn",
  929.     (u_long)sp->st_waiting_lsn.file, (u_long)sp->st_waiting_lsn.offset,
  930.     p);
  932. dl("Number of duplicate master conditions detected.n",
  933.     (u_long)sp->st_dupmasters);
  934. if (sp->st_env_id != DB_EID_INVALID)
  935. dl("Current environment ID.n", (u_long)sp->st_env_id);
  936. else
  937. printf("No current environment ID.n");
  938. dl("Current environment priority.n", (u_long)sp->st_env_priority);
  939. dl("Current generation number.n", (u_long)sp->st_gen);
  940. dl("Number of duplicate log records received.n",
  941.     (u_long)sp->st_log_duplicated);
  942. dl("Number of log records currently queued.n",
  943.     (u_long)sp->st_log_queued);
  944. dl("Maximum number of log records ever queued at once.n",
  945.     (u_long)sp->st_log_queued_max);
  946. dl("Total number of log records queued.n",
  947.     (u_long)sp->st_log_queued_total);
  948. dl("Number of log records received and appended to the log.n",
  949.     (u_long)sp->st_log_records);
  950. dl("Number of log records missed and requested.n",
  951.     (u_long)sp->st_log_requested);
  952. if (sp->st_master != DB_EID_INVALID)
  953. dl("Current master ID.n", (u_long)sp->st_master);
  954. else
  955. printf("No current master ID.n");
  956. dl("Number of times the master has changed.n",
  957.     (u_long)sp->st_master_changes);
  958. dl("Number of messages received with a bad generation number.n",
  959.     (u_long)sp->st_msgs_badgen);
  960. dl("Number of messages received and processed.n",
  961.     (u_long)sp->st_msgs_processed);
  962. dl("Number of messages ignored due to pending recovery.n",
  963.     (u_long)sp->st_msgs_recover);
  964. dl("Number of failed message sends.n",
  965.     (u_long)sp->st_msgs_send_failures);
  966. dl("Number of messages sent.n", (u_long)sp->st_msgs_sent);
  967. dl("Number of new site messages received.n", (u_long)sp->st_newsites);
  968. dl("Transmission limited.n", (u_long)sp->st_nthrottles);
  969. dl("Number of outdated conditions detected.n",
  970.     (u_long)sp->st_outdated);
  971. dl("Number of transactions applied.n", (u_long)sp->st_txns_applied);
  973. dl("Number of elections held.n", (u_long)sp->st_elections);
  974. dl("Number of elections won.n", (u_long)sp->st_elections_won);
  976. if (sp->st_election_status == 0)
  977. printf("No election in progress.n");
  978. else {
  979. dl("Current election phase.n", (u_long)sp->st_election_status);
  980. dl("Election winner.n",
  981.     (u_long)sp->st_election_cur_winner);
  982. dl("Election generation number.n",
  983.     (u_long)sp->st_election_gen);
  984. printf("%lu/%lutMaximum LSN of election winner.n",
  985.     (u_long)sp->st_election_lsn.file,
  986.     (u_long)sp->st_election_lsn.offset);
  987. dl("Number of sites expected to participate in elections.n",
  988.     (u_long)sp->st_election_nsites);
  989. dl("Election priority.n", (u_long)sp->st_election_priority);
  990. dl("Election tiebreaker value.n",
  991.     (u_long)sp->st_election_tiebreaker);
  992. dl("Votes received this election round.n",
  993.     (u_long)sp->st_election_votes);
  994. }
  996. free(sp);
  998. return (0);
  999. }
  1001. /*
  1002.  * txn_stats --
  1003.  * Display transaction statistics.
  1004.  */
  1005. int
  1006. txn_stats(dbenv, flags)
  1007. DB_ENV *dbenv;
  1008. u_int32_t flags;
  1009. {
  1010. DB_TXN_STAT *sp;
  1011. u_int32_t i;
  1012. int ret;
  1013. const char *p;
  1015. if ((ret = dbenv->txn_stat(dbenv, &sp, flags)) != 0) {
  1016. dbenv->err(dbenv, ret, NULL);
  1017. return (1);
  1018. }
  1020. p = sp->st_last_ckp.file == 0 ?
  1021.     "No checkpoint LSN." : "File/offset for last checkpoint LSN.";
  1022. printf("%lu/%lut%sn",
  1023.     (u_long)sp->st_last_ckp.file, (u_long)sp->st_last_ckp.offset, p);
  1024. if (sp->st_time_ckp == 0)
  1025. printf("0tNo checkpoint timestamp.n");
  1026. else
  1027. printf("%.24stCheckpoint timestamp.n",
  1028.     ctime(&sp->st_time_ckp));
  1029. printf("%lxtLast transaction ID allocated.n",
  1030.     (u_long)sp->st_last_txnid);
  1031. dl("Maximum number of active transactions possible.n",
  1032.     (u_long)sp->st_maxtxns);
  1033. dl("Active transactions.n", (u_long)sp->st_nactive);
  1034. dl("Maximum active transactions.n", (u_long)sp->st_maxnactive);
  1035. dl("Number of transactions begun.n", (u_long)sp->st_nbegins);
  1036. dl("Number of transactions aborted.n", (u_long)sp->st_naborts);
  1037. dl("Number of transactions committed.n", (u_long)sp->st_ncommits);
  1038. dl("Number of transactions restored.n", (u_long)sp->st_nrestores);
  1040. dl_bytes("Transaction region size",
  1041.     (u_long)0, (u_long)0, (u_long)sp->st_regsize);
  1042. dl("The number of region locks granted after waiting.n",
  1043.     (u_long)sp->st_region_wait);
  1044. dl("The number of region locks granted without waiting.n",
  1045.     (u_long)sp->st_region_nowait);
  1047. qsort(sp->st_txnarray,
  1048.     sp->st_nactive, sizeof(sp->st_txnarray[0]), txn_compare);
  1049. for (i = 0; i < sp->st_nactive; ++i) {
  1050. printf("tid: %lx; begin LSN: file/offset %lu/%lu",
  1051.     (u_long)sp->st_txnarray[i].txnid,
  1052.     (u_long)sp->st_txnarray[i].lsn.file,
  1053.     (u_long)sp->st_txnarray[i].lsn.offset);
  1054. if (sp->st_txnarray[i].parentid == 0)
  1055. printf("n");
  1056. else
  1057. printf(" parent: %lxn",
  1058.     (u_long)sp->st_txnarray[i].parentid);
  1059. }
  1061. free(sp);
  1063. return (0);
  1064. }
  1066. int
  1067. txn_compare(a1, b1)
  1068. const void *a1, *b1;
  1069. {
  1070. const DB_TXN_ACTIVE *a, *b;
  1072. a = a1;
  1073. b = b1;
  1075. if (a->txnid > b->txnid)
  1076. return (1);
  1077. if (a->txnid < b->txnid)
  1078. return (-1);
  1079. return (0);
  1080. }
  1082. /*
  1083.  * dl --
  1084.  * Display a big value.
  1085.  */
  1086. void
  1087. dl(msg, value)
  1088. const char *msg;
  1089. u_long value;
  1090. {
  1091. /*
  1092.  * Two formats: if less than 10 million, display as the number, if
  1093.  * greater than 10 million display as ###M.
  1094.  */
  1095. if (value < 10000000)
  1096. printf("%lut%s", value, msg);
  1097. else
  1098. printf("%luMt%s", value / 1000000, msg);
  1099. }
  1101. /*
  1102.  * dl_bytes --
  1103.  * Display a big number of bytes.
  1104.  */
  1105. void
  1106. dl_bytes(msg, gbytes, mbytes, bytes)
  1107. const char *msg;
  1108. u_long gbytes, mbytes, bytes;
  1109. {
  1110. const char *sep;
  1112. /* Normalize the values. */
  1113. while (bytes >= MEGABYTE) {
  1114. ++mbytes;
  1115. bytes -= MEGABYTE;
  1116. }
  1117. while (mbytes >= GIGABYTE / MEGABYTE) {
  1118. ++gbytes;
  1119. mbytes -= GIGABYTE / MEGABYTE;
  1120. }
  1122. sep = "";
  1123. if (gbytes > 0) {
  1124. printf("%luGB", gbytes);
  1125. sep = " ";
  1126. }
  1127. if (mbytes > 0) {
  1128. printf("%s%luMB", sep, mbytes);
  1129. sep = " ";
  1130. }
  1131. if (bytes >= 1024) {
  1132. printf("%s%luKB", sep, bytes / 1024);
  1133. bytes %= 1024;
  1134. sep = " ";
  1135. }
  1136. if (bytes > 0)
  1137. printf("%s%luB", sep, bytes);
  1139. printf("t%s.n", msg);
  1140. }
  1142. /*
  1143.  * prflags --
  1144.  * Print out flag values.
  1145.  */
  1146. void
  1147. prflags(flags, fnp)
  1148. u_int32_t flags;
  1149. const FN *fnp;
  1150. {
  1151. const char *sep;
  1153. sep = "t";
  1154. printf("Flags:");
  1155. for (; fnp->mask != 0; ++fnp)
  1156. if (fnp->mask & flags) {
  1157. printf("%s%s", sep, fnp->name);
  1158. sep = ", ";
  1159. }
  1160. printf("n");
  1161. }
  1163. /*
  1164.  * db_init --
  1165.  * Initialize the environment.
  1166.  */
  1167. int
  1168. db_init(dbenv, home, ttype, cache, is_private)
  1169. DB_ENV *dbenv;
  1170. char *home;
  1171. test_t ttype;
  1172. u_int32_t cache;
  1173. int *is_private;
  1174. {
  1175. u_int32_t oflags;
  1176. int ret;
  1178. /*
  1179.  * If our environment open fails, and we're trying to look at a
  1180.  * shared region, it's a hard failure.
  1181.  *
  1182.  * We will probably just drop core if the environment we join does
  1183.  * not include a memory pool.  This is probably acceptable; trying
  1184.  * to use an existing environment that does not contain a memory
  1185.  * pool to look at a database can be safely construed as operator
  1186.  * error, I think.
  1187.  */
  1188. *is_private = 0;
  1189. if ((ret =
  1190.     dbenv->open(dbenv, home, DB_JOINENV | DB_USE_ENVIRON, 0)) == 0)
  1191. return (0);
  1192. if (ttype != T_DB && ttype != T_LOG) {
  1193. dbenv->err(dbenv, ret, "DB_ENV->open%s%s",
  1194.     home == NULL ? "" : ": ", home == NULL ? "" : home);
  1195. return (1);
  1196. }
  1198. /*
  1199.  * We're looking at a database or set of log files and no environment
  1200.  * exists.  Create one, but make it private so no files are actually
  1201.  * created.  Declare a reasonably large cache so that we don't fail
  1202.  * when reporting statistics on large databases.
  1203.  *
  1204.  * An environment is required to look at databases because we may be
  1205.  * trying to look at databases in directories other than the current
  1206.  * one.
  1207.  */
  1208. if ((ret = dbenv->set_cachesize(dbenv, 0, cache, 1)) != 0) {
  1209. dbenv->err(dbenv, ret, "set_cachesize");
  1210. return (1);
  1211. }
  1212. *is_private = 1;
  1213. oflags = DB_CREATE | DB_PRIVATE | DB_USE_ENVIRON;
  1214. if (ttype == T_DB)
  1215. oflags |= DB_INIT_MPOOL;
  1216. if (ttype == T_LOG)
  1217. oflags |= DB_INIT_LOG;
  1218. if ((ret = dbenv->open(dbenv, home, oflags, 0)) == 0)
  1219. return (0);
  1221. /* An environment is required. */
  1222. dbenv->err(dbenv, ret, "open");
  1223. return (1);
  1224. }
  1226. /*
  1227.  * argcheck --
  1228.  * Return if argument flags are okay.
  1229.  */
  1230. int
  1231. argcheck(arg, ok_args)
  1232. char *arg;
  1233. const char *ok_args;
  1234. {
  1235. for (; *arg != ''; ++arg)
  1236. if (strchr(ok_args, *arg) == NULL)
  1237. return (0);
  1238. return (1);
  1239. }
  1241. int
  1242. usage()
  1243. {
  1244. fprintf(stderr, "%snt%sn",
  1245.     "usage: db_stat [-celmNrtVZ] [-C Aclmop]",
  1246.     "[-d file [-f] [-s database]] [-h home] [-M Ahlm] [-P password]");
  1247. return (EXIT_FAILURE);
  1248. }
  1250. int
  1251. version_check(progname)
  1252. const char *progname;
  1253. {
  1254. int v_major, v_minor, v_patch;
  1256. /* Make sure we're loaded with the right version of the DB library. */
  1257. (void)db_version(&v_major, &v_minor, &v_patch);
  1258. if (v_major != DB_VERSION_MAJOR ||
  1259.     v_minor != DB_VERSION_MINOR || v_patch != DB_VERSION_PATCH) {
  1260. fprintf(stderr,
  1261. "%s: version %d.%d.%d doesn't match library version %d.%d.%dn",
  1262.     progname, DB_VERSION_MAJOR, DB_VERSION_MINOR,
  1263.     DB_VERSION_PATCH, v_major, v_minor, v_patch);
  1264. return (EXIT_FAILURE);
  1265. }
  1266. return (0);
  1267. }