cmd/prstat/prstat.c

	prstat.c revision e1009cb0cf252c69c92dc5b5d800c22d94a06659
/*
 * 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/types.h>
#include <sys/resource.h>
#include <sys/loadavg.h>
#include <sys/time.h>
#include <sys/pset.h>
#include <sys/vm_usage.h>
#include <zone.h>
#include <libzonecfg.h>

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <dirent.h>
#include <string.h>
#include <errno.h>
#include <poll.h>
#include <ctype.h>
#include <fcntl.h>
#include <limits.h>
#include <signal.h>
#include <time.h>
#include <project.h>

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

#include "prstat.h"
#include "prutil.h"
#include "prtable.h"
#include "prsort.h"
#include "prfile.h"

/*
 * x86 <sys/regs.h> ERR conflicts with <curses.h> ERR.  For the purposes
 * of this file, we care about the curses.h ERR so include that last.
 */

#if defined(ERR)
#undef  ERR
#endif

#ifndef TEXT_DOMAIN         /* should be defined by cc -D */
#define TEXT_DOMAIN "SYS_TEST"  /* use this only if it wasn't */
#endif

#include <curses.h>
#include <term.h>

#define PSINFO_HEADER_PROC \
"   PID USERNAME  SIZE   RSS STATE  PRI NICE      TIME  CPU PROCESS/NLWP       "
#define PSINFO_HEADER_PROC_LGRP \
"   PID USERNAME  SIZE   RSS STATE  PRI NICE      TIME  CPU LGRP PROCESS/NLWP  "
#define PSINFO_HEADER_LWP \
"   PID USERNAME  SIZE   RSS STATE  PRI NICE      TIME  CPU PROCESS/LWPID      "
#define PSINFO_HEADER_LWP_LGRP \
"   PID USERNAME  SIZE   RSS STATE  PRI NICE      TIME  CPU LGRP PROCESS/LWPID "
#define USAGE_HEADER_PROC \
"   PID USERNAME USR SYS TRP TFL DFL LCK SLP LAT VCX ICX SCL SIG PROCESS/NLWP  "
#define USAGE_HEADER_LWP \
"   PID USERNAME USR SYS TRP TFL DFL LCK SLP LAT VCX ICX SCL SIG PROCESS/LWPID "
#define USER_HEADER_PROC \
" NPROC USERNAME  SWAP   RSS MEMORY      TIME  CPU                             "
#define USER_HEADER_LWP \
"  NLWP USERNAME  SWAP   RSS MEMORY      TIME  CPU                             "
#define TASK_HEADER_PROC \
"TASKID    NPROC  SWAP   RSS MEMORY      TIME  CPU PROJECT                     "
#define TASK_HEADER_LWP \
"TASKID     NLWP  SWAP   RSS MEMORY      TIME  CPU PROJECT                     "
#define PROJECT_HEADER_PROC \
"PROJID    NPROC  SWAP   RSS MEMORY      TIME  CPU PROJECT                     "
#define PROJECT_HEADER_LWP \
"PROJID     NLWP  SWAP   RSS MEMORY      TIME  CPU PROJECT                     "
#define ZONE_HEADER_PROC \
"ZONEID    NPROC  SWAP   RSS MEMORY      TIME  CPU ZONE                        "
#define ZONE_HEADER_LWP \
"ZONEID     NLWP  SWAP   RSS MEMORY      TIME  CPU ZONE                        "
#define PSINFO_LINE \
"%6d %-8s %5s %5s %-6s %3s  %3s %9s %3.3s%% %-.16s/%d"
#define PSINFO_LINE_LGRP \
"%6d %-8s %5s %5s %-6s %3s  %3s %9s %3.3s%% %4d %-.16s/%d"
#define USAGE_LINE \
"%6d %-8s %3.3s %3.3s %3.3s %3.3s %3.3s %3.3s %3.3s %3.3s %3.3s %3.3s %3.3s "\
"%3.3s %-.12s/%d"
#define USER_LINE \
"%6d %-8s %5.5s %5.5s   %3.3s%% %9s %3.3s%%"
#define TASK_LINE \
"%6d %8d %5s %5s   %3.3s%% %9s %3.3s%% %28s"
#define PROJECT_LINE \
"%6d %8d %5s %5s   %3.3s%% %9s %3.3s%% %28s"
#define ZONE_LINE \
"%6d %8d %5s %5s   %3.3s%% %9s %3.3s%% %28s"

#define TOTAL_LINE \
"Total: %d processes, %d lwps, load averages: %3.2f, %3.2f, %3.2f"

/* global variables */

static char *t_ulon;            /* termcap: start underline */
static char *t_uloff;           /* termcap: end underline */
static char *t_up;              /* termcap: cursor 1 line up */
static char *t_eol;             /* termcap: clear end of line */
static char *t_smcup;           /* termcap: cursor mvcap on */
static char *t_rmcup;           /* termcap: cursor mvcap off */
static char *t_home;            /* termcap: move cursor home */
static char *movecur = NULL;        /* termcap: move up string */
static char *empty_string = "\0";       /* termcap: empty string */
static uint_t   print_movecur = FALSE;      /* print movecur or not */
static int  is_curses_on = FALSE;       /* current curses state */

static table_t  pid_tbl = {0, 0, NULL};     /* selected processes */
static table_t  cpu_tbl = {0, 0, NULL};     /* selected processors */
static table_t  set_tbl = {0, 0, NULL};     /* selected processor sets */
static table_t  prj_tbl = {0, 0, NULL};     /* selected projects */
static table_t  tsk_tbl = {0, 0, NULL};     /* selected tasks */
static table_t  lgr_tbl = {0, 0, NULL};     /* selected lgroups */
static zonetbl_t zone_tbl = {0, 0, NULL};   /* selected zones */
static nametbl_t euid_tbl = {0, 0, NULL};   /* selected effective users */
static nametbl_t ruid_tbl = {0, 0, NULL};   /* selected real users */

static uint_t   total_procs;            /* total number of procs */
static uint_t   total_lwps;         /* total number of lwps */
static float    total_cpu;          /* total cpu usage */
static float    total_mem;          /* total memory usage */

static list_t   lwps;               /* list of lwps/processes */
static list_t   users;              /* list of users */
static list_t   tasks;              /* list of tasks */
static list_t   projects;           /* list of projects */
static list_t   zones;              /* list of zones */
static list_t   lgroups;            /* list of lgroups */

static volatile uint_t sigwinch = 0;
static volatile uint_t sigtstp = 0;
static volatile uint_t sigterm = 0;

static long pagesize;

/* default settings */

static optdesc_t opts = {
    5,          /* interval between updates, seconds */
    15,         /* number of lines in top part */
    5,          /* number of lines in bottom part */
    -1,         /* number of iterations; infinitely */
    OPT_PSINFO | OPT_FULLSCREEN | OPT_USEHOME | OPT_TERMCAP,
    -1          /* sort in decreasing order */
};

/*
 * Print timestamp as decimal reprentation of time_t value (-d u was specified)
 * or the standard date format (-d d was specified).
 */
static void
print_timestamp(void)
{
    time_t t = time(NULL);
    static char *fmt = NULL;

    /* We only need to retrieve this once per invocation */
    if (fmt == NULL)
        fmt = nl_langinfo(_DATE_FMT);

    if (opts.o_outpmode & OPT_UDATE) {
        (void) printf("%ld", t);
    } else if (opts.o_outpmode & OPT_DDATE) {
        char dstr[64];
        int len;

        len = strftime(dstr, sizeof (dstr), fmt, localtime(&t));
        if (len > 0)
            (void) printf("%s", dstr);
    }
    (void) putp(t_eol);
    (void) putchar('\n');
}

