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

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

#include <sys/acct.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <fcntl.h>
#include <exacct.h>
#include <pwd.h>
#include <grp.h>
#include <project.h>
#include <stdlib.h>
#include <strings.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>

#ifndef _LP64
#define FMT_UINT64  "%-15llu"
#else
#define FMT_UINT64  "%-15lu"
#endif

#define MAX_DEPTH   25      /* maximum depth level */

static int vflag = 0;

typedef struct catalog_item {
    int type;
    char    *name;
} catalog_item_t;

/*
 * The actual constants are defined in <sys/exacct_catalog.h>.
 */
static catalog_item_t catalog[] = {
    { EXD_VERSION,          "version" },
    { EXD_FILETYPE,         "filetype" },
    { EXD_CREATOR,          "creator" },
    { EXD_HOSTNAME,         "hostname" },

    { EXD_GROUP_HEADER,     "group-header" },
    { EXD_GROUP_PROC,       "group-proc" },
    { EXD_GROUP_TASK,       "group-task" },
    { EXD_GROUP_LWP,        "group-lwp" },
    { EXD_GROUP_FLOW,       "group-flow" },
    { EXD_GROUP_PROC_TAG,       "group-proc-tag" },
    { EXD_GROUP_TASK_TAG,       "group-task-tag" },
    { EXD_GROUP_LWP_TAG,        "group-lwp-tag" },
    { EXD_GROUP_PROC_PARTIAL,   "group-proc-partial" },
    { EXD_GROUP_TASK_PARTIAL,   "group-task-partial" },
    { EXD_GROUP_TASK_INTERVAL,  "group-task-interval" },

    { EXD_PROC_PID,         "pid" },
    { EXD_PROC_ANCPID,      "ppid" },
    { EXD_PROC_UID,         "uid" },
    { EXD_PROC_GID,         "gid" },
    { EXD_PROC_TASKID,      "taskid" },
    { EXD_PROC_PROJID,      "projid" },
    { EXD_PROC_HOSTNAME,        "hostname" },
    { EXD_PROC_COMMAND,     "command" },
    { EXD_PROC_WAIT_STATUS,     "wait-status" },
    { EXD_PROC_START_SEC,       "start-sec" },
    { EXD_PROC_START_NSEC,      "start-nsec" },
    { EXD_PROC_FINISH_SEC,      "finish-sec" },
    { EXD_PROC_FINISH_NSEC,     "finish-nsec" },
    { EXD_PROC_CPU_USER_SEC,    "cpu-user-sec" },
    { EXD_PROC_CPU_USER_NSEC,   "cpu-user-nsec" },
    { EXD_PROC_CPU_SYS_SEC,     "cpu-sys-sec" },
    { EXD_PROC_CPU_SYS_NSEC,    "cpu-sys-nsec" },
    { EXD_PROC_TTY_MAJOR,       "tty-major" },
    { EXD_PROC_TTY_MINOR,       "tty-minor" },
    { EXD_PROC_FAULTS_MAJOR,    "faults-major" },
    { EXD_PROC_FAULTS_MINOR,    "faults-minor" },
    { EXD_PROC_MESSAGES_RCV,    "msgs-recv" },
    { EXD_PROC_MESSAGES_SND,    "msgs-snd" },
    { EXD_PROC_BLOCKS_IN,       "blocks-in" },
    { EXD_PROC_BLOCKS_OUT,      "blocks-out" },
    { EXD_PROC_CHARS_RDWR,      "chars-rdwr" },
    { EXD_PROC_CONTEXT_VOL,     "ctxt-vol" },
    { EXD_PROC_CONTEXT_INV,     "ctxt-inv" },
    { EXD_PROC_SIGNALS,     "signals" },
    { EXD_PROC_SWAPS,       "swaps" },
    { EXD_PROC_SYSCALLS,        "syscalls" },
    { EXD_PROC_TAG,         "proc-tag" },
    { EXD_PROC_ACCT_FLAGS,      "acctflags" },
    { EXD_PROC_ZONENAME,        "zone" },
    { EXD_PROC_MEM_RSS_AVG_K,   "memory-rss-avg-k" },
    { EXD_PROC_MEM_RSS_MAX_K,   "memory-rss-max-k" },

    { EXD_TASK_TASKID,      "taskid" },
    { EXD_TASK_ANCTASKID,       "anctaskid" },
    { EXD_TASK_PROJID,      "projid" },
    { EXD_TASK_HOSTNAME,        "hostname" },
    { EXD_TASK_START_SEC,       "start-sec" },
    { EXD_TASK_START_NSEC,      "start-nsec" },
    { EXD_TASK_FINISH_SEC,      "finish-sec" },
    { EXD_TASK_FINISH_NSEC,     "finish-nsec" },
    { EXD_TASK_CPU_USER_SEC,    "cpu-user-sec" },
    { EXD_TASK_CPU_USER_NSEC,   "cpu-user-nsec" },
    { EXD_TASK_CPU_SYS_SEC,     "cpu-sys-sec" },
    { EXD_TASK_CPU_SYS_NSEC,    "cpu-sys-nsec" },
    { EXD_TASK_FAULTS_MAJOR,    "faults-major" },
    { EXD_TASK_FAULTS_MINOR,    "faults-minor" },
    { EXD_TASK_MESSAGES_RCV,    "msgs-recv" },
    { EXD_TASK_MESSAGES_SND,    "msgs-snd" },
    { EXD_TASK_BLOCKS_IN,       "blocks-in" },
    { EXD_TASK_BLOCKS_OUT,      "blocks-out" },
    { EXD_TASK_CHARS_RDWR,      "chars-rdwr" },
    { EXD_TASK_CONTEXT_VOL,     "ctxt-vol" },
    { EXD_TASK_CONTEXT_INV,     "ctxt-inv" },
    { EXD_TASK_SIGNALS,     "signals" },
    { EXD_TASK_SWAPS,       "swaps" },
    { EXD_TASK_SYSCALLS,        "syscalls" },
    { EXD_TASK_TAG,         "task-tag" },
    { EXD_TASK_ZONENAME,        "zone" },

    { EXD_FLOW_V4SADDR,     "src-addr-v4" },
    { EXD_FLOW_V4DADDR,     "dest-addr-v4" },
    { EXD_FLOW_V6SADDR,     "src-addr-v6" },
    { EXD_FLOW_V6DADDR,     "dest-addr-v6" },
    { EXD_FLOW_SPORT,       "src-port" },
    { EXD_FLOW_DPORT,       "dest-port" },
    { EXD_FLOW_PROTOCOL,        "protocol" },
    { EXD_FLOW_DSFIELD,     "diffserv-field" },
    { EXD_FLOW_NBYTES,      "total-bytes" },
    { EXD_FLOW_NPKTS,       "total-packets" },
    { EXD_FLOW_CTIME,       "creation-time" },
    { EXD_FLOW_LSEEN,       "last-seen" },
    { EXD_FLOW_PROJID,      "projid" },
    { EXD_FLOW_UID,         "uid" },
    { EXD_FLOW_ANAME,       "action-name" },

    { EXD_NONE,         "none" }
};

