env_stat.c

这是国外的resip协议栈

/*-
 * See the file LICENSE for redistribution information.
 *
 * Copyright (c) 1996-2004
 *	Sleepycat Software.  All rights reserved.
 *
 * $Id: env_stat.c,v 1.21 2004/10/29 17:37:23 bostic Exp $
 */

#include "db_config.h"

#ifndef NO_SYSTEM_INCLUDES
#include <sys/types.h>
#endif

#include "db_int.h"
#include "dbinc/db_page.h"
#include "dbinc/db_shash.h"
#include "dbinc/db_am.h"
#include "dbinc/lock.h"
#include "dbinc/log.h"
#include "dbinc/mp.h"
#include "dbinc/txn.h"

#ifdef HAVE_STATISTICS
static int  __dbenv_print_all __P((DB_ENV *, u_int32_t));
static int  __dbenv_print_stats __P((DB_ENV *, u_int32_t));
static int  __dbenv_stat_print __P((DB_ENV *, u_int32_t));
static const char *__reg_type __P((reg_type_t));

/*
 * __dbenv_stat_print_pp --
 *	DB_ENV->stat_print pre/post processor.
 *
 * PUBLIC: int __dbenv_stat_print_pp __P((DB_ENV *, u_int32_t));
 */
int
__dbenv_stat_print_pp(dbenv, flags)
	DB_ENV *dbenv;
	u_int32_t flags;
{
	int rep_check, ret;

	PANIC_CHECK(dbenv);
	ENV_ILLEGAL_BEFORE_OPEN(dbenv, "DB_ENV->stat_print");

	if ((ret = __db_fchk(dbenv, "DB_ENV->stat_print",
	    flags, DB_STAT_ALL | DB_STAT_CLEAR | DB_STAT_SUBSYSTEM)) != 0)
		return (ret);

	rep_check = IS_ENV_REPLICATED(dbenv) ? 1 : 0;
	if (rep_check)
		__env_rep_enter(dbenv);
	ret = __dbenv_stat_print(dbenv, flags);
	if (rep_check)
		__env_db_rep_exit(dbenv);
	return (ret);
}

/*
 * __dbenv_stat_print --
 *	DB_ENV->stat_print method.
 */
static int
__dbenv_stat_print(dbenv, flags)
	DB_ENV *dbenv;
	u_int32_t flags;
{
	DB *dbp;
	int ret;

	if ((ret = __dbenv_print_stats(dbenv, flags)) != 0)
		return (ret);

	if (LF_ISSET(DB_STAT_ALL) &&
	    (ret = __dbenv_print_all(dbenv, flags)) != 0)
		return (ret);

	if (!LF_ISSET(DB_STAT_SUBSYSTEM))
		return (0);

	/* The subsystems don't know anything about DB_STAT_SUBSYSTEM. */
	LF_CLR(DB_STAT_SUBSYSTEM);

	if (LOGGING_ON(dbenv)) {
		__db_msg(dbenv, "%s", DB_GLOBAL(db_line));
		if ((ret = __log_stat_print(dbenv, flags)) != 0)
			return (ret);
	}

	if (LOCKING_ON(dbenv)) {
		__db_msg(dbenv, "%s", DB_GLOBAL(db_line));
		if ((ret = __lock_stat_print(dbenv, flags)) != 0)
			return (ret);
	}

	if (MPOOL_ON(dbenv)) {
		__db_msg(dbenv, "%s", DB_GLOBAL(db_line));
		if ((ret = __memp_stat_print(dbenv, flags)) != 0)
			return (ret);
	}

	if (REP_ON(dbenv)) {
		__db_msg(dbenv, "%s", DB_GLOBAL(db_line));
		if ((ret = __rep_stat_print(dbenv, flags)) != 0)
			return (ret);
	}

	if (TXN_ON(dbenv)) {
		__db_msg(dbenv, "%s", DB_GLOBAL(db_line));
		if ((ret = __txn_stat_print(dbenv, flags)) != 0)
			return (ret);
	}

	MUTEX_THREAD_LOCK(dbenv, dbenv->dblist_mutexp);
	for (dbp = LIST_FIRST(&dbenv->dblist);
	    dbp != NULL; dbp = LIST_NEXT(dbp, dblistlinks)) {
		__db_msg(dbenv, "%s", DB_GLOBAL(db_line));
		__db_msg(dbenv, "%s%s%s\tDatabase name",
		    dbp->fname, dbp->dname == NULL ? "" : "/",
		    dbp->dname == NULL ? "" : dbp->dname);
		if ((ret = __db_stat_print(dbp, flags)) != 0)
			break;
	}
	MUTEX_THREAD_UNLOCK(dbenv, dbenv->dblist_mutexp);

	return (ret);
}

