BSD 4 release

[unix-history] / usr / src / cmd / ps.c

diff --git a/usr/src/cmd/ps.c b/usr/src/cmd/ps.c
index a5e2bb7..53b2e2c 100644 (file)
--- a/usr/src/cmd/ps.c
+++ b/usr/src/cmd/ps.c
@@ -1,400 +1,1078 @@
+static char *sccsid = "@(#)ps.c        4.7 (Berkeley) 10/20/80";

 /*
 /*

- *     ps - process status
- *     examine and print certain things about processes
+ * ps; VAX 4BSD version

  */
 
 #include <stdio.h>
  */
 
 #include <stdio.h>

-#include <a.out.h>
-#include <core.h>
+#include <ctype.h>
+#include <nlist.h>
+#include <pwd.h>

 #include <sys/param.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/stat.h>
+#include <math.h>

 
 struct nlist nl[] = {
        { "_proc" },
 
 struct nlist nl[] = {
        { "_proc" },

-       { "_swapdev" },
-       { "_swplo" },
-       { "" },
+#define        X_PROC          0
+       { "_Usrptmap" },
+#define        X_USRPTMA       1
+       { "_usrpt" },
+#define        X_USRPT         2
+       { "_text" },
+#define        X_TEXT          3
+       { "_nswap" },
+#define        X_NSWAP         4
+       { "_maxslp" },
+#define        X_MAXSLP        5
+       { "_ccpu" },
+#define        X_CCPU          6
+       { "_ecmx" },
+#define        X_ECMX          7
+       { 0 },
+};
+
+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;

 };
 
 };
 

-struct proc mproc;
+char   *uhdr;
+char   *shdr;
+
+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 {
+       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)

 
 

-struct user u;

 int    chkpid;
 int    chkpid;

-int    retcode=1;
-int    lflg;
-int    vflg;
-int    kflg;
-int    xflg;
+int    aflg, cflg, eflg, gflg, kflg, lflg, sflg, uflg, vflg, xflg;

 char   *tptr;
 char   *tptr;

-long   lseek();
-char   *gettty();
-char   *getptr();
-char   *strncmp();
-int    aflg;
-int    mem;
-int    swmem;
-int    swap;
-daddr_t        swplo;
-
-int    ndev;
-struct devl {
-       char    dname[DIRSIZ];
-       dev_t   dev;
-} devl[256];
-
-char   *coref;
+char   *gettty(), *getcmd(), *getname(), *savestr(), *alloc(), *state();
+double pcpu(), pmem();
+int    pscomp();
+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;
+       register int i, j;
+       register char *ap;
+       int uid;
+       off_t procp;

 
 

-       if (argc>1) {
-               ap = argv[1];
+       if (chdir("/dev") < 0) {
+               perror("/dev");
+               exit(1);
+       }
+       twidth = 80;
+       setbuf(stdout, _sobuf);
+       argc--, argv++;
+       if (argc > 0) {
+               ap = argv[0];

                while (*ap) switch (*ap++) {
 
                while (*ap) switch (*ap++) {
 

-               case 'v':
-                       vflg++;
+               case 'C':
+                       rawcpu++;
+                       break;
+               case 'S':
+                       sumcpu++;

                        break;
                        break;

-

                case 'a':
                        aflg++;
                        break;
                case 'a':
                        aflg++;
                        break;

-
+               case 'c':
+                       cflg = !cflg;
+                       break;
+               case 'e':
+                       eflg++;
+                       break;
+               case 'g':
+                       gflg++;
+                       break;
+               case 'k':
+                       kflg++;
+                       break;
+               case 'l':
+                       lflg++;
+                       break;
+               case 's':
+                       sflg++;
+                       break;

                case 't':
                case 't':

-                       if(*ap)
+                       if (*ap)

                                tptr = ap;
                        aflg++;
                                tptr = ap;
                        aflg++;

+                       gflg++;

                        if (*tptr == '?')
                                xflg++;
                        if (*tptr == '?')
                                xflg++;

-                       goto bbreak;
-
-               case 'x':
-                       xflg++;
+                       while (*ap)
+                               ap++;

                        break;
                        break;

-
-               case '-':
+               case 'u':
+                       uflg++;

                        break;
                        break;

-
-               case 'l':
-                       lflg++;
+               case 'v':
+                       cflg = 1;
+                       vflg++;

                        break;
                        break;

-
-               case 'k':
-                       kflg++;
+               case 'w':
+                       if (twidth == 80)
+                               twidth = 132;
+                       else
+                               twidth = BUFSIZ;
+                       break;
+               case 'x':
+                       xflg++;

                        break;
                        break;

-

                default:
                default:

-                       chkpid = atoi(ap-1);
-                       goto bbreak;
+                       if (!isdigit(ap[-1]))
+                               break;
+                       chkpid = atoi(--ap);
+                       *ap = 0;
+                       aflg++;
+                       xflg++;

                        break;
                }
        }
                        break;
                }
        }

