env_stat.c

这是国外的resip协议栈

{
	static const FN fn[] = {
		{ DB_FH_NOSYNC,	"DB_FH_NOSYNC" },
		{ DB_FH_OPENED,	"DB_FH_OPENED" },
		{ DB_FH_UNLINK,	"DB_FH_UNLINK" },
		{ 0,		NULL }
	};

	__db_print_mutex(dbenv, NULL, fh->mutexp, "file-handle.mutex", flags);

	STAT_LONG("file-handle.reference count", fh->ref);
	STAT_LONG("file-handle.file descriptor", fh->fd);
	STAT_STRING("file-handle.file name", fh->name);

	STAT_ULONG("file-handle.page number", fh->pgno);
	STAT_ULONG("file-handle.page size", fh->pgsize);
	STAT_ULONG("file-handle.page offset", fh->offset);

	__db_prflags(dbenv, NULL, fh->flags, fn, NULL, "\tfile-handle.flags");
}

/*
 * __db_print_fileid --
 *	Print out a file ID.
 *
 * PUBLIC: void __db_print_fileid __P((DB_ENV *, u_int8_t *, const char *));
 */
void
__db_print_fileid(dbenv, id, suffix)
	DB_ENV *dbenv;
	u_int8_t *id;
	const char *suffix;
{
	DB_MSGBUF mb;
	int i;

	DB_MSGBUF_INIT(&mb);
	for (i = 0; i < DB_FILE_ID_LEN; ++i, ++id) {
		__db_msgadd(dbenv, &mb, "%x", (u_int)*id);
		if (i < DB_FILE_ID_LEN - 1)
			__db_msgadd(dbenv, &mb, " ");
	}
	if (suffix != NULL)
		__db_msgadd(dbenv, &mb, "%s", suffix);
	DB_MSGBUF_FLUSH(dbenv, &mb);
}

/*
 * __db_print_mutex --
 *	Print out mutex statistics.
 *
 * PUBLIC: void __db_print_mutex
 * PUBLIC:    __P((DB_ENV *, DB_MSGBUF *, DB_MUTEX *, const char *, u_int32_t));
 */
void
__db_print_mutex(dbenv, mbp, mutex, suffix, flags)
	DB_ENV *dbenv;
	DB_MSGBUF *mbp;
	DB_MUTEX *mutex;
	const char *suffix;
	u_int32_t flags;
{
	DB_MSGBUF mb;
	u_long value;
	int standalone;

	/* If we don't have a mutex, point that out and return. */
	if (mutex == NULL) {
		STAT_ISSET(suffix, mutex);
		return;
	}

	if (mbp == NULL) {
		DB_MSGBUF_INIT(&mb);
		mbp = &mb;
		standalone = 1;
	} else
		standalone = 0;

	/*
	 * !!!
	 * We may not hold the mutex lock -- that's OK, we're only reading
	 * the statistics.
	 */
	if ((value = mutex->mutex_set_wait) < 10000000)
		__db_msgadd(dbenv, mbp, "%lu", value);
	else
		__db_msgadd(dbenv, mbp, "%luM", value / 1000000);

	/*
	 * If standalone, append the mutex percent and the locker information
	 * after the suffix line.  Otherwise, append it after the counter.
	 *
	 * The setting of "suffix" tracks "standalone" -- if standalone, expect
	 * a suffix and prefix it with a <tab>, otherwise, it's optional.  This
	 * isn't a design, it's just the semantics we happen to need right now.
	 */
	if (standalone) {
		if (suffix == NULL)			/* Defense. */
			suffix = "";

		__db_msgadd(dbenv, &mb, "\t%s (%d%%", suffix,
		    DB_PCT(mutex->mutex_set_wait,
		    mutex->mutex_set_wait + mutex->mutex_set_nowait));
#ifdef DIAGNOSTIC
#ifdef HAVE_MUTEX_THREADS
		if (mutex->locked != 0)
			__db_msgadd(dbenv, &mb, "/%lu", (u_long)mutex->locked);
#else
		if (mutex->pid != 0)
			__db_msgadd(dbenv, &mb, "/%lu", (u_long)mutex->pid);
#endif
#endif
		__db_msgadd(dbenv, &mb, ")");

		DB_MSGBUF_FLUSH(dbenv, mbp);
	} else {
		__db_msgadd(dbenv, mbp, "/%d%%", DB_PCT(mutex->mutex_set_wait,
		    mutex->mutex_set_wait + mutex->mutex_set_nowait));
#ifdef DIAGNOSTIC
#ifdef HAVE_MUTEX_THREADS
		if (mutex->locked != 0)
			__db_msgadd(dbenv, &mb, "/%lu", (u_long)mutex->locked);
#else
		if (mutex->pid != 0)
			__db_msgadd(dbenv, &mb, "/%lu", (u_long)mutex->pid);
#endif
#endif
		if (suffix != NULL)
			__db_msgadd(dbenv, mbp, "%s", suffix);
	}

	if (LF_ISSET(DB_STAT_CLEAR))
		MUTEX_CLEAR(mutex);
}

/*
 * __db_dl --
 *	Display a big value.
 *
 * PUBLIC: void __db_dl __P((DB_ENV *, const char *, u_long));
 */
void
__db_dl(dbenv, msg, value)
	DB_ENV *dbenv;
	const char *msg;
	u_long value;
{
	/*
	 * Two formats: if less than 10 million, display as the number, if
	 * greater than 10 million display as ###M.
	 */
	if (value < 10000000)
		__db_msg(dbenv, "%lu\t%s", value, msg);
	else
		__db_msg(dbenv, "%luM\t%s (%lu)", value / 1000000, msg, value);
}