/*
 * __dbenv_print_stats --
 *	Display the default environment statistics.
 *
 */
static int
__dbenv_print_stats(dbenv, flags)
	DB_ENV *dbenv;
	u_int32_t flags;
{
	REGENV *renv;
	REGINFO *infop;

	infop = dbenv->reginfo;
	renv = infop->primary;

	if (LF_ISSET(DB_STAT_ALL)) {
		__db_msg(dbenv, "%s", DB_GLOBAL(db_line));
		__db_msg(dbenv, "Default database environment information:");
	}
	__db_msg(dbenv, "%d.%d.%d\tEnvironment version",
	    renv->majver, renv->minver, renv->patch);
	STAT_HEX("Magic number", renv->magic);
	STAT_LONG("Panic value", renv->envpanic);
	STAT_LONG("References", renv->refcnt);

	__db_print_mutex(dbenv, NULL, &renv->mutex,
	    "The number of region locks that required waiting", flags);

	return (0);
}

/*
 * __dbenv_print_all --
 *	Display the debugging environment statistics.
 */
static int
__dbenv_print_all(dbenv, flags)
	DB_ENV *dbenv;
	u_int32_t flags;
{
	static const FN fn[] = {
		{ DB_ENV_AUTO_COMMIT,		"DB_ENV_AUTO_COMMIT" },
		{ DB_ENV_CDB,			"DB_ENV_CDB" },
		{ DB_ENV_CDB_ALLDB,		"DB_ENV_CDB_ALLDB" },
		{ DB_ENV_CREATE,		"DB_ENV_CREATE" },
		{ DB_ENV_DBLOCAL,		"DB_ENV_DBLOCAL" },
		{ DB_ENV_DIRECT_DB,		"DB_ENV_DIRECT_DB" },
		{ DB_ENV_DIRECT_LOG,		"DB_ENV_DIRECT_LOG" },
		{ DB_ENV_DSYNC_LOG,		"DB_ENV_DSYNC_LOG" },
		{ DB_ENV_FATAL,			"DB_ENV_FATAL" },
		{ DB_ENV_LOCKDOWN,		"DB_ENV_LOCKDOWN" },
		{ DB_ENV_LOG_AUTOREMOVE,	"DB_ENV_LOG_AUTOREMOVE" },
		{ DB_ENV_LOG_INMEMORY,		"DB_ENV_LOG_INMEMORY" },
		{ DB_ENV_NOLOCKING,		"DB_ENV_NOLOCKING" },
		{ DB_ENV_NOMMAP,		"DB_ENV_NOMMAP" },
		{ DB_ENV_NOPANIC,		"DB_ENV_NOPANIC" },
		{ DB_ENV_OPEN_CALLED,		"DB_ENV_OPEN_CALLED" },
		{ DB_ENV_OVERWRITE,		"DB_ENV_OVERWRITE" },
		{ DB_ENV_PRIVATE,		"DB_ENV_PRIVATE" },
		{ DB_ENV_REGION_INIT,		"DB_ENV_REGION_INIT" },
		{ DB_ENV_RPCCLIENT,		"DB_ENV_RPCCLIENT" },
		{ DB_ENV_RPCCLIENT_GIVEN,	"DB_ENV_RPCCLIENT_GIVEN" },
		{ DB_ENV_SYSTEM_MEM,		"DB_ENV_SYSTEM_MEM" },
		{ DB_ENV_THREAD,		"DB_ENV_THREAD" },
		{ DB_ENV_TIME_NOTGRANTED,	"DB_ENV_TIME_NOTGRANTED" },
		{ DB_ENV_TXN_NOSYNC,		"DB_ENV_TXN_NOSYNC" },
		{ DB_ENV_TXN_WRITE_NOSYNC,	"DB_ENV_TXN_WRITE_NOSYNC" },
		{ DB_ENV_YIELDCPU,		"DB_ENV_YIELDCPU" },
		{ 0,				NULL }
	};
	static const FN ofn[] = {
		{ DB_CREATE,			"DB_CREATE" },
		{ DB_CXX_NO_EXCEPTIONS,	"DB_CXX_NO_EXCEPTIONS" },
		{ DB_FORCE,			"DB_FORCE" },
		{ DB_INIT_CDB,			"DB_INIT_CDB" },
		{ DB_INIT_LOCK,		"DB_INIT_LOCK" },
		{ DB_INIT_LOG,			"DB_INIT_LOG" },
		{ DB_INIT_MPOOL,		"DB_INIT_MPOOL" },
		{ DB_INIT_REP,			"DB_INIT_REP" },
		{ DB_INIT_TXN,			"DB_INIT_TXN" },
		{ DB_JOINENV,			"DB_JOINENV" },
		{ DB_LOCKDOWN,			"DB_LOCKDOWN" },
		{ DB_NOMMAP,			"DB_NOMMAP" },
		{ DB_PRIVATE,			"DB_PRIVATE" },
		{ DB_RDONLY,			"DB_RDONLY" },
		{ DB_RECOVER,			"DB_RECOVER" },
		{ DB_RECOVER_FATAL,		"DB_RECOVER_FATAL" },
		{ DB_SYSTEM_MEM,		"DB_SYSTEM_MEM" },
		{ DB_THREAD,			"DB_THREAD" },
		{ DB_TRUNCATE,			"DB_TRUNCATE" },
		{ DB_TXN_NOSYNC,		"DB_TXN_NOSYNC" },
		{ DB_USE_ENVIRON,		"DB_USE_ENVIRON" },
		{ DB_USE_ENVIRON_ROOT,		"DB_USE_ENVIRON_ROOT" },
		{ 0,				NULL }
	};
	static const FN vfn[] = {
		{ DB_VERB_DEADLOCK,		"DB_VERB_DEADLOCK" },
		{ DB_VERB_RECOVERY,		"DB_VERB_RECOVERY" },
		{ DB_VERB_REPLICATION,		"DB_VERB_REPLICATION" },
		{ DB_VERB_WAITSFOR,		"DB_VERB_WAITSFOR" },
		{ 0,				NULL }
	};
	DB_MSGBUF mb;
	REGENV *renv;
	REGINFO *infop;
	REGION *rp, regs[1024];
	size_t n;
	char **p;

	infop = dbenv->reginfo;
	renv = infop->primary;
	DB_MSGBUF_INIT(&mb);

	/*
	 * Lock the database environment while we get copies of the region
	 * information.
	 */
	MUTEX_LOCK(dbenv, &infop->rp->mutex);

	for (n = 0, rp = SH_LIST_FIRST(&renv->regionq, __db_region);
	    n < sizeof(regs) / sizeof(regs[0]) && rp != NULL;
	    ++n, rp = SH_LIST_NEXT(rp, q, __db_region)) {
		regs[n] = *rp;
		if (LF_ISSET(DB_STAT_CLEAR))
			MUTEX_CLEAR(&rp->mutex);
	}
	if (n > 0)
		--n;
	MUTEX_UNLOCK(dbenv, &infop->rp->mutex);

	if (LF_ISSET(DB_STAT_ALL)) {
		__db_msg(dbenv, "%s", DB_GLOBAL(db_line));
		__db_msg(dbenv, "Per region database environment information:");
	}
	while (n > 0) {
		rp = &regs[--n];
		__db_msg(dbenv, "%s Region:", __reg_type(rp->type));
		STAT_LONG("Region ID", rp->id);
		STAT_LONG("Segment ID", rp->segid);
		__db_dlbytes(dbenv,
		    "Size", (u_long)0, (u_long)0, (u_long)rp->size);
		__db_print_mutex(dbenv, NULL, &rp->mutex,
		    "The number of region locks that required waiting", flags);
	}

	__db_msg(dbenv, "%s", DB_GLOBAL(db_line));
	__db_msg(dbenv, "DB_ENV handle information:");
	STAT_ISSET("Errfile", dbenv->db_errfile);
	STAT_STRING("Errpfx", dbenv->db_errpfx);
	STAT_ISSET("Errcall", dbenv->db_errcall);
	STAT_ISSET("Feedback", dbenv->db_feedback);
	STAT_ISSET("Panic", dbenv->db_paniccall);
	STAT_ISSET("Malloc", dbenv->db_malloc);
	STAT_ISSET("Realloc", dbenv->db_realloc);
	STAT_ISSET("Free", dbenv->db_free);
	__db_prflags(dbenv, NULL, dbenv->verbose, vfn, NULL, "\tVerbose flags");

	STAT_ISSET("App private", dbenv->app_private);
	STAT_ISSET("App dispatch", dbenv->app_dispatch);
	STAT_STRING("Home", dbenv->db_home);
	STAT_STRING("Log dir", dbenv->db_log_dir);
	STAT_STRING("Tmp dir", dbenv->db_tmp_dir);
	if (dbenv->db_data_dir == NULL)
		STAT_ISSET("Data dir", dbenv->db_data_dir);
	else {
		for (p = dbenv->db_data_dir; *p != NULL; ++p)
			__db_msgadd(dbenv, &mb, "%s\tData dir", *p);
		DB_MSGBUF_FLUSH(dbenv, &mb);
	}
	STAT_FMT("Mode", "%#o", int, dbenv->db_mode);
	__db_prflags(dbenv, NULL, dbenv->open_flags, ofn, NULL, "\tOpen flags");
	STAT_ISSET("Lockfhp", dbenv->lockfhp);
	STAT_ISSET("Rec tab", dbenv->recover_dtab);
	STAT_ULONG("Rec tab slots", dbenv->recover_dtab_size);
	STAT_ISSET("RPC client", dbenv->cl_handle);
	STAT_LONG("RPC client ID", dbenv->cl_id);
	STAT_LONG("DB ref count", dbenv->db_ref);
	STAT_LONG("Shared mem key", dbenv->shm_key);
	STAT_ULONG("test-and-set spin configuration", dbenv->tas_spins);
	__db_print_mutex(
	    dbenv, NULL, dbenv->dblist_mutexp, "DB handle mutex", flags);

	STAT_ISSET("api1 internal", dbenv->api1_internal);
	STAT_ISSET("api2 internal", dbenv->api2_internal);
	STAT_ISSET("password", dbenv->passwd);
	STAT_ISSET("crypto handle", dbenv->crypto_handle);
	__db_print_mutex(dbenv, NULL, dbenv->mt_mutexp, "MT mutex", flags);

	__db_prflags(dbenv, NULL, dbenv->flags, fn, NULL, "\tFlags");

	return (0);
}

/*
 * __db_print_fh --
 *	Print out a file handle.
 *
 * PUBLIC: void __db_print_fh __P((DB_ENV *, DB_FH *, u_int32_t));
 */
void
__db_print_fh(dbenv, fh, flags)
	DB_ENV *dbenv;
	DB_FH *fh;
	u_int32_t flags;