+       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();
+               }
+       }
+       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");
+       }
+       exit(npr == 0);
+}

 
 

-bbreak:
-       if(chdir("/dev") < 0) {
-               fprintf(stderr, "Can't change to /dev\n");
+openfiles(argc, argv)
+       char **argv;
+{
+
+       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);
        }
                exit(1);
        }

-       nlist(argc>2? argv[2]:"/unix", nl);
-       if (nl[0].n_type==0) {
-               fprintf(stderr, "No namelist\n");
+}
+
+getkvars(argc, argv)
+       char **argv;
+{
+       register struct nlist *nlp;
+
+       nlistf = argc > 3 ? argv[3] : "/vmunix";
+       nlist(nlistf, nl);
+       if (nl[0].n_type == 0) {
+               fprintf(stderr, "%s: No namelist\n", nlistf);

                exit(1);
        }
                exit(1);
        }

-       coref = "/dev/mem";
-       if(kflg)
-               coref = "/usr/sys/core";
-       if ((mem = open(coref, 0)) < 0) {
-               fprintf(stderr, "No mem\n");
+       if (kflg)
+               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);
+       if (read(kmem, &nswap, sizeof (nswap)) != sizeof (nswap)) {
+               cantread("nswap", kmemf);

                exit(1);
        }
                exit(1);
        }

-       swmem = open(coref, 0);
-       /*
-        * read mem to find swap dev.
-        */
-       lseek(mem, (long)nl[1].n_value, 0);
-       read(mem, (char *)&nl[1].n_value, sizeof(nl[1].n_value));
-       /*
-        * Find base of swap
-        */
-       lseek(mem, (long)nl[2].n_value, 0);
-       read(mem, (char *)&swplo, sizeof(swplo));
-       /*
-        * Locate proc table
-        */
-       lseek(mem, (long)nl[0].n_value, 0);
-       getdev();
-       uid = getuid();
-       if (lflg)
-       printf(" F S UID   PID  PPID CPU PRI NICE  ADDR  SZ  WCHAN TTY TIME CMD\n"); else
-               if (chkpid==0) printf("   PID TTY TIME CMD\n");
-       for (i=0; i<NPROC; i++) {
-               read(mem, (char *)&mproc, sizeof mproc);
-               if (mproc.p_stat==0)
-                       continue;
-               if (mproc.p_pgrp==0 && xflg==0 && mproc.p_uid==0)
-                       continue;
-               puid = mproc.p_uid;
-               if ((uid != puid && aflg==0) ||
-                   (chkpid!=0 && chkpid!=mproc.p_pid))
-                       continue;
-               if(prcom(puid)) {
-                       printf("\n");
-                       retcode=0;
+       lseek(kmem, (long)nl[X_MAXSLP].n_value, 0);
+       if (read(kmem, &maxslp, sizeof (maxslp)) != sizeof (maxslp)) {
+               cantread("maxslp", kmemf);
+               exit(1);
+       }
+       lseek(kmem, (long)nl[X_CCPU].n_value, 0);
+       if (read(kmem, &ccpu, sizeof (ccpu)) != sizeof (ccpu)) {
+               cantread("ccpu", kmemf);
+               exit(1);
+       }
+       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);

                }
        }
                }
        }

-       exit(retcode);

 }
 
 }
 

+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");
+       dialbase = -1;
+       if ((df = fopen(".", "r")) == NULL) {
+               fprintf(stderr, "Can't open . in /dev\n");

                exit(1);
        }
                exit(1);
        }

-       ndev = 0;

        while (fread((char *)&dbuf, sizeof(dbuf), 1, df) == 1) {
        while (fread((char *)&dbuf, sizeof(dbuf), 1, df) == 1) {

-               if(dbuf.d_ino == 0)
+               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);

-       if ((swap = open("/dev/swap", 0)) < 0) {
-               fprintf(stderr, "Can't open /dev/swap\n");
-               exit(1);
+}
+
+/*
+ * 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()
+{
+       register char *cp = dbuf.d_name;
+       register struct ttys *dp;
+       int x;
+       struct stat stb;
+
+       switch (cp[0]) {
+
+       case 'c':
+               if (!strcmp(cp, "console")) {
+                       x = 0;
+                       goto donecand;
+               }
+               /* cu[la]? are possible!?! don't rule them out */
+               break;
+
+       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);
+               }
+               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 'v':
+               if ((cp[1] == 'a' || cp[1] == 'p') && isdigit(cp[2]) &&
+                   cp[3] == 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;
+       }
+       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;

 }
 
 }
 

