db_stat.c

这是linux下运行的mysql软件包,可用于linux 下安装 php + mysql + apach 的网络配置

	dl("The number of page allocations.\n",
	    (u_long)gsp->st_alloc);
	dl("The number of hash buckets examined during allocations\n",
	    (u_long)gsp->st_alloc_buckets);
	dl("The max number of hash buckets examined for an allocation\n",
	    (u_long)gsp->st_alloc_max_buckets);
	dl("The number of pages examined during allocations\n",
	    (u_long)gsp->st_alloc_pages);
	dl("The max number of pages examined for an allocation\n",
	    (u_long)gsp->st_alloc_max_pages);

	for (; fsp != NULL && *fsp != NULL; ++fsp) {
		printf("%s\n", DB_LINE);
		printf("Pool File: %s\n", (*fsp)->file_name);
		dl("Page size.\n", (u_long)(*fsp)->st_pagesize);
		dl("Requested pages mapped into the process' address space.\n",
		    (u_long)(*fsp)->st_map);
		dl("Requested pages found in the cache",
		    (u_long)(*fsp)->st_cache_hit);
		if ((*fsp)->st_cache_hit + (*fsp)->st_cache_miss != 0)
			printf(" (%.0f%%)", ((double)(*fsp)->st_cache_hit /
			    ((*fsp)->st_cache_hit + (*fsp)->st_cache_miss)) *
			    100);
		printf(".\n");
		dl("Requested pages not found in the cache.\n",
		    (u_long)(*fsp)->st_cache_miss);
		dl("Pages created in the cache.\n",
		    (u_long)(*fsp)->st_page_create);
		dl("Pages read into the cache.\n",
		    (u_long)(*fsp)->st_page_in);
		dl("Pages written from the cache to the backing file.\n",
		    (u_long)(*fsp)->st_page_out);
	}

	free(gsp);

	return (0);
}

/*
 * rep_stats --
 *	Display replication statistics.
 */
int
rep_stats(dbenv, flags)
	DB_ENV *dbenv;
	u_int32_t flags;
{
	DB_REP_STAT *sp;
	int is_client, ret;
	const char *p;

	if ((ret = dbenv->rep_stat(dbenv, &sp, flags)) != 0) {
		dbenv->err(dbenv, ret, NULL);
		return (1);
	}

	is_client = 0;
	switch (sp->st_status) {
	case DB_REP_MASTER:
		printf("Environment configured as a replication master.\n");
		break;
	case DB_REP_CLIENT:
		printf("Environment configured as a replication client.\n");
		is_client = 1;
		break;
	case DB_REP_LOGSONLY:
		printf("Environment configured as a logs-only replica.\n");
		is_client = 1;
		break;
	default:
		printf("Environment not configured for replication.\n");
		break;
	}

	printf("%lu/%lu\t%s\n",
	    (u_long)sp->st_next_lsn.file, (u_long)sp->st_next_lsn.offset,
	    is_client ? "Next LSN expected." : "Next LSN to be used.");
	p = sp->st_waiting_lsn.file == 0 ?
	    "Not waiting for any missed log records." :
	    "LSN of first missed log record being waited for.";
	printf("%lu/%lu\t%s\n",
	    (u_long)sp->st_waiting_lsn.file, (u_long)sp->st_waiting_lsn.offset,
	    p);

	dl("Number of duplicate master conditions detected.\n",
	    (u_long)sp->st_dupmasters);
	if (sp->st_env_id != DB_EID_INVALID)
		dl("Current environment ID.\n", (u_long)sp->st_env_id);
	else
		printf("No current environment ID.\n");
	dl("Current environment priority.\n", (u_long)sp->st_env_priority);
	dl("Current generation number.\n", (u_long)sp->st_gen);
	dl("Number of duplicate log records received.\n",
	    (u_long)sp->st_log_duplicated);
	dl("Number of log records currently queued.\n",
	    (u_long)sp->st_log_queued);
	dl("Maximum number of log records ever queued at once.\n",
	    (u_long)sp->st_log_queued_max);
	dl("Total number of log records queued.\n",
	    (u_long)sp->st_log_queued_total);
	dl("Number of log records received and appended to the log.\n",
	    (u_long)sp->st_log_records);
	dl("Number of log records missed and requested.\n",
	    (u_long)sp->st_log_requested);
	if (sp->st_master != DB_EID_INVALID)
		dl("Current master ID.\n", (u_long)sp->st_master);
	else
		printf("No current master ID.\n");
	dl("Number of times the master has changed.\n",
	    (u_long)sp->st_master_changes);
	dl("Number of messages received with a bad generation number.\n",
	    (u_long)sp->st_msgs_badgen);
	dl("Number of messages received and processed.\n",
	    (u_long)sp->st_msgs_processed);
	dl("Number of messages ignored due to pending recovery.\n",
	    (u_long)sp->st_msgs_recover);
	dl("Number of failed message sends.\n",
	    (u_long)sp->st_msgs_send_failures);
	dl("Number of messages sent.\n", (u_long)sp->st_msgs_sent);
	dl("Number of new site messages received.\n", (u_long)sp->st_newsites);
	dl("Transmission limited.\n", (u_long)sp->st_nthrottles);
	dl("Number of outdated conditions detected.\n",
	    (u_long)sp->st_outdated);
	dl("Number of transactions applied.\n", (u_long)sp->st_txns_applied);

	dl("Number of elections held.\n", (u_long)sp->st_elections);
	dl("Number of elections won.\n", (u_long)sp->st_elections_won);

	if (sp->st_election_status == 0)
		printf("No election in progress.\n");
	else {
		dl("Current election phase.\n", (u_long)sp->st_election_status);
		dl("Election winner.\n",
		    (u_long)sp->st_election_cur_winner);
		dl("Election generation number.\n",
		    (u_long)sp->st_election_gen);
		printf("%lu/%lu\tMaximum LSN of election winner.\n",
		    (u_long)sp->st_election_lsn.file,
		    (u_long)sp->st_election_lsn.offset);
		dl("Number of sites expected to participate in elections.\n",
		    (u_long)sp->st_election_nsites);
		dl("Election priority.\n", (u_long)sp->st_election_priority);
		dl("Election tiebreaker value.\n",
		    (u_long)sp->st_election_tiebreaker);
		dl("Votes received this election round.\n",
		    (u_long)sp->st_election_votes);
	}

	free(sp);

	return (0);
}

