cmd/ctstat/ctstat.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) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
 */

#include <sys/types.h>
#include <sys/ctfs.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>
#include <libuutil.h>
#include <sys/contract/process.h>
#include <sys/contract/device.h>
#include <limits.h>
#include <libcontract.h>
#include <libcontract_priv.h>
#include <dirent.h>

#include <locale.h>
#include <langinfo.h>

#include "statcommon.h"

static uint_t timestamp_fmt = NODATE;

static int opt_verbose = 0;
static int opt_showall = 0;

/*
 * usage
 *
 * Educate the user.
 */
static void
usage(void)
{
    (void) fprintf(stderr, gettext("Usage: %s [-a] [-i ctidlist] "
        "[-t typelist] [-T d|u] [-v] [interval [count]]\n"), uu_getpname());
    exit(UU_EXIT_USAGE);
}

/*
 * mystrtoul
 *
 * Convert a string into an int in [0, INT_MAX].  Exit if the argument
 * doen't fit this description.
 */
static int
mystrtoul(const char *arg)
{
    unsigned int result;

    if (uu_strtoint(arg, &result, sizeof (result), 10, 0, INT_MAX) == -1) {
        uu_warn(gettext("invalid numerical argument \"%s\"\n"), arg);
        usage();
    }

    return (result);
}

/*
 * int_compar
 *
 * A simple integer comparator.  Also used for id_ts, since they're the
 * same thing.
 */
static int
int_compar(const void *a1, const void *a2)
{
    int id1 = *(int *)a1;
    int id2 = *(int *)a2;

    if (id1 > id2)
        return (1);
    if (id2 > id1)
        return (-1);
    return (0);
}

typedef struct optvect {
    const char  *option;
    uint_t      bit;
} optvect_t;

static optvect_t option_params[] = {
    { "inherit", CT_PR_INHERIT },
    { "noorphan", CT_PR_NOORPHAN },
    { "pgrponly", CT_PR_PGRPONLY },
    { "regent", CT_PR_REGENT },
    { NULL }
};

static optvect_t option_events[] = {
    { "core", CT_PR_EV_CORE },
    { "signal", CT_PR_EV_SIGNAL },
    { "hwerr", CT_PR_EV_HWERR },
    { "empty", CT_PR_EV_EMPTY },
    { "fork", CT_PR_EV_FORK },
    { "exit", CT_PR_EV_EXIT },
    { NULL }
};

/*
 * print_bits
 *
 * Display a set whose membership is identified by a bitfield.
 */
static void
print_bits(uint_t bits, optvect_t *desc)
{
    int i, printed = 0;

    for (i = 0; desc[i].option; i++)
        if (desc[i].bit & bits) {
            if (printed)
                (void) putchar(' ');
            printed = 1;
            (void) fputs(desc[i].option, stdout);
        }
    if (printed)
        (void) putchar('\n');
    else
        (void) puts("none");
}

/*
 * print_ids
 *
 * Display a list of ids, sorted.
 */
static void
print_ids(id_t *ids, uint_t nids)
{
    int i;
    int first = 1;

    qsort(ids, nids, sizeof (int), int_compar);

    for (i = 0; i < nids; i++) {
        /*LINTED*/
        (void) printf(" %d" + first, ids[i]);
        first = 0;
    }
    if (first)
        (void) puts("none");
    else
        (void) putchar('\n');
}

typedef void printfunc_t(ct_stathdl_t);

/*
 * A structure defining a displayed field.  Includes a label to be
 * printed along side the field value, and a function which extracts
 * the data from a status structure, formats it, and displays it on
 * stdout.
 */
typedef struct verbout {
    const char  *label; /* field label */
    printfunc_t *func;  /* field display function */
} verbout_t;

/*
 * verb_cookie
 *
 * Used to display an error encountered when reading a contract status
 * field.
 */
static void
verb_error(int err)
{
    (void) printf("(error: %s)\n", strerror(err));
}

/*
 * verb_cookie
 *
 * Display the contract's cookie.
 */
static void
verb_cookie(ct_stathdl_t hdl)
{
    (void) printf("%#llx\n", ct_status_get_cookie(hdl));
}

/*
 * verb_info
 *
 * Display the parameters in the parameter set.
 */
