projects / unix-history / blobdiff
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
changes for 4.4BSD-Lite requested by USL
[unix-history] / usr / src / bin / ps / print.c
diff --git a/usr/src/bin/ps/print.c b/usr/src/bin/ps/print.c
index 99e95f4..c9173ff 100644 (file)
--- a/usr/src/bin/ps/print.c
+++ b/usr/src/bin/ps/print.c
@@ -1,93 +1,146 @@
 /*-
 /*-
- * Copyright (c) 1990 The Regents of the University of California.
- * All rights reserved.
+ * Copyright (c) 1990, 1993
+ *     The Regents of the University of California.  All rights reserved.
  *
  * %sccs.include.redist.c%
  */
 
 #ifndef lint
  *
  * %sccs.include.redist.c%
  */
 
 #ifndef lint
-static char sccsid[] = "@(#)print.c    5.3 (Berkeley) %G%";
+static char sccsid[] = "@(#)print.c    8.2 (Berkeley) %G%";
 #endif /* not lint */
 
 #endif /* not lint */
 
-#include <machine/pte.h>
-
 #include <sys/param.h>
 #include <sys/time.h>
 #include <sys/resource.h>
 #include <sys/proc.h>
 #include <sys/stat.h>
 #include <sys/param.h>
 #include <sys/time.h>
 #include <sys/resource.h>
 #include <sys/proc.h>
 #include <sys/stat.h>
+
+#ifdef SPPWAIT
+#define NEWVM
+#endif
+
+#ifdef NEWVM
+#include <sys/ucred.h>
+#include <sys/sysctl.h>
+#include <vm/vm.h>
+#else
+#include <machine/pte.h>
 #include <sys/vmparam.h>
 #include <sys/vm.h>
 #include <sys/vmparam.h>
 #include <sys/vm.h>
+#endif
+
+#include <err.h>
 #include <math.h>
 #include <math.h>
-#include <tzfile.h>
+#include <nlist.h>
 #include <stddef.h>
 #include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 #include <string.h>
+#include <tzfile.h>
+
 #include "ps.h"
 
 #include "ps.h"
 
+static void printval __P((char*, struct var *));
+
+void
 printheader()
 {
        register VAR *v;
 printheader()
 {
        register VAR *v;
+       register struct varent *vent;
 
 
-       for (v = vhead; v; v = v->next) {
+       for (vent = vhead; vent; vent = vent->next) {
+               v = vent->var;
                if (v->flag & LJUST) {
                if (v->flag & LJUST) {
-                       if (v->next == NULL)    /* last one */
-                               (void) printf("%s", v->header);
+                       if (vent->next == NULL) /* last one */
+                               (void)printf("%s", v->header);
                        else
                        else
-                               (void) printf("%-*s", v->width, v->header);
+                               (void)printf("%-*s", v->width, v->header);
                } else
                } else
-                       (void) printf("%*s", v->width, v->header);
-               if (v->next != NULL)
-                       (void) putchar(' ');
+                       (void)printf("%*s", v->width, v->header);
+               if (vent->next != NULL)
+                       (void)putchar(' ');
        }
        }
-       (void) putchar('\n');
+       (void)putchar('\n');
 }
 
 }
 
-command(k, v)
+void
+command(k, ve)
        KINFO *k;
        KINFO *k;
-       VAR *v;
+       VARENT *ve;
 {
        extern int termwidth, totwidth;
 {
        extern int termwidth, totwidth;
+       VAR *v;
 
 
-       if (v->next == NULL) {
+       v = ve->var;
+       if (ve->next == NULL) {
                /* last field */
                /* last field */
-               if (termwidth == UNLIMITED)
-                       (void) printf("%s", k->ki_args);
-               else {
+               if (termwidth == UNLIMITED) {
+                       if (k->ki_env)
+                               (void)printf("%s ", k->ki_env);
+                       (void)printf("%s", k->ki_args);
+               } else {
                        register int left = termwidth - (totwidth - v->width);
                        register int left = termwidth - (totwidth - v->width);
-                       register char *cp = k->ki_args;
+                       register char *cp;
 
                        if (left < 1) /* already wrapped, just use std width */
                                left = v->width;
 
                        if (left < 1) /* already wrapped, just use std width */
                                left = v->width;
+                       cp = k->ki_env;
+                       if (cp != 0) {
+                               while (--left >= 0 && *cp)
+                                       (void)putchar(*cp++);
+                               if (--left >= 0)
+                                       putchar(' ');
+                       }
+                       cp = k->ki_args;
                        while (--left >= 0 && *cp)
                        while (--left >= 0 && *cp)
-                               (void) putchar(*cp++);
+                               (void)putchar(*cp++);
                }
        } else
                }
        } else
-               (void) printf("%-*.*s", v->width, v->width, k->ki_args);
-
+               /* XXX env? */
+               (void)printf("%-*.*s", v->width, v->width, k->ki_args);
 }
 
 }
 