static void
psetloadavg(long psetid, void *ptr)
{
    double psetloadavg[3];
    double *loadavg = ptr;

    if (pset_getloadavg((psetid_t)psetid, psetloadavg, 3) != -1) {
        *loadavg++ += psetloadavg[0];
        *loadavg++ += psetloadavg[1];
        *loadavg += psetloadavg[2];
    }
}

/*
 * Queries the memory virtual and rss size for each member of a list.
 * This will override the values computed by /proc aggregation.
 */
static void
list_getsize(list_t *list)
{
    id_info_t *id;
    vmusage_t *results, *next;
    vmusage_t *match;
    size_t nres = 0;
    size_t i;
    uint_t flags = 0;
    int ret;
    size_t physmem = sysconf(_SC_PHYS_PAGES) * pagesize;

    /*
     * Determine what swap/rss results to calculate.  getvmusage() will
     * prune results returned to non-global zones automatically, so
     * there is no need to pass different flags when calling from a
     * non-global zone.
     *
     * Currently list_getsize() is only called with a single flag.  This
     * is because -Z, -J, -T, and -a are mutually exclusive.  Regardless
     * of this, we handle multiple flags.
     */
    if (opts.o_outpmode & OPT_USERS) {
        /*
         * Gather rss for all users in all zones.  Treat the same
         * uid in different zones as the same user.
         */
        flags |= VMUSAGE_COL_RUSERS;

    } else if (opts.o_outpmode & OPT_TASKS) {
        /* Gather rss for all tasks in all zones */
        flags |= VMUSAGE_ALL_TASKS;

    } else if (opts.o_outpmode & OPT_PROJECTS) {
        /*
         * Gather rss for all projects in all zones.  Treat the same
         * projid in diffrent zones as the same project.
         */
        flags |= VMUSAGE_COL_PROJECTS;

    } else if (opts.o_outpmode & OPT_ZONES) {
        /* Gather rss for all zones */
        flags |= VMUSAGE_ALL_ZONES;

    } else {
        Die(gettext(
            "Cannot determine rss flags for output options %x\n"),
            opts.o_outpmode);
    }

    /*
     * getvmusage() returns an array of result structures.  One for
     * each zone, project, task, or user on the system, depending on
     * flags.
     *
     * If getvmusage() fails, prstat will use the size already gathered
     * from psinfo
     */
    if (getvmusage(flags, opts.o_interval, NULL, &nres) != 0)
        return;

    results = (vmusage_t *)Malloc(sizeof (vmusage_t) * nres);
    for (;;) {
        ret = getvmusage(flags, opts.o_interval, results, &nres);
        if (ret == 0)
            break;
        if (errno == EOVERFLOW) {
            results = (vmusage_t *)Realloc(results,
                sizeof (vmusage_t) * nres);
            continue;
        }
        /*
         * Failure for some other reason.  Prstat will use the size
         * already gathered from psinfo.
         */
        free(results);
        return;
    }
    for (id = list->l_head; id != NULL; id = id->id_next) {

        match = NULL;
        next = results;
        for (i = 0; i < nres; i++, next++) {
            switch (flags) {
            case VMUSAGE_COL_RUSERS:
                if (next->vmu_id == id->id_uid)
                    match = next;
                break;
            case VMUSAGE_ALL_TASKS:
                if (next->vmu_id == id->id_taskid)
                    match = next;
                break;
            case VMUSAGE_COL_PROJECTS:
                if (next->vmu_id == id->id_projid)
                    match = next;
                break;
            case VMUSAGE_ALL_ZONES:
                if (next->vmu_id == id->id_zoneid)
                    match = next;
                break;
            default:
                Die(gettext(
                    "Unknown vmusage flags %d\n"), flags);
            }
        }
        if (match != NULL) {
            id->id_size = match->vmu_swap_all / 1024;
            id->id_rssize = match->vmu_rss_all / 1024;
            id->id_pctmem = (100.0 * (float)match->vmu_rss_all) /
                (float)physmem;
            /* Output using data from getvmusage() */
            id->id_sizematch = B_TRUE;
        }
        /*
         * If no match is found, prstat will use the size already
         * gathered from psinfo.
         */
    }
    free(results);
}

/*
 * A routine to display the contents of the list on the screen
 */
