BSD 4 release
[unix-history] / usr / src / cmd / ps.c
index ac451c3..53b2e2c 100644 (file)
+static char *sccsid = "@(#)ps.c        4.7 (Berkeley) 10/20/80";
 /*
 /*
- *     ps - process status
- *     This is the augmented UCB ps for UCB/VM Unix (9/79)
- *     examine and print certain things about processes
- *     usage: ps [acgklrt#uvwx] [corefile] [swapfile] [system]
+ * ps; VAX 4BSD version
  */
 
 #include <stdio.h>
  */
 
 #include <stdio.h>
-#include <a.out.h>
+#include <ctype.h>
+#include <nlist.h>
 #include <pwd.h>
 #include <sys/param.h>
 #include <pwd.h>
 #include <sys/param.h>
-#include <sys/proc.h>
 #include <sys/tty.h>
 #include <sys/dir.h>
 #include <sys/user.h>
 #include <sys/tty.h>
 #include <sys/dir.h>
 #include <sys/user.h>
+#include <sys/proc.h>
 #include <sys/pte.h>
 #include <sys/vm.h>
 #include <sys/text.h>
 #include <sys/pte.h>
 #include <sys/vm.h>
 #include <sys/text.h>
-#include <psout.h>
+#include <sys/stat.h>
+#include <math.h>
 
 struct nlist nl[] = {
        { "_proc" },
 #define        X_PROC          0
 
 struct nlist nl[] = {
        { "_proc" },
 #define        X_PROC          0
-       { "_swapdev" },
-#define        X_SWAPDEV       1
-       { "_swplo" },
-#define        X_SWPLO         2
-       { "_Usrptma" },
-#define        X_USRPTMA       3
+       { "_Usrptmap" },
+#define        X_USRPTMA       1
        { "_usrpt" },
        { "_usrpt" },
-#define        X_USRPT         4
+#define        X_USRPT         2
        { "_text" },
        { "_text" },
-#define        X_TEXT          5
+#define        X_TEXT          3
        { "_nswap" },
        { "_nswap" },
-#define        X_NSWAP         6
+#define        X_NSWAP         4
+       { "_maxslp" },
+#define        X_MAXSLP        5
+       { "_ccpu" },
+#define        X_CCPU          6
+       { "_ecmx" },
+#define        X_ECMX          7
        { 0 },
 };
 
        { 0 },
 };
 
-struct proc mproc;
-struct text text[NTEXT];
+struct savcom {
+       union {
+               struct  lsav *lp;
+               float   u_pctcpu;
+               struct  vsav *vp;
+               int     s_ssiz;
+       } sun;
+       struct  asav *ap;
+} savcom[NPROC];
+
+struct asav {
+       char    *a_cmdp;
+       int     a_flag;
+       short   a_stat, a_uid, a_pid, a_nice, a_pri, a_slptime, a_time;
+       size_t  a_size, a_rss, a_tsiz, a_txtrss;
+       short   a_xccount;
+       char    a_tty[DIRSIZ+1];
+       dev_t   a_ttyd;
+       time_t  a_cpu;
+};
+
+char   *lhdr;
+struct lsav {
+       short   l_ppid;
+       char    l_cpu;
+       int     l_addr;
+       caddr_t l_wchan;
+};
+
+char   *uhdr;
+char   *shdr;
 
 
-#define INTPPG         (NBPG/sizeof(int))              /* ints per page */
+char   *vhdr;
+struct vsav {
+       u_int   v_majflt;
+       size_t  v_swrss, v_txtswrss;
+       float   v_pctcpu;
+};
+
+struct proc proc[8];           /* 8 = a few, for less syscalls */
+struct proc *mproc;
+struct text *text;
+
+int    paduser1;               /* avoid hardware mem clobbering botch */
 union {
 union {
-       struct user yy;
-       int xx[INTPPG][UPAGES];
-      } zz;
+       struct  user user;
+       char    upages[UPAGES][NBPG];
+} user;
+#define u      user.user
+int    paduser2;               /* avoid hardware mem clobbering botch */
+
 #define clear(x)       ((int)x & 0x7fffffff)
 #define clear(x)       ((int)x & 0x7fffffff)
-#define u zz.yy
-int    chkpid = 0;
-int    aflg;   /* -a: all processes, not just mine */
-int    cflg;   /* -c: complete listing of args, not just comm. */
-int    gflg;   /* -g: complete listing including group headers, etc */
-int    kflg;   /* -k: read from core file instead of real memory */
-int    lflg;   /* -l: long listing form */
-int    rflg;   /* -r: raw output in style <psout.h> */
-int    sflg;   /* -s: stack depth */
-int    uflg;   /* -u: user name */
-int     vflg;  /* -v: virtual memory statistics */
-int    wflg;   /* -w[w]: wide terminal */
-int    xflg;   /* -x: ALL processes, even those without ttys */
-int    login;  /* -: this is a login shell */
+
+int    chkpid;
+int    aflg, cflg, eflg, gflg, kflg, lflg, sflg, uflg, vflg, xflg;
 char   *tptr;
 char   *tptr;
-char   *gettty();
+char   *gettty(), *getcmd(), *getname(), *savestr(), *alloc(), *state();
+double pcpu(), pmem();
 int    pscomp();
 int    pscomp();
-struct pte pagetbl[NPTEPG];
-int    kmem;
-int    mem;
-int    swap;
-daddr_t        swplo;
-int    nswap;
-int    Usrptma;
-int    usrpt;
-
-int    ndev;
-struct devl {
-       char    dname[DIRSIZ];
-       dev_t   dev;
-} devl[256];
-
-struct psout outargs[NPROC];   /* info for first npr processes */
-int npr;       /* number of processes found so far */
-int argwidth;  /* number of chars of args to print */
-
-char   *coref;
+int    nswap, maxslp;
+double ccpu;
+int    ecmx;
+struct pte *Usrptma, *usrpt;
+
+struct ttys {
+       char    name[DIRSIZ+1];
+       dev_t   ttyd;
+       struct  ttys *next;
+       struct  ttys *cand;
+} *allttys, *cand[16];
+
+struct savcom savcom[NPROC];
+int    npr;
+
+int    cmdstart;
+int    twidth;
+char   *kmemf, *memf, *swapf, *nlistf;
+int    kmem, mem, swap;
+int    rawcpu, sumcpu;
+
+int    pcbpf;
+int    argaddr;
+extern char _sobuf[];
 
 main(argc, argv)
 
 main(argc, argv)
