/*
 * 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 2006 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include <sys/pset.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/sysinfo.h>

#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <ctype.h>
#include <unistd.h>
#include <memory.h>
#include <string.h>
#include <strings.h>
#include <fcntl.h>
#include <errno.h>
#include <kstat.h>
#include <poll.h>

#include "statcommon.h"

#define	SNAP(s, i, l, n)	((s) ? agg_proc_snap(s, i, l, n) : 0)

#define	REPRINT		20

char cmdname[] = "mpstat";

static int hz;
static int display_pset = -1;
static int show_set = 0;
static int suppress_state;

static void print_header(int, int);
static void show_cpu_usage(struct snapshot *, struct snapshot *, int);
static void usage(void);

int
main(int argc, char **argv)
{
	int c;
	int display_agg = 0;
	int iter = 1;
	int interval = 0;
	int poll_interval = 0;
	char *endptr;
	int infinite_cycles = 0;
	kstat_ctl_t *kc;
	struct snapshot *old = NULL;
	struct snapshot *new = NULL;
	enum snapshot_types types = SNAP_CPUS;

	while ((c = getopt(argc, argv, "apP:q")) != (int)EOF)
		switch (c) {
			case 'a':
				/*
				 * Display aggregate data for processor sets.
				 */
				display_agg = 1;
				break;
			case 'p':
				/*
				 * Display all processor sets.
				 */
				if (display_pset != -1)
					usage();
				show_set = 1;
				break;
			case 'P':
				/*
				 * Display specific processor set.
				 */
				if (show_set == 1)
					usage();
				display_pset = (int)strtol
				    (optarg, &endptr, 10);
				if (*endptr != NULL)
					usage();
				/*
				 * Not valid to specify a negative processor
				 * set value.
				 */
				if (display_pset < 0)
					usage();
				break;
			case 'q':
				suppress_state = 1;
				break;
			case '?':
				usage();
				break;
		}

	hz = sysconf(_SC_CLK_TCK);

	if (argc > optind) {
		interval = (int)strtol(argv[optind], &endptr, 10);
		if (*endptr != NULL)
			usage();
		poll_interval = 1000 * interval;
		if (argc > optind + 1) {
			iter = (unsigned int)strtoul
			    (argv[optind + 1], &endptr, 10);
			if (*endptr != NULL || iter < 0)
				usage();
			if (iter == 0)
				return (0);
		} else {
			infinite_cycles = 1;
		}
	}

	if (display_agg || show_set || display_pset != -1)
		types |= SNAP_PSETS;

	kc = open_kstat();

	while (infinite_cycles || iter > 0) {
		free_snapshot(old);
		old = new;
		new = acquire_snapshot(kc, types, NULL);

		if (!suppress_state)
			snapshot_report_changes(old, new);

		/* if config changed, show stats from boot */
		if (snapshot_has_changed(old, new)) {
			free_snapshot(old);
			old = NULL;
		}

		show_cpu_usage(old, new, display_agg);

		if (!infinite_cycles && --iter < 1)
			break;

		(void) poll(NULL, 0, poll_interval);
	}
	(void) kstat_close(kc);

	return (0);
}

/*
 * Print an mpstat output header.
 */
static void
print_header(int display_agg, int show_set)
{
	if (display_agg == 1)
		(void) printf("SET minf mjf xcal  intr ithr  csw icsw migr "
		    "smtx  srw syscl  usr sys  wt idl sze");
	else {
		(void) printf("CPU minf mjf xcal  intr ithr  csw icsw migr "
		    "smtx  srw syscl  usr sys  wt idl");
		if (show_set == 1)
			(void) printf(" set");
	}
	(void) printf("\n");
}

