+/*
+ * 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]
+ */
+
+#include <stdio.h>
+#include <a.out.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/pte.h>
+#include <sys/vm.h>
+#include <sys/text.h>
+#include <psout.h>
+
+struct nlist nl[] = {
+ { "_proc" },
+#define X_PROC 0
+ { "_swapdev" },
+#define X_SWAPDEV 1
+ { "_swplo" },
+#define X_SWPLO 2
+ { "_Usrptma" },
+#define X_USRPTMA 3
+ { "_usrpt" },
+#define X_USRPT 4
+ { "_text" },
+#define X_TEXT 5
+ { "_nswap" },
+#define X_NSWAP 6
+ { 0 },
+};
+
+struct proc mproc;
+struct text text[NTEXT];
+
+#define INTPPG (NBPG/sizeof(int)) /* ints per page */
+union {
+ struct user yy;
+ int xx[INTPPG][UPAGES];
+ } zz;
+#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 */
+char *tptr;
+char *gettty();
+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;
+
+main(argc, argv)
+char **argv;
+{
+ int i;
+ char *ap;
+ int uid, puid;
+ char obuf[BUFSIZ];
+ register struct nlist *nlp;
+
+ setbuf(stdout, obuf);
+ argc--, argv++;
+ if (argc>0) {
+ ap = argv[0];
+ while (*ap) switch (*ap++) {
+ case '-':
+ break;
+
+ case 'a':
+ aflg++;
+ break;
+
+ case 'c':
+ cflg++;
+ break;
+
+ case 'g':
+ gflg++;
+ break;
+
+ case 'k':
+ kflg++;
+ break;
+
+ case 'l':
+ lflg++;
+ break;
+
+ case 'r':
+ rflg++;
+ break;
+
+ case 's':
+ sflg++;
+ break;
+
+ case 't':
+ if(*ap)
+ tptr = ap;
+ aflg++;
+ gflg++;
+ if (*tptr == '?')
+ xflg++;
+ while (*ap)
+ ap++;
+ break;
+
+ case 'u':
+ uflg++;
+ break;
+
+ case 'v':
+ vflg++;
+ break;
+
+ case 'w':
+ wflg++;
+ break;
+
+ case 'x':
+ xflg++;
+ break;
+
+ default:
+ chkpid=atoi(--ap);
+ *ap = '\0';
+ aflg++;
+ xflg++;
+ break;
+ }
+ }
+ coref = "/dev/kmem";
+ if(kflg)
+ coref = argc > 1 ? argv[1] : "/vmcore";
+
+ if ((kmem = open(coref, 0)) < 0) {
+ perror(coref);
+ done(1);
+ }
+ if ((mem = open("/dev/mem", 0)) < 0) {
+ fprintf(stderr, "No mem\n");
+ done(1);
+ }
+ if (kflg)
+ mem = kmem;
+
+ if ((swap = open(argc>2 ? argv[2]: "/dev/drum", 0)) < 0) {
+ fprintf(stderr, "Can't open /dev/drum\n");
+ done(1);
+ }
+
+ nlist(argc>3 ? argv[3] : "/vmunix", nl);
+ if (nl[0].n_type==0) {
+ fprintf(stderr, "No namelist\n");
+ done(1);
+ }
+
+ if(chdir("/dev") < 0) {
+ fprintf(stderr, "Can't change to /dev\n");
+ done(1);
+ }
+ 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));
+ 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 (kflg)
+ swplo = 0;
+ getdev();
+ uid = getuid();
+ if (sflg + lflg + vflg + uflg > 1) {
+ printf("Cannot combine s, l, v, and/or u.\n");
+ 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");
+ }
+ 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);
+ }
+ done(!npr);
+}
+
+getdev()
+{
+#include <sys/stat.h>
+ register FILE *df;
+ struct stat sbuf;
+ struct direct dbuf;
+
+ if ((df = fopen("/dev", "r")) == NULL) {
+ fprintf(stderr, "Can't open /dev\n");
+ done(1);
+ }
+ ndev = 0;
+ while (fread(&dbuf, sizeof(dbuf), 1, df) == 1) {
+ if(dbuf.d_ino == 0)
+ 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++;
+ }
+ fclose(df);
+}
+
+savcom(puid)
+{
+ 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;
+
+ /* skip long sleeping or dead processes if -v unless -g or -x */
+ if (!gflg && vflg && !xflg) {
+ switch (mproc.p_stat) {
+
+ case SSLEEP:
+ case SSTOP:
+ if (mproc.p_slptime > MAXSLP)
+ return (0);
+ break;
+
+ case SRUN:
+ case SIDL:
+ break;
+
+ case SZOMB:
+ return (0);
+ }
+ }
+ /* 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);
+ }
+ }
+ 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;
+ }
+ a->o_aveflt = mproc.p_aveflt;
+ a->o_minorflt = u.u_minorflt;
+ a->o_majorflt = u.u_majorflt;
+ }
+ 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;
+ } 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;
+ }
+ }
+ 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;
+ 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);
+ }
+ }
+ goto garbage;
+}
+
+prcom(a)
+ register struct psout *a;
+{
+ long tm;
+
+ if (rflg) {
+ write(1, a, sizeof (*a));
+ return(0);
+ }
+ 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;
+
+ case SRUN:
+ case SIDL:
+ if (a->o_flag & SLOAD)
+ printf("R");
+ else
+ printf("W");
+ break;
+ }
+ 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);
+ }
+ if (a->o_pid == 0) {
+ printf(" swapper");
+ return(1);
+ }
+ if (a->o_pid == 2) {
+ printf(" pagedaemon");
+ return(1);
+ }
+ if (cflg) {
+ printf(" %s", a->o_comm);
+ return(1);
+ }
+ a -> o_args[argwidth] = 0; /* force it to quit early */
+ printf(" %s", a->o_args);
+ return (1);
+}
+
+char *
+gettty()
+{
+ register i;
+ register char *p;
+
+ 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);
+ }
+ }
+ return("?");
+}
+
+/*
+ * 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 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++;
+ }
+ 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);
+}
+
+panic(cp)
+ char *cp;
+{
+
+#ifdef DEBUG
+ printf("%s\n", cp);
+#endif
+}
+
+min(a, b)
+{
+
+ return (a < b ? a : b);
+}
+
+done(exitno)
+{
+ if (login) {
+ printf("Press return when done: ");
+ getchar();
+ }
+ exit(exitno);
+}
+
+/*
+ * fixup figures out everybodys name and sorts into a nice order.
+ */
+fixup(np) int np; {
+ register int i;
+ register struct passwd *pw;
+ 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);
+ }
+ }
+ }
+
+ qsort(outargs, np, sizeof(outargs[0]), pscomp);
+}
+
+pscomp(x1, x2) struct psout *x1, *x2; {
+ register int c;
+
+ c = (x1)->o_ttyd - (x2)->o_ttyd;
+ if (c==0) c = (x1)->o_pid - (x2)->o_pid;
+ return(c);
+}
projects / unix-history / commitdiff