static void disp_obj(ea_object_t *o, int indent);

/*
 * Convert catalog ID into catalog name.
 */
static char *
catalog_name(int type)
{
    int i = 0;

    while (catalog[i].type != EXD_NONE) {
        if (catalog[i].type == type)
            return (catalog[i].name);
        i++;
    }

    return ("unknown");
}

/*
 * Display port information, if available
 */
static void
disp_port(uint16_t port)
{
    struct servent *port_info;

    port_info = getservbyport(htons(port), NULL);
    if (port_info != NULL) {
        (void) printf("%s", port_info->s_name);
    }
}

/*
 * Display host name for a given IP address if available.
 */
static void
disp_host(char *addr, int family)
{
    struct hostent *phe;
    uint_t len;
    int error_num;

    len = (family == AF_INET) ? sizeof (struct in_addr) :
        sizeof (struct in6_addr);

    if ((phe = getipnodebyaddr(addr, len, family, &error_num)) != NULL) {
        (void) printf("%s", phe->h_name);
    }
}

/*
 * Display protocol information, if available.
 */
static void
disp_proto(uint8_t protocol)
{
    struct protoent *proto_ent;

    proto_ent = getprotobynumber(protocol);
    if (proto_ent != NULL) {
        (void) printf("%s", proto_ent->p_name);
    }

}

/*
 * Display recursively exacct objects in a given embedded group.
 */
static void
disp_embedded_group(ea_object_t *eo, int indent)
{
    while (eo != NULL) {
        disp_obj(eo, indent + 1);
        if (eo->eo_type == EO_GROUP)
            disp_embedded_group(eo->eo_group.eg_objs, indent + 1);
        eo = eo->eo_next;
    }
}

/*
 * Display the data stored in a given exacct object.
 */