static void
print_cpu(struct cpu_snapshot *c1, struct cpu_snapshot *c2)
{
	uint64_t ticks = 0;
	double etime, percent;
	kstat_t *old_vm = NULL;
	kstat_t *old_sys = NULL;

	if (display_pset != -1 && display_pset != c2->cs_pset_id)
		return;

	/*
	 * the first mpstat output will have c1 = NULL, to give
	 * results since boot
	 */
	if (c1) {
		old_vm = &c1->cs_vm;
		old_sys = &c1->cs_sys;

		/* check there are stats to report */
		if (!CPU_ACTIVE(c1))
			return;
	}

	/* check there are stats to report */
	if (!CPU_ACTIVE(c2))
		return;

	ticks = cpu_ticks_delta(old_sys, &c2->cs_sys);

	etime = (double)ticks / hz;
	if (etime == 0.0) /* Prevent divide by zero errors */
		etime = 1.0;
	percent = 100.0 / etime / hz;

	(void) printf("%3d %4.0f %3.0f %4.0f %5.0f %4.0f "
	"%4.0f %4.0f %4.0f %4.0f %4.0f %5.0f  %3.0f %3.0f "
	"%3.0f %3.0f",
	c2->cs_id,
	(kstat_delta(old_vm, &c2->cs_vm, "hat_fault") +
		kstat_delta(old_vm, &c2->cs_vm, "as_fault")) / etime,
	kstat_delta(old_vm, &c2->cs_vm, "maj_fault") / etime,
	kstat_delta(old_sys, &c2->cs_sys, "xcalls") / etime,
	kstat_delta(old_sys, &c2->cs_sys, "intr") / etime,
	kstat_delta(old_sys, &c2->cs_sys, "intrthread") / etime,
	kstat_delta(old_sys, &c2->cs_sys, "pswitch") / etime,
	kstat_delta(old_sys, &c2->cs_sys, "inv_swtch") / etime,
	kstat_delta(old_sys, &c2->cs_sys, "cpumigrate") / etime,
	kstat_delta(old_sys, &c2->cs_sys, "mutex_adenters") / etime,
	(kstat_delta(old_sys, &c2->cs_sys, "rw_rdfails") +
	kstat_delta(old_sys, &c2->cs_sys, "rw_wrfails")) / etime,
	kstat_delta(old_sys, &c2->cs_sys, "syscall") / etime,
	kstat_delta(old_sys, &c2->cs_sys, "cpu_ticks_user") * percent,
	kstat_delta(old_sys, &c2->cs_sys, "cpu_ticks_kernel") * percent,
	kstat_delta(old_sys, &c2->cs_sys, "cpu_ticks_wait") * percent,
	kstat_delta(old_sys, &c2->cs_sys, "cpu_ticks_idle") * percent);

	if (show_set)
		(void) printf(" %3d", c2->cs_pset_id);
	(void) printf("\n");
}

/*ARGSUSED*/
static void
compare_cpu(void *v1, void *v2, void *data)
{
	struct cpu_snapshot *c1 = (struct cpu_snapshot *)v1;
	struct cpu_snapshot *c2 = (struct cpu_snapshot *)v2;

	if (c2 == NULL)
		return;

	print_cpu(c1, c2);
}

static int
pset_has_stats(struct pset_snapshot *p)
{
	int count = 0;
	size_t i;
	for (i = 0; i < p->ps_nr_cpus; i++) {
		if (CPU_ACTIVE(p->ps_cpus[i]))
			count++;
	}
	return (count);
}

static void
agg_stat(kstat_t *k1, kstat_t *k2, char *name)
{
	kstat_named_t *ksn = kstat_data_lookup(k1, name);
	kstat_named_t *ksn2 = kstat_data_lookup(k2, name);
	ksn->value.ui64 += ksn2->value.ui64;
}

static kstat_t *
agg_vm(struct pset_snapshot *p, kstat_t *ks)
{
	size_t i;

	if (p->ps_nr_cpus == NULL)
		return (NULL);

	if (kstat_copy(&p->ps_cpus[0]->cs_vm, ks))
		return (NULL);

	for (i = 1; i < p->ps_nr_cpus; i++) {
		agg_stat(ks, &p->ps_cpus[i]->cs_vm, "hat_fault");
		agg_stat(ks, &p->ps_cpus[i]->cs_vm, "as_fault");
		agg_stat(ks, &p->ps_cpus[i]->cs_vm, "maj_fault");
	}

	return (ks);
}

static kstat_t *
agg_sys(struct pset_snapshot *p, kstat_t *ks)
{
	size_t i;

	if (p->ps_nr_cpus == NULL)
		return (NULL);

	if (kstat_copy(&p->ps_cpus[0]->cs_sys, ks))
		return (NULL);

	for (i = 1; i < p->ps_nr_cpus; i++) {
		agg_stat(ks, &p->ps_cpus[i]->cs_sys, "xcalls");
		agg_stat(ks, &p->ps_cpus[i]->cs_sys, "intr");
		agg_stat(ks, &p->ps_cpus[i]->cs_sys, "intrthread");
		agg_stat(ks, &p->ps_cpus[i]->cs_sys, "pswitch");
		agg_stat(ks, &p->ps_cpus[i]->cs_sys, "inv_swtch");
		agg_stat(ks, &p->ps_cpus[i]->cs_sys, "cpumigrate");
		agg_stat(ks, &p->ps_cpus[i]->cs_sys, "mutex_adenters");
		agg_stat(ks, &p->ps_cpus[i]->cs_sys, "rw_rdfails");
		agg_stat(ks, &p->ps_cpus[i]->cs_sys, "rw_wrfails");
		agg_stat(ks, &p->ps_cpus[i]->cs_sys, "syscall");
		agg_stat(ks, &p->ps_cpus[i]->cs_sys, "cpu_ticks_user");
		agg_stat(ks, &p->ps_cpus[i]->cs_sys, "cpu_ticks_kernel");
		agg_stat(ks, &p->ps_cpus[i]->cs_sys, "cpu_ticks_wait");
		agg_stat(ks, &p->ps_cpus[i]->cs_sys, "cpu_ticks_idle");
	}

	return (ks);
}