-ucomm(k, v)
+void
+ucomm(k, ve)
        KINFO *k;
        KINFO *k;
-       VAR *v;
+       VARENT *ve;
 {
 {
-       (void) printf("%-*s", v->width, k->ki_p->p_comm);
+       VAR *v;
+
+       v = ve->var;
+       (void)printf("%-*s", v->width, KI_PROC(k)->p_comm);
 }
 
 }
 
-logname(k, v)
+void
+logname(k, ve)
        KINFO *k;
        KINFO *k;
-       VAR *v;
+       VARENT *ve;
 {
 {
-       (void) printf("%-*s", v->width, k->ki_p->p_logname);
+       VAR *v;
+
+       v = ve->var;
+#ifndef NEWVM
+       (void)printf("%-*s", v->width, KI_PROC(k)->p_logname);
+#else /* NEWVM */
+       (void)printf("%-*s", v->width, KI_EPROC(k)->e_login);
+#endif /* NEWVM */
 }
 
 }
 
-state(k, v)
+void
+state(k, ve)
        KINFO *k;
        KINFO *k;
-       VAR *v;
+       VARENT *ve;
 {
 {
+       register struct proc *p;
+       register int flag;
+       register char *cp;
+       VAR *v;
        char buf[16];
        char buf[16];
-       register char *cp = buf;
-       register struct proc *p = k->ki_p;
-       register flag = p->p_flag;
+
+       v = ve->var;
+       p = KI_PROC(k);
+       flag = p->p_flag;
+       cp = buf;
 
        switch (p->p_stat) {
 
 
        switch (p->p_stat) {
 
@@ -99,7 +152,7 @@ state(k, v)
                if (flag & SSINTR)      /* interuptable (long) */
                        *cp = p->p_slptime >= MAXSLP ? 'I' : 'S';
                else
                if (flag & SSINTR)      /* interuptable (long) */
                        *cp = p->p_slptime >= MAXSLP ? 'I' : 'S';
                else
-                       *cp = (flag & SPAGE) ? 'P' : 'D';
+                       *cp = 'D';
                break;
 
        case SRUN:
                break;
 
        case SRUN:
@@ -116,209 +169,298 @@ state(k, v)
        }
        cp++;
        if (flag & SLOAD) {
        }
        cp++;
        if (flag & SLOAD) {
+#ifndef NEWVM
                if (p->p_rssize > p->p_maxrss)
                        *cp++ = '>';
                if (p->p_rssize > p->p_maxrss)
                        *cp++ = '>';
+#endif
        } else
                *cp++ = 'W';
        if (p->p_nice < NZERO)
                *cp++ = '<';
        else if (p->p_nice > NZERO)
                *cp++ = 'N';
        } else
                *cp++ = 'W';
        if (p->p_nice < NZERO)
                *cp++ = '<';
        else if (p->p_nice > NZERO)
                *cp++ = 'N';
+#ifndef NEWVM
        if (flag & SUANOM)
                *cp++ = 'A';
        else if (flag & SSEQL)
                *cp++ = 'S';
        if (flag & SUANOM)
                *cp++ = 'A';
        else if (flag & SSEQL)
                *cp++ = 'S';
+#endif
        if (flag & STRC)
                *cp++ = 'X';
        if (flag & STRC)
                *cp++ = 'X';
-       if (flag & SWEXIT)
+       if (flag & SWEXIT && p->p_stat != SZOMB)
                *cp++ = 'E';
                *cp++ = 'E';
+#ifdef NEWVM
+       if (flag & SPPWAIT)
+#else
        if (flag & SVFORK)
        if (flag & SVFORK)
+#endif
                *cp++ = 'V';
                *cp++ = 'V';
+#ifdef NEWVM
+       if (flag & (SSYS|SLOCK|SKEEP|SPHYSIO))
+#else
        if (flag & (SSYS|SLOCK|SULOCK|SKEEP|SPHYSIO))
        if (flag & (SSYS|SLOCK|SULOCK|SKEEP|SPHYSIO))
+#endif
                *cp++ = 'L';
                *cp++ = 'L';
-       if (k->ki_e->e_flag & EPROC_SLEADER)
+       if (KI_EPROC(k)->e_flag & EPROC_SLEADER)
                *cp++ = 's';
                *cp++ = 's';
-       if ((flag & SCTTY) && k->ki_e->e_pgid == k->ki_e->e_tpgid)
+       if ((flag & SCTTY) && KI_EPROC(k)->e_pgid == KI_EPROC(k)->e_tpgid)
                *cp++ = '+';
        *cp = '\0';
                *cp++ = '+';
        *cp = '\0';
-       (void) printf("%-*s", v->width, buf);
+       (void)printf("%-*s", v->width, buf);
 }
 
 }
 
