trapstat/sun4/trapstat.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright (c) 2001, 2010, Oracle and/or its affiliates. All rights reserved.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>
#include <signal.h>
#include <strings.h>
#include <limits.h>
#include <sys/mman.h>
#include <sys/pset.h>
#include <sys/varargs.h>
#include <sys/trapstat.h>
#include <sys/wait.h>
#include <stddef.h>
#include <termio.h>
#include "_trapstat.h"

#define	TSTAT_DEVICE	"/dev/trapstat"
#define	TSTAT_COMMAND	"trapstat"
#define	TSTAT_DELTA(data, old, member) g_absolute ? (data)->member : \
	(uint64_t)(0.5 + (g_interval / (double)((data)->tdata_snapts - \
	(old)->tdata_snapts)) * (double)((data)->member - (old)->member))

#define	TSTAT_PRINT_MISSDATA(diff, time) \
	(void) printf(" %9lld %4.1f", (diff), (time));

#define	TSTAT_PAGESIZE_MODIFIERS	" kmgtp"
#define	TSTAT_PAGESIZE_STRLEN		10
#define	TSTAT_MAX_RATE			5000
#define	TSTAT_COLUMN_OFFS	26
#define	TSTAT_COLUMNS_PER_CPU	9

static tstat_data_t *g_data[2];
static tstat_data_t *g_ndata, *g_odata;
static processorid_t g_max_cpus;
static int8_t *g_selected;
static timer_t g_tid;
static int g_interval = NANOSEC;
static int g_peffect = 1;
static int g_absolute = 0;
static sigset_t g_oset;

static psetid_t g_pset = PS_NONE;
static processorid_t *g_pset_cpus;
static uint_t g_pset_ncpus;

static int g_cpus_per_line = (80 - TSTAT_COLUMN_OFFS) / TSTAT_COLUMNS_PER_CPU;
static int g_winch;

static int g_pgsizes;
static size_t *g_pgsize;
static char **g_pgnames;
static size_t g_datasize;

static int g_gen;
static int g_fd;
static uint8_t g_active[TSTAT_NENT];

static hrtime_t g_start;

static int g_exec_errno;
static int g_child_exited;
static int g_child_status;

static void (*g_process)(void *, uint64_t, double);
static void *g_arg;

typedef struct tstat_sum {
	uint64_t	tsum_diff;
	double		tsum_time;
} tstat_sum_t;

/*
 * Define a dummy g_traps reader to establish a symbol capabilities lead.
 * This routine should never be called, as the sun4u and sun4v variants
 * will be used as appropriate.
 */
/* ARGSUSED0 */
tstat_ent_t *
get_trap_ent(int ndx)
{
	return (NULL);
}

static void
usage(void)
{
	(void) fprintf(stderr,
	    "\nusage:  trapstat [ -t | -T | -e entrylist ]\n"
	    "   [ -C psrset | -c cpulist ]\n"
	    "   [ -P ] [ -a ] [ -r rate ] [[ interval [ count ] ] | "
	    "command [ args ] ]\n\n"
	    "Trap selection options:\n\n"
	    " -t             TLB statistics\n"
	    " -T             TLB statistics, with pagesize information\n"
	    " -e entrylist   Enable statistics only for entries specified "
	    "by entrylist\n\n"
	    "CPU selection options:\n\n"
	    " -c cpulist     Enable statistics only for specified CPU list\n"
	    " -C psrset      Enable statistics only for specified processor "
	    "set\n\n"
	    "Other options:\n\n"
	    " -a             Display trap values as accumulating values "
	    "instead of rates\n"
	    " -l             List trap table entries and exit\n"
	    " -P             Display output in parsable format\n"
	    " -r hz          Set sampling rate to be hz samples "
	    "per second\n\n");

	exit(EXIT_FAILURE);
}

static void
fatal(char *fmt, ...)
{
	va_list ap;
	int error = errno;

	va_start(ap, fmt);

	(void) fprintf(stderr, TSTAT_COMMAND ": ");
	(void) vfprintf(stderr, fmt, ap);

	if (fmt[strlen(fmt) - 1] != '\n')
		(void) fprintf(stderr, ": %s\n", strerror(error));

	exit(EXIT_FAILURE);
}

static void
set_width(void)
{
	struct winsize win;

	if (!isatty(fileno(stdout)))
		return;

	if (ioctl(fileno(stdout), TIOCGWINSZ, &win) == -1)
		return;

	if (win.ws_col == 0) {
		/*
		 * If TIOCGWINSZ returned 0 for the columns, just return --
		 * thereby using the default value of g_cpus_per_line.  (This
		 * happens, e.g., when running over a tip line.)
		 */
		return;
	}

	g_cpus_per_line = (win.ws_col - TSTAT_COLUMN_OFFS) /
	    TSTAT_COLUMNS_PER_CPU;

	if (g_cpus_per_line < 1)
		g_cpus_per_line = 1;
}

static void
intr(int signo)
{
	int error = errno;

	switch (signo) {
	case SIGWINCH:
		g_winch = 1;
		set_width();
		break;

	case SIGCHLD:
		g_child_exited = 1;

		while (wait(&g_child_status) == -1 && errno == EINTR)
			continue;
		break;

	default:
		break;
	}

	errno = error;
}