static void
verb_param(ct_stathdl_t hdl)
{
    uint_t param;
    int err;

    if (err = ct_pr_status_get_param(hdl, &param))
        verb_error(err);
    else
        print_bits(param, option_params);
}

/*
 * verb_info
 *
 * Display the events in the informative event set.
 */
static void
verb_info(ct_stathdl_t hdl)
{
    print_bits(ct_status_get_informative(hdl), option_events);
}

/*
 * verb_crit
 *
 * Display the events in the critical event set.
 */
static void
verb_crit(ct_stathdl_t hdl)
{
    print_bits(ct_status_get_critical(hdl), option_events);
}

/*
 * verb_minor
 *
 * Display the minor device
 */
static void
verb_minor(ct_stathdl_t hdl)
{
    int err;
    char *buf;

    if (err = ct_dev_status_get_minor(hdl, &buf))
        verb_error(err);
    else
        (void) printf("%s\n", buf);
}

/*
 * verb_state
 *
 * Display the state of the device
 */
static void
verb_dev_state(ct_stathdl_t hdl)
{
    int err;
    uint_t state;

    if (err = ct_dev_status_get_dev_state(hdl, &state))
        verb_error(err);
    else
        (void) printf("%s\n", state == CT_DEV_EV_ONLINE ? "online" :
            state == CT_DEV_EV_DEGRADED ? "degraded" : "offline");
}

/*
 * verb_fatal
 *
 * Display the events in the fatal event set.
 */
static void
verb_fatal(ct_stathdl_t hdl)
{
    uint_t event;
    int err;

    if (err = ct_pr_status_get_fatal(hdl, &event))
        verb_error(err);
    else
        print_bits(event, option_events);
}

/*
 * verb_members
 *
 * Display the list of member contracts.
 */
static void
verb_members(ct_stathdl_t hdl)
{
    pid_t *pids;
    uint_t npids;
    int err;

    if (err = ct_pr_status_get_members(hdl, &pids, &npids)) {
        verb_error(err);
        return;
    }

    print_ids(pids, npids);
}

/*
 * verb_inherit
 *
 * Display the list of inherited contracts.
 */
static void
verb_inherit(ct_stathdl_t hdl)
{
    ctid_t *ctids;
    uint_t nctids;
    int err;

    if (err = ct_pr_status_get_contracts(hdl, &ctids, &nctids))
        verb_error(err);
    else
        print_ids(ctids, nctids);
}

/*
 * verb_svc_fmri
 *
 * Display the process contract service fmri
 */
static void
verb_svc_fmri(ct_stathdl_t hdl)
{
    char *svc_fmri;
    int err;
    if (err = ct_pr_status_get_svc_fmri(hdl, &svc_fmri))
        verb_error(err);
    else
        (void) printf("%s\n", svc_fmri);
}

/*
 * verb_svc_aux
 *
 * Display the process contract service fmri auxiliar
 */
static void
verb_svc_aux(ct_stathdl_t hdl)
{
    char *svc_aux;
    int err;
    if (err = ct_pr_status_get_svc_aux(hdl, &svc_aux))
        verb_error(err);
    else
        (void) printf("%s\n", svc_aux);
}

/*
 * verb_svc_ctid
 *
 * Display the process contract service fmri ctid
 */
static void
verb_svc_ctid(ct_stathdl_t hdl)
{
    ctid_t svc_ctid;
    int err;
    if (err = ct_pr_status_get_svc_ctid(hdl, &svc_ctid))
        verb_error(err);
    else
        (void) printf("%ld\n", svc_ctid);
}

/*
 * verb_svc_creator
 *
 * Display the process contract creator's execname
 */
static void
verb_svc_creator(ct_stathdl_t hdl)
{
    char *svc_creator;
    int err;
    if (err = ct_pr_status_get_svc_creator(hdl, &svc_creator))
        verb_error(err);
    else
        (void) printf("%s\n", svc_creator);
}

/*
 * Common contract status fields.
 */
static verbout_t vcommon[] = {
    "cookie", verb_cookie,
    NULL,
};

/*
 * Process contract-specific status fields.
 * The critical and informative event sets are here because the event
 * names are contract-specific.  They are listed first, however, so
 * they are displayed adjacent to the "normal" common output.
 */