-pri(k, v)
+void
+pri(k, ve)
        KINFO *k;
        KINFO *k;
-       VAR *v;
+       VARENT *ve;
 {
 {
-       (void) printf("%*d", v->width, k->ki_p->p_pri - PZERO);
+       VAR *v;
+
+       v = ve->var;
+       (void)printf("%*d", v->width, KI_PROC(k)->p_priority - PZERO);
 }
 
 }
 
-uname(k, v)
+void
+uname(k, ve)
        KINFO *k;
        KINFO *k;
-       VAR *v;
+       VARENT *ve;
 {
 {
-       (void) printf("%-*s", v->width, user_from_uid(k->ki_p->p_uid, 0));
+       VAR *v;
+
+       v = ve->var;
+#ifndef NEWVM
+       (void)printf("%-*s",
+           (int)v->width, user_from_uid(KI_PROC(k)->p_uid, 0));
+#else
+       (void)printf("%-*s",
+           (int)v->width, user_from_uid(KI_EPROC(k)->e_ucred.cr_uid, 0));
+#endif
 }
 
 }
 
-runame(k, v)
+void
+runame(k, ve)
        KINFO *k;
        KINFO *k;
-       VAR *v;
+       VARENT *ve;
 {
 {
-       (void) printf("%-*s", v->width, user_from_uid(k->ki_p->p_ruid, 0));
+       VAR *v;
+
+       v = ve->var;
+#ifndef NEWVM
+       (void)printf("%-*s",
+           (int)v->width, user_from_uid(KI_PROC(k)->p_ruid, 0));
+#else
+       (void)printf("%-*s",
+           (int)v->width, user_from_uid(KI_EPROC(k)->e_pcred.p_ruid, 0));
+#endif
 }
 
 }
 
-tdev(k, v)
+void
+tdev(k, ve)
        KINFO *k;
        KINFO *k;
-       VAR *v;
+       VARENT *ve;
 {
 {
-       dev_t dev = k->ki_e->e_tdev;
+       VAR *v;
+       dev_t dev;
+       char buff[16];
 
 
+       v = ve->var;
+       dev = KI_EPROC(k)->e_tdev;
        if (dev == NODEV)
        if (dev == NODEV)
-               (void) printf("%*s", v->width, "??");
+               (void)printf("%*s", v->width, "??");
        else {
        else {
-               char buff[16];
-
-               (void) sprintf(buff, "%d/%d", major(dev), minor(dev));
-               (void) printf("%*s", v->width, buff);
+               (void)snprintf(buff, sizeof(buff),
+                   "%d/%d", major(dev), minor(dev));
+               (void)printf("%*s", v->width, buff);
        }
 }
 
        }
 }
 
-tname(k, v)
+void
+tname(k, ve)
        KINFO *k;
        KINFO *k;