/*
 * txn_stats --
 *	Display transaction statistics.
 */
int
txn_stats(dbenv, flags)
	DB_ENV *dbenv;
	u_int32_t flags;
{
	DB_TXN_STAT *sp;
	u_int32_t i;
	int ret;
	const char *p;

	if ((ret = dbenv->txn_stat(dbenv, &sp, flags)) != 0) {
		dbenv->err(dbenv, ret, NULL);
		return (1);
	}

	p = sp->st_last_ckp.file == 0 ?
	    "No checkpoint LSN." : "File/offset for last checkpoint LSN.";
	printf("%lu/%lu\t%s\n",
	    (u_long)sp->st_last_ckp.file, (u_long)sp->st_last_ckp.offset, p);
	if (sp->st_time_ckp == 0)
		printf("0\tNo checkpoint timestamp.\n");
	else
		printf("%.24s\tCheckpoint timestamp.\n",
		    ctime(&sp->st_time_ckp));
	printf("%lx\tLast transaction ID allocated.\n",
	    (u_long)sp->st_last_txnid);
	dl("Maximum number of active transactions possible.\n",
	    (u_long)sp->st_maxtxns);
	dl("Active transactions.\n", (u_long)sp->st_nactive);
	dl("Maximum active transactions.\n", (u_long)sp->st_maxnactive);
	dl("Number of transactions begun.\n", (u_long)sp->st_nbegins);
	dl("Number of transactions aborted.\n", (u_long)sp->st_naborts);
	dl("Number of transactions committed.\n", (u_long)sp->st_ncommits);
	dl("Number of transactions restored.\n", (u_long)sp->st_nrestores);

	dl_bytes("Transaction region size",
	    (u_long)0, (u_long)0, (u_long)sp->st_regsize);
	dl("The number of region locks granted after waiting.\n",
	    (u_long)sp->st_region_wait);
	dl("The number of region locks granted without waiting.\n",
	    (u_long)sp->st_region_nowait);

	qsort(sp->st_txnarray,
	    sp->st_nactive, sizeof(sp->st_txnarray[0]), txn_compare);
	for (i = 0; i < sp->st_nactive; ++i) {
		printf("\tid: %lx; begin LSN: file/offset %lu/%lu",
		    (u_long)sp->st_txnarray[i].txnid,
		    (u_long)sp->st_txnarray[i].lsn.file,
		    (u_long)sp->st_txnarray[i].lsn.offset);
		if (sp->st_txnarray[i].parentid == 0)
			printf("\n");
		else
			printf(" parent: %lx\n",
			    (u_long)sp->st_txnarray[i].parentid);
	}

	free(sp);

	return (0);
}

int
txn_compare(a1, b1)
	const void *a1, *b1;
{
	const DB_TXN_ACTIVE *a, *b;

	a = a1;
	b = b1;

	if (a->txnid > b->txnid)
		return (1);
	if (a->txnid < b->txnid)
		return (-1);
	return (0);
}