static void
setup(void)
{
	struct sigaction act;
	struct sigevent ev;
	sigset_t set;
	int i;

	for (i = 0; i < TSTAT_NENT; i++) {
		tstat_ent_t	*gtp;

		if ((gtp = get_trap_ent(i)) == NULL)
			continue;

		if (gtp->tent_type == TSTAT_ENT_RESERVED)
			gtp->tent_name = "reserved";

		if (gtp->tent_type == TSTAT_ENT_UNUSED)
			gtp->tent_name = "unused";
	}

	g_max_cpus = (processorid_t)sysconf(_SC_CPUID_MAX) + 1;

	if ((g_selected = malloc(sizeof (int8_t) * g_max_cpus)) == NULL)
		fatal("could not allocate g_selected");

	bzero(g_selected, sizeof (int8_t) * g_max_cpus);

	g_pset_cpus = malloc(sizeof (processorid_t) * g_max_cpus);
	if (g_pset_cpus == NULL)
		fatal("could not allocate g_pset_cpus");

	bzero(g_pset_cpus, sizeof (processorid_t) * g_max_cpus);

	if ((g_pgsizes = getpagesizes(NULL, 0)) == -1)
		fatal("getpagesizes()");

	if ((g_pgsize = malloc(sizeof (size_t) * g_pgsizes)) == NULL)
		fatal("could not allocate g_pgsize array");

	if (getpagesizes(g_pgsize, g_pgsizes) == -1)
		fatal("getpagesizes(%d)", g_pgsizes);

	if ((g_pgnames = malloc(sizeof (char *) * g_pgsizes)) == NULL)
		fatal("could not allocate g_pgnames");

	for (i = 0; i < g_pgsizes; i++) {
		size_t j, mul;
		size_t sz = g_pgsize[i];

		if ((g_pgnames[i] = malloc(TSTAT_PAGESIZE_STRLEN)) == NULL)
			fatal("could not allocate g_pgnames[%d]", i);

		for (j = 0, mul = 10; (1 << mul) <= sz; j++, mul += 10)
			continue;

		(void) snprintf(g_pgnames[i], TSTAT_PAGESIZE_STRLEN,
		    "%d%c", sz >> (mul - 10), " kmgtpe"[j]);
	}

	g_datasize =
	    sizeof (tstat_data_t) + (g_pgsizes - 1) * sizeof (tstat_pgszdata_t);

	if ((g_data[0] = malloc(g_datasize * g_max_cpus)) == NULL)
		fatal("could not allocate data buffer 0");

	if ((g_data[1] = malloc(g_datasize * g_max_cpus)) == NULL)
		fatal("could not allocate data buffer 1");

	(void) sigemptyset(&act.sa_mask);
	act.sa_flags = 0;
	act.sa_handler = intr;
	(void) sigaction(SIGUSR1, &act, NULL);
	(void) sigaction(SIGCHLD, &act, NULL);

	(void) sigaddset(&act.sa_mask, SIGCHLD);
	(void) sigaddset(&act.sa_mask, SIGUSR1);
	(void) sigaction(SIGWINCH, &act, NULL);
	set_width();

	(void) sigemptyset(&set);
	(void) sigaddset(&set, SIGCHLD);
	(void) sigaddset(&set, SIGUSR1);
	(void) sigaddset(&set, SIGWINCH);
	(void) sigprocmask(SIG_BLOCK, &set, &g_oset);

	ev.sigev_notify = SIGEV_SIGNAL;
	ev.sigev_signo = SIGUSR1;

	if (timer_create(CLOCK_HIGHRES, &ev, &g_tid) == -1)
		fatal("cannot create CLOCK_HIGHRES timer");
}

static void
set_interval(hrtime_t nsec)
{
	struct itimerspec ts;

	/*
	 * If the interval is less than one second, we'll report the
	 * numbers in terms of rate-per-interval.  If the interval is
	 * greater than one second, we'll report numbers in terms of
	 * rate-per-second.
	 */
	g_interval = nsec < NANOSEC ? nsec : NANOSEC;

	ts.it_value.tv_sec = nsec / NANOSEC;
	ts.it_value.tv_nsec = nsec % NANOSEC;
	ts.it_interval.tv_sec = nsec / NANOSEC;
	ts.it_interval.tv_nsec = nsec % NANOSEC;

	if (timer_settime(g_tid, TIMER_RELTIME, &ts, NULL) == -1)
		fatal("cannot set time on CLOCK_HIGHRES timer");
}

static void
print_entries(FILE *stream, int parsable)
{
	int entno;

	if (!parsable) {
		(void) fprintf(stream, "  %3s %3s | %-20s | %s\n", "hex",
		    "dec", "entry name", "description");

		(void) fprintf(stream, "----------+----------------------"
		    "+-----------------------\n");
	}

	for (entno = 0; entno < TSTAT_NENT; entno++) {
		tstat_ent_t	*gtp;

		if ((gtp = get_trap_ent(entno)) == NULL)
			continue;

		if (gtp->tent_type != TSTAT_ENT_USED)
			continue;

		(void) fprintf(stream, "0x%03x %3d %s%-20s %s%s\n",
		    entno, entno,
		    parsable ? "" : "| ", gtp->tent_name,
		    parsable ? "" : "| ", gtp->tent_descr);
	}
}