static void
disp_obj(ea_object_t *o, int indent)
{
    char objname[30] = "                              ";
    int eol = 1;

    if (indent > MAX_DEPTH) {
        objname[0] = '>';
        indent = 1;
    }

    (void) printf("%6x\t", (o->eo_catalog & EXD_DATA_MASK));
    (void) snprintf(objname + indent, 30 - indent, "%-s",
        catalog_name(o->eo_catalog & EXD_DATA_MASK));
    (void) printf("%-30s\t", objname);

    switch (o->eo_catalog & EXT_TYPE_MASK) {
    case EXT_UINT8:
        (void) printf("%-15u", o->eo_item.ei_uint8);
        if (vflag &&
            ((o->eo_catalog & EXD_DATA_MASK) == EXD_FLOW_PROTOCOL)) {
            disp_proto(o->eo_item.ei_uint8);
        }
        break;
    case EXT_UINT16:
        (void) printf("%-15u", o->eo_item.ei_uint16);
        if (vflag &&
            (((o->eo_catalog & EXD_DATA_MASK) == EXD_FLOW_SPORT) ||
            ((o->eo_catalog & EXD_DATA_MASK) == EXD_FLOW_DPORT))) {
            disp_port(o->eo_item.ei_uint16);
        }
        break;
    case EXT_UINT32:
        switch (o->eo_catalog & EXD_DATA_MASK) {
        case EXD_PROC_WAIT_STATUS:
            {
                int wstat = o->eo_item.ei_uint32;

                if (vflag) {
                    if (WIFEXITED(wstat))
                        (void) printf("%-14d exit",
                            WEXITSTATUS(wstat));
                    else if (WIFSIGNALED(wstat))
                        (void) printf("%14d, signal",
                            WTERMSIG(wstat));
                    else
                        (void) printf("%d", wstat);
                } else {
                    (void) printf("%d", wstat);
                }
            }
            break;
        case EXD_PROC_UID:
            {
                uid_t uid = o->eo_item.ei_uint32;

                (void) printf("%-15u", uid);
                if (vflag) {
                    struct passwd *pwd;
                    if ((pwd = getpwuid(uid)) != NULL)
                        (void) printf("%s",
                            pwd->pw_name);
                }
            }
            break;
        case EXD_PROC_GID:
            {
                gid_t gid = o->eo_item.ei_uint32;

                (void) printf("%-15u", gid);
                if (vflag) {
                    struct group *grp;
                    if ((grp = getgrgid(gid)) != NULL)
                        (void) printf("%s",
                            grp->gr_name);
                }
            }
            break;
        case EXD_PROC_PROJID:
        case EXD_TASK_PROJID:
            {
                projid_t projid = o->eo_item.ei_uint32;

                (void) printf("%-15lu", projid);
                if (vflag) {
                    struct project proj;
                    char projbuf[PROJECT_BUFSZ];

                    if (getprojbyid(projid, &proj, projbuf,
                        PROJECT_BUFSZ) != NULL)
                        (void) printf("%s",
                            proj.pj_name);
                }
            }
            break;
        case EXD_PROC_ACCT_FLAGS:
            {
                int flag = o->eo_item.ei_uint32;

                (void) printf("%-15u", flag);
                if (vflag) {
                    if (flag & AFORK)
                        (void) printf("FORK ");
                    if (flag & ASU)
                        (void) printf("SU");
                }
            }
            break;
        case EXD_FLOW_V4SADDR:
            /* FALLTHRU */
        case EXD_FLOW_V4DADDR:
            {
                char str[INET_ADDRSTRLEN];
                uint32_t addr = htonl(o->eo_item.ei_uint32);

                (void) printf("%-15s",
                    inet_ntop(AF_INET, &addr, str,
                    INET_ADDRSTRLEN));
                if (vflag) {
                    disp_host((char *)&addr, AF_INET);
                }
            }
            break;
        default:
            (void) printf("%u", o->eo_item.ei_uint32);
        }
        break;
    case EXT_UINT64:
        {
            time_t _time;
            char timebuf[20];

            (void) printf(FMT_UINT64, o->eo_item.ei_uint64);
            if (!vflag)
                break;
            if (ea_match_object_catalog(o, EXD_TASK_START_SEC) ||
                ea_match_object_catalog(o, EXD_TASK_FINISH_SEC) ||
                ea_match_object_catalog(o, EXD_PROC_START_SEC) ||
                ea_match_object_catalog(o, EXD_PROC_FINISH_SEC) ||
                ea_match_object_catalog(o, EXD_FLOW_LSEEN) ||
                ea_match_object_catalog(o, EXD_FLOW_CTIME)) {
                _time = o->eo_item.ei_uint64;
                (void) strftime(timebuf, sizeof (timebuf),
                    "%D %T", localtime(&_time));
                (void) fputs(timebuf, stdout);
            }
        }
        break;
    case EXT_DOUBLE:
        (void) printf("%f", o->eo_item.ei_double);
        break;
    case EXT_STRING:
        (void) printf("\"%s\"", o->eo_item.ei_string);
        break;
    case EXT_RAW:
        switch (o->eo_catalog & EXD_DATA_MASK) {
        case EXD_FLOW_V6SADDR:
            /* FALLTHRU */
        case EXD_FLOW_V6DADDR:
            {
                in6_addr_t *addr;
                char str[INET6_ADDRSTRLEN];

                addr = (in6_addr_t *)o->eo_item.ei_raw;
                (void) printf("%-28s", inet_ntop(AF_INET6,
                    &addr->s6_addr, str, INET6_ADDRSTRLEN));
                if (vflag) {
                    disp_host((char *)&addr->s6_addr,
                        AF_INET6);
                }

            }
            break;
        default:
            {
                ea_size_t size = o->eo_item.ei_size;
                char *buf = o->eo_item.ei_raw;
                uint64_t i;

                for (i = 0; i < size && i < 6; i++)
                    (void) printf("0x%2X ", buf[i]);
                if (size > 6)
                    (void) printf("...");
            }
        }
        break;
    case EXT_GROUP:
        (void) printf("[group of %u object(s)]", o->eo_group.eg_nobjs);
        break;
    case EXT_EXACCT_OBJECT:
        /*
         * Embedded exacct records.
         */
        {
            ea_object_type_t ot;
            ea_object_t *op;
            ea_object_t *eo;

            ot = ea_unpack_object(&op, EUP_ALLOC,
                o->eo_item.ei_object, o->eo_item.ei_size);

            if (ot == EO_ERROR) {
                (void) printf("error: couldn't unpack embedded "
                    "object\n");
                break;
            }
            eol = 0;
            if (ot == EO_GROUP) {
                (void) printf("[embedded group of %u "
                    "object(s)]\n", op->eo_group.eg_nobjs);
                eo = op->eo_group.eg_objs;
                disp_embedded_group(eo, indent);
            } else {
                (void) printf("[embedded object]\n");
                disp_obj(op, indent);
            }
            ea_free_object(op, EUP_ALLOC);
        }
        break;
    default:
        (void) printf("[complex value]");
        break;
    }

    if (eol)
        (void) printf("\n");

}