-char **argv;
+       char **argv;
 {
 {
-       int i;
-       char *ap;
-       int uid, puid;
-       char obuf[BUFSIZ];
-       register struct nlist *nlp;
+       register int i, j;
+       register char *ap;
+       int uid;
+       off_t procp;
 
 
-       setbuf(stdout, obuf);
+       if (chdir("/dev") < 0) {
+               perror("/dev");
+               exit(1);
+       }
+       twidth = 80;
+       setbuf(stdout, _sobuf);
        argc--, argv++;
        argc--, argv++;
-       if (argc>0) {
+       if (argc > 0) {
                ap = argv[0];
                while (*ap) switch (*ap++) {
                ap = argv[0];
                while (*ap) switch (*ap++) {
-               case '-':
-                       break;
 
 
+               case 'C':
+                       rawcpu++;
+                       break;
+               case 'S':
+                       sumcpu++;
+                       break;
                case 'a':
                        aflg++;
                        break;
                case 'a':
                        aflg++;
                        break;
-
                case 'c':
                case 'c':
-                       cflg++;
+                       cflg = !cflg;
+                       break;
+               case 'e':
+                       eflg++;
                        break;
                        break;
-
                case 'g':
                        gflg++;
                        break;
                case 'g':
                        gflg++;
                        break;
-
                case 'k':
                        kflg++;
                        break;
                case 'k':
                        kflg++;
                        break;
-
                case 'l':
                        lflg++;
                        break;
                case 'l':
                        lflg++;
                        break;
-
-               case 'r':
-                       rflg++;
-                       break;
-
                case 's':
                        sflg++;
                        break;
                case 's':
                        sflg++;
                        break;
-
                case 't':
                case 't':
-                       if(*ap)
+                       if (*ap)
                                tptr = ap;
                        aflg++;
                        gflg++;
                                tptr = ap;
                        aflg++;
                        gflg++;
@@ -138,480 +178,758 @@ char **argv;
                        while (*ap)
                                ap++;
                        break;
                        while (*ap)
                                ap++;
                        break;
-
                case 'u':
                        uflg++;
                        break;
                case 'u':
                        uflg++;
                        break;
-
                case 'v':
                case 'v':
+                       cflg = 1;
                        vflg++;
                        break;
                        vflg++;
                        break;
-
                case 'w':
                case 'w':
-                       wflg++;
+                       if (twidth == 80)
+                               twidth = 132;
+                       else
+                               twidth = BUFSIZ;
                        break;
                        break;
-
                case 'x':
                        xflg++;
                        break;
                case 'x':
                        xflg++;
                        break;
-
                default:
                default:
-                       chkpid=atoi(--ap);
-                       *ap = '\0';
+                       if (!isdigit(ap[-1]))
+                               break;
+                       chkpid = atoi(--ap);
+                       *ap = 0;
                        aflg++;
                        xflg++;
                        break;
                }
        }
                        aflg++;
                        xflg++;
                        break;
                }
        }
-       coref = "/dev/kmem";
-       if(kflg)
-               coref = argc > 1 ? argv[1] : "/vmcore";
-
-       if ((kmem = open(coref, 0)) < 0) {
-               perror(coref);
-               done(1);
+       openfiles(argc, argv);
+       getkvars(argc, argv);
+       getdev();
+       uid = getuid();
+       printhdr();
+       procp = nl[X_PROC].n_value;
+       for (i=0; i<NPROC; i += 8) {
+               lseek(kmem, (char *)procp, 0);
+               j = NPROC - i;
+               if (j > 8)
+                       j = 8;
+               j *= sizeof (struct proc);
+               if (read(kmem, (char *)proc, j) != j)
+                       cantread("proc table", kmemf);
+               procp += j;
+               for (j = j / sizeof (struct proc) - 1; j >= 0; j--) {
+                       mproc = &proc[j];
+                       if (mproc->p_stat == 0 ||
+                           mproc->p_pgrp == 0 && xflg == 0)
+                               continue;
+                       if (tptr == 0 && gflg == 0 && xflg == 0 &&
+                           mproc->p_ppid == 1 && (mproc->p_flag&SDETACH) == 0)
+                               continue;
+                       if (uid != mproc->p_uid && aflg==0 ||
+                           chkpid != 0 && chkpid != mproc->p_pid)
+                               continue;
+                       if (vflg && gflg == 0 && xflg == 0) {
+                               if (mproc->p_stat == SZOMB ||
+                                   mproc->p_flag&SWEXIT)
+                                       continue;
+                               if (mproc->p_slptime > MAXSLP &&
+                                   (mproc->p_stat == SSLEEP ||
+                                    mproc->p_stat == SSTOP))
+                               continue;
+                       }
+                       save();
+               }
        }
        }
-       if ((mem = open("/dev/mem", 0)) < 0) {
-               fprintf(stderr, "No mem\n");
-               done(1);
+       qsort(savcom, npr, sizeof(savcom[0]), pscomp);
+       for (i=0; i<npr; i++) {
+               register struct savcom *sp = &savcom[i];
+               if (lflg)
+                       lpr(sp);
+               else if (vflg)
+                       vpr(sp);
+               else if (uflg)
+                       upr(sp);
+               else
+                       spr(sp);
+               if (sp->ap->a_flag & SWEXIT)
+                       printf(" <exiting>");
+               else if (sp->ap->a_stat == SZOMB)
+                       printf(" <defunct>");
+               else if (sp->ap->a_pid == 0)
+                       printf(" swapper");
+               else if (sp->ap->a_pid == 2)
+                       printf(" pagedaemon");
+               else
+                       printf(" %.*s", twidth - cmdstart - 2, sp->ap->a_cmdp);
+               printf("\n");
        }
        }
-       if (kflg) 
-               mem = kmem;
+       exit(npr == 0);
+}
 
 
-       if ((swap = open(argc>2 ? argv[2]: "/dev/drum", 0)) < 0) {
-               fprintf(stderr, "Can't open /dev/drum\n");
-               done(1);
-       }
+openfiles(argc, argv)
+       char **argv;
+{
 
 
-       nlist(argc>3 ? argv[3] : "/vmunix", nl);
-       if (nl[0].n_type==0) {
-               fprintf(stderr, "No namelist\n");
-               done(1);
+       kmemf = "kmem";
+       if (kflg)
+               kmemf = argc > 1 ? argv[1] : "/vmcore";
+       kmem = open(kmemf, 0);
+       if (kmem < 0) {
+               perror(kmemf);
+               exit(1);
        }
        }
+       if (kflg)  {
+               mem = kmem;
+               memf = kmemf;
+       } else {
+               memf = "mem";
+               mem = open(memf, 0);
+               if (mem < 0) {
+                       perror(memf);
+                       exit(1);
+               }
+       }
+       swapf = argc>2 ? argv[2]: "drum";
+       swap = open(swapf, 0);
+       if (swap < 0) {
+               perror(swapf);
+               exit(1);
+       }
+}
+
+getkvars(argc, argv)
+       char **argv;
+{
+       register struct nlist *nlp;
 
 
-       if(chdir("/dev") < 0) {
-               fprintf(stderr, "Can't change to /dev\n");
-               done(1);
+       nlistf = argc > 3 ? argv[3] : "/vmunix";
+       nlist(nlistf, nl);
+       if (nl[0].n_type == 0) {
+               fprintf(stderr, "%s: No namelist\n", nlistf);
+               exit(1);
        }
        if (kflg)
        }
        if (kflg)
-               for (nlp= nl; nlp < &nl[sizeof (nl)/sizeof (nl[0])]; nlp++)
-                       nlp->n_value &= 0x7ffffffff;
-       Usrptma = nl[X_USRPTMA].n_value;
-       usrpt = nl[X_USRPT].n_value;
-       /*
-        * read kmem to find swap dev.
-        */
-       lseek(kmem, (long)nl[X_SWAPDEV].n_value, 0);
-       read(kmem, &nl[X_SWAPDEV].n_value, sizeof(nl[X_SWAPDEV].n_value));
-       /*
-        * Find base and size of swap
-        */
-       lseek(kmem, (long)nl[X_SWPLO].n_value, 0);
-       read(kmem, &swplo, sizeof(swplo));
+               for (nlp = nl; nlp < &nl[sizeof (nl)/sizeof (nl[0])]; nlp++)
+                       nlp->n_value = clear(nlp->n_value);
+       Usrptma = (struct pte *)nl[X_USRPTMA].n_value;
+       usrpt = (struct pte *)nl[X_USRPT].n_value;
        lseek(kmem, (long)nl[X_NSWAP].n_value, 0);
        lseek(kmem, (long)nl[X_NSWAP].n_value, 0);
-       read(kmem, &nswap, sizeof (nswap));
-       /*
-        * If v flag get text table
-        */
-       if (vflg) {
-               lseek(kmem, (long)nl[X_TEXT].n_value, 0);
-               read(kmem, text, sizeof (text));
+       if (read(kmem, &nswap, sizeof (nswap)) != sizeof (nswap)) {
+               cantread("nswap", kmemf);
+               exit(1);
        }
        }
-       if (kflg)
-               swplo = 0;
-       getdev();
-       uid = getuid();
-       if (sflg + lflg + vflg + uflg > 1) {
-               printf("Cannot combine s, l, v, and/or u.\n");
+       lseek(kmem, (long)nl[X_MAXSLP].n_value, 0);
+       if (read(kmem, &maxslp, sizeof (maxslp)) != sizeof (maxslp)) {
+               cantread("maxslp", kmemf);
                exit(1);
        }
                exit(1);
        }
-       /* different psout widths depending on how much printed & w flag */
-       if (wflg <= 1) {
-               argwidth = 63;
-               if (wflg) argwidth += 52;       /* 132 col term */
-               if (lflg) argwidth -= 49;       /* extra junk printed */
-               if (vflg) argwidth -= 48;       /* extra junk for -v */
-               if (sflg) argwidth -= 4;        /* 4 cols of stack size */
-               if (uflg) argwidth -= 27;       /* user name */
-       } else  argwidth = 127;
-       if (rflg)
-               ;       /* No heading for raw output */
-       else if (lflg)
-               printf("   F S UID   PID  PPID CPU PRI NICE ADDR  SZ  RSS WCHAN TTY TIME COMMAND\n");
-       else if (vflg)
-               printf("F    PID TT  TIME TIM SL MINFLT MAJFLT SIZE RSS SRS TSIZ TRS PF COMMAND\n");
-       else if (uflg)
-               printf("USER       PID %%CPU NICE  SZ  RSS TTY TIME COMMAND\n");
-       else if (chkpid==0) {
-               if (sflg)
-                       printf(" SSIZ");
-               printf("   PID TTY TIME COMMAND\n");
+       lseek(kmem, (long)nl[X_CCPU].n_value, 0);
+       if (read(kmem, &ccpu, sizeof (ccpu)) != sizeof (ccpu)) {
+               cantread("ccpu", kmemf);
+               exit(1);
        }
        }
-       fflush(stdout);
-       for (i=0; i<NPROC; i++) {
-               lseek(kmem, (long)(nl[X_PROC].n_value+i*(sizeof mproc)), 0);
-               read(kmem, &mproc, sizeof mproc);
-               /* skip processes that don't exist */
-               if (mproc.p_stat==0)
-                       continue;
-               /* skip those without a tty unless -x */
-               if (mproc.p_pgrp==0 && xflg==0)
-                       continue;
-               /* skip group leaders on a tty unless -g, -x, or -t.. */
-               if (!gflg && !xflg && !tptr && mproc.p_pid == mproc.p_pgrp)
-                       continue;
-               /* -g also skips those where **argv is "-" - see savcom */
-               puid = mproc.p_uid;
-               /* skip other peoples processes unless -a or a specific pid */
-               if ((uid != puid && aflg==0) ||
-                   (chkpid!=0 && chkpid!=mproc.p_pid))
-                       continue;
-               if (savcom(puid))
-                       npr++;
-       }
-       fixup(npr);
-       for (i=0; i<npr; i++)
-               if (prcom(&outargs[i])) {
-                       putchar('\n');
-                       fflush(stdout);
+       lseek(kmem, (long)nl[X_ECMX].n_value, 0);
+       if (read(kmem, &ecmx, sizeof (ecmx)) != sizeof (ecmx)) {
+               cantread("ecmx", kmemf);
+               exit(1);
+       }
+       if (uflg || vflg) {
+               text = (struct text *)alloc(NTEXT * sizeof (struct text));
+               if (text == 0) {
+                       fprintf(stderr, "no room for text table\n");
+                       exit(1);
+               }
+               lseek(kmem, (long)nl[X_TEXT].n_value, 0);
+               if (read(kmem, (char *)text, NTEXT * sizeof (struct text))
+                   != NTEXT * sizeof (struct text)) {
+                       cantread("text table", kmemf);
+                       exit(1);
                }
                }
-       done(!npr);
+       }
+}
+
+printhdr()
+{
+       char *hdr;
+
+       if (sflg+lflg+vflg+uflg > 1) {
+               fprintf(stderr, "ps: specify only one of s,l,v and u\n");
+               exit(1);
+       }
+       hdr = lflg ? lhdr : (vflg ? vhdr : (uflg ? uhdr : shdr));
+       if (lflg+vflg+uflg+sflg == 0)
+               hdr += strlen("SSIZ ");
+       cmdstart = strlen(hdr);
+       printf("%s COMMAND\n", hdr);
+       fflush(stdout);
 }
 
 }
 