static void
select_entry(char *entry)
{
	ulong_t entno;
	char *end;

	/*
	 * The entry may be specified as a number (e.g., "0x68", "104") or
	 * as a name ("dtlb-miss").
	 */
	entno = strtoul(entry, &end, 0);

	if (*end == '\0') {
		if (entno >= TSTAT_NENT)
			goto bad_entry;
	} else {
		for (entno = 0; entno < TSTAT_NENT; entno++) {
			tstat_ent_t	*gtp;

			if ((gtp = get_trap_ent(entno)) == NULL)
				continue;

			if (gtp->tent_type != TSTAT_ENT_USED)
				continue;

			if (strcmp(entry, gtp->tent_name) == 0)
				break;
		}

		if (entno == TSTAT_NENT)
			goto bad_entry;
	}

	if (ioctl(g_fd, TSTATIOC_ENTRY, entno) == -1)
		fatal("TSTATIOC_ENTRY failed for entry 0x%x", entno);

	g_active[entno] = 1;
	return;

bad_entry:
	(void) fprintf(stderr, TSTAT_COMMAND ": invalid entry '%s'", entry);
	(void) fprintf(stderr, "; valid entries:\n\n");
	print_entries(stderr, 0);
	exit(EXIT_FAILURE);
}

static void
select_cpu(processorid_t cpu)
{
	if (g_pset != PS_NONE)
		fatal("cannot specify both a processor set and a processor\n");

	if (cpu < 0 || cpu >= g_max_cpus)
		fatal("cpu %d out of range\n", cpu);

	if (p_online(cpu, P_STATUS) == -1) {
		if (errno != EINVAL)
			fatal("could not get status for cpu %d", cpu);
		fatal("cpu %d not present\n", cpu);
	}

	g_selected[cpu] = 1;
}

static void
select_cpus(processorid_t low, processorid_t high)
{
	if (g_pset != PS_NONE)
		fatal("cannot specify both a processor set and processors\n");

	if (low < 0 || low >= g_max_cpus)
		fatal("invalid cpu '%d'\n", low);

	if (high < 0 || high >= g_max_cpus)
		fatal("invalid cpu '%d'\n", high);

	if (low >= high)
		fatal("invalid range '%d' to '%d'\n", low, high);

	do {
		if (p_online(low, P_STATUS) != -1)
			g_selected[low] = 1;
	} while (++low <= high);
}

static void
select_pset(psetid_t pset)
{
	processorid_t i;

	if (pset < 0)
		fatal("processor set %d is out of range\n", pset);

	/*
	 * Only one processor set can be specified.
	 */
	if (g_pset != PS_NONE)
		fatal("at most one processor set may be specified\n");

	/*
	 * One cannot select processors _and_ a processor set.
	 */
	for (i = 0; i < g_max_cpus; i++)
		if (g_selected[i])
			break;

	if (i != g_max_cpus)
		fatal("cannot specify both a processor and a processor set\n");

	g_pset = pset;
	g_pset_ncpus = g_max_cpus;

	if (pset_info(g_pset, NULL, &g_pset_ncpus, g_pset_cpus) == -1)
		fatal("invalid processor set: %d\n", g_pset);

	if (g_pset_ncpus == 0)
		fatal("processor set %d empty\n", g_pset);

	if (ioctl(g_fd, TSTATIOC_NOCPU) == -1)
		fatal("TSTATIOC_NOCPU failed");

	for (i = 0; i < g_pset_ncpus; i++)
		g_selected[g_pset_cpus[i]] = 1;
}

static void
check_pset(void)
{
	uint_t ncpus = g_max_cpus;
	processorid_t i;

	if (g_pset == PS_NONE)
		return;

	if (pset_info(g_pset, NULL, &ncpus, g_pset_cpus) == -1) {
		if (errno == EINVAL)
			fatal("processor set %d destroyed\n", g_pset);

		fatal("couldn't get info for processor set %d", g_pset);
	}

	if (ncpus == 0)
		fatal("processor set %d empty\n", g_pset);

	if (ncpus == g_pset_ncpus) {
		for (i = 0; i < g_pset_ncpus; i++) {
			if (!g_selected[g_pset_cpus[i]])
				break;
		}

		/*
		 * If the number of CPUs hasn't changed, and every CPU
		 * in the processor set is also selected, we know that the
		 * processor set itself hasn't changed.
		 */
		if (i == g_pset_ncpus)
			return;
	}

	/*
	 * If we're here, we have a new processor set.  First, we need
	 * to zero out the selection array.
	 */
	bzero(g_selected, sizeof (int8_t) * g_max_cpus);

	g_pset_ncpus = ncpus;

	if (ioctl(g_fd, TSTATIOC_STOP) == -1)
		fatal("TSTATIOC_STOP failed");

	if (ioctl(g_fd, TSTATIOC_NOCPU) == -1)
		fatal("TSATIOC_NOCPU failed");

	for (i = 0; i < g_pset_ncpus; i++) {
		g_selected[g_pset_cpus[i]] = 1;
		if (ioctl(g_fd, TSTATIOC_CPU, g_pset_cpus[i]) == -1)
			fatal("TSTATIOC_CPU failed for cpu %d", i);
	}

	/*
	 * Now that we have selected the CPUs, we're going to reenable
	 * trapstat, and reread the data for the current generation.
	 */
	if (ioctl(g_fd, TSTATIOC_GO) == -1)
		fatal("TSTATIOC_GO failed");

	if (ioctl(g_fd, TSTATIOC_READ, g_data[g_gen]) == -1)
		fatal("TSTATIOC_READ failed");
}