/*
 * Read and display a group of exacct objects from the file.
 */
static void
disp_group(ea_file_t *ef, uint_t nobjs, int indent)
{
    uint_t i;

    for (i = 0; i < nobjs; i++) {
        ea_object_t scratch;
        int res;

        if ((res = ea_get_object(ef, &scratch)) == -1) {
            (void) fprintf(stderr,
                "bad file: ea_get_object()==%d\n", res);
            exit(2);
        }

        disp_obj(&scratch, indent + 1);

        if (scratch.eo_type == EO_GROUP)
            disp_group(ef, scratch.eo_group.eg_nobjs, indent + 1);
        else
            (void) ea_free_item(&scratch, EUP_ALLOC);
    }
}

static void
usage()
{
    (void) fprintf(stderr, "Usage: exdump [-v] <file>\n");
    exit(2);
}

int
main(int argc, char *argv[])
{
    ea_file_t ef;
    ea_object_t scratch;
    char *fname;
    int opt;

    while ((opt = getopt(argc, argv, "v")) != EOF) {
        switch (opt) {
        case 'v':
            vflag = 1;
            break;
        default:
            usage();
        }
    }

    if (argc == optind)
        usage();
    if (argc > optind)
        fname = argv[optind++];
    if (argc > optind)
        usage();

    if (ea_open(&ef, fname, NULL,
        vflag ? EO_NO_VALID_HDR : 0, O_RDONLY, 0) == -1) {
        (void) fprintf(stderr, "exdump: cannot open %s\n", fname);
        return (1);
    }

    bzero(&scratch, sizeof (ea_object_t));
    while (ea_get_object(&ef, &scratch) != -1) {
        disp_obj(&scratch, 0);
        if (scratch.eo_type == EO_GROUP)
            disp_group(&ef, scratch.eo_group.eg_nobjs, 0);
        else
            (void) ea_free_item(&scratch, EUP_ALLOC);
        (void) bzero(&scratch, sizeof (ea_object_t));
    }

    (void) ea_close(&ef);
    return (0);
}