-       VAR *v;
+       VARENT *ve;
 {
 {
+       VAR *v;
        dev_t dev;
        dev_t dev;
-       char *ttname, *devname();
+       char *ttname;
 
 
-       dev = k->ki_e->e_tdev;
+       v = ve->var;
+       dev = KI_EPROC(k)->e_tdev;
        if (dev == NODEV || (ttname = devname(dev, S_IFCHR)) == NULL)
        if (dev == NODEV || (ttname = devname(dev, S_IFCHR)) == NULL)
-               (void) printf("%-*s", v->width, "??");
+               (void)printf("%-*s", v->width, "??");
        else {
                if (strncmp(ttname, "tty", 3) == 0)
                        ttname += 3;
        else {
                if (strncmp(ttname, "tty", 3) == 0)
                        ttname += 3;
-               (void) printf("%*.*s%c", v->width-1, v->width-1, ttname,
-                       k->ki_e->e_flag & EPROC_CTTY ? ' ' : '-');
+               (void)printf("%*.*s%c", v->width-1, v->width-1, ttname,
+                       KI_EPROC(k)->e_flag & EPROC_CTTY ? ' ' : '-');
        }
 }
 
        }
 }
 
-longtname(k, v)
+void
+longtname(k, ve)
        KINFO *k;
        KINFO *k;
-       VAR *v;
+       VARENT *ve;
 {
 {
+       VAR *v;
        dev_t dev;
        dev_t dev;
-       char *ttname, *devname();
+       char *ttname;
 
 
-       dev = k->ki_e->e_tdev;
+       v = ve->var;
+       dev = KI_EPROC(k)->e_tdev;
        if (dev == NODEV || (ttname = devname(dev, S_IFCHR)) == NULL)
        if (dev == NODEV || (ttname = devname(dev, S_IFCHR)) == NULL)
-               (void) printf("%-*s", v->width, "??");
+               (void)printf("%-*s", v->width, "??");
        else
        else
-               (void) printf("%-*s", v->width, ttname);
+               (void)printf("%-*s", v->width, ttname);
 }
 
 }
 
-started(k, v)
+void
+started(k, ve)
        KINFO *k;
        KINFO *k;
-       VAR *v;
+       VARENT *ve;
 {
 {
+       VAR *v;
        static time_t now;
        struct tm *tp;
        char buf[100];
 
        static time_t now;
        struct tm *tp;
        char buf[100];
 
-       if (!k->ki_u) {
-               (void) printf("%-*s", v->width, "-");
+       v = ve->var;
+       if (!k->ki_u.u_valid) {
+               (void)printf("%-*s", v->width, "-");
                return;
        }
 
                return;
        }
 
-       tp = localtime(&k->ki_u->u_start.tv_sec);
+       tp = localtime(&k->ki_u.u_start.tv_sec);
        if (!now)
                (void)time(&now);
        if (!now)
                (void)time(&now);
-       if (now - k->ki_u->u_start.tv_sec < 24 * SECSPERHOUR) {
-               static char *fmt = "%l:@M%p";
+       if (now - k->ki_u.u_start.tv_sec < 24 * SECSPERHOUR) {
+               static char fmt[] = "%l:@M%p";
                fmt[3] = '%';                   /* I *hate* SCCS... */
                fmt[3] = '%';                   /* I *hate* SCCS... */
-               (void) strftime(buf, sizeof(buf) - 1, fmt, tp);
-       } else if (now - k->ki_u->u_start.tv_sec < 7 * SECSPERDAY) {
-               static char *fmt = "%a@I%p";
+               (void)strftime(buf, sizeof(buf) - 1, fmt, tp);
+       } else if (now - k->ki_u.u_start.tv_sec < 7 * SECSPERDAY) {
+               static char fmt[] = "%a@I%p";
                fmt[2] = '%';                   /* I *hate* SCCS... */
                fmt[2] = '%';                   /* I *hate* SCCS... */
-               (void) strftime(buf, sizeof(buf) - 1, fmt, tp);
+               (void)strftime(buf, sizeof(buf) - 1, fmt, tp);
        } else
        } else
-               (void) strftime(buf, sizeof(buf) - 1, "%e%b%y", tp);
-       (void) printf("%-*s", v->width, buf);
+               (void)strftime(buf, sizeof(buf) - 1, "%e%b%y", tp);
+       (void)printf("%-*s", v->width, buf);
 }
 
 }
 
-lstarted(k, v)
+void
+lstarted(k, ve)
        KINFO *k;
        KINFO *k;