static void
list_print(list_t *list)
{
    lwp_info_t *lwp;
    id_info_t *id;
    char usr[4], sys[4], trp[4], tfl[4];
    char dfl[4], lck[4], slp[4], lat[4];
    char vcx[4], icx[4], scl[4], sig[4];
    char psize[6], prssize[6], pmem[6], pcpu[6], ptime[12];
    char pstate[7], pnice[4], ppri[4];
    char pname[LOGNAME_MAX+1];
    char projname[PROJNAME_MAX+1];
    char zonename[ZONENAME_MAX+1];
    float cpu, mem;
    double loadavg[3] = {0, 0, 0};
    int i, lwpid;

    if (foreach_element(&set_tbl, &loadavg, psetloadavg) == 0) {
        /*
         * If processor sets aren't specified, we display system-wide
         * load averages.
         */
        (void) getloadavg(loadavg, 3);
    }

    if (((opts.o_outpmode & OPT_UDATE) || (opts.o_outpmode & OPT_DDATE)) &&
        ((list->l_type == LT_LWPS) || !(opts.o_outpmode & OPT_SPLIT)))
        print_timestamp();
    if (opts.o_outpmode & OPT_TTY)
        (void) putchar('\r');
    (void) putp(t_ulon);

    switch (list->l_type) {
    case LT_PROJECTS:
        if (opts.o_outpmode & OPT_LWPS)
            (void) printf(PROJECT_HEADER_LWP);
        else
            (void) printf(PROJECT_HEADER_PROC);
        break;
    case LT_TASKS:
        if (opts.o_outpmode & OPT_LWPS)
            (void) printf(TASK_HEADER_LWP);
        else
            (void) printf(TASK_HEADER_PROC);
        break;
    case LT_ZONES:
        if (opts.o_outpmode & OPT_LWPS)
            (void) printf(ZONE_HEADER_LWP);
        else
            (void) printf(ZONE_HEADER_PROC);
        break;
    case LT_USERS:
        if (opts.o_outpmode & OPT_LWPS)
            (void) printf(USER_HEADER_LWP);
        else
            (void) printf(USER_HEADER_PROC);
        break;
    case LT_LWPS:
        if (opts.o_outpmode & OPT_LWPS) {
            if (opts.o_outpmode & OPT_PSINFO) {
                if (opts.o_outpmode & OPT_LGRP)
                    (void) printf(PSINFO_HEADER_LWP_LGRP);
                else
                    (void) printf(PSINFO_HEADER_LWP);
            }
            if (opts.o_outpmode & OPT_MSACCT)
                (void) printf(USAGE_HEADER_LWP);
        } else {
            if (opts.o_outpmode & OPT_PSINFO) {
                if (opts.o_outpmode & OPT_LGRP)
                    (void) printf(PSINFO_HEADER_PROC_LGRP);
                else
                    (void) printf(PSINFO_HEADER_PROC);
            }
            if (opts.o_outpmode & OPT_MSACCT)
                (void) printf(USAGE_HEADER_PROC);
        }
        break;
    }

    (void) putp(t_uloff);
    (void) putp(t_eol);
    (void) putchar('\n');

    for (i = 0; i < list->l_used; i++) {
        switch (list->l_type) {
        case LT_PROJECTS:
        case LT_TASKS:
        case LT_USERS:
        case LT_ZONES:
            id = list->l_ptrs[i];
            /*
             * CPU usage and memory usage normalization
             */
            if (total_cpu >= 100)
                cpu = (100 * id->id_pctcpu) / total_cpu;
            else
                cpu = id->id_pctcpu;
            if (id->id_sizematch == B_FALSE && total_mem >= 100)
                mem = (100 * id->id_pctmem) / total_mem;
            else
                mem = id->id_pctmem;
            if (list->l_type == LT_USERS)
                pwd_getname(id->id_uid, pname, LOGNAME_MAX + 1);
            else if (list->l_type == LT_ZONES)
                getzonename(id->id_zoneid, zonename,
                    ZONENAME_MAX);
            else
                getprojname(id->id_projid, projname,
                    PROJNAME_MAX);
            Format_size(psize, id->id_size, 6);
            Format_size(prssize, id->id_rssize, 6);
            Format_pct(pmem, mem, 4);
            Format_pct(pcpu, cpu, 4);
            Format_time(ptime, id->id_time, 10);
            if (opts.o_outpmode & OPT_TTY)
                (void) putchar('\r');
            if (list->l_type == LT_PROJECTS)
                (void) printf(PROJECT_LINE, (int)id->id_projid,
                    id->id_nproc, psize, prssize, pmem, ptime,
                    pcpu, projname);
            else if (list->l_type == LT_TASKS)
                (void) printf(TASK_LINE, (int)id->id_taskid,
                    id->id_nproc, psize, prssize, pmem, ptime,
                    pcpu, projname);
            else if (list->l_type == LT_ZONES)
                (void) printf(ZONE_LINE, (int)id->id_zoneid,
                    id->id_nproc, psize, prssize, pmem, ptime,
                    pcpu, zonename);
            else
                (void) printf(USER_LINE, id->id_nproc, pname,
                    psize, prssize, pmem, ptime, pcpu);
            (void) putp(t_eol);
            (void) putchar('\n');
            break;
        case LT_LWPS:
            lwp = list->l_ptrs[i];
            if (opts.o_outpmode & OPT_LWPS)
                lwpid = lwp->li_info.pr_lwp.pr_lwpid;
            else
                lwpid = lwp->li_info.pr_nlwp +
                    lwp->li_info.pr_nzomb;
            pwd_getname(lwp->li_info.pr_uid, pname,
                LOGNAME_MAX + 1);
            if (opts.o_outpmode & OPT_PSINFO) {
                Format_size(psize, lwp->li_info.pr_size, 6);
                Format_size(prssize, lwp->li_info.pr_rssize, 6);
                Format_state(pstate,
                    lwp->li_info.pr_lwp.pr_sname,
                    lwp->li_info.pr_lwp.pr_onpro, 7);
                if (strcmp(lwp->li_info.pr_lwp.pr_clname,
                    "RT") == 0 ||
                    strcmp(lwp->li_info.pr_lwp.pr_clname,
                    "SYS") == 0 ||
                    lwp->li_info.pr_lwp.pr_sname == 'Z')
                    (void) strcpy(pnice, "  -");
                else
                    Format_num(pnice,
                        lwp->li_info.pr_lwp.pr_nice - NZERO,
                        4);
                Format_num(ppri, lwp->li_info.pr_lwp.pr_pri, 4);
                Format_pct(pcpu,
                    FRC2PCT(lwp->li_info.pr_lwp.pr_pctcpu), 4);
                if (opts.o_outpmode & OPT_LWPS)
                    Format_time(ptime,
                        lwp->li_info.pr_lwp.pr_time.tv_sec,
                        10);
                else
                    Format_time(ptime,
                        lwp->li_info.pr_time.tv_sec, 10);
                if (opts.o_outpmode & OPT_TTY)
                    (void) putchar('\r');
                stripfname(lwp->li_info.pr_fname);
                if (opts.o_outpmode & OPT_LGRP) {
                    (void) printf(PSINFO_LINE_LGRP,
                        (int)lwp->li_info.pr_pid, pname,
                        psize, prssize, pstate, ppri, pnice,
                        ptime, pcpu,
                        (int)lwp->li_info.pr_lwp.pr_lgrp,
                        lwp->li_info.pr_fname, lwpid);
                } else {
                    (void) printf(PSINFO_LINE,
                        (int)lwp->li_info.pr_pid, pname,
                        psize, prssize, pstate, ppri, pnice,
                        ptime, pcpu,
                        lwp->li_info.pr_fname, lwpid);
                }
                (void) putp(t_eol);
                (void) putchar('\n');
            }
            if (opts.o_outpmode & OPT_MSACCT) {
                Format_pct(usr, lwp->li_usr, 4);
                Format_pct(sys, lwp->li_sys, 4);
                Format_pct(slp, lwp->li_slp, 4);
                Format_num(vcx, lwp->li_vcx, 4);
                Format_num(icx, lwp->li_icx, 4);
                Format_num(scl, lwp->li_scl, 4);
                Format_num(sig, lwp->li_sig, 4);
                Format_pct(trp, lwp->li_trp, 4);
                Format_pct(tfl, lwp->li_tfl, 4);
                Format_pct(dfl, lwp->li_dfl, 4);
                Format_pct(lck, lwp->li_lck, 4);
                Format_pct(lat, lwp->li_lat, 4);
                if (opts.o_outpmode & OPT_TTY)
                    (void) putchar('\r');
                stripfname(lwp->li_info.pr_fname);
                (void) printf(USAGE_LINE,
                    (int)lwp->li_info.pr_pid, pname,
                    usr, sys, trp, tfl, dfl, lck,
                    slp, lat, vcx, icx, scl, sig,
                    lwp->li_info.pr_fname, lwpid);
                (void) putp(t_eol);
                (void) putchar('\n');
            }
            break;
        }
    }

    if (opts.o_outpmode & OPT_TTY)
        (void) putchar('\r');
    if (opts.o_outpmode & OPT_TERMCAP) {
        switch (list->l_type) {
        case LT_PROJECTS:
        case LT_USERS:
        case LT_TASKS:
        case LT_ZONES:
            while (i++ < opts.o_nbottom) {
                (void) putp(t_eol);
                (void) putchar('\n');
            }
            break;
        case LT_LWPS:
            while (i++ < opts.o_ntop) {
                (void) putp(t_eol);
                (void) putchar('\n');
            }
        }
    }

    if (opts.o_outpmode & OPT_TTY)
        (void) putchar('\r');

    if ((opts.o_outpmode & OPT_SPLIT) && list->l_type == LT_LWPS)
        return;

    (void) printf(TOTAL_LINE, total_procs, total_lwps,
        loadavg[LOADAVG_1MIN], loadavg[LOADAVG_5MIN],
        loadavg[LOADAVG_15MIN]);
    (void) putp(t_eol);
    (void) putchar('\n');
    if (opts.o_outpmode & OPT_TTY)
        (void) putchar('\r');
    (void) putp(t_eol);
    (void) fflush(stdout);
}