static void
missdata(tstat_missdata_t *miss, tstat_missdata_t *omiss)
{
	hrtime_t ts = g_ndata->tdata_snapts - g_odata->tdata_snapts;
	hrtime_t tick = g_ndata->tdata_snaptick - g_odata->tdata_snaptick;
	uint64_t raw = miss->tmiss_count - omiss->tmiss_count;
	uint64_t diff = g_absolute ? miss->tmiss_count :
	    (uint64_t)(0.5 + g_interval /
	    (double)ts * (double)(miss->tmiss_count - omiss->tmiss_count));
	hrtime_t peffect = raw * g_ndata->tdata_peffect * g_peffect, time;
	double p;

	/*
	 * Now we need to account for the trapstat probe effect.  Take
	 * the amount of time spent in the handler, and add the
	 * amount of time known to be due to the trapstat probe effect.
	 */
	time = miss->tmiss_time - omiss->tmiss_time + peffect;

	if (time >= tick) {
		/*
		 * This really shouldn't happen unless our calculation of
		 * the probe effect was vastly incorrect.  In any case,
		 * print 99.9 for the time instead of printing negative
		 * values...
		 */
		time = tick / 1000 * 999;
	}

	p = (double)time / (double)tick * (double)100.0;

	(*g_process)(g_arg, diff, p);
}

static void
tlbdata(tstat_tlbdata_t *tlb, tstat_tlbdata_t *otlb)
{
	missdata(&tlb->ttlb_tlb, &otlb->ttlb_tlb);
	missdata(&tlb->ttlb_tsb, &otlb->ttlb_tsb);
}

static void
print_missdata(double *ttl, uint64_t diff, double p)
{
	TSTAT_PRINT_MISSDATA(diff, p);

	if (ttl != NULL)
		*ttl += p;
}

static void
print_modepgsz(char *prefix, tstat_modedata_t *data, tstat_modedata_t *odata)
{
	int ps;
	size_t incr = sizeof (tstat_pgszdata_t);

	for (ps = 0; ps < g_pgsizes; ps++) {
		double ttl = 0.0;

		g_process = (void(*)(void *, uint64_t, double))print_missdata;
		g_arg = &ttl;

		(void) printf("%s %4s|", prefix, g_pgnames[ps]);
		tlbdata(&data->tmode_itlb, &odata->tmode_itlb);
		(void) printf(" |");
		tlbdata(&data->tmode_dtlb, &odata->tmode_dtlb);

		(void) printf(" |%4.1f\n", ttl);

		data = (tstat_modedata_t *)((uintptr_t)data + incr);
		odata = (tstat_modedata_t *)((uintptr_t)odata + incr);
	}
}

static void
parsable_modepgsz(char *prefix, tstat_modedata_t *data, tstat_modedata_t *odata)
{
	int ps;
	size_t incr = sizeof (tstat_pgszdata_t);

	g_process = (void(*)(void *, uint64_t, double))print_missdata;
	g_arg = NULL;

	for (ps = 0; ps < g_pgsizes; ps++) {
		(void) printf("%s %7d", prefix, g_pgsize[ps]);
		tlbdata(&data->tmode_itlb, &odata->tmode_itlb);
		tlbdata(&data->tmode_dtlb, &odata->tmode_dtlb);
		(void) printf("\n");

		data = (tstat_modedata_t *)((uintptr_t)data + incr);
		odata = (tstat_modedata_t *)((uintptr_t)odata + incr);
	}
}

static void
sum_missdata(void *sump, uint64_t diff, double p)
{
	tstat_sum_t *sum = *((tstat_sum_t **)sump);

	sum->tsum_diff += diff;
	sum->tsum_time += p;

	(*(tstat_sum_t **)sump)++;
}

static void
sum_modedata(tstat_modedata_t *data, tstat_modedata_t *odata, tstat_sum_t *sum)
{
	int ps, incr = sizeof (tstat_pgszdata_t);
	tstat_sum_t *sump;

	for (ps = 0; ps < g_pgsizes; ps++) {
		sump = sum;

		g_process = sum_missdata;
		g_arg = &sump;

		tlbdata(&data->tmode_itlb, &odata->tmode_itlb);
		tlbdata(&data->tmode_dtlb, &odata->tmode_dtlb);

		data = (tstat_modedata_t *)((uintptr_t)data + incr);
		odata = (tstat_modedata_t *)((uintptr_t)odata + incr);
	}
}

