/*- * See the file LICENSE for redistribution information. * * Copyright (c) 1996-2005 * Sleepycat Software. All rights reserved. * * $Id: db_stati.c,v 12.10 2005/11/08 03:13:31 bostic Exp $ */ #include "db_config.h" #ifndef NO_SYSTEM_INCLUDES #include <sys/types.h> #if TIME_WITH_SYS_TIME #include <sys/time.h> #include <time.h> #else #if HAVE_SYS_TIME_H #include <sys/time.h> #else #include <time.h> #endif #endif #include <string.h> #endif #include "db_int.h" #include "dbinc/db_page.h" #include "dbinc/db_shash.h" #include "dbinc/btree.h" #include "dbinc/hash.h" #include "dbinc/qam.h" #include "dbinc/lock.h" #include "dbinc/log.h" #include "dbinc/mp.h" #ifdef HAVE_STATISTICS static int __db_print_all __P((DB *, u_int32_t)); static int __db_print_citem __P((DBC *)); static int __db_print_cursor __P((DB *)); static int __db_print_stats __P((DB *, u_int32_t)); static int __db_stat_arg __P((DB *, u_int32_t)); /* * __db_stat_pp -- * DB->stat pre/post processing. * * PUBLIC: int __db_stat_pp __P((DB *, DB_TXN *, void *, u_int32_t)); */ int __db_stat_pp(dbp, txn, spp, flags) DB *dbp; DB_TXN *txn; void *spp; u_int32_t flags; { DB_ENV *dbenv; DB_THREAD_INFO *ip; int handle_check, ret, t_ret; dbenv = dbp->dbenv; PANIC_CHECK(dbp->dbenv); DB_ILLEGAL_BEFORE_OPEN(dbp, "DB->stat"); if ((ret = __db_stat_arg(dbp, flags)) != 0) return (ret); ENV_ENTER(dbenv, ip); /* Check for replication block. */ handle_check = IS_ENV_REPLICATED(dbenv); if (handle_check && (ret = __db_rep_enter(dbp, 1, 0, 0)) != 0) { handle_check = 0; goto err; } ret = __db_stat(dbp, txn, spp, flags); /* Release replication block. */ if (handle_check && (t_ret = __env_db_rep_exit(dbenv)) != 0 && ret == 0) ret = t_ret; err: ENV_LEAVE(dbenv, ip); return (ret); } /* * __db_stat -- * DB->stat. * * PUBLIC: int __db_stat __P((DB *, DB_TXN *, void *, u_int32_t)); */ int __db_stat(dbp, txn, spp, flags) DB *dbp; DB_TXN *txn; void *spp; u_int32_t flags; { DB_ENV *dbenv; DBC *dbc; int ret, t_ret; dbenv = dbp->dbenv; /* Acquire a cursor. */ if ((ret = __db_cursor(dbp, txn, &dbc, LF_ISSET(DB_READ_COMMITTED | DB_READ_UNCOMMITTED))) != 0) return (ret); DEBUG_LWRITE(dbc, NULL, "DB->stat", NULL, NULL, flags); LF_CLR(DB_READ_COMMITTED | DB_READ_UNCOMMITTED); switch (dbp->type) { case DB_BTREE: case DB_RECNO: ret = __bam_stat(dbc, spp, flags); break; case DB_HASH: ret = __ham_stat(dbc, spp, flags); break; case DB_QUEUE: ret = __qam_stat(dbc, spp, flags); break; case DB_UNKNOWN: default: ret = (__db_unknown_type(dbenv, "DB->stat", dbp->type)); break; } if ((t_ret = __db_c_close(dbc)) != 0 && ret == 0) ret = t_ret; return (ret); } /* * __db_stat_arg -- * Check DB->stat arguments. */ static int __db_stat_arg(dbp, flags) DB *dbp; u_int32_t flags; { DB_ENV *dbenv; dbenv = dbp->dbenv; /* Check for invalid function flags. */ LF_CLR(DB_READ_COMMITTED | DB_READ_UNCOMMITTED); switch (flags) { case 0: case DB_FAST_STAT: case DB_CACHED_COUNTS: /* Deprecated and undocumented. */ break; case DB_RECORDCOUNT: /* Deprecated and undocumented. */ if (dbp->type == DB_RECNO) break; if (dbp->type == DB_BTREE && F_ISSET(dbp, DB_AM_RECNUM)) break; /* FALLTHROUGH */ default: return (__db_ferr(dbenv, "DB->stat", 0)); } return (0); } /* * __db_stat_print_pp -- * DB->stat_print pre/post processing. * * PUBLIC: int __db_stat_print_pp __P((DB *, u_int32_t)); */ int __db_stat_print_pp(dbp, flags) DB *dbp; u_int32_t flags; { DB_ENV *dbenv; DB_THREAD_INFO *ip; int handle_check, ret, t_ret; dbenv = dbp->dbenv; PANIC_CHECK(dbenv); DB_ILLEGAL_BEFORE_OPEN(dbp, "DB->stat"); /* * !!! * The actual argument checking is simple, do it inline. */ if ((ret = __db_fchk(dbenv, "DB->stat_print", flags, DB_FAST_STAT | DB_STAT_ALL)) != 0) return (ret); ENV_ENTER(dbenv, ip); /* Check for replication block. */ handle_check = IS_ENV_REPLICATED(dbenv); if (handle_check && (ret = __db_rep_enter(dbp, 1, 0, 0)) != 0) { handle_check = 0; goto err; } ret = __db_stat_print(dbp, flags); /* Release replication block. */ if (handle_check && (t_ret = __env_db_rep_exit(dbenv)) != 0 && ret == 0) ret = t_ret; err: ENV_LEAVE(dbenv, ip); return (ret); } /* * __db_stat_print -- * DB->stat_print. * * PUBLIC: int __db_stat_print __P((DB *, u_int32_t)); */ int __db_stat_print(dbp, flags) DB *dbp; u_int32_t flags; { int ret; time_t now; (void)time(&now); __db_msg(dbp->dbenv, "%.24s\tLocal time", ctime(&now)); if (LF_ISSET(DB_STAT_ALL) && (ret = __db_print_all(dbp, flags)) != 0) return (ret); if ((ret = __db_print_stats(dbp, flags)) != 0) return (ret); return (0); } /* * __db_print_stats -- * Display default DB handle statistics. */ static int __db_print_stats(dbp, flags) DB *dbp; u_int32_t flags; { DBC *dbc; DB_ENV *dbenv; int ret, t_ret; dbenv = dbp->dbenv; /* Acquire a cursor. */ if ((ret = __db_cursor(dbp, NULL, &dbc, 0)) != 0) return (ret); DEBUG_LWRITE(dbc, NULL, "DB->stat_print", NULL, NULL, 0); switch (dbp->type) { case DB_BTREE: case DB_RECNO: ret = __bam_stat_print(dbc, flags); break; case DB_HASH: ret = __ham_stat_print(dbc, flags); break; case DB_QUEUE: ret = __qam_stat_print(dbc, flags); break; case DB_UNKNOWN: default: ret = (__db_unknown_type(dbenv, "DB->stat_print", dbp->type)); break; } if ((t_ret = __db_c_close(dbc)) != 0 && ret == 0) ret = t_ret; return (ret); } /* * __db_print_all -- * Display debugging DB handle statistics. */ static int __db_print_all(dbp, flags) DB *dbp; u_int32_t flags; { static const FN fn[] = { { DB_AM_CHKSUM, "DB_AM_CHKSUM" }, { DB_AM_CL_WRITER, "DB_AM_CL_WRITER" }, { DB_AM_COMPENSATE, "DB_AM_COMPENSATE" }, { DB_AM_CREATED, "DB_AM_CREATED" }, { DB_AM_CREATED_MSTR, "DB_AM_CREATED_MSTR" }, { DB_AM_DBM_ERROR, "DB_AM_DBM_ERROR" }, { DB_AM_DELIMITER, "DB_AM_DELIMITER" }, { DB_AM_DISCARD, "DB_AM_DISCARD" }, { DB_AM_DUP, "DB_AM_DUP" }, { DB_AM_DUPSORT, "DB_AM_DUPSORT" }, { DB_AM_ENCRYPT, "DB_AM_ENCRYPT" }, { DB_AM_FIXEDLEN, "DB_AM_FIXEDLEN" }, { DB_AM_INMEM, "DB_AM_INMEM" }, { DB_AM_IN_RENAME, "DB_AM_IN_RENAME" }, { DB_AM_NOT_DURABLE, "DB_AM_NOT_DURABLE" }, { DB_AM_OPEN_CALLED, "DB_AM_OPEN_CALLED" }, { DB_AM_PAD, "DB_AM_PAD" }, { DB_AM_PGDEF, "DB_AM_PGDEF" }, { DB_AM_RDONLY, "DB_AM_RDONLY" }, { DB_AM_READ_UNCOMMITTED, "DB_AM_READ_UNCOMMITTED" }, { DB_AM_RECNUM, "DB_AM_RECNUM" }, { DB_AM_RECOVER, "DB_AM_RECOVER" }, { DB_AM_RENUMBER, "DB_AM_RENUMBER" }, { DB_AM_REVSPLITOFF, "DB_AM_REVSPLITOFF" }, { DB_AM_SECONDARY, "DB_AM_SECONDARY" }, { DB_AM_SNAPSHOT, "DB_AM_SNAPSHOT" }, { DB_AM_SUBDB, "DB_AM_SUBDB" }, { DB_AM_SWAP, "DB_AM_SWAP" }, { DB_AM_TXN, "DB_AM_TXN" }, { DB_AM_VERIFYING, "DB_AM_VERIFYING" }, { 0, NULL } }; DB_ENV *dbenv; dbenv = dbp->dbenv; __db_msg(dbenv, "%s", DB_GLOBAL(db_line)); __db_msg(dbenv, "DB handle information:"); STAT_ULONG("Page size", dbp->pgsize); STAT_ISSET("Append recno", dbp->db_append_recno); STAT_ISSET("Feedback", dbp->db_feedback); STAT_ISSET("Dup compare", dbp->dup_compare); STAT_ISSET("App private", dbp->app_private); STAT_ISSET("DbEnv", dbp->dbenv); STAT_STRING("Type", __db_dbtype_to_string(dbp->type)); __mutex_print_debug_single(dbenv, "Thread mutex", dbp->mutex, flags); STAT_STRING("File", dbp->fname); STAT_STRING("Database", dbp->dname); STAT_HEX("Open flags", dbp->open_flags); __db_print_fileid(dbenv, dbp->fileid, "\tFile ID"); STAT_ULONG("Cursor adjust ID", dbp->adj_fileid); STAT_ULONG("Meta pgno", dbp->meta_pgno); STAT_ULONG("Locker ID", dbp->lid); STAT_ULONG("Handle lock", dbp->cur_lid); STAT_ULONG("Associate lock", dbp->associate_lid); STAT_ULONG("RPC remote ID", dbp->cl_id); __db_msg(dbenv, "%.24s\tReplication handle timestamp", dbp->timestamp == 0 ? "0" : ctime(&dbp->timestamp)); STAT_ISSET("Secondary callback", dbp->s_callback); STAT_ISSET("Primary handle", dbp->s_primary); STAT_ISSET("api internal", dbp->api_internal); STAT_ISSET("Btree/Recno internal", dbp->bt_internal); STAT_ISSET("Hash internal", dbp->h_internal); STAT_ISSET("Queue internal", dbp->q_internal); STAT_ISSET("XA internal", dbp->xa_internal); __db_prflags(dbenv, NULL, dbp->flags, fn, NULL, "\tFlags"); if (dbp->log_filename == NULL) STAT_ISSET("File naming information", dbp->log_filename); else __dbreg_print_fname(dbenv, dbp->log_filename); (void)__db_print_cursor(dbp); return (0); } /* * __db_print_cursor -- * Display the cursor active and free queues. */ static int __db_print_cursor(dbp) DB *dbp; { DB_ENV *dbenv; DBC *dbc; int ret, t_ret; dbenv = dbp->dbenv; __db_msg(dbenv, "%s", DB_GLOBAL(db_line)); __db_msg(dbenv, "DB handle cursors:"); ret = 0; MUTEX_LOCK(dbp->dbenv, dbp->mutex); __db_msg(dbenv, "Active queue:"); for (dbc = TAILQ_FIRST(&dbp->active_queue); dbc != NULL; dbc = TAILQ_NEXT(dbc, links)) if ((t_ret = __db_print_citem(dbc)) != 0 && ret == 0) ret = t_ret; __db_msg(dbenv, "Join queue:"); for (dbc = TAILQ_FIRST(&dbp->join_queue); dbc != NULL; dbc = TAILQ_NEXT(dbc, links)) if ((t_ret = __db_print_citem(dbc)) != 0 && ret == 0) ret = t_ret; __db_msg(dbenv, "Free queue:"); for (dbc = TAILQ_FIRST(&dbp->free_queue); dbc != NULL; dbc = TAILQ_NEXT(dbc, links)) if ((t_ret = __db_print_citem(dbc)) != 0 && ret == 0) ret = t_ret; MUTEX_UNLOCK(dbp->dbenv, dbp->mutex); return (ret); } static int __db_print_citem(dbc) DBC *dbc; { static const FN fn[] = { { DBC_ACTIVE, "DBC_ACTIVE" }, { DBC_COMPENSATE, "DBC_COMPENSATE" }, { DBC_MULTIPLE, "DBC_MULTIPLE" }, { DBC_MULTIPLE_KEY, "DBC_MULTIPLE_KEY" }, { DBC_OPD, "DBC_OPD" }, { DBC_OWN_LID, "DBC_OWN_LID" }, { DBC_READ_COMMITTED, "DBC_READ_COMMITTED" }, { DBC_READ_UNCOMMITTED, "DBC_READ_UNCOMMITTED" }, { DBC_RECOVER, "DBC_RECOVER" }, { DBC_RMW, "DBC_RMW" }, { DBC_TRANSIENT, "DBC_TRANSIENT" }, { DBC_WRITECURSOR, "DBC_WRITECURSOR" }, { DBC_WRITER, "DBC_WRITER" }, { 0, NULL } }; DB *dbp; DBC_INTERNAL *cp; DB_ENV *dbenv; dbp = dbc->dbp; dbenv = dbp->dbenv; cp = dbc->internal; STAT_POINTER("DBC", dbc); STAT_POINTER("Associated dbp", dbc->dbp); STAT_POINTER("Associated txn", dbc->txn); STAT_POINTER("Internal", cp); STAT_HEX("Default locker ID", dbc->lref == NULL ? 0 : ((DB_LOCKER *)dbc->lref)->id); STAT_HEX("Locker", dbc->locker); STAT_STRING("Type", __db_dbtype_to_string(dbc->dbtype)); STAT_POINTER("Off-page duplicate cursor", cp->opd); STAT_POINTER("Referenced page", cp->page); STAT_ULONG("Root", cp->root); STAT_ULONG("Page number", cp->pgno); STAT_ULONG("Page index", cp->indx); STAT_STRING("Lock mode", __db_lockmode_to_string(cp->lock_mode)); __db_prflags(dbenv, NULL, dbc->flags, fn, NULL, "\tFlags"); switch (dbc->dbtype) { case DB_BTREE: case DB_RECNO: __bam_print_cursor(dbc); break; case DB_HASH: __ham_print_cursor(dbc); break; case DB_UNKNOWN: DB_ASSERT(dbp->type != DB_UNKNOWN); /* FALLTHROUGH */ case DB_QUEUE: default: break; } return (0); } #else /* !HAVE_STATISTICS */ int __db_stat_pp(dbp, txn, spp, flags) DB *dbp; DB_TXN *txn; void *spp; u_int32_t flags; { COMPQUIET(spp, NULL); COMPQUIET(txn, NULL); COMPQUIET(flags, 0); return (__db_stat_not_built(dbp->dbenv)); } int __db_stat_print_pp(dbp, flags) DB *dbp; u_int32_t flags; { COMPQUIET(flags, 0); return (__db_stat_not_built(dbp->dbenv)); } #endif