static lwp_info_t *
list_add_lwp(list_t *list, pid_t pid, id_t lwpid)
{
    lwp_info_t *lwp;

    if (list->l_head == NULL) {
        list->l_head = list->l_tail = lwp = Zalloc(sizeof (lwp_info_t));
    } else {
        lwp = Zalloc(sizeof (lwp_info_t));
        lwp->li_prev = list->l_tail;
        ((lwp_info_t *)list->l_tail)->li_next = lwp;
        list->l_tail = lwp;
    }
    lwp->li_info.pr_pid = pid;
    lwp->li_info.pr_lwp.pr_lwpid = lwpid;
    lwpid_add(lwp, pid, lwpid);
    list->l_count++;
    return (lwp);
}

static void
list_remove_lwp(list_t *list, lwp_info_t *lwp)
{
    if (lwp->li_prev)
        lwp->li_prev->li_next = lwp->li_next;
    else
        list->l_head = lwp->li_next;    /* removing the head */
    if (lwp->li_next)
        lwp->li_next->li_prev = lwp->li_prev;
    else
        list->l_tail = lwp->li_prev;    /* removing the tail */
    lwpid_del(lwp->li_info.pr_pid, lwp->li_info.pr_lwp.pr_lwpid);
    if (lwpid_pidcheck(lwp->li_info.pr_pid) == 0)
        fds_rm(lwp->li_info.pr_pid);
    list->l_count--;
    free(lwp);
}

static void
list_clear(list_t *list)
{
    if (list->l_type == LT_LWPS) {
        lwp_info_t  *lwp = list->l_tail;
        lwp_info_t  *lwp_tmp;

        fd_closeall();
        while (lwp) {
            lwp_tmp = lwp;
            lwp = lwp->li_prev;
            list_remove_lwp(&lwps, lwp_tmp);
        }
    } else {
        id_info_t *id = list->l_head;
        id_info_t *nextid;

        while (id) {
            nextid = id->id_next;
            free(id);
            id = nextid;
        }
        list->l_count = 0;
        list->l_head = list->l_tail = NULL;
    }
}

static void
list_update(list_t *list, lwp_info_t *lwp)
{
    id_info_t *id;

    if (list->l_head == NULL) {         /* first element */
        list->l_head = list->l_tail = id = Zalloc(sizeof (id_info_t));
        goto update;
    }

    for (id = list->l_head; id; id = id->id_next) {
        if ((list->l_type == LT_USERS) &&
            (id->id_uid != lwp->li_info.pr_uid))
            continue;
        if ((list->l_type == LT_TASKS) &&
            (id->id_taskid != lwp->li_info.pr_taskid))
            continue;
        if ((list->l_type == LT_PROJECTS) &&
            (id->id_projid != lwp->li_info.pr_projid))
            continue;
        if ((list->l_type == LT_ZONES) &&
            (id->id_zoneid != lwp->li_info.pr_zoneid))
            continue;
        if ((list->l_type == LT_LGRPS) &&
            (id->id_lgroup != lwp->li_info.pr_lwp.pr_lgrp))
            continue;
        id->id_nproc++;
        id->id_taskid   = lwp->li_info.pr_taskid;
        id->id_projid   = lwp->li_info.pr_projid;
        id->id_zoneid   = lwp->li_info.pr_zoneid;
        id->id_lgroup   = lwp->li_info.pr_lwp.pr_lgrp;

        if (lwp->li_flags & LWP_REPRESENT) {
            id->id_size += lwp->li_info.pr_size;
            id->id_rssize   += lwp->li_info.pr_rssize;
        }
        id->id_pctcpu   += FRC2PCT(lwp->li_info.pr_lwp.pr_pctcpu);
        if (opts.o_outpmode & OPT_LWPS)
            id->id_time += TIME2SEC(lwp->li_info.pr_lwp.pr_time);
        else
            id->id_time += TIME2SEC(lwp->li_info.pr_time);
        id->id_pctmem   += FRC2PCT(lwp->li_info.pr_pctmem);
        id->id_key  += lwp->li_key;
        total_cpu   += FRC2PCT(lwp->li_info.pr_lwp.pr_pctcpu);
        total_mem   += FRC2PCT(lwp->li_info.pr_pctmem);
        return;
    }

    id = list->l_tail;
    id->id_next = Zalloc(sizeof (id_info_t));
    id->id_next->id_prev = list->l_tail;
    id->id_next->id_next = NULL;
    list->l_tail = id->id_next;
    id = list->l_tail;
update:
    id->id_uid  = lwp->li_info.pr_uid;
    id->id_projid   = lwp->li_info.pr_projid;
    id->id_taskid   = lwp->li_info.pr_taskid;
    id->id_zoneid   = lwp->li_info.pr_zoneid;
    id->id_lgroup   = lwp->li_info.pr_lwp.pr_lgrp;
    id->id_nproc++;
    id->id_sizematch = B_FALSE;
    if (lwp->li_flags & LWP_REPRESENT) {
        id->id_size = lwp->li_info.pr_size;
        id->id_rssize   = lwp->li_info.pr_rssize;
    }
    id->id_pctcpu   = FRC2PCT(lwp->li_info.pr_lwp.pr_pctcpu);
    if (opts.o_outpmode & OPT_LWPS)
        id->id_time = TIME2SEC(lwp->li_info.pr_lwp.pr_time);
    else
        id->id_time = TIME2SEC(lwp->li_info.pr_time);
    id->id_pctmem   = FRC2PCT(lwp->li_info.pr_pctmem);
    id->id_key  = lwp->li_key;
    total_cpu   += id->id_pctcpu;
    total_mem   += id->id_pctmem;
    list->l_count++;
}

static void
lwp_update(lwp_info_t *lwp, pid_t pid, id_t lwpid, struct prusage *usage)
{
    float period;

    if (!lwpid_is_active(pid, lwpid)) {
        /*
         * If we are reading cpu times for the first time then
         * calculate average cpu times based on whole process
         * execution time.
         */
        (void) memcpy(&lwp->li_usage, usage, sizeof (prusage_t));
        period = TIME2NSEC(usage->pr_rtime);
        period = period/(float)100;

        if (period == 0) { /* zombie */
            period = 1;
            lwp->li_usr = 0;
            lwp->li_sys = 0;
            lwp->li_slp = 0;
        } else {
            lwp->li_usr = TIME2NSEC(usage->pr_utime)/period;
            lwp->li_sys = TIME2NSEC(usage->pr_stime)/period;
            lwp->li_slp = TIME2NSEC(usage->pr_slptime)/period;
        }
        lwp->li_trp = TIME2NSEC(usage->pr_ttime)/period;
        lwp->li_tfl = TIME2NSEC(usage->pr_tftime)/period;
        lwp->li_dfl = TIME2NSEC(usage->pr_dftime)/period;
        lwp->li_lck = TIME2NSEC(usage->pr_ltime)/period;
        lwp->li_lat = TIME2NSEC(usage->pr_wtime)/period;
        period = (period / NANOSEC)*(float)100; /* now in seconds */
        lwp->li_vcx = (ulong_t)
            (opts.o_interval * (usage->pr_vctx/period));
        lwp->li_icx = (ulong_t)
            (opts.o_interval * (usage->pr_ictx/period));
        lwp->li_scl = (ulong_t)
            (opts.o_interval * (usage->pr_sysc/period));
        lwp->li_sig = (ulong_t)
            (opts.o_interval * (usage->pr_sigs/period));
        (void) lwpid_set_active(pid, lwpid);
    } else {
        /*
         * If this is not a first time we are reading a process's
         * CPU times then recalculate CPU times based on fresh data
         * obtained from procfs and previous CPU time usage values.
         */
        period = TIME2NSEC(usage->pr_rtime)-
            TIME2NSEC(lwp->li_usage.pr_rtime);
        period = period/(float)100;

        if (period == 0) { /* zombie */
            period = 1;
            lwp->li_usr = 0;
            lwp->li_sys = 0;
            lwp->li_slp = 0;
        } else {
            lwp->li_usr = (TIME2NSEC(usage->pr_utime)-
                TIME2NSEC(lwp->li_usage.pr_utime))/period;
            lwp->li_sys = (TIME2NSEC(usage->pr_stime) -
                TIME2NSEC(lwp->li_usage.pr_stime))/period;
            lwp->li_slp = (TIME2NSEC(usage->pr_slptime) -
                TIME2NSEC(lwp->li_usage.pr_slptime))/period;
        }
        lwp->li_trp = (TIME2NSEC(usage->pr_ttime) -
            TIME2NSEC(lwp->li_usage.pr_ttime))/period;
        lwp->li_tfl = (TIME2NSEC(usage->pr_tftime) -
            TIME2NSEC(lwp->li_usage.pr_tftime))/period;
        lwp->li_dfl = (TIME2NSEC(usage->pr_dftime) -
            TIME2NSEC(lwp->li_usage.pr_dftime))/period;
        lwp->li_lck = (TIME2NSEC(usage->pr_ltime) -
            TIME2NSEC(lwp->li_usage.pr_ltime))/period;
        lwp->li_lat = (TIME2NSEC(usage->pr_wtime) -
            TIME2NSEC(lwp->li_usage.pr_wtime))/period;
        lwp->li_vcx = usage->pr_vctx - lwp->li_usage.pr_vctx;
        lwp->li_icx = usage->pr_ictx - lwp->li_usage.pr_ictx;
        lwp->li_scl = usage->pr_sysc - lwp->li_usage.pr_sysc;
        lwp->li_sig = usage->pr_sigs - lwp->li_usage.pr_sigs;
        (void) memcpy(&lwp->li_usage, usage, sizeof (prusage_t));
    }
}