static verbout_t vprocess[] = {
    "informative event set", verb_info,
    "critical event set", verb_crit,
    "fatal event set", verb_fatal,
    "parameter set", verb_param,
    "member processes", verb_members,
    "inherited contracts", verb_inherit,
    "service fmri", verb_svc_fmri,
    "service fmri ctid", verb_svc_ctid,
    "creator", verb_svc_creator,
    "aux", verb_svc_aux,
    NULL
};

static verbout_t vdevice[] = {
    "device", verb_minor,
    "dev_state", verb_dev_state,
    NULL
};

/*
 * print_verbose
 *
 * Displays a contract's verbose status, common fields first.
 */
static void
print_verbose(ct_stathdl_t hdl, verbout_t *spec, verbout_t *common)
{
    int i;
    int tmp, maxwidth = 0;

    /*
     * Compute the width of all the fields.
     */
    for (i = 0; common[i].label; i++)
        if ((tmp = strlen(common[i].label)) > maxwidth)
            maxwidth = tmp;
    if (spec)
        for (i = 0; spec[i].label; i++)
            if ((tmp = strlen(spec[i].label)) > maxwidth)
                maxwidth = tmp;
    maxwidth += 2;

    /*
     * Display the data.
     */
    for (i = 0; common[i].label; i++) {
        tmp = printf("\t%s", common[i].label);
        if (tmp < 0)
            tmp = 0;
        (void) printf("%-*s", maxwidth - tmp + 1, ":");
        common[i].func(hdl);
    }
    if (spec)
        for (i = 0; spec[i].label; i++) {
            (void) printf("\t%s%n", spec[i].label, &tmp);
            (void) printf("%-*s", maxwidth - tmp + 1, ":");
            spec[i].func(hdl);
        }
}

struct {
    const char *name;
    verbout_t *verbout;
} cttypes[] = {
    { "process", vprocess },
    { "device", vdevice },
    { NULL }
};

/*
 * get_type
 *
 * Given a type name, return an index into the above array of types.
 */
static int
get_type(const char *typestr)
{
    int i;
    for (i = 0; cttypes[i].name; i++)
        if (strcmp(cttypes[i].name, typestr) == 0)
            return (i);
    uu_die(gettext("invalid contract type: %s\n"), typestr);
    /* NOTREACHED */
}

/*
 * print_header
 *
 * Display the status header.
 */
static void
print_header(void)
{
    (void) printf("%-8s%-8s%-8s%-8s%-8s%-8s%-8s%-8s\n", "CTID", "ZONEID",
        "TYPE", "STATE", "HOLDER", "EVENTS", "QTIME", "NTIME");
}

/*
 * print_contract
 *
 * Display status for contract ID 'id' from type directory 'dir'.  If
 * only contracts of a specific set of types should be displayed,
 * 'types' will be a sorted list of type indices of length 'ntypes'.
 */