static void
print_sum(tstat_sum_t *sum, int divisor)
{
	int i;
	double ttl = 0.0;

	for (i = 0; i < 4; i++) {
		if (i == 2)
			(void) printf(" |");

		sum[i].tsum_time /= divisor;

		TSTAT_PRINT_MISSDATA(sum[i].tsum_diff, sum[i].tsum_time);
		ttl += sum[i].tsum_time;
	}

	(void) printf(" |%4.1f\n", ttl);
}

static void
print_tlbpgsz(tstat_data_t *data, tstat_data_t *odata)
{
	int i, cpu, ncpus = 0;
	char pre[12];
	tstat_sum_t sum[4];

	(void) printf("cpu m size| %9s %4s %9s %4s | %9s %4s %9s %4s |%4s\n"
	    "----------+-------------------------------+-----------------------"
	    "--------+----\n", "itlb-miss", "%tim", "itsb-miss", "%tim",
	    "dtlb-miss", "%tim", "dtsb-miss", "%tim", "%tim");

	bzero(sum, sizeof (sum));

	for (i = 0; i < g_max_cpus; i++) {
		tstat_pgszdata_t *pgsz = data->tdata_pgsz;
		tstat_pgszdata_t *opgsz = odata->tdata_pgsz;

		if ((cpu = data->tdata_cpuid) == -1)
			break;

		if (i != 0)
			(void) printf("----------+-----------------------------"
			    "--+-------------------------------+----\n");

		g_ndata = data;
		g_odata = odata;

		(void) sprintf(pre, "%3d u", cpu);
		print_modepgsz(pre, &pgsz->tpgsz_user, &opgsz->tpgsz_user);
		sum_modedata(&pgsz->tpgsz_user, &opgsz->tpgsz_user, sum);

		(void) printf("- - - - - + - - - - - - - - - - - - - -"
		    " - + - - - - - - - - - - - - - - - + - -\n");

		(void) sprintf(pre, "%3d k", cpu);
		print_modepgsz(pre, &pgsz->tpgsz_kernel, &opgsz->tpgsz_kernel);
		sum_modedata(&pgsz->tpgsz_kernel, &opgsz->tpgsz_kernel, sum);

		data = (tstat_data_t *)((uintptr_t)data + g_datasize);
		odata = (tstat_data_t *)((uintptr_t)odata + g_datasize);
		ncpus++;
	}

	(void) printf("==========+===============================+========="
	    "======================+====\n");
	(void) printf("      ttl |");
	print_sum(sum, ncpus);
	(void) printf("\n");
}

static void
parsable_tlbpgsz(tstat_data_t *data, tstat_data_t *odata)
{
	int i, cpu;
	char pre[30];

	for (i = 0; i < g_max_cpus; i++) {
		tstat_pgszdata_t *pgsz = data->tdata_pgsz;
		tstat_pgszdata_t *opgsz = odata->tdata_pgsz;

		if ((cpu = data->tdata_cpuid) == -1)
			break;

		g_ndata = data;
		g_odata = odata;

		(void) sprintf(pre, "%lld %3d u",
		    data->tdata_snapts - g_start, cpu);
		parsable_modepgsz(pre, &pgsz->tpgsz_user, &opgsz->tpgsz_user);

		pre[strlen(pre) - 1] = 'k';
		parsable_modepgsz(pre, &pgsz->tpgsz_kernel,
		    &opgsz->tpgsz_kernel);

		data = (tstat_data_t *)((uintptr_t)data + g_datasize);
		odata = (tstat_data_t *)((uintptr_t)odata + g_datasize);
	}
}

static void
print_modedata(tstat_modedata_t *data, tstat_modedata_t *odata, int parsable)
{
	int ps, i;
	size_t incr = sizeof (tstat_pgszdata_t);
	tstat_sum_t sum[4], *sump = sum;
	double ttl = 0.0;

	bzero(sum, sizeof (sum));
	g_process = sum_missdata;
	g_arg = &sump;

	for (ps = 0; ps < g_pgsizes; ps++) {
		tlbdata(&data->tmode_itlb, &odata->tmode_itlb);
		tlbdata(&data->tmode_dtlb, &odata->tmode_dtlb);

		data = (tstat_modedata_t *)((uintptr_t)data + incr);
		odata = (tstat_modedata_t *)((uintptr_t)odata + incr);
		sump = sum;
	}

	for (i = 0; i < 4; i++) {
		if (i == 2 && !parsable)
			(void) printf(" |");

		TSTAT_PRINT_MISSDATA(sum[i].tsum_diff, sum[i].tsum_time);
		ttl += sum[i].tsum_time;
	}

	if (parsable) {
		(void) printf("\n");
		return;
	}

	(void) printf(" |%4.1f\n", ttl);
}