+cantread(what, fromwhat)
+       char *what, *fromwhat;
+{
+
+       fprintf(stderr, "ps: error reading %s from %s", what, fromwhat);
+}
+
+struct direct dbuf;
+int    dialbase;
+
 getdev()
 {
 getdev()
 {
-#include <sys/stat.h>
        register FILE *df;
        register FILE *df;
-       struct stat sbuf;
-       struct direct dbuf;
+       register struct ttys *dp;
 
 
-       if ((df = fopen("/dev", "r")) == NULL) {
-               fprintf(stderr, "Can't open /dev\n");
-               done(1);
+       dialbase = -1;
+       if ((df = fopen(".", "r")) == NULL) {
+               fprintf(stderr, "Can't open . in /dev\n");
+               exit(1);
        }
        }
-       ndev = 0;
-       while (fread(&dbuf, sizeof(dbuf), 1, df) == 1) {
-               if(dbuf.d_ino == 0)
+       while (fread((char *)&dbuf, sizeof(dbuf), 1, df) == 1) {
+               if (dbuf.d_ino == 0)
                        continue;
                        continue;
-               if(stat(dbuf.d_name, &sbuf) < 0)
-                       continue;
-               if ((sbuf.st_mode&S_IFMT) != S_IFCHR)
-                       continue;
-               strcpy(devl[ndev].dname, dbuf.d_name);
-               devl[ndev].dev = sbuf.st_rdev;
-               ndev++;
+               maybetty(dp);
        }
        fclose(df);
 }
 
        }
        fclose(df);
 }
 
