/*      $NetBSD: ps.c,v 1.40 2021/04/17 08:34:27 maya Exp $  */

/*-
 * Copyright (c) 1999
 *      The NetBSD Foundation, Inc.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *      This product includes software developed by the NetBSD Foundation.
 * 4. Neither the name of the Foundation nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

/*
 * XXX Notes XXX
 * showps -- print data needed at each refresh
 * fetchps -- get data used by mode (done at each refresh)
 * labelps -- print labels (ie info not needing refreshing)
 * initps -- prepare once-only data structures for mode
 * openps -- prepare per-run information for mode, return window
 * closeps -- close mode to prepare to switch modes
 * cmdps -- optional, handle commands
 */

#include <sys/cdefs.h>
#ifndef lint
__RCSID("$NetBSD: ps.c,v 1.40 2021/04/17 08:34:27 maya Exp $");
#endif /* not lint */

#include <sys/param.h>
#include <sys/sched.h>
#include <sys/sysctl.h>
#include <sys/stat.h>

#include <curses.h>
#include <math.h>
#include <pwd.h>
#include <stdlib.h>
#include <string.h>
#include <tzfile.h>
#include <unistd.h>

#include "systat.h"
#include "extern.h"
#include "ps.h"

int compare_pctcpu_noidle(const void *, const void *);
char *state2str(struct kinfo_proc2 *);
char *tty2str(struct kinfo_proc2 *);
int rss2int(struct kinfo_proc2 *);
int vsz2int(struct kinfo_proc2 *);
char *comm2str(struct kinfo_proc2 *);
double pmem2float(struct kinfo_proc2 *);
char *start2str(struct kinfo_proc2 *);
char *time2str(struct kinfo_proc2 *);

static time_t now;

#define SHOWUSER_ANY    (uid_t)-1
static uid_t showuser = SHOWUSER_ANY;

#ifndef P_ZOMBIE
#define P_ZOMBIE(p)     ((p)->p_stat == SZOMB)
#endif

void
labelps(void)
{
        mvwaddstr(wnd, 0, 0, "USER      PID %CPU %MEM    VSZ   RSS TT  STAT STARTED       TIME COMMAND");
}

void
showps(void)
{
        int i, k, y, vsz, rss;
        const char *user, *comm, *state, *tty, *start, *time_str;
        pid_t pid;
        double pctcpu, pctmem;
        struct kinfo_proc2 *kp;

        now = 0;        /* force start2str to reget current time */

        qsort(pt, nproc + 1, sizeof (struct p_times), compare_pctcpu_noidle);

        y = 1;
        i = nproc + 1;
        if (i > getmaxy(wnd)-2)
                i = getmaxy(wnd)-1;
        for (k = 0; i > 0 ; k++) {
                if (pt[k].pt_kp == NULL) /* We're all the way down to the imaginary idle proc */
                        break;

                kp = pt[k].pt_kp;
                if (showuser != SHOWUSER_ANY && kp->p_uid != showuser)
                        continue;
                user = user_from_uid(kp->p_uid, 0);
                pid = kp->p_pid;
                pctcpu = 100.0 * pt[k].pt_pctcpu;
                pctmem = pmem2float(pt[k].pt_kp);
                vsz = vsz2int(pt[k].pt_kp);
                rss = rss2int(pt[k].pt_kp);
                tty = tty2str(pt[k].pt_kp);
                state = state2str(pt[k].pt_kp);
                start = start2str(pt[k].pt_kp);
                time_str = time2str(pt[k].pt_kp);
                comm = comm2str(pt[k].pt_kp);
                /*comm = pt[k].pt_kp->kp_proc.p_comm; */

                wmove(wnd, y, 0);
                wclrtoeol(wnd);
                mvwprintw(wnd, y++, 0,
                    "%-8.8s%5d %4.1f %4.1f %6d %5d %-3s %-4s %7s %10.10s %s",
                    user, pid, pctcpu, pctmem, vsz, rss, tty, state, start,
                    time_str, comm);
                i--;
        }
        wmove(wnd, y, 0);
        wclrtobot(wnd);
}

int
compare_pctcpu_noidle(const void *a, const void *b)
{
        if (((const struct p_times *) a)->pt_kp == NULL)
                return 1;

        if (((const struct p_times *) b)->pt_kp == NULL)
                return -1;

        return (((const struct p_times *) a)->pt_pctcpu >
                ((const struct p_times *) b)->pt_pctcpu)? -1: 1;
}

/* from here down adapted from .../src/usr.bin/ps/print.c .  Any mistakes are my own, however. */
char *
state2str(struct kinfo_proc2 *kp)
{       
        int flag; 
        char *cp;
        char buf[5];
        static char statestr[4];

        flag = kp->p_flag;
        cp = buf;

        switch (kp->p_stat) {
        case LSSTOP:
                *cp = 'T';
                break;

        case LSSLEEP:
                if (flag & L_SINTR)     /* interruptable (long) */
                        *cp = kp->p_slptime >= (uint32_t)maxslp ? 'I' : 'S';
                else
                        *cp = 'D';
                break;

        case LSRUN:
        case LSIDL:
        case LSONPROC:
                *cp = 'R';
                break;

        case LSZOMB:
#ifdef LSDEAD
        case LSDEAD:
#endif
                *cp = 'Z';
                break;

        default:
                *cp = '?';
        }
        cp++;
        if (kp->p_nice < NZERO)
                *cp++ = '<';
        else if (kp->p_nice > NZERO)
                *cp++ = 'N';
        if (flag & P_TRACED)
                *cp++ = 'X';
        if (flag & P_WEXIT &&
            /* XXX - I don't like this */
            (kp->p_stat != LSZOMB))
                *cp++ = 'E';
        if (flag & P_PPWAIT)
                *cp++ = 'V';
        if (kp->p_eflag & EPROC_SLEADER)
                *cp++ = 's'; 
        if ((flag & P_CONTROLT) && kp->p__pgid == kp->p_tpgid)
                *cp++ = '+';
        *cp = '\0';
        snprintf(statestr, sizeof(statestr), "%-s",  buf);

        return statestr;
}