-       VAR *v;
+       VARENT *ve;
 {
 {
+       VAR *v;
        char buf[100];
 
        char buf[100];
 
-       if (!k->ki_u) {
-               (void) printf("%-*s", v->width, "-");
+       v = ve->var;
+       if (!k->ki_u.u_valid) {
+               (void)printf("%-*s", v->width, "-");
                return;
        }
                return;
        }
-       (void) strftime(buf, sizeof(buf) -1, "%C",
-           localtime(&k->ki_u->u_start.tv_sec));
-       (void) printf("%-*s", v->width, buf);
+       (void)strftime(buf, sizeof(buf) -1, "%C",
+           localtime(&k->ki_u.u_start.tv_sec));
+       (void)printf("%-*s", v->width, buf);
 }
 
 }
 
-wchan(k, v)
+void
+wchan(k, ve)
        KINFO *k;
        KINFO *k;
-       VAR *v;
+       VARENT *ve;
 {
 {
-       if (k->ki_p->p_wchan) {
-               if (k->ki_p->p_pri > PZERO)
-                       (void) printf("%-*.*s", v->width, v->width, k->ki_e->e_wmesg);
+       VAR *v;
+
+       v = ve->var;
+       if (KI_PROC(k)->p_wchan) {
+               if (KI_PROC(k)->p_wmesg)
+                       (void)printf("%-*.*s", v->width, v->width, 
+                                     KI_EPROC(k)->e_wmesg);
                else
                else
-                       (void) printf("%*x", v->width,
-                           (int)k->ki_p->p_wchan &~ KERNBASE);
+                       (void)printf("%-*x", v->width,
+                           (int)KI_PROC(k)->p_wchan &~ KERNBASE);
        } else
        } else
-               (void) printf("%-*s", v->width, "-");
+               (void)printf("%-*s", v->width, "-");
 }
 
 #define pgtok(a)        (((a)*NBPG)/1024)
 
 }
 
 #define pgtok(a)        (((a)*NBPG)/1024)
 
-vsize(k, v)
+void
+vsize(k, ve)
        KINFO *k;
        KINFO *k;
-       VAR *v;
+       VARENT *ve;
 {
 {
-       (void) printf("%*d", v->width,
-           pgtok(k->ki_p->p_dsize + k->ki_p->p_ssize + k->ki_e->e_xsize));
+       VAR *v;
+
+       v = ve->var;
+       (void)printf("%*d", v->width,
+#ifndef NEWVM
+           pgtok(KI_PROC(k)->p_dsize + KI_PROC(k)->p_ssize + KI_EPROC(k)->e_xsize));
+#else /* NEWVM */
+           pgtok(KI_EPROC(k)->e_vm.vm_dsize + KI_EPROC(k)->e_vm.vm_ssize +
+               KI_EPROC(k)->e_vm.vm_tsize));
+#endif /* NEWVM */
 }
 
 }
 
-rssize(k, v)
+void
+rssize(k, ve)
        KINFO *k;
        KINFO *k;
-       VAR *v;
+       VARENT *ve;
 {
 {
-       (void) printf("%*d", v->width,
-           pgtok(k->ki_p->p_rssize + (k->ki_e->e_xccount ?
-           (k->ki_e->e_xrssize / k->ki_e->e_xccount) : 0)));
+       VAR *v;
+
+       v = ve->var;
+#ifndef NEWVM
+       (void)printf("%*d", v->width,
+           pgtok(KI_PROC(k)->p_rssize + (KI_EPROC(k)->e_xccount ?
+           (KI_EPROC(k)->e_xrssize / KI_EPROC(k)->e_xccount) : 0)));
+#else /* NEWVM */
+       /* XXX don't have info about shared */
+       (void)printf("%*d", v->width, pgtok(KI_EPROC(k)->e_vm.vm_rssize));
+#endif /* NEWVM */
 }
 
 }
 
-p_rssize(k, v)         /* doesn't account for text */
+void
+p_rssize(k, ve)                /* doesn't account for text */
        KINFO *k;
        KINFO *k;
-       VAR *v;
+       VARENT *ve;
 {
 {
-       (void) printf("%*d", v->width, pgtok(k->ki_p->p_rssize));
+       VAR *v;
+
+       v = ve->var;
+#ifndef NEWVM
+       (void)printf("%*d", v->width, pgtok(KI_PROC(k)->p_rssize));
+#else /* NEWVM */
+       (void)printf("%*d", v->width, pgtok(KI_EPROC(k)->e_vm.vm_rssize));
+#endif /* NEWVM */
 }
 
 }
 
