stat/mpstat/mpstat.c

	mpstat.c revision 4944376cd5de3dcd3b4feeaad9cbedbc024d1474
/*
 * 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 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#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 <signal.h>
#include <locale.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";
int caught_cont = 0;

extern uint_t timestamp_fmt;

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;
    char *endptr;
    int infinite_cycles = 0;
    kstat_ctl_t *kc;
    struct snapshot *old = NULL;
    struct snapshot *new = NULL;
    enum snapshot_types types = SNAP_CPUS;
    hrtime_t start_n;
    hrtime_t period_n;

    (void) setlocale(LC_ALL, "");
#if !defined(TEXT_DOMAIN)       /* Should be defined by cc -D */
#define TEXT_DOMAIN "SYS_TEST"      /* Use this only if it weren't */
#endif
    (void) textdomain(TEXT_DOMAIN);

    while ((c = getopt(argc, argv, "apP:qT:")) != (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 'T':
                if (optarg) {
                    if (*optarg == 'u')
                        timestamp_fmt = UDATE;
                    else if (*optarg == 'd')
                        timestamp_fmt = DDATE;
                    else
                        usage();
                } else {
                    usage();
                }
                break;
            case '?':
                usage();
                break;
        }

    hz = sysconf(_SC_CLK_TCK);

    if (argc > optind) {
        interval = (int)strtol(argv[optind], &endptr, 10);
        if (*endptr != NULL)
            usage();
        period_n = (hrtime_t)interval * NANOSEC;
        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();

    /* Set up handler for SIGCONT */
    if (signal(SIGCONT, cont_handler) == SIG_ERR)
        fail(1, "signal failed");

    start_n = gethrtime();

    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;

        /* Have a kip */
        sleep_until(&start_n, period_n, infinite_cycles, &caught_cont);
    }
    (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 (timestamp_fmt != NODATE)
        print_timestamp();

    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] [-T d|u] "
        "[interval [count]]\n");
    exit(1);
}