-long
-round(a, b)
-       long            a, b;
+char *
+gettty()

 {
 {

-       long            w = ((a+b-1)/b)*b;
+       register char *p;
+       register struct ttys *dp;
+       struct stat stb;
+       int x;

 
 

-       return(w);
+       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;
+       }
+       /* 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;
+               }
+               if (dp->ttyd == u.u_ttyd)
+                       goto found;
+       }
+       return ("?");
+found:
+       p = dp->name;
+       if (p[0]=='t' && p[1]=='t' && p[2]=='y')
+               p += 3;
+       return (p);

 }
 
 }
 

-struct map {
-       long    b1, e1; long f1;
-       long    b2, e2; long f2;
-};
-struct map datmap;
-int    file;
-prcom(puid)
+save()

 {
 {

-       char abuf[512];
-       long addr;
-       register int *ip;
-       register char *cp, *cp1;
-       long tm;
-       int c, nbad;
-       register char *tp;
-       long txtsiz, datsiz, stksiz;
-       int septxt;
-       int lw=(lflg?35:80);
-       char **ap;
-
-       if (mproc.p_flag&SLOAD) {
-               addr = ctob((long)mproc.p_addr);
-               file = swmem;
+       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 {

-               addr = (mproc.p_addr+swplo)<<9;
-               file = swap;
-       }
-       lseek(file, addr, 0);
-       if (read(file, (char *)&u, sizeof(u)) != sizeof(u))
-               return(0);
-
-       /* set up address maps for user pcs */
-       txtsiz = ctob(u.u_tsize);
-       datsiz = ctob(u.u_dsize);
-       stksiz = ctob(u.u_ssize);
-       septxt = u.u_sep;
-       datmap.b1 = (septxt ? 0 : round(txtsiz,TXTRNDSIZ));
-       datmap.e1 = datmap.b1+datsiz;
-       datmap.f1 = ctob(USIZE)+addr;
-       datmap.b2 = stackbas(stksiz);
-       datmap.e2 = stacktop(stksiz);
-       datmap.f2 = ctob(USIZE)+(datmap.e1-datmap.b1)+addr;
-
-       tp = gettty();
-       if (tptr && strncmp(tptr, tp, 2))
-               return(0);
-       if (lflg) {
-               printf("%2o %c%4d", mproc.p_flag,
-                       "0SWRIZT"[mproc.p_stat], puid);
+               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;
+               }

        }
        }

-       printf("%6u", mproc.p_pid);
+#undef e
+       ap->a_cpu /= HZ;

        if (lflg) {
        if (lflg) {

-               printf("%6u%4d%4d%5d%6o%4d", mproc.p_ppid, mproc.p_cpu&0377,
-                       mproc.p_pri,
-                       mproc.p_nice,
-                       mproc.p_addr, (mproc.p_size+7)>>3);
-               if (mproc.p_wchan)
-                       printf("%7o", mproc.p_wchan);
-               else
-                       printf("       ");
-       }
-       printf(" %-2.2s", tp);
-       if (mproc.p_stat==SZOMB) {
-               printf("  <defunct>");
-               return(1);
-       }
-       tm = (u.u_utime + u.u_stime + 30)/60;
-       printf(" %2ld:", tm/60);
-       tm %= 60;
-       printf(tm<10?"0%ld":"%ld", tm);
-       if (vflg && lflg==0) {  /* 0 == old tflg (print long times) */
-               tm = (u.u_cstime + 30)/60;
-               printf(" %2ld:", tm/60);
-               tm %= 60;
-               printf(tm<10?"0%ld":"%ld", tm);
-               tm = (u.u_cutime + 30)/60;
-               printf(" %2ld:", tm/60);
-               tm %= 60;
-               printf(tm<10?"0%ld":"%ld", tm);
-       }
-       if (mproc.p_pid == 0) {
-               printf(" swapper");
-               return(1);
-       }
-       addr += ctob((long)mproc.p_size) - 512;
-
-       /* look for sh special */
-       lseek(file, addr+512-sizeof(char **), 0);
-       if (read(file, (char *)&ap, sizeof(char *)) != sizeof(char *))
-               return(1);
-       if (ap) {
-               char b[82];
-               char *bp = b;
-               while((cp=getptr(ap++)) && cp && (bp<b+lw) ) {
-                       nbad = 0;
-                       while((c=getbyte(cp++)) && (bp<b+lw)) {
-                               if (c<' ' || c>'~') {
-                                       if (nbad++>3)
-                                               break;
-                                       continue;
-                               }
-                               *bp++ = c;
-                       }
-                       *bp++ = ' ';
+               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;

                }
                }

-               *bp++ = 0;
-               printf(lflg?" %.30s":" %.60s", b);
-               return(1);
-       }
-
-       lseek(file, addr, 0);
-       if (read(file, abuf, sizeof(abuf)) != sizeof(abuf))
-               return(1);
-       for (ip = (int *)&abuf[512]-2; ip > (int *)abuf; ) {
-               if (*--ip == -1 || *ip==0) {
-                       cp = (char *)(ip+1);
-                       if (*cp==0)
-                               cp++;
-                       nbad = 0;
-                       for (cp1 = cp; cp1 < &abuf[512]; cp1++) {
-                               c = *cp1&0177;
-                               if (c==0)
-                                       *cp1 = ' ';
-                               else if (c < ' ' || c > 0176) {
-                                       if (++nbad >= 5) {
-                                               *cp1++ = ' ';
-                                               break;
-                                       }
-                                       *cp1 = '?';
-                               } else if (c=='=') {
-                                       *cp1 = 0;
-                                       while (cp1>cp && *--cp1!=' ')
-                                               *cp1 = 0;
+               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;
-                       printf(lflg?" %.30s":" %.60s", cp);
-                       return(1);
+                       sp->sun.s_ssiz = (&user.upages[UPAGES][NBPG] - cp);

                }
        }
                }
        }