static int
read_procfile(fd_t **fd, char *pidstr, char *file, void *buf, size_t bufsize)
{
    char procfile[MAX_PROCFS_PATH];

    (void) snprintf(procfile, MAX_PROCFS_PATH,
        "/proc/%s/%s", pidstr, file);
    if ((*fd = fd_open(procfile, O_RDONLY, *fd)) == NULL)
        return (1);
    if (pread(fd_getfd(*fd), buf, bufsize, 0) != bufsize) {
        fd_close(*fd);
        return (1);
    }
    return (0);
}

static void
add_proc(psinfo_t *psinfo)
{
    lwp_info_t *lwp;
    id_t lwpid;
    pid_t pid = psinfo->pr_pid;

    lwpid = psinfo->pr_lwp.pr_lwpid;
    if ((lwp = lwpid_get(pid, lwpid)) == NULL)
        lwp = list_add_lwp(&lwps, pid, lwpid);
    lwp->li_flags |= LWP_ALIVE | LWP_REPRESENT;
    (void) memcpy(&lwp->li_info, psinfo, sizeof (psinfo_t));
    lwp->li_info.pr_lwp.pr_pctcpu = lwp->li_info.pr_pctcpu;
}

static void
add_lwp(psinfo_t *psinfo, lwpsinfo_t *lwpsinfo, int flags)
{
    lwp_info_t *lwp;
    pid_t pid = psinfo->pr_pid;
    id_t lwpid = lwpsinfo->pr_lwpid;

    if ((lwp = lwpid_get(pid, lwpid)) == NULL)
        lwp = list_add_lwp(&lwps, pid, lwpid);
    lwp->li_flags &= ~LWP_REPRESENT;
    lwp->li_flags |= LWP_ALIVE;
    lwp->li_flags |= flags;
    (void) memcpy(&lwp->li_info, psinfo,
        sizeof (psinfo_t) - sizeof (lwpsinfo_t));
    (void) memcpy(&lwp->li_info.pr_lwp, lwpsinfo, sizeof (lwpsinfo_t));
}

static void
prstat_scandir(DIR *procdir)
{
    char *pidstr;
    pid_t pid;
    id_t lwpid;
    size_t entsz;
    long nlwps, nent, i;
    char *buf, *ptr;

    fds_t *fds;
    lwp_info_t *lwp;
    dirent_t *direntp;

    prheader_t  header;
    psinfo_t    psinfo;
    prusage_t   usage;
    lwpsinfo_t  *lwpsinfo;
    prusage_t   *lwpusage;

    total_procs = 0;
    total_lwps = 0;
    total_cpu = 0;
    total_mem = 0;

    convert_zone(&zone_tbl);
    for (rewinddir(procdir); (direntp = readdir(procdir)); ) {
        pidstr = direntp->d_name;
        if (pidstr[0] == '.')   /* skip "." and ".."  */
            continue;
        pid = atoi(pidstr);
        if (pid == 0 || pid == 2 || pid == 3)
            continue;   /* skip sched, pageout and fsflush */
        if (has_element(&pid_tbl, pid) == 0)
            continue;   /* check if we really want this pid */
        fds = fds_get(pid); /* get ptr to file descriptors */

        if (read_procfile(&fds->fds_psinfo, pidstr,
            "psinfo", &psinfo, sizeof (psinfo_t)) != 0)
            continue;
        if (!has_uid(&ruid_tbl, psinfo.pr_uid) ||
            !has_uid(&euid_tbl, psinfo.pr_euid) ||
            !has_element(&prj_tbl, psinfo.pr_projid) ||
            !has_element(&tsk_tbl, psinfo.pr_taskid) ||
            !has_zone(&zone_tbl, psinfo.pr_zoneid)) {
            fd_close(fds->fds_psinfo);
            continue;
        }
        nlwps = psinfo.pr_nlwp + psinfo.pr_nzomb;

        if (nlwps > 1 && (opts.o_outpmode & (OPT_LWPS | OPT_PSETS))) {
            int rep_lwp = 0;

            if (read_procfile(&fds->fds_lpsinfo, pidstr, "lpsinfo",
                &header, sizeof (prheader_t)) != 0) {
                fd_close(fds->fds_psinfo);
                continue;
            }

            nent = header.pr_nent;
            entsz = header.pr_entsize * nent;
            ptr = buf = Malloc(entsz);
            if (pread(fd_getfd(fds->fds_lpsinfo), buf,
                entsz, sizeof (struct prheader)) != entsz) {
                fd_close(fds->fds_lpsinfo);
                fd_close(fds->fds_psinfo);
                free(buf);
                continue;
            }

            nlwps = 0;
            for (i = 0; i < nent; i++, ptr += header.pr_entsize) {
                /*LINTED ALIGNMENT*/
                lwpsinfo = (lwpsinfo_t *)ptr;
                if (!has_element(&cpu_tbl,
                    lwpsinfo->pr_onpro) ||
                    !has_element(&set_tbl,
                    lwpsinfo->pr_bindpset) ||
                    !has_element(&lgr_tbl, lwpsinfo->pr_lgrp))
                    continue;
                nlwps++;
                if ((opts.o_outpmode & (OPT_PSETS | OPT_LWPS))
                    == OPT_PSETS) {
                    /*
                     * If one of process's LWPs is bound
                     * to a given processor set, report the
                     * whole process.  We may be doing this
                     * a few times but we'll get an accurate
                     * lwp count in return.
                     */
                    add_proc(&psinfo);
                } else {
                    if (rep_lwp == 0) {
                        rep_lwp = 1;
                        add_lwp(&psinfo, lwpsinfo,
                            LWP_REPRESENT);
                    } else {
                        add_lwp(&psinfo, lwpsinfo, 0);
                    }
                }
            }
            free(buf);
            if (nlwps == 0) {
                fd_close(fds->fds_lpsinfo);
                fd_close(fds->fds_psinfo);
                continue;
            }
        } else {
            if (!has_element(&cpu_tbl, psinfo.pr_lwp.pr_onpro) ||
                !has_element(&set_tbl, psinfo.pr_lwp.pr_bindpset) ||
                !has_element(&lgr_tbl, psinfo.pr_lwp.pr_lgrp)) {
                fd_close(fds->fds_psinfo);
                continue;
            }
            add_proc(&psinfo);
        }
        if (!(opts.o_outpmode & OPT_MSACCT)) {
            total_procs++;
            total_lwps += nlwps;
            continue;
        }
        /*
         * Get more information about processes from /proc/pid/usage.
         * If process has more than one lwp, then we may have to
         * also look at the /proc/pid/lusage file.
         */
        if ((opts.o_outpmode & OPT_LWPS) && (nlwps > 1)) {
            if (read_procfile(&fds->fds_lusage, pidstr, "lusage",
                &header, sizeof (prheader_t)) != 0) {
                fd_close(fds->fds_lpsinfo);
                fd_close(fds->fds_psinfo);
                continue;
            }
            nent = header.pr_nent;
            entsz = header.pr_entsize * nent;
            buf = Malloc(entsz);
            if (pread(fd_getfd(fds->fds_lusage), buf,
                entsz, sizeof (struct prheader)) != entsz) {
                fd_close(fds->fds_lusage);
                fd_close(fds->fds_lpsinfo);
                fd_close(fds->fds_psinfo);
                free(buf);
                continue;
            }
            for (i = 1, ptr = buf + header.pr_entsize; i < nent;
                i++, ptr += header.pr_entsize) {
                /*LINTED ALIGNMENT*/
                lwpusage = (prusage_t *)ptr;
                lwpid = lwpusage->pr_lwpid;
                /*
                 * New LWPs created after we read lpsinfo
                 * will be ignored.  Don't want to do
                 * everything all over again.
                 */
                if ((lwp = lwpid_get(pid, lwpid)) == NULL)
                    continue;
                lwp_update(lwp, pid, lwpid, lwpusage);
            }
            free(buf);
        } else {
            if (read_procfile(&fds->fds_usage, pidstr, "usage",
                &usage, sizeof (prusage_t)) != 0) {
                fd_close(fds->fds_lpsinfo);
                fd_close(fds->fds_psinfo);
                continue;
            }
            lwpid = psinfo.pr_lwp.pr_lwpid;
            if ((lwp = lwpid_get(pid, lwpid)) == NULL)
                continue;
            lwp_update(lwp, pid, lwpid, &usage);
        }
        total_procs++;
        total_lwps += nlwps;
    }
    fd_update();
}