static void
print_contract(const char *dir, ctid_t id, verbout_t *spec,
    int *types, int ntypes)
{
    ct_stathdl_t status;
    char hstr[100], qstr[20], nstr[20];
    ctstate_t state;
    int fd = 0;
    int t;

    /*
     * Open and obtain status.
     */
    if ((fd = contract_open(id, dir, "status", O_RDONLY)) == -1) {
        if (errno == ENOENT)
            return;
        uu_die(gettext("could not open contract status file"));
    }

    if (errno = ct_status_read(fd, opt_verbose ? CTD_ALL : CTD_COMMON,
        &status))
        uu_die(gettext("failed to get contract status for %d"), id);
    (void) close(fd);

    /*
     * Unless otherwise directed, don't display dead contracts.
     */
    state = ct_status_get_state(status);
    if (!opt_showall && state == CTS_DEAD) {
        ct_status_free(status);
        return;
    }

    /*
     * If we are only allowed to display certain contract types,
     * perform that filtering here.  We stash a copy of spec so we
     * don't have to recompute it later.
     */
    if (types) {
        int key = get_type(ct_status_get_type(status));
        spec = cttypes[key].verbout;
        if (bsearch(&key, types, ntypes, sizeof (int), int_compar) ==
            NULL) {
            ct_status_free(status);
            return;
        }
    }

    /*
     * Precompute those fields which have both textual and
     * numerical values.
     */
    if ((state == CTS_OWNED) || (state == CTS_INHERITED))
        (void) snprintf(hstr, sizeof (hstr), "%ld",
            ct_status_get_holder(status));
    else
        (void) snprintf(hstr, sizeof (hstr), "%s", "-");

    if ((t = ct_status_get_qtime(status)) == -1) {
        qstr[0] = nstr[0] = '-';
        qstr[1] = nstr[1] = '\0';
    } else {
        (void) snprintf(qstr, sizeof (qstr), "%d", t);
        (void) snprintf(nstr, sizeof (nstr), "%d",
            ct_status_get_ntime(status));
    }

    /*
     * Emit the contract's status.
     */
    (void) printf("%-7ld %-7ld %-7s %-7s %-7s %-7d %-7s %-8s\n",
        ct_status_get_id(status),
        ct_status_get_zoneid(status),
        ct_status_get_type(status),
        (state == CTS_OWNED) ? "owned" :
        (state == CTS_INHERITED) ? "inherit" :
        (state == CTS_ORPHAN) ? "orphan" : "dead", hstr,
        ct_status_get_nevents(status), qstr, nstr);

    /*
     * Emit verbose status information, if requested.  If we
     * weren't provided a verbose output spec or didn't compute it
     * earlier, do it now.
     */
    if (opt_verbose) {
        if (spec == NULL)
            spec = cttypes[get_type(ct_status_get_type(status))].
                verbout;
        print_verbose(status, spec, vcommon);
    }

    ct_status_free(status);
}

/*
 * scan_type
 *
 * Display all contracts of the requested type.
 */
static void
scan_type(int typeno)
{
    DIR *dir;
    struct dirent64 *de;
    char path[PATH_MAX];

    verbout_t *vo = cttypes[typeno].verbout;
    const char *type = cttypes[typeno].name;

    if (snprintf(path, PATH_MAX, CTFS_ROOT "/%s", type) >= PATH_MAX ||
        (dir = opendir(path)) == NULL)
        uu_die(gettext("bad contract type: %s\n"), type);
    while ((de = readdir64(dir)) != NULL) {
        /*
         * Eliminate special files (e.g. '.', '..').
         */
        if (de->d_name[0] < '0' || de->d_name[0] > '9')
            continue;
        print_contract(type, mystrtoul(de->d_name), vo, NULL, 0);
    }
    (void) closedir(dir);
}

/*
 * scan_ids
 *
 * Display all contracts with the requested IDs.
 */
static void
scan_ids(ctid_t *ids, int nids)
{
    int i;
    for (i = 0; i < nids; i++)
        print_contract("all", ids[i], NULL, NULL, 0);
}

/*
 * scan_all
 *
 * Display the union of the requested IDs and types.  So that the
 * output is sorted by contract ID, it takes the slow road by testing
 * each entry in /system/contract/all against its criteria.  Used when
 * the number of types is greater than 1, when we have a mixture of
 * types and ids, or no lists were provided at all.
 */
static void
scan_all(int *types, int ntypes, ctid_t *ids, int nids)
{
    DIR *dir;
    struct dirent64 *de;
    const char *path = CTFS_ROOT "/all";
    int key, test;

    if ((dir = opendir(path)) == NULL)
        uu_die(gettext("could not open %s"), path);
    while ((de = readdir64(dir)) != NULL) {
        /*
         * Eliminate special files (e.g. '.', '..').
         */
        if (de->d_name[0] < '0' || de->d_name[0] > '9')
            continue;
        key = mystrtoul(de->d_name);

        /*
         * If we are given IDs to look at and this contract
         * isn't in the ID list, or if we weren't given a list
         * if IDs but were given a list of types, provide the
         * list of acceptable types to print_contract.
         */
        test = nids ? (bsearch(&key, ids, nids, sizeof (int),
            int_compar) == NULL) : (ntypes != 0);
        print_contract("all", key, NULL, (test ? types : NULL), ntypes);
    }
    (void) closedir(dir);
}

/*
 * walk_args
 *
 * Apply fp to each token in the comma- or space- separated argument
 * string str and store the results in the array starting at results.
 */
