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

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

MySQL数据库

开发平台：

Visual C++

db_stat.c：源码内容
  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 1996, 1997, 1998, 1999, 2000
  5.  * Sleepycat Software.  All rights reserved.
  6.  */
  8. #include "db_config.h"
  10. #ifndef lint
  11. static const char copyright[] =
  12.     "Copyright (c) 1996-2000nSleepycat Software Inc.  All rights reserved.n";
  13. static const char revid[] =
  14.     "$Id: db_stat.c,v 11.42 2001/01/18 18:36:59 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 "db_page.h"
  39. #include "db_shash.h"
  40. #include "lock.h"
  41. #include "mp.h"
  43. #define PCT(f, t, pgsize)
  44.     ((t) == 0 ? 0 :
  45.     (((double)(((t) * (pgsize)) - (f)) / ((t) * (pgsize))) * 100))
  47. typedef enum { T_NOTSET, T_DB, T_ENV, T_LOCK, T_LOG, T_MPOOL, T_TXN } test_t;
  49. int  argcheck __P((char *, const char *));
  50. int  btree_stats __P((DB_ENV *, DB *, DB_BTREE_STAT *));
  51. int  db_init __P((char *, test_t));
  52. void  dl __P((const char *, u_long));
  53. void  dl_bytes __P((const char *, u_long, u_long, u_long));
  54. int  env_stats __P((DB_ENV *));
  55. int  hash_stats __P((DB_ENV *, DB *));
  56. int  lock_ok __P((char *));
  57. int  lock_stats __P((DB_ENV *));
  58. int  log_stats __P((DB_ENV *));
  59. int  main __P((int, char *[]));
  60. int  mpool_ok __P((char *));
  61. int  mpool_stats __P((DB_ENV *));
  62. void  prflags __P((u_int32_t, const FN *));
  63. int  queue_stats __P((DB_ENV *, DB *));
  64. int  txn_compare __P((const void *, const void *));
  65. int  txn_stats __P((DB_ENV *));
  66. void  usage __P((void));
  67. void  version_check __P((void));
  69. DB_ENV *dbenv;
  70. char *internal;
  71. const char
  72. *progname = "db_stat"; /* Program name. */
  74. int
  75. main(argc, argv)
  76. int argc;
  77. char *argv[];
  78. {
  79. extern char *optarg;
  80. extern int optind;
  81. DB_BTREE_STAT *sp;
  82. DB *alt_dbp, *dbp;
  83. test_t ttype;
  84. int ch, checked, d_close, e_close, exitval, nflag, ret;
  85. char *db, *home, *subdb;
  87. version_check();
  89. dbp = NULL;
  90. ttype = T_NOTSET;
  91. nflag = 0;
  92. d_close = e_close = exitval = 0;
  93. db = home = subdb = NULL;
  94. while ((ch = getopt(argc, argv, "C:cd:eh:lM:mNs:tV")) != EOF)
  95. switch (ch) {
  96. case 'C':
  97. ttype = T_LOCK;
  98. if (!argcheck(internal = optarg, "Acflmo"))
  99. usage();
  100. break;
  101. case 'c':
  102. ttype = T_LOCK;
  103. break;
  104. case 'd':
  105. db = optarg;
  106. ttype = T_DB;
  107. break;
  108. case 'e':
  109. ttype = T_ENV;
  110. break;
  111. case 'h':
  112. home = optarg;
  113. break;
  114. case 'l':
  115. ttype = T_LOG;
  116. break;
  117. case 'M':
  118. ttype = T_MPOOL;
  119. if (!argcheck(internal = optarg, "Ahlm"))
  120. usage();
  121. break;
  122. case 'm':
  123. ttype = T_MPOOL;
  124. break;
  125. case 'N':
  126. nflag = 1;
  127. if ((ret = db_env_set_panicstate(0)) != 0) {
  128. fprintf(stderr,
  129.     "%s: db_env_set_panicstate: %sn",
  130.     progname, db_strerror(ret));
  131. return (1);
  132. }
  133. break;
  134. case 's':
  135. subdb = optarg;
  136. ttype = T_DB;
  137. break;
  138. case 't':
  139. ttype = T_TXN;
  140. break;
  141. case 'V':
  142. printf("%sn", db_version(NULL, NULL, NULL));
  143. exit(0);
  144. case '?':
  145. default:
  146. usage();
  147. }
  148. argc -= optind;
  149. argv += optind;
  151. switch (ttype) {
  152. case T_DB:
  153. if (db == NULL)
  154. usage();
  155. break;
  156. case T_NOTSET:
  157. usage();
  158. /* NOTREACHED */
  159. default:
  160. break;
  161. }
  163. /* Handle possible interruptions. */
  164. __db_util_siginit();
  166. /*
  167.  * Create an environment object and initialize it for error
  168.  * reporting.
  169.  */
  170. if ((ret = db_env_create(&dbenv, 0)) != 0) {
  171. fprintf(stderr,
  172.     "%s: db_env_create: %sn", progname, db_strerror(ret));
  173. goto shutdown;
  174. }
  175. e_close = 1;
  177. dbenv->set_errfile(dbenv, stderr);
  178. dbenv->set_errpfx(dbenv, progname);
  180. if (nflag && (ret = dbenv->set_mutexlocks(dbenv, 0)) != 0) {
  181. dbenv->err(dbenv, ret, "set_mutexlocks");
  182. goto shutdown;
  183. }
  185. /* Initialize the environment. */
  186. if (db_init(home, ttype) != 0)
  187. goto shutdown;
  189. switch (ttype) {
  190. case T_DB:
  191. /* Create the DB object and open the file. */
  192. if ((ret = db_create(&dbp, dbenv, 0)) != 0) {
  193. dbenv->err(dbenv, ret, "db_create");
  194. goto shutdown;
  195. }
  197. if ((ret =
  198.     dbp->open(dbp, db, subdb, DB_UNKNOWN, DB_RDONLY, 0)) != 0) {
  199. dbp->err(dbp, ret, "open: %s", db);
  200. goto shutdown;
  201. }
  203. /*
  204.  * See if we can open this db read/write to update counts.
  205.  * If its a master-db then we cannot.  So check to see,
  206.  * if its btree then it might be.
  207.  */
  208. checked = 0;
  209. if (subdb == NULL && dbp->type == DB_BTREE) {
  210. if ((ret = dbp->stat(dbp, &sp, NULL, 0)) != 0) {
  211. dbp->err(dbp, ret, "dbp->stat");
  212. return (1);
  213. }
  214. checked = 1;
  215. }
  217. if (subdb != NULL ||
  218.     dbp->type != DB_BTREE ||
  219.     (sp->bt_metaflags & BTM_SUBDB) == 0) {
  220. if ((ret = db_create(&alt_dbp, dbenv, 0)) != 0) {
  221. dbenv->err(dbenv, ret, "db_create");
  222. goto shutdown;
  223. }
  224. if ((ret = dbp->open(alt_dbp,
  225.     db, subdb, DB_UNKNOWN, 0, 0)) == 0) {
  226. (void)dbp->close(dbp, 0);
  227. dbp = alt_dbp;
  228. }
  229. /* Need to run again to update counts */
  230. checked = 0;
  231. }
  233. d_close = 1;
  234. switch (dbp->type) {
  235. case DB_BTREE:
  236. case DB_RECNO:
  237. if (btree_stats(dbenv, dbp, checked == 1 ? sp : NULL))
  238. goto shutdown;
  239. break;
  240. case DB_HASH:
  241. if (hash_stats(dbenv, dbp))
  242. goto shutdown;
  243. break;
  244. case DB_QUEUE:
  245. if (queue_stats(dbenv, dbp))
  246. goto shutdown;
  247. break;
  248. case DB_UNKNOWN:
  249. abort(); /* Impossible. */
  250. /* NOTREACHED */
  251. }
  252. break;
  253. case T_ENV:
  254. if (env_stats(dbenv))
  255. exitval = 1;
  256. break;
  257. case T_LOCK:
  258. if (lock_stats(dbenv))
  259. exitval = 1;
  260. break;
  261. case T_LOG:
  262. if (log_stats(dbenv))
  263. exitval = 1;
  264. break;
  265. case T_MPOOL:
  266. if (mpool_stats(dbenv))
  267. exitval = 1;
  268. break;
  269. case T_TXN:
  270. if (txn_stats(dbenv))
  271. exitval = 1;
  272. break;
  273. case T_NOTSET:
  274. abort(); /* Impossible. */
  275. /* NOTREACHED */
  276. }
  278. if (0) {
  279. shutdown: exitval = 1;
  280. }
  281. if (d_close && (ret = dbp->close(dbp, 0)) != 0) {
  282. exitval = 1;
  283. dbp->err(dbp, ret, "close");
  284. }
  285. if (e_close && (ret = dbenv->close(dbenv, 0)) != 0) {
  286. exitval = 1;
  287. fprintf(stderr,
  288.     "%s: dbenv->close: %sn", progname, db_strerror(ret));
  289. }
  291. /* Resend any caught signal. */
  292. __db_util_sigresend();
  294. return (exitval);
  295. }
  297. /*
  298.  * env_stats --
  299.  * Display environment statistics.
  300.  */
  301. int
  302. env_stats(dbenvp)
  303. DB_ENV *dbenvp;
  304. {
  305. REGENV renv;
  306. REGION *rp, regs[1024];
  307. int n, ret;
  308. const char *lable;
  310. n = sizeof(regs) / sizeof(regs[0]);
  311. if ((ret = __db_e_stat(dbenvp, &renv, regs, &n)) != 0)  {
  312. dbenvp->err(dbenvp, ret, "__db_e_stat");
  313. return (1);
  314. }
  316. printf("%d.%d.%dtEnvironment version.n",
  317.     renv.majver, renv.minver, renv.patch);
  318. printf("%lxtMagic number.n", (u_long)renv.magic);
  319. printf("%dtPanic value.n", renv.panic);
  321. /* Adjust the reference count for us... */
  322. printf("%dtReferences.n", renv.refcnt - 1);
  324. dl("Locks granted without waiting.n",
  325.     (u_long)renv.mutex.mutex_set_nowait);
  326. dl("Locks granted after waiting.n",
  327.     (u_long)renv.mutex.mutex_set_wait);
  329. while (n > 0) {
  330. printf("%sn", DB_LINE);
  331. rp = &regs[--n];
  332. switch (rp->type) {
  333. case REGION_TYPE_ENV:
  334. lable = "Environment";
  335. break;
  336. case REGION_TYPE_LOCK:
  337. lable = "Lock";
  338. break;
  339. case REGION_TYPE_LOG:
  340. lable = "Log";
  341. break;
  342. case REGION_TYPE_MPOOL:
  343. lable = "Mpool";
  344. break;
  345. case REGION_TYPE_MUTEX:
  346. lable = "Mutex";
  347. break;
  348. case REGION_TYPE_TXN:
  349. lable = "Txn";
  350. break;
  351. case INVALID_REGION_TYPE:
  352. default:
  353. lable = "Invalid";
  354. break;
  355. }
  356. printf("%s Region: %d.n", lable, rp->id);
  357. dl_bytes("Size", (u_long)0, (u_long)0, (u_long)rp->size);
  358. printf("%ldtSegment ID.n", rp->segid);
  359. dl("Locks granted without waiting.n",
  360.     (u_long)rp->mutex.mutex_set_nowait);
  361. dl("Locks granted after waiting.n",
  362.     (u_long)rp->mutex.mutex_set_wait);
  363. }
  365. return (0);
  366. }
  368. /*
  369.  * btree_stats --
  370.  * Display btree/recno statistics.
  371.  */
  372. int
  373. btree_stats(dbenvp, dbp, msp)
  374. DB_ENV *dbenvp;
  375. DB *dbp;
  376. DB_BTREE_STAT *msp;
  377. {
  378. static const FN fn[] = {
  379. { BTM_DUP, "duplicates" },
  380. { BTM_FIXEDLEN, "fixed-length" },
  381. { BTM_RECNO, "recno" },
  382. { BTM_RECNUM, "record-numbers" },
  383. { BTM_RENUMBER, "renumber" },
  384. { BTM_SUBDB, "multiple-databases" },
  385. { 0, NULL }
  386. };
  387. DB_BTREE_STAT *sp;
  388. int ret;
  390. COMPQUIET(dbenvp, NULL);
  392. if (msp != NULL)
  393. sp = msp;
  394. else if ((ret = dbp->stat(dbp, &sp, NULL, 0)) != 0) {
  395. dbp->err(dbp, ret, "dbp->stat");
  396. return (1);
  397. }
  399. printf("%lxtBtree magic number.n", (u_long)sp->bt_magic);
  400. printf("%lutBtree version number.n", (u_long)sp->bt_version);
  401. prflags(sp->bt_metaflags, fn);
  402. if (dbp->type == DB_BTREE) {
  403. #ifdef NOT_IMPLEMENTED
  404. dl("Maximum keys per-page.n", (u_long)sp->bt_maxkey);
  405. #endif
  406. dl("Minimum keys per-page.n", (u_long)sp->bt_minkey);
  407. }
  408. if (dbp->type == DB_RECNO) {
  409. dl("Fixed-length record size.n", (u_long)sp->bt_re_len);
  410. if (isprint(sp->bt_re_pad) && !isspace(sp->bt_re_pad))
  411. printf("%ctFixed-length record pad.n",
  412.     (int)sp->bt_re_pad);
  413. else
  414. printf("0x%xtFixed-length record pad.n",
  415.     (int)sp->bt_re_pad);
  416. }
  417. dl("Underlying database page size.n", (u_long)sp->bt_pagesize);
  418. dl("Number of levels in the tree.n", (u_long)sp->bt_levels);
  419. dl(dbp->type == DB_BTREE ?
  420.     "Number of unique keys in the tree.n" :
  421.     "Number of records in the tree.n", (u_long)sp->bt_nkeys);
  422. dl("Number of data items in the tree.n", (u_long)sp->bt_ndata);
  424. dl("Number of tree internal pages.n", (u_long)sp->bt_int_pg);
  425. dl("Number of bytes free in tree internal pages",
  426.     (u_long)sp->bt_int_pgfree);
  427. printf(" (%.0f%% ff).n",
  428.     PCT(sp->bt_int_pgfree, sp->bt_int_pg, sp->bt_pagesize));
  430. dl("Number of tree leaf pages.n", (u_long)sp->bt_leaf_pg);
  431. dl("Number of bytes free in tree leaf pages",
  432.     (u_long)sp->bt_leaf_pgfree);
  433. printf(" (%.0f%% ff).n",
  434.     PCT(sp->bt_leaf_pgfree, sp->bt_leaf_pg, sp->bt_pagesize));
  436. dl("Number of tree duplicate pages.n", (u_long)sp->bt_dup_pg);
  437. dl("Number of bytes free in tree duplicate pages",
  438.     (u_long)sp->bt_dup_pgfree);
  439. printf(" (%.0f%% ff).n",
  440.     PCT(sp->bt_dup_pgfree, sp->bt_dup_pg, sp->bt_pagesize));
  442. dl("Number of tree overflow pages.n", (u_long)sp->bt_over_pg);
  443. dl("Number of bytes free in tree overflow pages",
  444.     (u_long)sp->bt_over_pgfree);
  445. printf(" (%.0f%% ff).n",
  446.     PCT(sp->bt_over_pgfree, sp->bt_over_pg, sp->bt_pagesize));
  448. dl("Number of pages on the free list.n", (u_long)sp->bt_free);
  450. return (0);
  451. }
  453. /*
  454.  * hash_stats --
  455.  * Display hash statistics.
  456.  */
  457. int
  458. hash_stats(dbenvp, dbp)
  459. DB_ENV *dbenvp;
  460. DB *dbp;
  461. {
  462. static const FN fn[] = {
  463. { DB_HASH_DUP, "duplicates" },
  464. { DB_HASH_SUBDB,"multiple-databases" },
  465. { 0, NULL }
  466. };
  467. DB_HASH_STAT *sp;
  468. int ret;
  470. COMPQUIET(dbenvp, NULL);
  472. if ((ret = dbp->stat(dbp, &sp, NULL, 0)) != 0) {
  473. dbp->err(dbp, ret, "dbp->stat");
  474. return (1);
  475. }
  477. printf("%lxtHash magic number.n", (u_long)sp->hash_magic);
  478. printf("%lutHash version number.n", (u_long)sp->hash_version);
  479. prflags(sp->hash_metaflags, fn);
  480. dl("Underlying database page size.n", (u_long)sp->hash_pagesize);
  481. dl("Number of keys in the database.n", (u_long)sp->hash_nkeys);
  482. dl("Number of data items in the database.n", (u_long)sp->hash_ndata);
  484. dl("Number of hash buckets.n", (u_long)sp->hash_buckets);
  485. dl("Number of bytes free on bucket pages", (u_long)sp->hash_bfree);
  486. printf(" (%.0f%% ff).n",
  487.     PCT(sp->hash_bfree, sp->hash_buckets, sp->hash_pagesize));
  489. dl("Number of overflow pages.n", (u_long)sp->hash_bigpages);
  490. dl("Number of bytes free in overflow pages",
  491.     (u_long)sp->hash_big_bfree);
  492. printf(" (%.0f%% ff).n",
  493.     PCT(sp->hash_big_bfree, sp->hash_bigpages, sp->hash_pagesize));
  495. dl("Number of bucket overflow pages.n", (u_long)sp->hash_overflows);
  496. dl("Number of bytes free in bucket overflow pages",
  497.     (u_long)sp->hash_ovfl_free);
  498. printf(" (%.0f%% ff).n",
  499.     PCT(sp->hash_ovfl_free, sp->hash_overflows, sp->hash_pagesize));
  501. dl("Number of duplicate pages.n", (u_long)sp->hash_dup);
  502. dl("Number of bytes free in duplicate pages",
  503.     (u_long)sp->hash_dup_free);
  504. printf(" (%.0f%% ff).n",
  505.     PCT(sp->hash_dup_free, sp->hash_dup, sp->hash_pagesize));
  507. dl("Number of pages on the free list.n", (u_long)sp->hash_free);
  509. return (0);
  510. }
  512. /*
  513.  * queue_stats --
  514.  * Display queue statistics.
  515.  */
  516. int
  517. queue_stats(dbenvp, dbp)
  518. DB_ENV *dbenvp;
  519. DB *dbp;
  520. {
  521. DB_QUEUE_STAT *sp;
  522. int ret;
  524. COMPQUIET(dbenvp, NULL);
  526. if ((ret = dbp->stat(dbp, &sp, NULL, 0)) != 0) {
  527. dbp->err(dbp, ret, "dbp->stat");
  528. return (1);
  529. }
  531. printf("%lxtQueue magic number.n", (u_long)sp->qs_magic);
  532. printf("%lutQueue version number.n", (u_long)sp->qs_version);
  533. dl("Fixed-length record size.n", (u_long)sp->qs_re_len);
  534. if (isprint(sp->qs_re_pad) && !isspace(sp->qs_re_pad))
  535. printf("%ctFixed-length record pad.n", (int)sp->qs_re_pad);
  536. else
  537. printf("0x%xtFixed-length record pad.n", (int)sp->qs_re_pad);
  538. dl("Underlying database page size.n", (u_long)sp->qs_pagesize);
  539. dl("Number of records in the database.n", (u_long)sp->qs_nkeys);
  540. dl("Number of database pages.n", (u_long)sp->qs_pages);
  541. dl("Number of bytes free in database pages", (u_long)sp->qs_pgfree);
  542. printf(" (%.0f%% ff).n",
  543.     PCT(sp->qs_pgfree, sp->qs_pages, sp->qs_pagesize));
  544. printf("%lutFirst undeleted record.n", (u_long)sp->qs_first_recno);
  545. printf(
  546.     "%lutLast allocated record number.n", (u_long)sp->qs_cur_recno);
  548. return (0);
  549. }
  551. /*
  552.  * lock_stats --
  553.  * Display lock statistics.
  554.  */
  555. int
  556. lock_stats(dbenvp)
  557. DB_ENV *dbenvp;
  558. {
  559. DB_LOCK_STAT *sp;
  560. int ret;
  562. if (internal != NULL) {
  563. __lock_dump_region(dbenvp, internal, stdout);
  564. return (0);
  565. }
  567. if ((ret = lock_stat(dbenvp, &sp, NULL)) != 0) {
  568. dbenvp->err(dbenvp, ret, NULL);
  569. return (1);
  570. }
  572. dl("Last allocated locker ID.n", (u_long)sp->st_lastid);
  573. dl("Number of lock modes.n", (u_long)sp->st_nmodes);
  574. dl("Maximum number of locks possible.n", (u_long)sp->st_maxlocks);
  575. dl("Maximum number of lockers possible.n", (u_long)sp->st_maxlockers);
  576. dl("Maximum number of objects possible.n", (u_long)sp->st_maxobjects);
  577. dl("Current locks.n", (u_long)sp->st_nlocks);
  578. dl("Maximum number of locks so far.n", (u_long)sp->st_maxnlocks);
  579. dl("Current number of lockers.n", (u_long)sp->st_nlockers);
  580. dl("Maximum number  lockers so far.n", (u_long)sp->st_maxnlockers);
  581. dl("Current number lock objects.n", (u_long)sp->st_nobjects);
  582. dl("Maximum number of lock objects so far.n",
  583.     (u_long)sp->st_maxnobjects);
  584. dl("Number of lock requests.n", (u_long)sp->st_nrequests);
  585. dl("Number of lock releases.n", (u_long)sp->st_nreleases);
  586. dl("Number of lock requests that would have waited.n",
  587.     (u_long)sp->st_nnowaits);
  588. dl("Number of lock conflicts.n", (u_long)sp->st_nconflicts);
  589. dl("Number of deadlocks.n", (u_long)sp->st_ndeadlocks);
  590. dl_bytes("Lock region size",
  591.     (u_long)0, (u_long)0, (u_long)sp->st_regsize);
  592. dl("The number of region locks granted without waiting.n",
  593.     (u_long)sp->st_region_nowait);
  594. dl("The number of region locks granted after waiting.n",
  595.     (u_long)sp->st_region_wait);
  597. return (0);
  598. }
  600. /*
  601.  * log_stats --
  602.  * Display log statistics.
  603.  */
  604. int
  605. log_stats(dbenvp)
  606. DB_ENV *dbenvp;
  607. {
  608. DB_LOG_STAT *sp;
  609. int ret;
  611. if ((ret = log_stat(dbenvp, &sp, NULL)) != 0) {
  612. dbenvp->err(dbenvp, ret, NULL);
  613. return (1);
  614. }
  616. printf("%lxtLog magic number.n", (u_long)sp->st_magic);
  617. printf("%lutLog version number.n", (u_long)sp->st_version);
  618. dl_bytes("Log region size",
  619.     (u_long)0, (u_long)0, (u_long)sp->st_regsize);
  620. dl_bytes("Log record cache size",
  621.     (u_long)0, (u_long)0, (u_long)sp->st_lg_bsize);
  622. printf("%#otLog file mode.n", sp->st_mode);
  623. if (sp->st_lg_max % MEGABYTE == 0)
  624. printf("%luMbtLog file size.n",
  625.     (u_long)sp->st_lg_max / MEGABYTE);
  626. else if (sp->st_lg_max % 1024 == 0)
  627. printf("%luKbtLog file size.n", (u_long)sp->st_lg_max / 1024);
  628. else
  629. printf("%lutLog file size.n", (u_long)sp->st_lg_max);
  630. dl_bytes("Log bytes written",
  631.     (u_long)0, (u_long)sp->st_w_mbytes, (u_long)sp->st_w_bytes);
  632. dl_bytes("Log bytes written since last checkpoint",
  633.     (u_long)0, (u_long)sp->st_wc_mbytes, (u_long)sp->st_wc_bytes);
  634. dl("Total log file writes.n", (u_long)sp->st_wcount);
  635. dl("Total log file write due to overflow.n",
  636.     (u_long)sp->st_wcount_fill);
  637. dl("Total log file flushes.n", (u_long)sp->st_scount);
  638. printf("%lutCurrent log file number.n", (u_long)sp->st_cur_file);
  639. printf("%lutCurrent log file offset.n", (u_long)sp->st_cur_offset);
  640. dl("The number of region locks granted without waiting.n",
  641.     (u_long)sp->st_region_nowait);
  642. dl("The number of region locks granted after waiting.n",
  643.     (u_long)sp->st_region_wait);
  645. return (0);
  646. }
  648. /*
  649.  * mpool_stats --
  650.  * Display mpool statistics.
  651.  */
  652. int
  653. mpool_stats(dbenvp)
  654. DB_ENV *dbenvp;
  655. {
  656. DB_MPOOL_FSTAT **fsp;
  657. DB_MPOOL_STAT *gsp;
  658. int ret;
  660. if (internal != NULL) {
  661. __memp_dump_region(dbenvp, internal, stdout);
  662. return (1);
  663. }
  665. if ((ret = memp_stat(dbenvp, &gsp, &fsp, NULL)) != 0) {
  666. dbenvp->err(dbenvp, ret, NULL);
  667. return (1);
  668. }
  670. dl_bytes("Total cache size",
  671.     (u_long)gsp->st_gbytes, (u_long)0, (u_long)gsp->st_bytes);
  672. dl("Number of caches.n", (u_long)gsp->st_ncache);
  673. dl("Pool individual cache size.n", (u_long)gsp->st_regsize);
  674. dl("Requested pages found in the cache", (u_long)gsp->st_cache_hit);
  675. if (gsp->st_cache_hit + gsp->st_cache_miss != 0)
  676. printf(" (%.0f%%)", ((double)gsp->st_cache_hit /
  677.     (gsp->st_cache_hit + gsp->st_cache_miss)) * 100);
  678. printf(".n");
  679. dl("Requested pages mapped into the process' address space.n",
  680.     (u_long)gsp->st_map);
  681. dl("Requested pages not found in the cache.n",
  682.     (u_long)gsp->st_cache_miss);
  683. dl("Pages created in the cache.n", (u_long)gsp->st_page_create);
  684. dl("Pages read into the cache.n", (u_long)gsp->st_page_in);
  685. dl("Pages written from the cache to the backing file.n",
  686.     (u_long)gsp->st_page_out);
  687. dl("Clean pages forced from the cache.n",
  688.     (u_long)gsp->st_ro_evict);
  689. dl("Dirty pages forced from the cache.n",
  690.     (u_long)gsp->st_rw_evict);
  691. dl("Dirty buffers written by trickle-sync thread.n",
  692.     (u_long)gsp->st_page_trickle);
  693. dl("Current clean buffer count.n",
  694.     (u_long)gsp->st_page_clean);
  695. dl("Current dirty buffer count.n",
  696.     (u_long)gsp->st_page_dirty);
  697. dl("Number of hash buckets used for page location.n",
  698.     (u_long)gsp->st_hash_buckets);
  699. dl("Total number of times hash chains searched for a page.n",
  700.     (u_long)gsp->st_hash_searches);
  701. dl("The longest hash chain searched for a page.n",
  702.     (u_long)gsp->st_hash_longest);
  703. dl("Total number of hash buckets examined for page location.n",
  704.     (u_long)gsp->st_hash_examined);
  705. dl("The number of region locks granted without waiting.n",
  706.     (u_long)gsp->st_region_nowait);
  707. dl("The number of region locks granted after waiting.n",
  708.     (u_long)gsp->st_region_wait);
  710. for (; fsp != NULL && *fsp != NULL; ++fsp) {
  711. printf("%sn", DB_LINE);
  712. printf("Pool File: %sn", (*fsp)->file_name);
  713. dl("Page size.n", (u_long)(*fsp)->st_pagesize);
  714. dl("Requested pages found in the cache",
  715.     (u_long)(*fsp)->st_cache_hit);
  716. if ((*fsp)->st_cache_hit + (*fsp)->st_cache_miss != 0)
  717. printf(" (%.0f%%)", ((double)(*fsp)->st_cache_hit /
  718.     ((*fsp)->st_cache_hit + (*fsp)->st_cache_miss)) *
  719.     100);
  720. printf(".n");
  721. dl("Requested pages mapped into the process' address space.n",
  722.     (u_long)(*fsp)->st_map);
  723. dl("Requested pages not found in the cache.n",
  724.     (u_long)(*fsp)->st_cache_miss);
  725. dl("Pages created in the cache.n",
  726.     (u_long)(*fsp)->st_page_create);
  727. dl("Pages read into the cache.n",
  728.     (u_long)(*fsp)->st_page_in);
  729. dl("Pages written from the cache to the backing file.n",
  730.     (u_long)(*fsp)->st_page_out);
  731. }
  733. return (0);
  734. }
  736. /*
  737.  * txn_stats --
  738.  * Display transaction statistics.
  739.  */
  740. int
  741. txn_stats(dbenvp)
  742. DB_ENV *dbenvp;
  743. {
  744. DB_TXN_STAT *sp;
  745. u_int32_t i;
  746. int ret;
  747. const char *p;
  749. if ((ret = txn_stat(dbenvp, &sp, NULL)) != 0) {
  750. dbenvp->err(dbenvp, ret, NULL);
  751. return (1);
  752. }
  754. p = sp->st_last_ckp.file == 0 ?
  755.     "No checkpoint LSN." : "File/offset for last checkpoint LSN.";
  756. printf("%lu/%lut%sn",
  757.     (u_long)sp->st_last_ckp.file, (u_long)sp->st_last_ckp.offset, p);
  758. p = sp->st_pending_ckp.file == 0 ?
  759.     "No pending checkpoint LSN." :
  760.     "File/offset for last pending checkpoint LSN.";
  761. printf("%lu/%lut%sn",
  762.     (u_long)sp->st_pending_ckp.file,
  763.     (u_long)sp->st_pending_ckp.offset, p);
  764. if (sp->st_time_ckp == 0)
  765. printf("0tNo checkpoint timestamp.n");
  766. else
  767. printf("%.24stCheckpoint timestamp.n",
  768.     ctime(&sp->st_time_ckp));
  769. printf("%lxtLast transaction ID allocated.n",
  770.     (u_long)sp->st_last_txnid);
  771. dl("Maximum number of active transactions possible.n",
  772.     (u_long)sp->st_maxtxns);
  773. dl("Active transactions.n", (u_long)sp->st_nactive);
  774. dl("Maximum active transactions.n", (u_long)sp->st_maxnactive);
  775. dl("Number of transactions begun.n", (u_long)sp->st_nbegins);
  776. dl("Number of transactions aborted.n", (u_long)sp->st_naborts);
  777. dl("Number of transactions committed.n", (u_long)sp->st_ncommits);
  778. dl_bytes("Transaction region size",
  779.     (u_long)0, (u_long)0, (u_long)sp->st_regsize);
  780. dl("The number of region locks granted without waiting.n",
  781.     (u_long)sp->st_region_nowait);
  782. dl("The number of region locks granted after waiting.n",
  783.     (u_long)sp->st_region_wait);
  784. qsort(sp->st_txnarray,
  785.     sp->st_nactive, sizeof(sp->st_txnarray[0]), txn_compare);
  786. for (i = 0; i < sp->st_nactive; ++i)
  787. printf("tid: %lx; initial LSN file/offest %lu/%lun",
  788.     (u_long)sp->st_txnarray[i].txnid,
  789.     (u_long)sp->st_txnarray[i].lsn.file,
  790.     (u_long)sp->st_txnarray[i].lsn.offset);
  792. return (0);
  793. }
  795. int
  796. txn_compare(a1, b1)
  797. const void *a1, *b1;
  798. {
  799. const DB_TXN_ACTIVE *a, *b;
  801. a = a1;
  802. b = b1;
  804. if (a->txnid > b->txnid)
  805. return (1);
  806. if (a->txnid < b->txnid)
  807. return (-1);
  808. return (0);
  809. }
  811. /*
  812.  * dl --
  813.  * Display a big value.
  814.  */
  815. void
  816. dl(msg, value)
  817. const char *msg;
  818. u_long value;
  819. {
  820. /*
  821.  * Two formats: if less than 10 million, display as the number, if
  822.  * greater than 10 million display as ###M.
  823.  */
  824. if (value < 10000000)
  825. printf("%lut%s", value, msg);
  826. else
  827. printf("%luMt%s", value / 1000000, msg);
  828. }
  830. /*
  831.  * dl_bytes --
  832.  * Display a big number of bytes.
  833.  */
  834. void
  835. dl_bytes(msg, gbytes, mbytes, bytes)
  836. const char *msg;
  837. u_long gbytes, mbytes, bytes;
  838. {
  839. const char *sep;
  840. u_long sbytes;
  841. int showbytes;
  843. sbytes = bytes;
  844. while (bytes > MEGABYTE) {
  845. ++mbytes;
  846. bytes -= MEGABYTE;
  847. }
  848. while (mbytes > GIGABYTE / MEGABYTE) {
  849. ++gbytes;
  850. --mbytes;
  851. }
  853. sep = "";
  854. showbytes = 0;
  855. if (gbytes > 0) {
  856. printf("%luGB", gbytes);
  857. sep = " ";
  858. showbytes = 1;
  859. }
  860. if (mbytes > 0) {
  861. printf("%s%luMB", sep, mbytes);
  862. sep = " ";
  863. showbytes = 1;
  864. }
  865. if (bytes > 1024) {
  866. printf("%s%luKB", sep, bytes / 1024);
  867. bytes %= 1024;
  868. sep = " ";
  869. showbytes = 1;
  870. }
  871. if (bytes > 0)
  872. printf("%s%luB", sep, bytes);
  873. printf("t%s", msg);
  874. if (showbytes)
  875. printf(" (%lu bytes)", sbytes);
  876. printf(".n");
  877. }
  879. /*
  880.  * prflags --
  881.  * Print out flag values.
  882.  */
  883. void
  884. prflags(flags, fnp)
  885. u_int32_t flags;
  886. const FN *fnp;
  887. {
  888. const char *sep;
  890. sep = "t";
  891. printf("Flags:");
  892. for (; fnp->mask != 0; ++fnp)
  893. if (fnp->mask & flags) {
  894. printf("%s%s", sep, fnp->name);
  895. sep = ", ";
  896. }
  897. printf("n");
  898. }
  900. /*
  901.  * db_init --
  902.  * Initialize the environment.
  903.  */
  904. int
  905. db_init(home, ttype)
  906. char *home;
  907. test_t ttype;
  908. {
  909. int ret;
  911. /*
  912.  * If our environment open fails, and we're trying to look at a
  913.  * shared region, it's a hard failure.
  914.  */
  915. if ((ret = dbenv->open(dbenv,
  916.     home, DB_JOINENV | DB_USE_ENVIRON, 0)) == 0)
  917. return (0);
  918. if (ttype != T_DB) {
  919. dbenv->err(dbenv, ret, "DBENV->open%s%s",
  920.     home == NULL ? "" : ": ", home == NULL ? "" : home);
  921. return (1);
  922. }
  924. /*
  925.  * We're trying to look at a database.
  926.  *
  927.  * An environment is required because we may be trying to look at
  928.  * databases in directories other than the current one.  We could
  929.  * avoid using an environment iff the -h option wasn't specified,
  930.  * but that seems like more work than it's worth.
  931.  *
  932.  *
  933.  * No environment exists.  Create one, but make it private so that
  934.  * no files are actually created.
  935.  *
  936.  * Note that we will probably just drop core if the environment
  937.  * we joined above does not include a memory pool.  This is probably
  938.  * acceptable;  trying to use an existing shared environment that
  939.  * does not contain a memory pool to look at a database can
  940.  * be safely construed as operator error, I think.
  941.  */
  942. if ((ret = dbenv->open(dbenv, home,
  943.     DB_CREATE | DB_INIT_MPOOL | DB_PRIVATE | DB_USE_ENVIRON, 0)) == 0)
  944. return (0);
  946. /* An environment is required. */
  947. dbenv->err(dbenv, ret, "open");
  948. return (1);
  949. }
  951. /*
  952.  * argcheck --
  953.  * Return if argument flags are okay.
  954.  */
  955. int
  956. argcheck(arg, ok_args)
  957. char *arg;
  958. const char *ok_args;
  959. {
  960. for (; *arg != ''; ++arg)
  961. if (strchr(ok_args, *arg) == NULL)
  962. return (0);
  963. return (1);
  964. }
  966. void
  967. usage()
  968. {
  969. fprintf(stderr, "usage: db_stat %sn",
  970.     "[-celmNtV] [-C Acflmo] [-d file [-s file]] [-h home] [-M Ahlm]");
  971. exit (1);
  972. }
  974. void
  975. version_check()
  976. {
  977. int v_major, v_minor, v_patch;
  979. /* Make sure we're loaded with the right version of the DB library. */
  980. (void)db_version(&v_major, &v_minor, &v_patch);
  981. if (v_major != DB_VERSION_MAJOR ||
  982.     v_minor != DB_VERSION_MINOR || v_patch != DB_VERSION_PATCH) {
  983. fprintf(stderr,
  984. "%s: version %d.%d.%d doesn't match library version %d.%d.%dn",
  985.     progname, DB_VERSION_MAJOR, DB_VERSION_MINOR,
  986.     DB_VERSION_PATCH, v_major, v_minor, v_patch);
  987. exit (1);
  988. }
  989. }