/*
 * This procedure removes all dead lwps from the linked list of all lwps.
 * It also creates linked list of ids if necessary.
 */
static void
list_refresh(list_t *list)
{
    lwp_info_t *lwp, *lwp_next;

    if (!(list->l_type & LT_LWPS))
        return;

    for (lwp = list->l_head; lwp != NULL; ) {
        if (lwp->li_flags & LWP_ALIVE) {
            /*
             * Process all live LWPs.
             * When we're done, mark them as dead.
             * They will be marked "alive" on the next
             * /proc scan if they still exist.
             */
            lwp->li_key = list_getkeyval(list, lwp);
            if (opts.o_outpmode & OPT_USERS)
                list_update(&users, lwp);
            if (opts.o_outpmode & OPT_TASKS)
                list_update(&tasks, lwp);
            if (opts.o_outpmode & OPT_PROJECTS)
                list_update(&projects, lwp);
            if (opts.o_outpmode & OPT_ZONES)
                list_update(&zones, lwp);
            if (opts.o_outpmode & OPT_LGRP)
                list_update(&lgroups, lwp);
            lwp->li_flags &= ~LWP_ALIVE;
            lwp = lwp->li_next;

        } else {
            lwp_next = lwp->li_next;
            list_remove_lwp(&lwps, lwp);
            lwp = lwp_next;
        }
    }
}

static void
curses_on()
{
    if ((opts.o_outpmode & OPT_TERMCAP) && (is_curses_on == FALSE)) {
        (void) initscr();
        (void) nonl();
        (void) putp(t_smcup);
        is_curses_on = TRUE;
    }
}

static void
curses_off()
{
    if ((is_curses_on == TRUE) && (opts.o_outpmode & OPT_TERMCAP)) {
        (void) putp(t_rmcup);
        (void) endwin();
        is_curses_on = FALSE;
    }
    (void) fflush(stdout);
}

static int
nlines()
{
    struct winsize ws;
    char *envp;
    int n;
    if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws) != -1) {
        if (ws.ws_row > 0)
            return (ws.ws_row);
    }
    if (envp = getenv("LINES")) {
        if ((n = Atoi(envp)) > 0) {
            opts.o_outpmode &= ~OPT_USEHOME;
            return (n);
        }
    }
    return (-1);
}

static void
setmovecur()
{
    int i, n;
    if ((opts.o_outpmode & OPT_FULLSCREEN) &&
        (opts.o_outpmode & OPT_USEHOME)) {
        movecur = t_home;
        return;
    }
    if (opts.o_outpmode & OPT_SPLIT) {
        n = opts.o_ntop + opts.o_nbottom + 2;
    } else {
        if (opts.o_outpmode & OPT_USERS)
            n = opts.o_nbottom + 1;
        else
            n = opts.o_ntop + 1;
    }
    if (((opts.o_outpmode & OPT_UDATE) || (opts.o_outpmode & OPT_DDATE)))
        n++;

    if (movecur != NULL && movecur != empty_string && movecur != t_home)
        free(movecur);
    movecur = Zalloc(strlen(t_up) * (n + 5));
    for (i = 0; i <= n; i++)
        (void) strcat(movecur, t_up);
}

static int
setsize()
{
    static int oldn = 0;
    int n;

    if (opts.o_outpmode & OPT_FULLSCREEN) {
        n = nlines();
        if (n == oldn)
            return (0);
        oldn = n;
        if (n == -1) {
            opts.o_outpmode &= ~OPT_USEHOME;
            setmovecur();       /* set default window size */
            return (1);
        }
        n = n - 3;  /* minus header, total and cursor lines */
        if ((opts.o_outpmode & OPT_UDATE) ||
            (opts.o_outpmode & OPT_DDATE))
            n--;    /* minus timestamp */
        if (n < 1)
            Die(gettext("window is too small (try -n)\n"));
        if (opts.o_outpmode & OPT_SPLIT) {
            if (n < 8) {
                Die(gettext("window is too small (try -n)\n"));
            } else {
                opts.o_ntop = (n / 4) * 3;
                opts.o_nbottom = n - 1 - opts.o_ntop;
            }
        } else {
            if (opts.o_outpmode & OPT_USERS)
                opts.o_nbottom = n;
            else
                opts.o_ntop = n;
        }
    }
    setmovecur();
    return (1);
}