char *
tty2str(struct kinfo_proc2 *kp)
{
        static char ttystr[4];
        char *tty_name;

        if (kp->p_tdev == (uint32_t)NODEV ||
            (tty_name = devname(kp->p_tdev, S_IFCHR)) == NULL)
                strlcpy(ttystr, "??", sizeof(ttystr));
        else {
                if (strncmp(tty_name, "tty", 3) == 0 ||
                    strncmp(tty_name, "dty", 3) == 0)
                        tty_name += 3;
                snprintf(ttystr, sizeof(ttystr), "%s%c", tty_name,
                    kp->p_eflag & EPROC_CTTY ? ' ' : '-');
        }

        return ttystr;
}

#define pgtok(a)        (((a)*getpagesize())/1024)

int
vsz2int(struct kinfo_proc2 *kp)
{
        int     i;

        i = pgtok(kp->p_vm_msize);

        return ((i < 0) ? 0 : i);
}

int
rss2int(struct kinfo_proc2 *kp)
{
        int     i;
 
        i = pgtok(kp->p_vm_rssize);

        /* XXX don't have info about shared */
        return ((i < 0) ? 0 : i);
}

char *
comm2str(struct kinfo_proc2 *kp)
{
        char **argv;
        static char commstr[41];

        commstr[0]='\0';

        argv = kvm_getargv2(kd, kp, 40);
        if (argv != NULL) {
                while (*argv) {
                        strlcat(commstr, *argv, sizeof(commstr));
                        argv++;
                        strlcat(commstr, " ", sizeof(commstr));
                }
        } else {
                const char *fmt;

                /*
                 * Commands that don't set an argv vector are printed with
                 * square brackets if they are system commands.  Otherwise
                 * they are printed within parentheses.
                 */
                if (kp->p_flag & P_SYSTEM)
                        fmt = "[]";
                else
                        fmt = "()";

                snprintf(commstr, sizeof(commstr), "%c%s%c", fmt[0],
                    kp->p_comm, fmt[1]);
        }

        return commstr;
}

double
pmem2float(struct kinfo_proc2 *kp)
{                              
        double fracmem;
        static int szptudot = -1;

        /*
         * XXX want pmap ptpages, segtab, etc. (per architecture),
         * not just the uarea.
         */
        if (szptudot < 0) {
                int mib[2];
                size_t size;
                int uspace;

                mib[0] = CTL_VM;
                mib[1] = VM_USPACE;
                size = sizeof(uspace);
                if (sysctl(mib, 2, &uspace, &size, NULL, 0) == 0) {
                        szptudot = uspace / getpagesize();
                } else {
                        /* pick a vaguely useful default */
                        szptudot = getpagesize();
                }
        }

        /* XXX don't have info about shared */
        fracmem = ((double)kp->p_vm_rssize + szptudot) / mempages;
        return (fracmem >= 0) ? 100.0 * fracmem : 0;
}

char *
start2str(struct kinfo_proc2 *kp)
{
        struct timeval u_start;
        struct tm *tp;
        time_t startt;
        static char startstr[10];

        u_start.tv_sec = kp->p_ustart_sec;
        u_start.tv_usec = kp->p_ustart_usec;

        startt = u_start.tv_sec;
        tp = localtime(&startt);
        if (now == 0)
                time(&now);
        if (now - u_start.tv_sec < 24 * SECSPERHOUR) {
                strftime(startstr, sizeof(startstr) - 1, "%l:%M%p", tp);
        } else if (now - u_start.tv_sec < 7 * SECSPERDAY) {
                strftime(startstr, sizeof(startstr) - 1, "%a%I%p", tp);
        } else  
                strftime(startstr, sizeof(startstr) - 1, "%e%b%y", tp);

        return startstr;
}

char *    
time2str(struct kinfo_proc2 *kp)
{              
        long secs;
        long psecs;     /* "parts" of a second. first micro, then centi */
        static char timestr[18];

        /* XXX - I don't like this. */
        if (kp->p_stat == SZOMB) {
                secs = 0;
                psecs = 0;
        } else {
                /*
                 * This counts time spent handling interrupts.  We could
                 * fix this, but it is not 100% trivial (and interrupt
                 * time fractions only work on the sparc anyway).       XXX
                 */
                secs = kp->p_rtime_sec;
                psecs = kp->p_rtime_usec;
#if 0
                if (sumrusage) {
                        secs += k->ki_u.u_cru.ru_utime.tv_sec +
                                k->ki_u.u_cru.ru_stime.tv_sec;
                        psecs += k->ki_u.u_cru.ru_utime.tv_usec +
                                k->ki_u.u_cru.ru_stime.tv_usec;
                }
#endif
                /*
                 * round and scale to 100's
                 */
                psecs = (psecs + 5000) / 10000;
                secs += psecs / 100;
                psecs = psecs % 100;
        }
        snprintf(timestr, sizeof(timestr), "%3ld:%02ld.%02ld", secs/60,
            secs%60, psecs);

        return timestr;
}

void
ps_user(char *args)
{
        uid_t uid;

        if (args == NULL || *args == 0 || strcmp(args, "+") == 0) {
                uid = SHOWUSER_ANY;
        } else if (uid_from_user(args, &uid) != 0) {
                error("%s: unknown user", args);
                return;
        }

        showuser = uid;
        display(0);
}