-savcom(puid)
+/*
+ * Attempt to avoid stats by guessing minor device
+ * numbers from tty names.  Console is known,
+ * know that r(hp|up|mt) are unlikely as are different mem's,
+ * floppy, null, tty, etc.
+ */
+maybetty()
 {
 {
-       int abuf[INTPPG];
-       long addr;
-       register int *ip;
-       register struct psout *a;
-       register char *cp, *cp1;
-       long tm;
-       int cc, nbad;
-       int szpt, p0br;
-       register char *tp;
-       struct dblock db;
-       struct pte apte;
+       register char *cp = dbuf.d_name;
+       register struct ttys *dp;
+       int x;
+       struct stat stb;
 
 
-       /* skip long sleeping or dead processes if -v unless -g or -x */
-       if (!gflg && vflg && !xflg) {
-               switch (mproc.p_stat) {
+       switch (cp[0]) {
+
+       case 'c':
+               if (!strcmp(cp, "console")) {
+                       x = 0;
+                       goto donecand;
+               }
+               /* cu[la]? are possible!?! don't rule them out */
+               break;
 
 
-               case SSLEEP:
-               case SSTOP:
-                       if (mproc.p_slptime > MAXSLP)
+       case 'd':
+               if (!strcmp(cp, "drum"))
+                       return (0);
+               break;
+
+       case 'f':
+               if (!strcmp(cp, "floppy"))
+                       return (0);
+               break;
+
+       case 'k':
+               cp++;
+               if (*cp == 'U')
+                       cp++;
+               goto trymem;
+
+       case 'r':
+               cp++;
+               if (*cp == 'r' || *cp == 'u' || *cp == 'h')
+                       cp++;
+#define is(a,b) cp[0] == 'a' && cp[1] == 'b'
+               if (is(r,p) || is(u,p) || is(r,k) || is(r,m) || is(m,t)) {
+                       cp += 2;
+                       if (isdigit(*cp) && cp[2] == 0)
                                return (0);
                                return (0);
-                       break;
+               }
+               break;
 
 
-               case SRUN:
-               case SIDL:
-                       break;
+       case 'm':
+trymem:
+               if (cp[0] == 'm' && cp[1] == 'e' && cp[2] == 'm' && cp[3] == 0)
+                       return (0);
+               break;
+
+       case 'n':
+               if (!strcmp(cp, "null"))
+                       return (0);
+               break;
 
 
-               case SZOMB:
+       case 'v':
+               if ((cp[1] == 'a' || cp[1] == 'p') && isdigit(cp[2]) &&
+                   cp[3] == 0)
                        return (0);
                        return (0);
+               break;
+       }
+mightbe:
+       cp = dbuf.d_name;
+       while (cp < &dbuf.d_name[DIRSIZ] && *cp)
+               cp++;
+       --cp;
+       x = 0;
+       if (cp[-1] == 'd') {
+               if (dialbase == -1) {
+                       if (stat("ttyd0", &stb) == 0)
+                               dialbase = stb.st_rdev & 017;
+                       else
+                               dialbase = -2;
                }
                }
+               if (dialbase == -2)
+                       x = 0;
+               else
+                       x = 11;
        }
        }
-       /* read in the user structure */
-       if ((mproc.p_flag& SLOAD ) == 0) {
-               /* not loaded - get from swap */
-               addr = (mproc.p_swaddr+swplo)<<9;
-               lseek(swap, addr, 0);
-               if (read(swap, &u, sizeof(u)) != sizeof(u))
-                       return(0);
-       } else {
-               /* loaded, get each page from memory separately */
-               for(cc=0; cc<UPAGES; cc++) {    /* get u area */
-                       int upage = ctob(mproc.p_addr[cc]);
-                       lseek(mem,upage,0);
-                       if (read(mem,((int *)&u)+INTPPG*cc,NBPG) != NBPG)       
-                               return(0);
+       if (cp > dbuf.d_name && isdigit(cp[-1]) && isdigit(*cp))
+               x += 10 * (cp[-1] - ' ') + cp[0] - '0';
+       else if (*cp >= 'a' && *cp <= 'f')
+               x += 10 + *cp - 'a';
+       else if (isdigit(*cp))
+               x += *cp - '0';
+       else
+               x = -1;
+donecand:
+       dp = (struct ttys *)alloc(sizeof (struct ttys));
+       strncpy(dp->name, dbuf.d_name, DIRSIZ);
+       dp->next = allttys;
+       dp->ttyd = -1;
+       allttys = dp;
+       if (x == -1)
+               return;
+       x &= 017;
+       dp->cand = cand[x];
+       cand[x] = dp;
+}
+
+char *
+gettty()
+{
+       register char *p;
+       register struct ttys *dp;
+       struct stat stb;
+       int x;
+
+       if (u.u_ttyp == 0)
+               return("?");
+       x = u.u_ttyd & 017;
+       for (dp = cand[x]; dp; dp = dp->cand) {
+               if (dp->ttyd == -1) {
+                       if (stat(dp->name, &stb) == 0 &&
+                          (stb.st_mode&S_IFMT)==S_IFCHR)
+                               dp->ttyd = stb.st_rdev;
+                       else
+                               dp->ttyd = -2;
                }
                }
+               if (dp->ttyd == u.u_ttyd)
+                       goto found;
        }
        }
-       tp = gettty();
-       if (tptr && strcmpn(tptr, tp, 2))
-               return(0);
-       a = &outargs[npr];
-       /* saving com starts here */
-       a->o_uid = puid;
-       a->o_pid = mproc.p_pid;
-       a->o_flag = mproc.p_flag;
-       a->o_ppid = mproc.p_ppid;
-       a->o_cpu  = mproc.p_cpu;
-       a->o_pctcpu = 0.0;      /* This needs to be fixed later */
-       a->o_pri  = mproc.p_pri;
-       a->o_nice = mproc.p_nice;
-       a->o_addr0 = mproc.p_addr[0];
-       a->o_dsize = mproc.p_dsize;
-       a->o_ssize = mproc.p_ssize;
-       a->o_rssize = mproc.p_rssize;
-       a->o_swrss = mproc.p_swrss;
-       a->o_wchan = mproc.p_wchan;
-       a->o_pgrp = mproc.p_pgrp;
-       a->o_tty[0] = tp[0];
-       a->o_tty[1] = tp[1] ? tp[1] : ' ';
-       a->o_ttyd = u.u_ttyd;
-       a->o_stat = mproc.p_stat;
-       a->o_flag = mproc.p_flag;
-       if (a->o_stat==SZOMB) return(1);
-       a->o_utime = u.u_utime;
-       a->o_stime = u.u_stime;
-       a->o_cutime = u.u_cutime;
-       a->o_cstime = u.u_cstime;
-       a->o_sigs = u.u_signal[SIGINT] + u.u_signal[SIGQUIT];
-       a->o_time = mproc.p_time;
-       a->o_slptime = mproc.p_slptime;
-       a->o_uname[0] = 0;
-       if (sflg) {
-               for (cp = (char *)u.u_stack; cp < (char *)&u + ctob(UPAGES); cp++)
-                       if (*cp)
-                               break;
-               a->o_stksize = (int) ((char *)&u + ctob(UPAGES) - cp);
-       }
-       if (mproc.p_stat==SZOMB) return(1);
-       if (vflg) {
-               register struct text *xp;
-
-               if (mproc.p_textp) {
-                       xp = &text[mproc.p_textp - (struct text *)nl[5].n_value];
-                       a->o_xsize = xp->x_size;
-                       a->o_xrssize = xp->x_rssize;
-               } else {
-                       a->o_xsize = 0;
-                       a->o_xrssize = 0;
+       /* ick */
+       for (dp = allttys; dp; dp = dp->next) {
+               if (dp->ttyd == -1) {
+                       if (stat(dp->name, &stb) == 0)
+                               dp->ttyd = stb.st_rdev;
+                       else
+                               dp->ttyd = -2;
                }
                }
-               a->o_aveflt = mproc.p_aveflt;
-               a->o_minorflt = u.u_minorflt;
-               a->o_majorflt = u.u_majorflt;
+               if (dp->ttyd == u.u_ttyd)
+                       goto found;
        }
        }
-       strcpy(a->o_comm, u.u_comm);
-       if (cflg)
-               return (1);
-       a->o_args[0] = 0;       /* in case of early return */
-       if ((mproc.p_flag & SLOAD) == 0) {
-               vstodb(0, 1, &u.u_smap, &db, 1);
-               addr = ctob(swplo + db.db_base);
-               lseek(swap, addr, 0);
-               if (read(swap, abuf, sizeof(abuf)) != sizeof(abuf))
-                       goto garbage;
+       return ("?");
+found:
+       p = dp->name;
+       if (p[0]=='t' && p[1]=='t' && p[2]=='y')
+               p += 3;
+       return (p);
+}
+
+save()
+{
+       register struct savcom *sp;
+       register struct asav *ap;
+       register char *cp;
+       register struct text *xp;
+       char *ttyp, *cmdp;
+
+       if (mproc->p_stat != SZOMB && getu() == 0)
+               return;
+       ttyp = gettty();
+       if (xflg == 0 && ttyp[0] == '?' || tptr && strcmpn(tptr, ttyp, 2))
+               return;
+       sp = &savcom[npr];
+       cmdp = getcmd();
+       if (cmdp == 0)
+               return;
+       sp->ap = ap = (struct asav *)alloc(sizeof (struct asav));
+       sp->ap->a_cmdp = cmdp;
+#define e(a,b) ap->a = mproc->b
+       e(a_flag, p_flag); e(a_stat, p_stat); e(a_nice, p_nice);
+       e(a_uid, p_uid); e(a_pid, p_pid); e(a_pri, p_pri);
+       e(a_slptime, p_slptime); e(a_time, p_time);
+       ap->a_tty[0] = ttyp[0];
+       ap->a_tty[1] = ttyp[1] ? ttyp[1] : ' ';
+       if (ap->a_stat == SZOMB) {
+               register struct xproc *xp = (struct xproc *)mproc;
+
+               ap->a_cpu = xp->xp_vm.vm_utime + xp->xp_vm.vm_stime;
        } else {
        } else {
-               szpt = u.u_pcb.pcb_szpt;
-               p0br = kflg ? clear((int)mproc.p_p0br) : (int)mproc.p_p0br;
-               cc = Usrptma + (p0br + NBPG*(szpt-1) - usrpt)/NPTEPG;
-               lseek(kmem, cc, 0);
-               if (read(kmem, &apte, sizeof(apte)) != sizeof(apte))
-                       goto garbage;
-               lseek(mem, ctob(apte.pg_pfnum), 0);
-               if (read(mem,pagetbl,sizeof(pagetbl)) != sizeof(pagetbl))   
-                       goto garbage;
-               if (pagetbl[NPTEPG-1].pg_fod == 0 && pagetbl[NPTEPG-1].pg_pfnum) {
-                       lseek(mem,ctob((pagetbl[NPTEPG-1].pg_pfnum)),0);
-                       if (read(mem,abuf,sizeof(abuf)) != sizeof(abuf))
-                               goto garbage;
-               } else {
-                       vstodb(0, 1, &u.u_smap, &db, 1);
-                       addr = ctob(swplo + db.db_base);
-                       lseek(swap, addr, 0);
-                       if (read(swap, abuf, sizeof(abuf)) != sizeof(abuf))
-                               goto garbage;
+               ap->a_size = mproc->p_dsize + mproc->p_ssize;
+               e(a_rss, p_rssize); 
+               ap->a_ttyd = u.u_ttyd;
+               ap->a_cpu = u.u_vm.vm_utime + u.u_vm.vm_stime;
+               if (sumcpu)
+                       ap->a_cpu += u.u_cvm.vm_utime + u.u_cvm.vm_stime;
+               if (mproc->p_textp && text) {
+                       xp = &text[mproc->p_textp -
+                                   (struct text *)nl[X_TEXT].n_value];
+                       ap->a_tsiz = xp->x_size;
+                       ap->a_txtrss = xp->x_rssize;
+                       ap->a_xccount = xp->x_ccount;
                }
        }
                }
        }
-       abuf[INTPPG] = 0;
-       for (ip = &abuf[INTPPG-2]; ip > abuf;) {
-               if (*--ip == -1 || *ip == 0) {
-                       cp = (char *)(ip+1);
-                       if (*cp==0)
-                               cp++;
-                       nbad = 0;
-                       for (cp1 = cp; cp1 < (char *)&abuf[INTPPG]; cp1++) {
-                               cc = *cp1&0177;
-                               if (cc==0)
-                                       *cp1 = ' ';
-                               else if (cc < ' ' || cc > 0176) {
-                                       if (++nbad >= 5) {
-                                               *cp1++ = ' ';
-                                               break;
-                                       }
-                                       *cp1 = '?';
-                               } else if (cc=='=') {
-                                       *cp1 = 0;
-                                       while (cp1>cp && *--cp1!=' ')
-                                               *cp1 = 0;
+#undef e
+       ap->a_cpu /= HZ;
+       if (lflg) {
+               register struct lsav *lp;
+
+               sp->sun.lp = lp = (struct lsav *)alloc(sizeof (struct lsav));
+#define e(a,b) lp->a = mproc->b
+               e(l_ppid, p_ppid); e(l_cpu, p_cpu);
+               if (ap->a_stat != SZOMB)
+                       e(l_wchan, p_wchan);
+#undef e
+               lp->l_addr = pcbpf;
+       } else if (vflg) {
+               register struct vsav *vp;
+
+               sp->sun.vp = vp = (struct vsav *)alloc(sizeof (struct vsav));
+#define e(a,b) vp->a = mproc->b
+               if (ap->a_stat != SZOMB) {
+                       e(v_swrss, p_swrss);
+                       vp->v_majflt = u.u_vm.vm_majflt;
+                       if (mproc->p_textp)
+                               vp->v_txtswrss = xp->x_swrss;
+               }
+               vp->v_pctcpu = pcpu();
+#undef e
+       } else if (uflg)
+               sp->sun.u_pctcpu = pcpu();
+       else if (sflg) {
+               if (ap->a_stat != SZOMB) {
+                       for (cp = (char *)u.u_stack;
+                           cp < &user.upages[UPAGES][NBPG]; )
+                               if (*cp++)
                                        break;
                                        break;
-                               }
-                       }
-                       while (*--cp1==' ')
-                               *cp1 = 0;
-                       strcpy(a->o_args, cp);
-garbage:
-                       cp = a->o_args;
-                       if (cp[0]=='-'&&cp[1]<=' ' || cp[0]=='?' || cp[0]<=' ') {
-                               strcat(cp, " (");
-                               strcat(cp, u.u_comm);
-                               strcat(cp, ")");
-                       }
-                       cp[127] = 0;    /* max room in psout is 128 chars */
-                       if (xflg || gflg || tptr || cp[0]!='-')
-                               return(1);
-                       return(0);
+                       sp->sun.s_ssiz = (&user.upages[UPAGES][NBPG] - cp);
                }
        }
                }
        }
-       goto garbage;
+       npr++;
 }
 
 }
 