static int
walk_args(const char *str, int (*fp)(const char *), int *results)
{
    char *copy, *token;
    int count = 0;

    if ((copy = strdup(str)) == NULL)
        uu_die(gettext("strdup() failed"));

    token = strtok(copy, ", ");
    if (token == NULL) {
        free(copy);
        return (0);
    }

    do {
        if (fp)
            *(results++) = fp(token);
        count++;
    } while (token = strtok(NULL, ", "));
    free(copy);

    return (count);
}

/*
 * parse
 *
 * Parse the comma- or space- separated string str, using fp to covert
 * the tokens to integers.  Append the list of integers to the array
 * pointed to by *idps, growing the array if necessary.
 */
static int
parse(const char *str, int **idsp, int nids, int (*fp)(const char *fp))
{
    int count;
    int *array;

    count = walk_args(str, NULL, NULL);
    if (count == 0)
        return (0);

    if ((array = calloc(nids + count, sizeof (int))) == NULL)
        uu_die(gettext("calloc() failed"));

    if (*idsp) {
        (void) memcpy(array, *idsp, nids * sizeof (int));
        free(*idsp);
    }

    (void) walk_args(str, fp, array + nids);

    *idsp = array;
    return (count + nids);
}

/*
 * parse_ids
 *
 * Extract a list of ids from the comma- or space- separated string str
 * and append them to the array *idsp, growing it if necessary.
 */
static int
parse_ids(const char *arg, int **idsp, int nids)
{
    return (parse(arg, idsp, nids, mystrtoul));
}

/*
 * parse_types
 *
 * Extract a list of types from the comma- or space- separated string
 * str and append them to the array *idsp, growing it if necessary.
 */
static int
parse_types(const char *arg, int **typesp, int ntypes)
{
    return (parse(arg, typesp, ntypes, get_type));
}

/*
 * compact
 *
 * Sorts and removes duplicates from array.  Initial size of array is
 * in *size; final size is stored in *size.
 */
static void
compact(int *array, int *size)
{
    int i, j, last = -1;

    qsort(array, *size, sizeof (int), int_compar);
    for (i = j = 0; i < *size; i++) {
        if (array[i] != last) {
            last = array[i];
            array[j++] = array[i];
        }
    }
    *size = j;
}

int
main(int argc, char **argv)
{
    unsigned int interval = 0, count = 1;
    ctid_t  *ids = NULL;
    int *types = NULL;
    int nids = 0, ntypes = 0;
    int i, s;

    (void) setlocale(LC_ALL, "");
    (void) textdomain(TEXT_DOMAIN);

    (void) uu_setpname(argv[0]);

    while ((s = getopt(argc, argv, "ai:T:t:v")) != EOF) {
        switch (s) {
        case 'a':
            opt_showall = 1;
            break;
        case 'i':
            nids = parse_ids(optarg, (int **)&ids, nids);
            break;
        case 'T':
            if (optarg) {
                if (*optarg == 'u')
                    timestamp_fmt = UDATE;
                else if (*optarg == 'd')
                    timestamp_fmt = DDATE;
                else
                    usage();
            } else {
                usage();
            }
            break;
        case 't':
            ntypes = parse_types(optarg, &types, ntypes);
            break;
        case 'v':
            opt_verbose = 1;
            break;
        default:
            usage();
        }
    }

    argc -= optind;
    argv += optind;

    if (argc > 2 || argc < 0)
        usage();

    if (argc > 0) {
        interval = mystrtoul(argv[0]);
        count = 0;
    }

    if (argc > 1) {
        count = mystrtoul(argv[1]);
        if (count == 0)
            return (0);
    }

    if (nids)
        compact((int *)ids, &nids);
    if (ntypes)
        compact(types, &ntypes);

    for (i = 0; count == 0 || i < count; i++) {
        if (i)
            (void) sleep(interval);
        if (timestamp_fmt != NODATE)
            print_timestamp(timestamp_fmt);
        print_header();
        if (nids && ntypes)
            scan_all(types, ntypes, ids, nids);
        else if (ntypes == 1)
            scan_type(*types);
        else if (nids)
            scan_ids(ids, nids);
        else
            scan_all(types, ntypes, ids, nids);
    }

    return (0);
}