/*
 * dl --
 *	Display a big value.
 */
void
dl(msg, value)
	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)
		printf("%lu\t%s", value, msg);
	else
		printf("%luM\t%s", value / 1000000, msg);
}

/*
 * dl_bytes --
 *	Display a big number of bytes.
 */
void
dl_bytes(msg, gbytes, mbytes, bytes)
	const char *msg;
	u_long gbytes, mbytes, bytes;
{
	const char *sep;

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

	sep = "";
	if (gbytes > 0) {
		printf("%luGB", gbytes);
		sep = " ";
	}
	if (mbytes > 0) {
		printf("%s%luMB", sep, mbytes);
		sep = " ";
	}
	if (bytes >= 1024) {
		printf("%s%luKB", sep, bytes / 1024);
		bytes %= 1024;
		sep = " ";
	}
	if (bytes > 0)
		printf("%s%luB", sep, bytes);

	printf("\t%s.\n", msg);
}

/*
 * prflags --
 *	Print out flag values.
 */
void
prflags(flags, fnp)
	u_int32_t flags;
	const FN *fnp;
{
	const char *sep;

	sep = "\t";
	printf("Flags:");
	for (; fnp->mask != 0; ++fnp)
		if (fnp->mask & flags) {
			printf("%s%s", sep, fnp->name);
			sep = ", ";
		}
	printf("\n");
}

/*
 * db_init --
 *	Initialize the environment.
 */
int
db_init(dbenv, home, ttype, cache, is_private)
	DB_ENV *dbenv;
	char *home;
	test_t ttype;
	u_int32_t cache;
	int *is_private;
{
	u_int32_t oflags;
	int ret;

	/*
	 * If our environment open fails, and we're trying to look at a
	 * shared region, it's a hard failure.
	 *
	 * We will probably just drop core if the environment we join does
	 * not include a memory pool.  This is probably acceptable; trying
	 * to use an existing environment that does not contain a memory
	 * pool to look at a database can be safely construed as operator
	 * error, I think.
	 */
	*is_private = 0;
	if ((ret =
	    dbenv->open(dbenv, home, DB_JOINENV | DB_USE_ENVIRON, 0)) == 0)
		return (0);
	if (ttype != T_DB && ttype != T_LOG) {
		dbenv->err(dbenv, ret, "DB_ENV->open%s%s",
		    home == NULL ? "" : ": ", home == NULL ? "" : home);
		return (1);
	}

	/*
	 * We're looking at a database or set of log files and no environment
	 * exists.  Create one, but make it private so no files are actually
	 * created.  Declare a reasonably large cache so that we don't fail
	 * when reporting statistics on large databases.
	 *
	 * An environment is required to look at databases because we may be
	 * trying to look at databases in directories other than the current
	 * one.
	 */
	if ((ret = dbenv->set_cachesize(dbenv, 0, cache, 1)) != 0) {
		dbenv->err(dbenv, ret, "set_cachesize");
		return (1);
	}
	*is_private = 1;
	oflags = DB_CREATE | DB_PRIVATE | DB_USE_ENVIRON;
	if (ttype == T_DB)
		oflags |= DB_INIT_MPOOL;
	if (ttype == T_LOG)
		oflags |= DB_INIT_LOG;
	if ((ret = dbenv->open(dbenv, home, oflags, 0)) == 0)
		return (0);

	/* An environment is required. */
	dbenv->err(dbenv, ret, "open");
	return (1);
}

/*
 * argcheck --
 *	Return if argument flags are okay.
 */
int
argcheck(arg, ok_args)
	char *arg;
	const char *ok_args;
{
	for (; *arg != '\0'; ++arg)
		if (strchr(ok_args, *arg) == NULL)
			return (0);
	return (1);
}

int
usage()
{
	fprintf(stderr, "%s\n\t%s\n",
	    "usage: db_stat [-celmNrtVZ] [-C Aclmop]",
	    "[-d file [-f] [-s database]] [-h home] [-M Ahlm] [-P password]");
	return (EXIT_FAILURE);
}

int
version_check(progname)
	const char *progname;
{
	int v_major, v_minor, v_patch;

	/* Make sure we're loaded with the right version of the DB library. */
	(void)db_version(&v_major, &v_minor, &v_patch);
	if (v_major != DB_VERSION_MAJOR ||
	    v_minor != DB_VERSION_MINOR || v_patch != DB_VERSION_PATCH) {
		fprintf(stderr,
	"%s: version %d.%d.%d doesn't match library version %d.%d.%d\n",
		    progname, DB_VERSION_MAJOR, DB_VERSION_MINOR,
		    DB_VERSION_PATCH, v_major, v_minor, v_patch);
		return (EXIT_FAILURE);
	}
	return (0);
}