static uint64_t
get_nr_ticks(struct pset_snapshot *p1, struct pset_snapshot *p2)
{
	kstat_t *old = NULL;
	kstat_t *new = NULL;
	size_t i = 0;

	for (i = 0; p1 && i < p1->ps_nr_cpus; i++) {
		if (p1->ps_cpus[i]->cs_sys.ks_data) {
			old = &p1->ps_cpus[i]->cs_sys;
			break;
		}
	}

	for (i = 0; p2 && i < p2->ps_nr_cpus; i++) {
		if (p2->ps_cpus[i]->cs_sys.ks_data) {
			new = &p2->ps_cpus[i]->cs_sys;
			break;
		}
	}

	if (old == NULL && new == NULL)
		return (0);

	if (new == NULL) {
		new = old;
		old = NULL;
	}

	return (cpu_ticks_delta(old, new));
}

static void
print_pset(struct pset_snapshot *p1, struct pset_snapshot *p2)
{
	uint64_t ticks = 0;
	double etime, percent;
	kstat_t old_vm;
	kstat_t old_sys;
	kstat_t new_vm;
	kstat_t new_sys;

	if (display_pset != -1 && display_pset != p2->ps_id)
		return;

	if ((p1 && !pset_has_stats(p1)) || !pset_has_stats(p2))
		return;

	old_vm.ks_data = old_sys.ks_data = NULL;
	new_vm.ks_data = new_sys.ks_data = NULL;

	/*
	 * FIXME: these aggs will count "new" or disappeared cpus
	 * in a set, leaving an apparent huge change.
	 */

	/*
	 * the first mpstat output will have p1 = NULL, to give
	 * results since boot
	 */
	if (p1) {
		if (!agg_vm(p1, &old_vm) || !agg_sys(p1, &old_sys))
			goto out;
	}

	if (!agg_vm(p2, &new_vm) || !agg_sys(p2, &new_sys))
		goto out;

	ticks = get_nr_ticks(p1, p2);

	etime = (double)ticks / hz;
	if (etime == 0.0) /* Prevent divide by zero errors */
		etime = 1.0;
	percent = 100.0 / p2->ps_nr_cpus / etime / hz;

	(void) printf("%3d %4.0f %3.0f %4.0f %5.0f %4.0f "
	"%4.0f %4.0f %4.0f %4.0f %4.0f %5.0f  %3.0f %3.0f "
	"%3.0f %3.0f %3d\n",
	p2->ps_id,
	(kstat_delta(&old_vm, &new_vm, "hat_fault") +
		kstat_delta(&old_vm, &new_vm, "as_fault")) / etime,
	kstat_delta(&old_vm, &new_vm, "maj_fault") / etime,
	kstat_delta(&old_sys, &new_sys, "xcalls") / etime,
	kstat_delta(&old_sys, &new_sys, "intr") / etime,
	kstat_delta(&old_sys, &new_sys, "intrthread") / etime,
	kstat_delta(&old_sys, &new_sys, "pswitch") / etime,
	kstat_delta(&old_sys, &new_sys, "inv_swtch") / etime,
	kstat_delta(&old_sys, &new_sys, "cpumigrate") / etime,
	kstat_delta(&old_sys, &new_sys, "mutex_adenters") / etime,
	(kstat_delta(&old_sys, &new_sys, "rw_rdfails") +
	kstat_delta(&old_sys, &new_sys, "rw_wrfails")) / etime,
	kstat_delta(&old_sys, &new_sys, "syscall") / etime,
	kstat_delta(&old_sys, &new_sys, "cpu_ticks_user") * percent,
	kstat_delta(&old_sys, &new_sys, "cpu_ticks_kernel") * percent,
	kstat_delta(&old_sys, &new_sys, "cpu_ticks_wait") * percent,
	kstat_delta(&old_sys, &new_sys, "cpu_ticks_idle") * percent,
	p2->ps_nr_cpus);

out:
	free(old_vm.ks_data);
	free(old_sys.ks_data);
	free(new_vm.ks_data);
	free(new_sys.ks_data);
}

/*ARGSUSED*/
static void
compare_pset(void *v1, void *v2, void *data)
{
	struct pset_snapshot *p1 = (struct pset_snapshot *)v1;
	struct pset_snapshot *p2 = (struct pset_snapshot *)v2;

	if (p2 == NULL)
		return;

	print_pset(p1, p2);
}


/*
 * Report statistics for a sample interval.
 */
static void
show_cpu_usage(struct snapshot *old, struct snapshot *new, int display_agg)
{
	static int lines_until_reprint = 0;
	enum snapshot_types type = SNAP_CPUS;
	snapshot_cb cb = compare_cpu;

	if (lines_until_reprint == 0 || nr_active_cpus(new) > 1) {
		print_header(display_agg, show_set);
		lines_until_reprint = REPRINT;
	}

	lines_until_reprint--;

	if (display_agg) {
		type = SNAP_PSETS;
		cb = compare_pset;
	}

	/* print stats since boot the first time round */
	(void) snapshot_walk(type, old, new, cb, NULL);
	(void) fflush(stdout);
}

/*
 * Usage message on error.
 */
static void
usage(void)
{
	(void) fprintf(stderr,
	    "Usage: mpstat [-aq] [-p | -P processor_set] [interval [count]]\n");
	exit(1);
}