-prcom(a)
-       register struct psout *a;
+double
+pmem(ap)
+       register struct asav *ap;
 {
 {
-       long tm;
+       double fracmem;
+       int szptudot;
 
 
-       if (rflg) {
-               write(1, a, sizeof (*a));
-               return(0);
+       if ((ap->a_flag&SLOAD) == 0)
+               fracmem = 0.0;
+       else {
+               szptudot = UPAGES + clrnd(ctopt(ap->a_size+ap->a_tsiz));
+               fracmem = ((float)ap->a_rss+szptudot)/CLSIZE/ecmx;
+               if (ap->a_xccount)
+                       fracmem += ((float)ap->a_txtrss)/CLSIZE/
+                           ap->a_xccount/ecmx;
        }
        }
-       if (lflg) {
-               printf("%4x %c", 0xffff & a->o_flag,
-                       "0SWRIZT"[a->o_stat]);
-               printf("%4d", a->o_uid);
-       } else if (vflg) {
-               switch (a->o_stat) {
-
-               case SSLEEP:
-               case SSTOP:
-                       if ((a->o_flag & SLOAD) == 0)
-                               printf("W");
-                       else if (a->o_pri >= PZERO)
-                               printf("S");
-                       else if (a->o_flag & SPAGE)
-                               printf("P");
-                       else
-                               printf("D");
-                       break;
+       return (100.0 * fracmem);
+}
 
 
-               case SRUN:
-               case SIDL:
-                       if (a->o_flag & SLOAD)
-                               printf("R");
-                       else
-                               printf("W");
-                       break;
+double
+pcpu()
+{
+       time_t time;
+
+       time = mproc->p_time;
+       if (time == 0 || (mproc->p_flag&SLOAD) == 0)
+               return (0.0);
+       if (rawcpu)
+               return (100.0 * mproc->p_pctcpu);
+       return (100.0 * mproc->p_pctcpu / (1.0 - exp(time * log(ccpu))));
+}
+
+getu()
+{
+       struct pte *pteaddr, apte;
+       int pad1;       /* avoid hardware botch */
+       struct pte arguutl[UPAGES+CLSIZE];
+       int pad2;       /* avoid hardware botch */
+       register int i;
+       int ncl, size;
+
+       size = sflg ? ctob(UPAGES) : sizeof (struct user);
+       if ((mproc->p_flag & SLOAD) == 0) {
+               lseek(swap, ctob(mproc->p_swaddr), 0);
+               if (read(swap, (char *)&user.user, size) != size) {
+                       fprintf(stderr, "ps: cant read u for pid %d from %s\n",
+                           mproc->p_pid, swapf);
+                       return (0);
                }
                }
-               if (a->o_nice > NZERO)
-                       printf("N");
-               else
-                       printf(" ");
-       } else if (uflg) {
-               printf("%-8.8s", a->o_uname);
-       }
-       if (sflg) {
-               printf("%5d", a->o_stksize);
-       }
-       printf("%6u", a->o_pid);
-       if (lflg)
-               printf("%6u%4d%4d%4d%6x", a->o_ppid, a->o_cpu&0377,
-                       a->o_pri, a->o_nice, a->o_addr0);
-       else if (uflg)
-               printf("%5.1f%4d ", a->o_pctcpu, a->o_nice);
-       if (lflg || uflg)
-               printf("%4d%5d", a->o_dsize+a->o_ssize, a->o_rssize);
-       if (lflg)
-               if (a->o_wchan)
-                       printf("%6x", clear(a->o_wchan));
-               else
-                       printf("      ");
-       printf(" %-2.2s", a->o_tty);
-       if (a->o_stat==SZOMB) {
-               printf("  <defunct>");
-               return(1);
-       }
-       tm = (a->o_utime + a->o_stime + 30)/60;
-       printf("%3ld:", tm/60);
-       tm %= 60;
-       printf(tm<10?"0%ld":"%ld", tm);
-       if (vflg) {
-/*
-               tm = (a->o_stime + 30) / 60;
-               printf(" %2ld:", tm/60);
-               tm %= 60;
-               printf(tm<10?"0%ld":"%ld", tm);
-*/
-               printf("%4d%3d", a->o_time, a->o_slptime);
-       }
-#ifdef notdef
-       if (0 && lflg==0) {     /* 0 == old tflg (print long times) */
-               tm = (a->o_cstime + 30)/60;
-               printf(" %2ld:", tm/60);
-               tm %= 60;
-               printf(tm<10?"0%ld":"%ld", tm);
-               tm = (a->o_cutime + 30)/60;
-               printf(" %2ld:", tm/60);
-               tm %= 60;
-               printf(tm<10?"0%ld":"%ld", tm);
-       }
-#endif
-       if (vflg) {
-               printf("%7d%7d",a->o_minorflt,a->o_majorflt);
-               printf("%5d%4d%4d", a->o_dsize+a->o_ssize, a->o_rssize, a->o_swrss);
-               printf("%5d%4d", a->o_xsize, a->o_xrssize);
-               printf("%3d", a->o_aveflt);
+               pcbpf = 0;
+               argaddr = 0;
+               return (1);
        }
        }
-       if (a->o_pid == 0) {
-               printf(" swapper");
-               return(1);
+       pteaddr = &Usrptma[btokmx(mproc->p_p0br) + mproc->p_szpt - 1];
+       lseek(kmem, kflg ? clear(pteaddr) : (int)pteaddr, 0);
+       if (read(kmem, (char *)&apte, sizeof(apte)) != sizeof(apte)) {
+               printf("ps: cant read indir pte to get u for pid %d from %s\n",
+                   mproc->p_pid, swapf);
+               return (0);
        }
        }
-       if (a->o_pid == 2) {
-               printf(" pagedaemon");
-               return(1);
+       lseek(mem,
+           ctob(apte.pg_pfnum+1) - (UPAGES+CLSIZE) * sizeof (struct pte), 0);
+       if (read(mem, (char *)arguutl, sizeof(arguutl)) != sizeof(arguutl)) {
+               printf("ps: cant read page table for u of pid %d from %s\n",
+                   mproc->p_pid, swapf);
+               return (0);
        }
        }
-       if (cflg) {
-               printf(" %s", a->o_comm);
-               return(1);
+       if (arguutl[0].pg_fod == 0 && arguutl[0].pg_pfnum)
+               argaddr = ctob(arguutl[0].pg_pfnum);
+       else
+               argaddr = 0;
+       pcbpf = arguutl[CLSIZE].pg_pfnum;
+       ncl = (size + NBPG*CLSIZE - 1) / (NBPG*CLSIZE);
+       while (--ncl >= 0) {
+               i = ncl * CLSIZE;
+               lseek(mem, ctob(arguutl[CLSIZE+i].pg_pfnum), 0);
+               if (read(mem, user.upages[i], CLSIZE*NBPG) != CLSIZE*NBPG) {
+                       printf("ps: cant read page %d of u of pid %d from %s\n",
+                           arguutl[CLSIZE+i].pg_pfnum, mproc->p_pid, memf);
+                       return(0);
+               }
        }
        }
-       a -> o_args[argwidth] = 0;      /* force it to quit early */
-       printf(" %s", a->o_args);
        return (1);
 }
 
 char *
        return (1);
 }
 
 char *
