/*
 * 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);
}