-       return(1);
+       npr++;
+}
+
+double
+pmem(ap)
+       register struct asav *ap;
+{
+       double fracmem;
+       int szptudot;
+
+       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;
+       }
+       return (100.0 * fracmem);
+}
+
+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);
+               }
+               pcbpf = 0;
+               argaddr = 0;
+               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);
+       }
+       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 (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);
+               }
+       }
+       return (1);

 }
 
 char *
 }
 
 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 *
 }
 
 char *

-getptr(adr)
-char **adr;
+state(ap)
+       register struct asav *ap;

 {
 {

-       char *ptr;
-       register char *p, *pa;
-       register i;
-
-       ptr = 0;
-       pa = (char *)adr;
-       p = (char *)&ptr;
-       for (i=0; i<sizeof(ptr); i++)
-               *p++ = getbyte(pa++);
-       return(ptr);
+       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);

 }
 
 }
 

-getbyte(adr)
-char *adr;
+/*
+ * Given a base/size pair in virtual swap area,
+ * return a physical base/size pair which is the
+ * (largest) initial, physically contiguous block.
+ */
+vstodb(vsbase, vssize, dmp, dbp, rev)
+       register int vsbase;
+       int vssize;
+       struct dmap *dmp;
+       register struct dblock *dbp;

 {
 {

-       register struct map *amap = &datmap;
-       char b;
-       long saddr;
-
-       if(!within(adr, amap->b1, amap->e1)) {
-               if(within(adr, amap->b2, amap->e2)) {
-                       saddr = (unsigned)adr + amap->f2 - amap->b2;
-               } else
-                       return(0);
-       } else
-               saddr = (unsigned)adr + amap->f1 - amap->b1;
-       if(lseek(file, saddr, 0)==-1
-                  || read(file, &b, 1)<1) {
-               return(0);
+       register int blk = DMMIN;
+       register swblk_t *ip = dmp->dm_map;
+
+       if (vsbase < 0 || vsbase + vssize > dmp->dm_size)
+               panic("vstodb");
+       while (vsbase >= blk) {
+               vsbase -= blk;
+               if (blk < DMMAX)
+                       blk *= 2;
+               ip++;

        }
        }

-       return((unsigned)b);
+       if (*ip <= 0 || *ip + blk > nswap)
+               panic("vstodb *ip");
+       dbp->db_size = min(vssize, blk - vsbase);
+       dbp->db_base = *ip + (rev ? blk - (vsbase + dbp->db_size) : vsbase);

 }
 
 }
 

+/*ARGSUSED*/
+panic(cp)
+       char *cp;
+{
+
+#ifdef DEBUG
+       printf("%s\n", cp);
+#endif
+}

 
 

-within(adr,lbd,ubd)
-char *adr;
-long lbd, ubd;
+min(a, b)

 {
 {

-       return((unsigned)adr>=lbd && (unsigned)adr<ubd);
+
+       return (a < b ? a : b);
+}
+
+pscomp(s1, s2)
+       struct savcom *s1, *s2;
+{
+       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];
+
+/*
+ * Stolen from ls...
+ */
+char *
+getname(uid)
+{
+       register struct passwd *pw;
+       static init;
+       struct passwd *getpwent();
+
+       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);
+}
+
+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);
+}
+
+char *
+savestr(cp)
+       char *cp;
+{
+       register int len;
+       register char *dp;
+
+       len = strlen(cp);
+       dp = (char *)alloc(len+1);
+       strcpy(dp, cp);
+       return (dp);

 }
 }