static void
print_tlb(tstat_data_t *data, tstat_data_t *odata)
{
	int i, cpu, ncpus = 0;
	tstat_sum_t sum[4];

	(void) printf("cpu m| %9s %4s %9s %4s | %9s %4s %9s %4s |%4s\n"
	    "-----+-------------------------------+-----------------------"
	    "--------+----\n", "itlb-miss", "%tim", "itsb-miss", "%tim",
	    "dtlb-miss", "%tim", "dtsb-miss", "%tim", "%tim");

	bzero(sum, sizeof (sum));

	for (i = 0; i < g_max_cpus; i++) {
		tstat_pgszdata_t *pgsz = data->tdata_pgsz;
		tstat_pgszdata_t *opgsz = odata->tdata_pgsz;

		if ((cpu = data->tdata_cpuid) == -1)
			break;

		if (i != 0)
			(void) printf("-----+-------------------------------+-"
			    "------------------------------+----\n");

		g_ndata = data;
		g_odata = odata;

		(void) printf("%3d u|", cpu);
		print_modedata(&pgsz->tpgsz_user, &opgsz->tpgsz_user, 0);
		sum_modedata(&pgsz->tpgsz_user, &opgsz->tpgsz_user, sum);

		(void) printf("%3d k|", cpu);
		print_modedata(&pgsz->tpgsz_kernel, &opgsz->tpgsz_kernel, 0);
		sum_modedata(&pgsz->tpgsz_kernel, &opgsz->tpgsz_kernel, sum);

		data = (tstat_data_t *)((uintptr_t)data + g_datasize);
		odata = (tstat_data_t *)((uintptr_t)odata + g_datasize);
		ncpus++;
	}

	(void) printf("=====+===============================+========="
	    "======================+====\n");

	(void) printf(" ttl |");
	print_sum(sum, ncpus);
	(void) printf("\n");
}

static void
parsable_tlb(tstat_data_t *data, tstat_data_t *odata)
{
	int i, cpu;

	for (i = 0; i < g_max_cpus; i++) {
		tstat_pgszdata_t *pgsz = data->tdata_pgsz;
		tstat_pgszdata_t *opgsz = odata->tdata_pgsz;

		if ((cpu = data->tdata_cpuid) == -1)
			break;

		g_ndata = data;
		g_odata = odata;

		(void) printf("%lld %3d u ", data->tdata_snapts - g_start, cpu);
		print_modedata(&pgsz->tpgsz_user, &opgsz->tpgsz_user, 1);
		(void) printf("%lld %3d k ", data->tdata_snapts - g_start, cpu);
		print_modedata(&pgsz->tpgsz_kernel, &opgsz->tpgsz_kernel, 1);

		data = (tstat_data_t *)((uintptr_t)data + g_datasize);
		odata = (tstat_data_t *)((uintptr_t)odata + g_datasize);
	}
}

static void
print_stats(tstat_data_t *data, tstat_data_t *odata)
{
	int i, j, k, done;
	processorid_t id;
	tstat_data_t *base = data;

	/*
	 * First, blast through all of the data updating our array
	 * of active traps.  We keep an array of active traps to prevent
	 * printing lines for traps that are never seen -- while still printing
	 * lines for traps that have been seen only once on some CPU.
	 */
	for (i = 0; i < g_max_cpus; i++) {
		if (data[i].tdata_cpuid == -1)
			break;

		for (j = 0; j < TSTAT_NENT; j++) {
			if (!data[i].tdata_traps[j] || g_active[j])
				continue;

			g_active[j] = 1;
		}
	}

	data = base;

	for (done = 0; !done; data += g_cpus_per_line) {
		for (i = 0; i < g_cpus_per_line; i++) {
			if (&data[i] - base >= g_max_cpus)
				break;

			if ((id = data[i].tdata_cpuid) == -1)
				break;

			if (i == 0)
				(void) printf("vct name                |");

			(void) printf("   %scpu%d", id >= 100 ? "" :
			    id >= 10 ? " " : "  ", id);
		}

		if (i == 0)
			break;

		if (i != g_cpus_per_line)
			done = 1;

		(void) printf("\n------------------------+");

		for (j = 0; j < i; j++)
			(void) printf("---------");
		(void) printf("\n");

		for (j = 0; j < TSTAT_NENT; j++) {
			tstat_ent_t	*gtp;

			if ((!g_active[j]) || ((gtp = get_trap_ent(j)) == NULL))
				continue;

			(void) printf("%3x %-20s|", j, gtp->tent_name);
			for (k = 0; k < i; k++) {
				(void) printf(" %8lld", TSTAT_DELTA(&data[k],
				    &odata[data - base + k], tdata_traps[j]));
			}
			(void) printf("\n");
		}
		(void) printf("\n");
	}
}

static void
parsable_stats(tstat_data_t *data, tstat_data_t *odata)
{
	tstat_data_t *base;
	int i;

	for (base = data; data - base < g_max_cpus; data++, odata++) {
		if (data->tdata_cpuid == -1)
			break;

		for (i = 0; i < TSTAT_NENT; i++) {
			tstat_ent_t	*gtp;

			if ((!data->tdata_traps[i] && !g_active[i]) ||
			    ((gtp = get_trap_ent(i)) == NULL))
				continue;

			(void) printf("%lld %d %x %s ",
			    data->tdata_snapts - g_start, data->tdata_cpuid, i,
			    gtp->tent_name);

			(void) printf("%lld\n", TSTAT_DELTA(data, odata,
			    tdata_traps[i]));
		}
	}
}