-gettty()
+getcmd()
 {
 {
-       register i;
-       register char *p;
+       char cmdbuf[BUFSIZ];
+       int pad1;               /* avoid hardware botch */
+       union {
+               char    argc[CLSIZE*NBPG];
+               int     argi[CLSIZE*NBPG/sizeof (int)];
+       } argspac;
+       int pad2;               /* avoid hardware botch */
+       register char *cp;
+       register int *ip;
+       char c;
+       int nbad;
+       struct dblock db;
 
 
-       if (u.u_ttyp==0)
-               return("?");
-       for (i=0; i<ndev; i++) {
-               if (devl[i].dev == u.u_ttyd) {
-                       p = devl[i].dname;
-                       if (p[0]=='t' && p[1]=='t' && p[2]=='y')
-                               p += 3;
-                       return(p);
+       if (mproc->p_stat == SZOMB || mproc->p_flag&(SSYS|SWEXIT))
+               return ("");
+       if (cflg) {
+               strncpy(cmdbuf, u.u_comm, sizeof (u.u_comm));
+               return (savestr(cmdbuf));
+       }
+       if ((mproc->p_flag & SLOAD) == 0 || argaddr == 0) {
+               vstodb(0, CLSIZE, &u.u_smap, &db, 1);
+               lseek(swap, ctob(db.db_base), 0);
+               if (read(swap, (char *)&argspac, sizeof(argspac))
+                   != sizeof(argspac))
+                       goto bad;
+       } else {
+               lseek(mem, argaddr, 0);
+               if (read(mem, (char *)&argspac, sizeof (argspac))
+                   != sizeof (argspac))
+                       goto bad;
+       }
+       ip = &argspac.argi[CLSIZE*NBPG/sizeof (int)];
+       ip -= 2;                /* last arg word and .long 0 */
+       while (*--ip)
+               if (ip == argspac.argi)
+                       goto retucomm;
+       *(char *)ip = ' ';
+       ip++;
+       nbad = 0;
+       for (cp = (char *)ip; cp < &argspac.argc[CLSIZE*NBPG]; cp++) {
+               c = *cp & 0177;
+               if (c == 0)
+                       *cp = ' ';
+               else if (c < ' ' || c > 0176) {
+                       if (++nbad >= 5*(eflg+1)) {
+                               *cp++ = ' ';
+                               break;
+                       }
+                       *cp = '?';
+               } else if (eflg == 0 && c == '=') {
+                       while (*--cp != ' ')
+                               if (cp <= (char *)ip)
+                                       break;
+                       break;
                }
        }
                }
        }
-       return("?");
+       *cp = 0;
+       while (*--cp == ' ')
+               *cp = 0;
+       cp = (char *)ip;
+       strncpy(cmdbuf, cp, &argspac.argc[CLSIZE*NBPG] - cp);
+       if (cp[0] == '-' || cp[0] == '?' || cp[0] <= ' ') {
+               strcat(cmdbuf, " (");
+               strncat(cmdbuf, u.u_comm, sizeof(u.u_comm));
+               strcat(cmdbuf, ")");
+       }
+/*
+       if (xflg == 0 && gflg == 0 && tptr == 0 && cp[0] == '-')
+               return (0);
+*/
+       return (savestr(cmdbuf));
+
+bad:
+       fprintf(stderr, "ps: error locating command name for pid %d\n",
+           mproc->p_pid);
+retucomm:
+       strcpy(cmdbuf, " (");
+       strncat(cmdbuf, u.u_comm, sizeof (u.u_comm));
+       strcat(cmdbuf, ")");
+       return (savestr(cmdbuf));
+}
+
+char   *lhdr =
+"     F UID   PID  PPID CP PRI NI ADDR  SZ  RSS WCHAN STAT TT  TIME";
+lpr(sp)
+       struct savcom *sp;
+{
+       register struct asav *ap = sp->ap;
+       register struct lsav *lp = sp->sun.lp;
+
+       printf("%6x%4d%6u%6u%3d%4d%3d%5x%4d%5d",
+           ap->a_flag, ap->a_uid,
+           ap->a_pid, lp->l_ppid, lp->l_cpu&0377, ap->a_pri-PZERO,
+           ap->a_nice-NZERO, lp->l_addr, ap->a_size/2, ap->a_rss/2);
+       printf(lp->l_wchan ? " %5x" : "      ", (int)lp->l_wchan&0xfffff);
+       printf(" %4.4s ", state(ap));
+       ptty(ap->a_tty);
+       ptime(ap);
+}
+
+ptty(tp)
+       char *tp;
+{
+
+       printf("%-2.2s", tp);
+}
+
+ptime(ap)
+       struct asav *ap;
+{
+
+       printf("%3ld:%02ld", ap->a_cpu / HZ, ap->a_cpu % HZ);
+}
+
+char   *uhdr =
+"USER       PID %CPU %MEM   SZ  RSS TT STAT  TIME";
+upr(sp)
+       struct savcom *sp;
+{
+       register struct asav *ap = sp->ap;
+       int vmsize, rmsize;
+
+       vmsize = (ap->a_size + ap->a_tsiz)/2;
+       rmsize = ap->a_rss/2;
+       if (ap->a_xccount)
+               rmsize += ap->a_txtrss/ap->a_xccount/2;
+       printf("%-8.8s %5d%5.1f%5.1f%5d%5d",
+           getname(ap->a_uid), ap->a_pid, sp->sun.u_pctcpu, pmem(ap),
+           vmsize, rmsize);
+       putchar(' ');
+       ptty(ap->a_tty);
+       printf(" %4.4s", state(ap));
+       ptime(ap);
+}
+
+char *vhdr =
+"  PID TT STAT  TIME SL RE PAGEIN SIZE  RSS  SRS TSIZ TRS %CPU %MEM";
+vpr(sp)
+       struct savcom *sp;
+{
+       register struct vsav *vp = sp->sun.vp;
+       register struct asav *ap = sp->ap;
+
+       printf("%5u ", ap->a_pid);
+       ptty(ap->a_tty);
+       printf(" %4.4s", state(ap));
+       ptime(ap);
+       printf("%3d%3d%7d%5d%5d%5d%5d%4d%5.1f%5.1f",
+          ap->a_slptime, ap->a_time > 99 ? 99 : ap->a_time, vp->v_majflt,
+          ap->a_size/2, ap->a_rss/2, vp->v_swrss/2,
+          ap->a_tsiz/2, ap->a_txtrss/2, vp->v_pctcpu, pmem(ap));
+}
+
+char   *shdr =
+"SSIZ   PID TT STAT  TIME";
+spr(sp)
+       struct savcom *sp;
+{
+       register struct asav *ap = sp->ap;
+
+       if (sflg)
+               printf("%4d ", sp->sun.s_ssiz);
+       printf("%5u", ap->a_pid);
+       putchar(' ');
+       ptty(ap->a_tty);
+       printf(" %4.4s", state(ap));
+       ptime(ap);
+}
+
+char *
+state(ap)
+       register struct asav *ap;
+{
+       char stat, load, nice, anom;
+       static char res[5];
+
+       switch (ap->a_stat) {
+
+       case SSTOP:
+               stat = 'T';
+               break;
+
+       case SSLEEP:
+               if (ap->a_pri >= PZERO)
+                       if (ap->a_slptime >= MAXSLP)
+                               stat = 'I';
+                       else
+                               stat = 'S';
+               else if (ap->a_flag & SPAGE)
+                       stat = 'P';
+               else
+                       stat = 'D';
+               break;
+
+       case SWAIT:
+       case SRUN:
+       case SIDL:
+               stat = 'R';
+               break;
+
+       case SZOMB:
+               stat = 'Z';
+               break;
+
+       default:
+               stat = '?';
+       }
+       load = ap->a_flag & SLOAD ? ' ' : 'W';
+       if (ap->a_nice < NZERO)
+               nice = '<';
+       else if (ap->a_nice > NZERO)
+               nice = 'N';
+       else
+               nice = ' ';
+       anom = ap->a_flag & (SANOM|SUANOM) ? 'A' : ' ';
+       res[0] = stat; res[1] = load; res[2] = nice; res[3] = anom;
+       return (res);
 }
 
 /*
 }
 
 /*
@@ -642,6 +960,7 @@ vstodb(vsbase, vssize, dmp, dbp, rev)
        dbp->db_base = *ip + (rev ? blk - (vsbase + dbp->db_size) : vsbase);
 }
 
        dbp->db_base = *ip + (rev ? blk - (vsbase + dbp->db_size) : vsbase);
 }
 
+/*ARGSUSED*/
 panic(cp)
        char *cp;
 {
 panic(cp)
        char *cp;
 {
@@ -657,46 +976,103 @@ min(a, b)
        return (a < b ? a : b);
 }
 
        return (a < b ? a : b);
 }
 
-done(exitno)
+pscomp(s1, s2)
+       struct savcom *s1, *s2;
 {
 {
-       if (login) {
-               printf("Press return when done: ");
-               getchar();
-       }
-       exit(exitno);
+       register int i;
+
+       if (uflg)
+               return (s2->sun.u_pctcpu > s1->sun.u_pctcpu ? 1 : -1);
+       if (vflg)
+               return (vsize(s2) - vsize(s1));
+       i = s1->ap->a_ttyd - s2->ap->a_ttyd;
+       if (i == 0)
+               i = s1->ap->a_pid - s2->ap->a_pid;
+       return (i);
+}
+
+vsize(sp)
+       struct savcom *sp;
+{
+       register struct asav *ap = sp->ap;
+       register struct vsav *vp = sp->sun.vp;
+       
+       if (ap->a_flag & SLOAD)
+               return (ap->a_rss +
+                   ap->a_txtrss / (ap->a_xccount ? ap->a_xccount : 1));
+       return (vp->v_swrss + (ap->a_xccount ? 0 : vp->v_txtswrss));
 }
 
 }
 
+#define        NMAX    8
+#define        NUID    2048
+
+char   names[NUID][NMAX+1];
+
 /*
 /*
- * fixup figures out everybodys name and sorts into a nice order.
+ * Stolen from ls...
  */
  */
-fixup(np) int np; {
-       register int i;
+char *
+getname(uid)
+{
        register struct passwd *pw;
        register struct passwd *pw;
+       static init;
        struct passwd *getpwent();
 
        struct passwd *getpwent();
 
-       if (uflg) {
-               /*
-                * If we want names, traverse the password file. For each
-                * passwd entry, look for it in the processes.
-                * In case of multiple entries in /etc/passwd, we believe
-                * the first one (same thing ls does).
-                */
-               while ((pw=getpwent()) != NULL) {
-                       for (i=0; i<np; i++)
-                               if (outargs[i].o_uid == pw -> pw_uid) {
-                                       if (outargs[i].o_uname[0] == 0)
-                                               strcpy(outargs[i].o_uname, pw -> pw_name);
-                               }
-               }
+       if (uid >= 0 && uid < NUID && names[uid][0])
+               return (&names[uid][0]);
+       if (init == 2)
+               return (0);
+       if (init == 0)
+               setpwent(), init = 1;
+       while (pw = getpwent()) {
+               if (pw->pw_uid >= NUID)
+                       continue;
+               if (names[pw->pw_uid][0])
+                       continue;
+               strncpy(names[pw->pw_uid], pw->pw_name, NMAX);
+               if (pw->pw_uid == uid)
+                       return (&names[uid][0]);
        }
        }
+       init = 2;
+       endpwent();
+       return (0);
+}
 
 
-       qsort(outargs, np, sizeof(outargs[0]), pscomp);
+char   *freebase;
+int    nleft;
+
+char *
+alloc(size)
+       int size;
+{
+       register char *cp;
+       register int i;
+
+       if (size > nleft) {
+               freebase = (char *)sbrk(i = size > 2048 ? size : 2048);
+               if (freebase == 0) {
+                       fprintf(stderr, "ps: ran out of memory\n");
+                       exit(1);
+               }
+               nleft = i - size;
+       } else
+               nleft -= size;
+       cp = freebase;
+       for (i = size; --i >= 0; )
+               *cp++ = 0;
+       freebase = cp;
+       return (cp - size);
 }
 
 }
 
-pscomp(x1, x2) struct psout *x1, *x2; {
-       register int c;
+char *
+savestr(cp)
+       char *cp;
+{
+       register int len;
+       register char *dp;
 
 
-       c = (x1)->o_ttyd - (x2)->o_ttyd;
-       if (c==0) c = (x1)->o_pid - (x2)->o_pid;
-       return(c);
+       len = strlen(cp);
+       dp = (char *)alloc(len+1);
+       strcpy(dp, cp);
+       return (dp);
 }
 }