static void
ldtermcap()
{
    int err;
    if (setupterm(NULL, STDIN_FILENO, &err) == ERR) {
        switch (err) {
        case 0:
            Warn(gettext("failed to load terminal info, "
                "defaulting to -c option\n"));
            break;
        case -1:
            Warn(gettext("terminfo database not found, "
                "defaulting to -c option\n"));
            break;
        default:
            Warn(gettext("failed to initialize terminal, "
                "defaulting to -c option\n"));
        }
        opts.o_outpmode &= ~OPT_TERMCAP;
        t_up = t_eol = t_smcup = t_rmcup = movecur = empty_string;
        t_ulon = t_uloff = empty_string;
        return;
    }
    t_ulon  = tigetstr("smul");
    t_uloff = tigetstr("rmul");
    t_up    = tigetstr("cuu1");
    t_eol   = tigetstr("el");
    t_smcup = tigetstr("smcup");
    t_rmcup = tigetstr("rmcup");
    t_home  = tigetstr("home");
    if ((t_up == (char *)-1) || (t_eol == (char *)-1) ||
        (t_smcup == (char *)-1) || (t_rmcup == (char *)-1)) {
        opts.o_outpmode &= ~OPT_TERMCAP;
        t_up = t_eol = t_smcup = t_rmcup = movecur = empty_string;
        return;
    }
    if (t_up == NULL || t_eol == NULL) {
        opts.o_outpmode &= ~OPT_TERMCAP;
        t_eol = t_up = movecur = empty_string;
        return;
    }
    if (t_ulon == (char *)-1 || t_uloff == (char *)-1 ||
        t_ulon == NULL || t_uloff == NULL) {
        t_ulon = t_uloff = empty_string;  /* can live without it */
    }
    if (t_smcup == NULL || t_rmcup == NULL)
        t_smcup = t_rmcup = empty_string;
    if (t_home == (char *)-1 || t_home == NULL) {
        opts.o_outpmode &= ~OPT_USEHOME;
        t_home = empty_string;
    }
}

static void
sig_handler(int sig)
{
    switch (sig) {
    case SIGTSTP:   sigtstp = 1;
            break;
    case SIGWINCH:  sigwinch = 1;
            break;
    case SIGINT:
    case SIGTERM:   sigterm = 1;
            break;
    }
}

static void
set_signals()
{
    (void) signal(SIGTSTP, sig_handler);
    (void) signal(SIGINT, sig_handler);
    (void) signal(SIGTERM, sig_handler);
    if (opts.o_outpmode & OPT_FULLSCREEN)
        (void) signal(SIGWINCH, sig_handler);
}

static void
fill_table(table_t *table, char *arg, char option)
{
    char *p = strtok(arg, ", ");

    if (p == NULL)
        Die(gettext("invalid argument for -%c\n"), option);

    add_element(table, (long)Atoi(p));
    while (p = strtok(NULL, ", "))
        add_element(table, (long)Atoi(p));
}

static void
fill_prj_table(char *arg)
{
    projid_t projid;
    char *p = strtok(arg, ", ");

    if (p == NULL)
        Die(gettext("invalid argument for -j\n"));

    if ((projid = getprojidbyname(p)) == -1)
        projid = Atoi(p);
    add_element(&prj_tbl, (long)projid);

    while (p = strtok(NULL, ", ")) {
        if ((projid = getprojidbyname(p)) == -1)
            projid = Atoi(p);
        add_element(&prj_tbl, (long)projid);
    }
}

static void
fill_set_table(char *arg)
{
    char *p = strtok(arg, ", ");
    psetid_t id;

    if (p == NULL)
        Die(gettext("invalid argument for -C\n"));

    if ((id = Atoi(p)) == 0)
        id = PS_NONE;
    add_element(&set_tbl, id);
    while (p = strtok(NULL, ", ")) {
        if ((id = Atoi(p)) == 0)
            id = PS_NONE;
        if (!has_element(&set_tbl, id))
            add_element(&set_tbl, id);
    }
}

static void
Exit()
{
    curses_off();
    list_clear(&lwps);
    list_clear(&users);
    list_clear(&tasks);
    list_clear(&projects);
    list_clear(&zones);
    fd_exit();
}