static void
check_data(tstat_data_t *data, tstat_data_t *odata)
{
	tstat_data_t *ndata;
	int i;

	if (data->tdata_cpuid == -1) {
		/*
		 * The last CPU we were watching must have been DR'd out
		 * of the system.  Print a vaguely useful message and exit.
		 */
		fatal("all initially selected CPUs have been unconfigured\n");
	}

	/*
	 * If a CPU is DR'd out of the system, we'll stop receiving data
	 * for it.  CPUs are never added, however (that is, if a CPU is
	 * DR'd into the system, we won't automatically start receiving
	 * data for it).  We check for this by making sure that all of
	 * the CPUs present in the old data are present in the new data.
	 * If we find one missing in the new data, we correct the old data
	 * by removing the old CPU.  This assures that delta are printed
	 * correctly.
	 */
	for (i = 0; i < g_max_cpus; i++) {
		if (odata->tdata_cpuid == -1)
			return;

		if (data->tdata_cpuid != odata->tdata_cpuid)
			break;

		data = (tstat_data_t *)((uintptr_t)data + g_datasize);
		odata = (tstat_data_t *)((uintptr_t)odata + g_datasize);
	}

	if (i == g_max_cpus)
		return;

	/*
	 * If we're here, we know that the odata is a CPU which has been
	 * DR'd out.  We'll now smoosh it out of the old data.
	 */
	for (odata->tdata_cpuid = -1; i < g_max_cpus - 1; i++) {
		ndata = (tstat_data_t *)((uintptr_t)odata + g_datasize);
		bcopy(ndata, odata, g_datasize);
		ndata->tdata_cpuid = -1;
	}

	/*
	 * There may be other CPUs DR'd out; tail-call recurse.
	 */
	check_data(data, odata);
}