/*
 * __db_dl_pct --
 *	Display a big value, and related percentage.
 *
 * PUBLIC: void __db_dl_pct
 * PUBLIC:          __P((DB_ENV *, const char *, u_long, int, const char *));
 */
void
__db_dl_pct(dbenv, msg, value, pct, tag)
	DB_ENV *dbenv;
	const char *msg, *tag;
	u_long value;
	int pct;
{
	DB_MSGBUF mb;

	DB_MSGBUF_INIT(&mb);

	/*
	 * Two formats: if less than 10 million, display as the number, if
	 * greater than 10 million display as ###M.
	 */
	if (value < 10000000)
		__db_msgadd(dbenv, &mb, "%lu\t%s", value, msg);
	else
		__db_msgadd(dbenv, &mb, "%luM\t%s", value / 1000000, msg);
	if (tag == NULL)
		__db_msgadd(dbenv, &mb, " (%d%%)", pct);
	else
		__db_msgadd(dbenv, &mb, " (%d%% %s)", pct, tag);

	DB_MSGBUF_FLUSH(dbenv, &mb);
}

/*
 * __db_dlbytes --
 *	Display a big number of bytes.
 *
 * PUBLIC: void __db_dlbytes
 * PUBLIC:     __P((DB_ENV *, const char *, u_long, u_long, u_long));
 */
void
__db_dlbytes(dbenv, msg, gbytes, mbytes, bytes)
	DB_ENV *dbenv;
	const char *msg;
	u_long gbytes, mbytes, bytes;
{
	DB_MSGBUF mb;
	const char *sep;

	DB_MSGBUF_INIT(&mb);

	/* Normalize the values. */
	while (bytes >= MEGABYTE) {
		++mbytes;
		bytes -= MEGABYTE;
	}
	while (mbytes >= GIGABYTE / MEGABYTE) {
		++gbytes;
		mbytes -= GIGABYTE / MEGABYTE;
	}

	if (gbytes == 0 && mbytes == 0 && bytes == 0)
		__db_msgadd(dbenv, &mb, "0");
	else {
		sep = "";
		if (gbytes > 0) {
			__db_msgadd(dbenv, &mb, "%luGB", gbytes);
			sep = " ";
		}
		if (mbytes > 0) {
			__db_msgadd(dbenv, &mb, "%s%luMB", sep, mbytes);
			sep = " ";
		}
		if (bytes >= 1024) {
			__db_msgadd(dbenv, &mb, "%s%luKB", sep, bytes / 1024);
			bytes %= 1024;
			sep = " ";
		}
		if (bytes > 0)
			__db_msgadd(dbenv, &mb, "%s%luB", sep, bytes);
	}

	__db_msgadd(dbenv, &mb, "\t%s", msg);

	DB_MSGBUF_FLUSH(dbenv, &mb);
}

/*
 * __db_print_reginfo --
 *	Print out underlying shared region information.
 *
 * PUBLIC: void __db_print_reginfo __P((DB_ENV *, REGINFO *, const char *));
 */
void
__db_print_reginfo(dbenv, infop, s)
	DB_ENV *dbenv;
	REGINFO *infop;
	const char *s;
{
	static const FN fn[] = {
		{ REGION_CREATE,	"REGION_CREATE" },
		{ REGION_CREATE_OK,	"REGION_CREATE_OK" },
		{ REGION_JOIN_OK,	"REGION_JOIN_OK" },
		{ 0,			NULL }
	};

	__db_msg(dbenv, "%s", DB_GLOBAL(db_line));
	__db_msg(dbenv, "%s REGINFO information:",  s);
	STAT_STRING("Region type", __reg_type(infop->type));
	STAT_ULONG("Region ID", infop->id);
	STAT_STRING("Region name", infop->name);
	STAT_HEX("Original region address", infop->addr_orig);
	STAT_HEX("Region address", infop->addr);
	STAT_HEX("Region primary address", infop->primary);
	STAT_ULONG("Region maximum allocation", infop->max_alloc);
	STAT_ULONG("Region allocated", infop->max_alloc);

	__db_prflags(dbenv, NULL, infop->flags, fn, NULL, "\tRegion flags");
}

/*
 * __reg_type --
 *	Return the region type string.
 */
static const char *
__reg_type(t)
	reg_type_t t;
{
	switch (t) {
	case REGION_TYPE_ENV:
		return ("Environment");
	case REGION_TYPE_LOCK:
		return ("Lock");
	case REGION_TYPE_LOG:
		return ("Log");
	case REGION_TYPE_MPOOL:
		return ("Mpool");
	case REGION_TYPE_MUTEX:
		return ("Mutex");
	case REGION_TYPE_TXN:
		return ("Transaction");
	case INVALID_REGION_TYPE:
		return ("Invalid");
	}
	return ("Unknown");
}

#else /* !HAVE_STATISTICS */

/*
 * __db_stat_not_built --
 *	Common error routine when library not built with statistics.
 *
 * PUBLIC: int __db_stat_not_built __P((DB_ENV *));
 */
int
__db_stat_not_built(dbenv)
	DB_ENV *dbenv;
{
	__db_err(dbenv, "Library build did not include statistics support");
	return (DB_OPNOTSUP);
}

int
__dbenv_stat_print_pp(dbenv, flags)
	DB_ENV *dbenv;
	u_int32_t flags;
{
	COMPQUIET(flags, 0);

	return (__db_stat_not_built(dbenv));
}
#endif