-cputime(k, v)
+void
+cputime(k, ve)
        KINFO *k;
        KINFO *k;
-       VAR *v;
+       VARENT *ve;
 {
        extern int sumrusage;
 {
        extern int sumrusage;
+       VAR *v;
        long secs;
        long psecs;     /* "parts" of a second. first micro, then centi */
        char obuff[128];
 
        long secs;
        long psecs;     /* "parts" of a second. first micro, then centi */
        char obuff[128];
 
-       if (k->ki_p->p_stat == SZOMB || k->ki_u == NULL) {
+       v = ve->var;
+       if (KI_PROC(k)->p_stat == SZOMB || !k->ki_u.u_valid) {
                secs = 0;
                psecs = 0;
        } else {
                secs = 0;
                psecs = 0;
        } else {
-               secs = k->ki_p->p_utime.tv_sec +
-                       k->ki_p->p_stime.tv_sec;
-               psecs = k->ki_p->p_utime.tv_usec +
-                       k->ki_p->p_stime.tv_usec;
+               /*
+                * 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 = KI_PROC(k)->p_rtime.tv_sec;
+               psecs = KI_PROC(k)->p_rtime.tv_usec;
                if (sumrusage) {
                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;
+                       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;
                }
                /*
                 * round and scale to 100's
                }
                /*
                 * round and scale to 100's
@@ -327,8 +469,9 @@ cputime(k, v)
                secs += psecs / 100;
                psecs = psecs % 100;
        }
                secs += psecs / 100;
                psecs = psecs % 100;
        }
-       (void) sprintf(obuff, "%3ld:%02ld.%02ld", secs/60, secs%60, psecs);
-       (void) printf("%*s", v->width, obuff);
+       (void)snprintf(obuff, sizeof(obuff),
+           "%3ld:%02ld.%02ld", secs/60, secs%60, psecs);
+       (void)printf("%*s", v->width, obuff);
 }
 
 double
 }
 
 double
@@ -345,30 +488,34 @@ getpcpu(k)
        if (failure)
                return (0.0);
 
        if (failure)
                return (0.0);
 
-       p = k->ki_p;
+       p = KI_PROC(k);
 #define        fxtofl(fixpt)   ((double)(fixpt) / fscale)
 
        /* XXX - I don't like this */
 #define        fxtofl(fixpt)   ((double)(fixpt) / fscale)
 
        /* XXX - I don't like this */
-       if (p->p_time == 0 || (p->p_flag & SLOAD) == 0)
+       if (p->p_swtime == 0 || (p->p_flag & SLOAD) == 0)
                return (0.0);
        if (rawcpu)
                return (100.0 * fxtofl(p->p_pctcpu));
        return (100.0 * fxtofl(p->p_pctcpu) /
                return (0.0);
        if (rawcpu)
                return (100.0 * fxtofl(p->p_pctcpu));
        return (100.0 * fxtofl(p->p_pctcpu) /
-               (1.0 - exp(p->p_time * log(fxtofl(ccpu)))));
+               (1.0 - exp(p->p_swtime * log(fxtofl(ccpu)))));
 }
 
 }
 
-pcpu(k, v)
+void
+pcpu(k, ve)
        KINFO *k;
        KINFO *k;
-       VAR *v;
+       VARENT *ve;
 {
 {
-       (void) printf("%*.1f", v->width, getpcpu(k));
+       VAR *v;
+
+       v = ve->var;
+       (void)printf("%*.1f", v->width, getpcpu(k));
 }
 
 double
 getpmem(k)
        KINFO *k;
 {
 }
 
 double
 getpmem(k)
        KINFO *k;
 {
-       extern int ecmx, nlistread;
+       extern int mempages, nlistread;
        static int failure;
        struct proc *p;
        struct eproc *e;
        static int failure;
        struct proc *p;
        struct eproc *e;
@@ -380,100 +527,155 @@ getpmem(k)
        if (failure)
                return (0.0);
 
        if (failure)
                return (0.0);
 
-       p = k->ki_p;
-       e = k->ki_e;
+       p = KI_PROC(k);
+       e = KI_EPROC(k);
        if ((p->p_flag & SLOAD) == 0)
                return (0.0);
        if ((p->p_flag & SLOAD) == 0)
                return (0.0);
+#ifndef NEWVM
        szptudot = UPAGES + clrnd(ctopt(p->p_dsize + p->p_ssize + e->e_xsize));
        szptudot = UPAGES + clrnd(ctopt(p->p_dsize + p->p_ssize + e->e_xsize));
-       fracmem = ((float)p->p_rssize + szptudot)/CLSIZE/ecmx;
+       fracmem = ((float)p->p_rssize + szptudot)/CLSIZE/mempages;
        if (p->p_textp && e->e_xccount)
        if (p->p_textp && e->e_xccount)
-               fracmem += ((float)e->e_xrssize)/CLSIZE/e->e_xccount/ecmx;
+               fracmem += ((float)e->e_xrssize)/CLSIZE/e->e_xccount/mempages;
+#else /* NEWVM */
+       /* XXX want pmap ptpages, segtab, etc. (per architecture) */
+       szptudot = UPAGES;
+       /* XXX don't have info about shared */
+       fracmem = ((float)e->e_vm.vm_rssize + szptudot)/CLSIZE/mempages;
+#endif /* NEWVM */
        return (100.0 * fracmem);
 }
 
        return (100.0 * fracmem);
 }
 
-pmem(k, v)
+void
+pmem(k, ve)
        KINFO *k;
        KINFO *k;
-       VAR *v;
+       VARENT *ve;
 {
 {
-       (void) printf("%*.1f", v->width, getpmem(k));
+       VAR *v;
+
+       v = ve->var;
+       (void)printf("%*.1f", v->width, getpmem(k));
 }
 
 }
 
-pagein(k, v)
+void
+pagein(k, ve)
        KINFO *k;
        KINFO *k;
-       VAR *v;
+       VARENT *ve;
 {
 {
-       (void) printf("%*d", v->width, k->ki_u ? k->ki_u->u_ru.ru_majflt : 0);
+       VAR *v;
+
+       v = ve->var;
+       (void)printf("%*d", v->width, 
+           k->ki_u.u_valid ? k->ki_u.u_ru.ru_majflt : 0);
 }
 
 }
 
-maxrss(k, v)
+void
+maxrss(k, ve)
        KINFO *k;
        KINFO *k;
-       VAR *v;
+       VARENT *ve;
 {
 {
-       if (k->ki_p->p_maxrss != (RLIM_INFINITY/NBPG))
-               (void) printf("%*d", v->width, pgtok(k->ki_p->p_maxrss));
+       VAR *v;
+
+       v = ve->var;
+#ifndef NEWVM  /* not yet */
+       if (KI_PROC(k)->p_maxrss != (RLIM_INFINITY/NBPG))
+               (void)printf("%*d", v->width, pgtok(KI_PROC(k)->p_maxrss));
        else
        else
-               (void) printf("%*s", v->width, "-");
+#endif /* NEWVM */
+               (void)printf("%*s", v->width, "-");
 }
 
 }
 
-tsize(k, v)
+void
+tsize(k, ve)
        KINFO *k;
        KINFO *k;
-       VAR *v;
+       VARENT *ve;
 {
 {
-       (void) printf("%*d", v->width, pgtok(k->ki_e->e_xsize));
+       VAR *v;
+
+       v = ve->var;
+#ifndef NEWVM
+       (void)printf("%*d", v->width, pgtok(KI_EPROC(k)->e_xsize));
+#else /* NEWVM */
+       (void)printf("%*d", v->width, pgtok(KI_EPROC(k)->e_vm.vm_tsize));
+#endif /* NEWVM */
 }
 
 }
 
-trss(k, v)
+#ifndef NEWVM
+void
+trss(k, ve)
        KINFO *k;
        KINFO *k;
-       VAR *v;
+       VARENT *ve;
 {
 {
-       (void) printf("%*d", v->width, pgtok(k->ki_e->e_xrssize));
+       VAR *v;
+
+       v = ve->var;
+       (void)printf("%*d", v->width, pgtok(KI_EPROC(k)->e_xrssize));
 }
 }
+#endif /* NEWVM */
 
 /*
  * Generic output routines.  Print fields from various prototype
  * structures.
  */
 
 /*
  * Generic output routines.  Print fields from various prototype
  * structures.
  */
-pvar(k, v)
+void
+pvar(k, ve)
        KINFO *k;
        KINFO *k;
-       VAR *v;
+       VARENT *ve;
 {
 {
-       printval((char *)((char *)k->ki_p + v->off), v);
+       VAR *v;
+
+       v = ve->var;
+       printval((char *)((char *)KI_PROC(k) + v->off), v);
 }
 
 }
 
-evar(k, v)
+void
+evar(k, ve)
        KINFO *k;
        KINFO *k;
-       VAR *v;
+       VARENT *ve;
 {
 {
-       printval((char *)((char *)k->ki_e + v->off), v);
+       VAR *v;
+
+       v = ve->var;
+       printval((char *)((char *)KI_EPROC(k) + v->off), v);
 }
 
 }
 
-uvar(k, v)
+void
+uvar(k, ve)
        KINFO *k;
        KINFO *k;
-       VAR *v;
+       VARENT *ve;
 {
 {
-       if (k->ki_u)
-               printval((char *)((char *)k->ki_u + v->off), v);
+       VAR *v;
+
+       v = ve->var;
+       if (k->ki_u.u_valid)
+               printval((char *)((char *)&k->ki_u + v->off), v);
        else
        else
-               (void) printf("%*s", v->width, "-");
+               (void)printf("%*s", v->width, "-");
 }
 
 }
 
-rvar(k, v)
+void
+rvar(k, ve)
        KINFO *k;
        KINFO *k;
-       VAR *v;
+       VARENT *ve;
 {
 {
-       if (k->ki_u)
-               printval((char *)((char *)(&k->ki_u->u_ru) + v->off), v);
+       VAR *v;
+
+       v = ve->var;
+       if (k->ki_u.u_valid)
+               printval((char *)((char *)(&k->ki_u.u_ru) + v->off), v);
        else
        else
-               (void) printf("%*s", v->width, "-");
+               (void)printf("%*s", v->width, "-");
 }
 
 }
 
+static void
 printval(bp, v)
        char *bp;
        VAR *v;
 {
        static char ofmt[32] = "%";
 printval(bp, v)
        char *bp;
        VAR *v;
 {
        static char ofmt[32] = "%";
-       register char *cp = ofmt+1, *fcp = v->fmt;
+       register char *fcp, *cp;
 
 
+       cp = ofmt + 1;
+       fcp = v->fmt;
        if (v->flag & LJUST)
                *cp++ = '-';
        *cp++ = '*';
        if (v->flag & LJUST)
                *cp++ = '-';
        *cp++ = '*';
@@ -481,27 +683,27 @@ printval(bp, v)
 
        switch (v->type) {
        case CHAR:
 
        switch (v->type) {
        case CHAR:
-               (void) printf(ofmt, v->width, *(char *)bp);
+               (void)printf(ofmt, v->width, *(char *)bp);
                break;
        case UCHAR:
                break;
        case UCHAR:
-               (void) printf(ofmt, v->width, *(u_char *)bp);
+               (void)printf(ofmt, v->width, *(u_char *)bp);
                break;
        case SHORT:
                break;
        case SHORT:
-               (void) printf(ofmt, v->width, *(short *)bp);
+               (void)printf(ofmt, v->width, *(short *)bp);
                break;
        case USHORT:
                break;
        case USHORT:
-               (void) printf(ofmt, v->width, *(u_short *)bp);
+               (void)printf(ofmt, v->width, *(u_short *)bp);
                break;
        case LONG:
                break;
        case LONG:
-               (void) printf(ofmt, v->width, *(long *)bp);
+               (void)printf(ofmt, v->width, *(long *)bp);
                break;
        case ULONG:
                break;
        case ULONG:
-               (void) printf(ofmt, v->width, *(u_long *)bp);
+               (void)printf(ofmt, v->width, *(u_long *)bp);
                break;
        case KPTR:
                break;
        case KPTR:
-               (void) printf(ofmt, v->width, *(u_long *)bp &~ KERNBASE);
+               (void)printf(ofmt, v->width, *(u_long *)bp &~ KERNBASE);
                break;
        default:
                break;
        default:
-               error("unknown type %d", v->type);
+               errx(1, "unknown type %d", v->type);
        }
 }
        }
 }
Continuous source code history from original PDP-7 UNIX to FreeBSD 2, the first fully unencumbered FreeBSD release.