int
main(int argc, char **argv)
{
	processorid_t id;
	char c, *end;
	ulong_t indefinite;
	long count = 0, rate = 0;
	int list = 0, parsable = 0;
	void (*print)(tstat_data_t *, tstat_data_t *);
	sigset_t set;

	struct {
		char opt;
		void (*print)(tstat_data_t *, tstat_data_t *);
		void (*parsable)(tstat_data_t *, tstat_data_t *);
		int repeat;
	} tab[] = {
		{ '\0',	print_stats,	parsable_stats,		0 },
		{ 'e',	print_stats,	parsable_stats,		1 },
		{ 't',	print_tlb,	parsable_tlb,		0 },
		{ 'T',	print_tlbpgsz,	parsable_tlbpgsz,	0 },
		{ -1,	NULL,		NULL,			0 }
	}, *tabent = NULL, *iter;

	uintptr_t offs = (uintptr_t)&tab->print - (uintptr_t)tab;

	/*
	 * If argv[0] is non-NULL, set argv[0] to keep any getopt(3C) output
	 * consistent with other error output.
	 */
	if (argv[0] != NULL)
		argv[0] = TSTAT_COMMAND;

	if ((g_fd = open(TSTAT_DEVICE, O_RDWR)) == -1)
		fatal("couldn't open " TSTAT_DEVICE);

	setup();

	while ((c = getopt(argc, argv, "alnNtTc:C:r:e:P")) != EOF) {
		/*
		 * First, check to see if this option changes our printing
		 * function.
		 */
		for (iter = tab; iter->opt >= 0; iter++) {
			if (c != iter->opt)
				continue;

			if (tabent != NULL) {
				if (tabent == iter) {
					if (tabent->repeat) {
						/*
						 * This option is allowed to
						 * have repeats; break out.
						 */
						break;
					}

					fatal("expected -%c at most once\n", c);
				}

				fatal("only one of -%c, -%c expected\n",
				    tabent->opt, c);
			}

			tabent = iter;
			break;
		}

		switch (c) {
		case 'a':
			g_absolute = 1;
			break;

		case 'e': {
			char *s = strtok(optarg, ",");

			while (s != NULL) {
				select_entry(s);
				s = strtok(NULL, ",");
			}

			break;
		}

		case 'l':
			list = 1;
			break;

		case 'n':
			/*
			 * This undocumented option prevents trapstat from
			 * actually switching the %tba to point to the
			 * interposing trap table.  It's very useful when
			 * debugging trapstat bugs:  one can specify "-n"
			 * and then examine the would-be interposing trap
			 * table without running the risk of RED stating.
			 */
			if (ioctl(g_fd, TSTATIOC_NOGO) == -1)
				fatal("TSTATIOC_NOGO");
			break;

		case 'N':
			/*
			 * This undocumented option forces trapstat to ignore
			 * its determined probe effect.  This may be useful
			 * if it is believed that the probe effect has been
			 * grossly overestimated.
			 */
			g_peffect = 0;
			break;

		case 't':
		case 'T':
			/*
			 * When running with TLB statistics, we want to
			 * minimize probe effect by running with all other
			 * entries explicitly disabled.
			 */
			if (ioctl(g_fd, TSTATIOC_NOENTRY) == -1)
				fatal("TSTATIOC_NOENTRY");

			if (ioctl(g_fd, TSTATIOC_TLBDATA) == -1)
				fatal("TSTATIOC_TLBDATA");
			break;

		case 'c': {
			/*
			 * We allow CPUs to be specified as an optionally
			 * comma separated list of either CPU IDs or ranges
			 * of CPU IDs.
			 */
			char *s = strtok(optarg, ",");

			while (s != NULL) {
				id = strtoul(s, &end, 0);

				if (id == ULONG_MAX && errno == ERANGE) {
					*end = '\0';
					fatal("invalid cpu '%s'\n", s);
				}

				if (*(s = end) != '\0') {
					processorid_t p;

					if (*s != '-')
						fatal("invalid cpu '%s'\n", s);
					p = strtoul(++s, &end, 0);

					if (*end != '\0' ||
					    (p == ULONG_MAX && errno == ERANGE))
						fatal("invalid cpu '%s'\n", s);

					select_cpus(id, p);
				} else {
					select_cpu(id);
				}

				s = strtok(NULL, ",");
			}

			break;
		}

		case 'C': {
			psetid_t pset = strtoul(optarg, &end, 0);

			if (*end != '\0' ||
			    (pset == ULONG_MAX && errno == ERANGE))
				fatal("invalid processor set '%s'\n", optarg);

			select_pset(pset);
			break;
		}

		case 'r': {
			rate = strtol(optarg, &end, 0);

			if (*end != '\0' ||
			    (rate == LONG_MAX && errno == ERANGE))
				fatal("invalid rate '%s'\n", optarg);

			if (rate <= 0)
				fatal("rate must be greater than zero\n");

			if (rate > TSTAT_MAX_RATE)
				fatal("rate may not exceed %d\n",
				    TSTAT_MAX_RATE);

			set_interval(NANOSEC / rate);
			break;
		}

		case 'P':
			offs = (uintptr_t)&tab->parsable - (uintptr_t)tab;
			parsable = 1;
			break;

		default:
			usage();
		}
	}

	if (list) {
		print_entries(stdout, parsable);
		exit(EXIT_SUCCESS);
	}

	if (optind != argc) {

		int interval = strtol(argv[optind], &end, 0);

		if (*end != '\0') {
			/*
			 * That wasn't a valid number.  It must be that we're
			 * to execute this command.
			 */
			switch (vfork()) {
			case 0:
				(void) close(g_fd);
				(void) sigprocmask(SIG_SETMASK, &g_oset, NULL);
				(void) execvp(argv[optind], &argv[optind]);

				/*
				 * No luck.  Set errno.
				 */
				g_exec_errno = errno;
				_exit(EXIT_FAILURE);
				/*NOTREACHED*/
			case -1:
				fatal("cannot fork");
				/*NOTREACHED*/
			default:
				break;
			}
		} else {
			if (interval <= 0)
				fatal("interval must be greater than zero.\n");

			if (interval == LONG_MAX && errno == ERANGE)
				fatal("invalid interval '%s'\n", argv[optind]);

			set_interval(NANOSEC * (hrtime_t)interval);

			if (++optind != argc) {
				char *s = argv[optind];

				count = strtol(s, &end, 0);

				if (*end != '\0' || count <= 0 ||
				    (count == LONG_MAX && errno == ERANGE))
					fatal("invalid count '%s'\n", s);
			}
		}
	} else {
		if (!rate)
			set_interval(NANOSEC);
	}

	if (tabent == NULL)
		tabent = tab;

	print = *(void(**)(tstat_data_t *, tstat_data_t *))
	    ((uintptr_t)tabent + offs);

	for (id = 0; id < g_max_cpus; id++) {
		if (!g_selected[id])
			continue;

		if (ioctl(g_fd, TSTATIOC_CPU, id) == -1)
			fatal("TSTATIOC_CPU failed for cpu %d", id);
	}

	g_start = gethrtime();

	if (ioctl(g_fd, TSTATIOC_GO) == -1)
		fatal("TSTATIOC_GO failed");

	if (ioctl(g_fd, TSTATIOC_READ, g_data[g_gen ^ 1]) == -1)
		fatal("initial TSTATIOC_READ failed");

	(void) sigemptyset(&set);

	for (indefinite = (count == 0); indefinite || count; count--) {

		(void) sigsuspend(&set);

		if (g_winch) {
			g_winch = 0;
			continue;
		}

		if (g_child_exited && g_exec_errno != 0) {
			errno = g_exec_errno;
			fatal("could not execute %s", argv[optind]);
		}

		if (ioctl(g_fd, TSTATIOC_READ, g_data[g_gen]) == -1)
			fatal("TSTATIOC_READ failed");

		/*
		 * Before we blithely print the data, we need to
		 * make sure that we haven't lost a CPU.
		 */
		check_data(g_data[g_gen], g_data[g_gen ^ 1]);
		(*print)(g_data[g_gen], g_data[g_gen ^ 1]);
		(void) fflush(stdout);

		if (g_child_exited) {
			if (WIFEXITED(g_child_status)) {
				if (WEXITSTATUS(g_child_status) == 0)
					break;

				(void) fprintf(stderr, TSTAT_COMMAND ": "
				    "warning: %s exited with code %d\n",
				    argv[optind], WEXITSTATUS(g_child_status));
			} else {
				(void) fprintf(stderr, TSTAT_COMMAND ": "
				    "warning: %s died on signal %d\n",
				    argv[optind], WTERMSIG(g_child_status));
			}
			break;
		}

		check_pset();

		g_gen ^= 1;
	}

	return (0);
}