int
main(int argc, char **argv)
{
    DIR *procdir;
    char *p;
    char *sortk = "cpu";    /* default sort key */
    int opt;
    int timeout;
    struct pollfd pollset;
    char key;

    (void) setlocale(LC_ALL, "");
    (void) textdomain(TEXT_DOMAIN);
    Progname(argv[0]);
    lwpid_init();
    fd_init(Setrlimit());

    pagesize = sysconf(_SC_PAGESIZE);

    while ((opt = getopt(argc, argv,
        "vcd:HmaRLtu:U:n:p:C:P:h:s:S:j:k:TJz:Z")) != (int)EOF) {
        switch (opt) {
        case 'R':
            opts.o_outpmode |= OPT_REALTIME;
            break;
        case 'c':
            opts.o_outpmode &= ~OPT_TERMCAP;
            opts.o_outpmode &= ~OPT_FULLSCREEN;
            break;
        case 'd':
            if (optarg) {
                if (*optarg == 'u')
                    opts.o_outpmode |= OPT_UDATE;
                else if (*optarg == 'd')
                    opts.o_outpmode |= OPT_DDATE;
                else
                    Usage();
            } else {
                Usage();
            }
            break;
        case 'h':
            fill_table(&lgr_tbl, optarg, 'h');
            break;
        case 'H':
            opts.o_outpmode |= OPT_LGRP;
            break;
        case 'm':
        case 'v':
            opts.o_outpmode &= ~OPT_PSINFO;
            opts.o_outpmode |=  OPT_MSACCT;
            break;
        case 't':
            opts.o_outpmode &= ~OPT_PSINFO;
            opts.o_outpmode |= OPT_USERS;
            break;
        case 'a':
            opts.o_outpmode |= OPT_SPLIT | OPT_USERS;
            break;
        case 'T':
            opts.o_outpmode |= OPT_SPLIT | OPT_TASKS;
            break;
        case 'J':
            opts.o_outpmode |= OPT_SPLIT | OPT_PROJECTS;
            break;
        case 'n':
            if ((p = strtok(optarg, ",")) == NULL)
                Die(gettext("invalid argument for -n\n"));
            opts.o_ntop = Atoi(p);
            if (p = strtok(NULL, ","))
                opts.o_nbottom = Atoi(p);
            opts.o_outpmode &= ~OPT_FULLSCREEN;
            break;
        case 's':
            opts.o_sortorder = -1;
            sortk = optarg;
            break;
        case 'S':
            opts.o_sortorder = 1;
            sortk = optarg;
            break;
        case 'u':
            if ((p = strtok(optarg, ", ")) == NULL)
                Die(gettext("invalid argument for -u\n"));
            add_uid(&euid_tbl, p);
            while (p = strtok(NULL, ", "))
                add_uid(&euid_tbl, p);
            break;
        case 'U':
            if ((p = strtok(optarg, ", ")) == NULL)
                Die(gettext("invalid argument for -U\n"));
            add_uid(&ruid_tbl, p);
            while (p = strtok(NULL, ", "))
                add_uid(&ruid_tbl, p);
            break;
        case 'p':
            fill_table(&pid_tbl, optarg, 'p');
            break;
        case 'C':
            fill_set_table(optarg);
            opts.o_outpmode |= OPT_PSETS;
            break;
        case 'P':
            fill_table(&cpu_tbl, optarg, 'P');
            break;
        case 'k':
            fill_table(&tsk_tbl, optarg, 'k');
            break;
        case 'j':
            fill_prj_table(optarg);
            break;
        case 'L':
            opts.o_outpmode |= OPT_LWPS;
            break;
        case 'z':
            if ((p = strtok(optarg, ", ")) == NULL)
                Die(gettext("invalid argument for -z\n"));
            add_zone(&zone_tbl, p);
            while (p = strtok(NULL, ", "))
                add_zone(&zone_tbl, p);
            break;
        case 'Z':
            opts.o_outpmode |= OPT_SPLIT | OPT_ZONES;
            break;
        default:
            Usage();
        }
    }

    (void) atexit(Exit);
    if ((opts.o_outpmode & OPT_USERS) &&
        !(opts.o_outpmode & OPT_SPLIT))
        opts.o_nbottom = opts.o_ntop;
    if (opts.o_ntop == 0 || opts.o_nbottom == 0)
        Die(gettext("invalid argument for -n\n"));
    if (!(opts.o_outpmode & OPT_SPLIT) && (opts.o_outpmode & OPT_USERS) &&
        ((opts.o_outpmode & (OPT_PSINFO | OPT_MSACCT))))
        Die(gettext("-t option cannot be used with -v or -m\n"));

    if ((opts.o_outpmode & OPT_SPLIT) && (opts.o_outpmode && OPT_USERS) &&
        !((opts.o_outpmode & (OPT_PSINFO | OPT_MSACCT))))
        Die(gettext("-t option cannot be used with "
            "-a, -J, -T or -Z\n"));

    if ((opts.o_outpmode & OPT_USERS) &&
        (opts.o_outpmode & (OPT_TASKS | OPT_PROJECTS | OPT_ZONES)))
        Die(gettext("-a option cannot be used with "
            "-t, -J, -T or -Z\n"));

    if (((opts.o_outpmode & OPT_TASKS) &&
        (opts.o_outpmode & (OPT_PROJECTS|OPT_ZONES))) ||
        ((opts.o_outpmode & OPT_PROJECTS) &&
        (opts.o_outpmode & (OPT_TASKS|OPT_ZONES)))) {
        Die(gettext(
            "-J, -T and -Z options are mutually exclusive\n"));
    }

    /*
     * There is not enough space to combine microstate information and
     * lgroup information and still fit in 80-column output.
     */
    if ((opts.o_outpmode & OPT_LGRP) && (opts.o_outpmode & OPT_MSACCT)) {
        Die(gettext("-H and -m options are mutually exclusive\n"));
    }

    if (argc > optind)
        opts.o_interval = Atoi(argv[optind++]);
    if (argc > optind)
        opts.o_count = Atoi(argv[optind++]);
    if (opts.o_count == 0)
        Die(gettext("invalid counter value\n"));
    if (argc > optind)
        Usage();
    if (opts.o_outpmode & OPT_REALTIME)
        Priocntl("RT");
    if (isatty(STDOUT_FILENO) == 1 && isatty(STDIN_FILENO))
        opts.o_outpmode |= OPT_TTY; /* interactive */
    if (!(opts.o_outpmode & OPT_TTY)) {
        opts.o_outpmode &= ~OPT_TERMCAP; /* no termcap for pipes */
        opts.o_outpmode &= ~OPT_FULLSCREEN;
    }
    if (opts.o_outpmode & OPT_TERMCAP)
        ldtermcap();        /* can turn OPT_TERMCAP off */
    if (opts.o_outpmode & OPT_TERMCAP)
        (void) setsize();
    list_alloc(&lwps, opts.o_ntop);
    list_alloc(&users, opts.o_nbottom);
    list_alloc(&tasks, opts.o_nbottom);
    list_alloc(&projects, opts.o_nbottom);
    list_alloc(&zones, opts.o_nbottom);
    list_alloc(&lgroups, opts.o_nbottom);
    list_setkeyfunc(sortk, &opts, &lwps, LT_LWPS);
    list_setkeyfunc(NULL, &opts, &users, LT_USERS);
    list_setkeyfunc(NULL, &opts, &tasks, LT_TASKS);
    list_setkeyfunc(NULL, &opts, &projects, LT_PROJECTS);
    list_setkeyfunc(NULL, &opts, &zones, LT_ZONES);
    list_setkeyfunc(NULL, &opts, &lgroups, LT_LGRPS);
    if (opts.o_outpmode & OPT_TERMCAP)
        curses_on();
    if ((procdir = opendir("/proc")) == NULL)
        Die(gettext("cannot open /proc directory\n"));
    if (opts.o_outpmode & OPT_TTY) {
        (void) printf(gettext("Please wait...\r"));
        if (!(opts.o_outpmode & OPT_TERMCAP))
            (void) putchar('\n');
        (void) fflush(stdout);
    }
    set_signals();
    pollset.fd = STDIN_FILENO;
    pollset.events = POLLIN;
    timeout = opts.o_interval * MILLISEC;

    /*
     * main program loop
     */
    do {
        if (sigterm == 1)
            break;
        if (sigtstp == 1) {
            curses_off();
            (void) signal(SIGTSTP, SIG_DFL);
            (void) kill(0, SIGTSTP);
            /*
             * prstat stops here until it receives SIGCONT signal.
             */
            sigtstp = 0;
            (void) signal(SIGTSTP, sig_handler);
            curses_on();
            print_movecur = FALSE;
            if (opts.o_outpmode & OPT_FULLSCREEN)
                sigwinch = 1;
        }
        if (sigwinch == 1) {
            if (setsize() == 1) {
                list_free(&lwps);
                list_free(&users);
                list_free(&tasks);
                list_free(&projects);
                list_free(&zones);
                list_alloc(&lwps, opts.o_ntop);
                list_alloc(&users, opts.o_nbottom);
                list_alloc(&tasks, opts.o_nbottom);
                list_alloc(&projects, opts.o_nbottom);
                list_alloc(&zones, opts.o_nbottom);
            }
            sigwinch = 0;
            (void) signal(SIGWINCH, sig_handler);
        }
        prstat_scandir(procdir);
        list_refresh(&lwps);
        if (print_movecur)
            (void) putp(movecur);
        print_movecur = TRUE;
        if ((opts.o_outpmode & OPT_PSINFO) ||
            (opts.o_outpmode & OPT_MSACCT)) {
            list_sort(&lwps);
            list_print(&lwps);
        }
        if (opts.o_outpmode & OPT_USERS) {
            list_getsize(&users);
            list_sort(&users);
            list_print(&users);
            list_clear(&users);
        }
        if (opts.o_outpmode & OPT_TASKS) {
            list_getsize(&tasks);
            list_sort(&tasks);
            list_print(&tasks);
            list_clear(&tasks);
        }
        if (opts.o_outpmode & OPT_PROJECTS) {
            list_getsize(&projects);
            list_sort(&projects);
            list_print(&projects);
            list_clear(&projects);
        }
        if (opts.o_outpmode & OPT_ZONES) {
            list_getsize(&zones);
            list_sort(&zones);
            list_print(&zones);
            list_clear(&zones);
        }
        if (opts.o_count == 1)
            break;
        /*
         * If poll() returns -1 and sets errno to EINTR here because
         * the process received a signal, it is Ok to abort this
         * timeout and loop around because we check the signals at the
         * top of the loop.
         */
        if (opts.o_outpmode & OPT_TTY) {
            if (poll(&pollset, (nfds_t)1, timeout) > 0) {
                if (read(STDIN_FILENO, &key, 1) == 1) {
                    if (tolower(key) == 'q')
                        break;
                }
            }
        } else {
            (void) sleep(opts.o_interval);
        }
    } while (opts.o_count == (-1) || --opts.o_count);

    if (opts.o_outpmode & OPT_TTY)
        (void) putchar('\r');
    return (0);
}