+#
+/*
+ ps - show process status - iiasa version (jek)
+ originally from harvard and/or CULC
+
+ flags are single letters
+ multiple flags can occur in one argument
+ dashes are optional but are needed to delimit lists of things
+ multiple lists are present(???)
+ flags that imply other arguments read the following arguments
+ until the end of the list or until an argument starts with dash
+ certain flags read exactly one argument
+ initialization (i flag) should be done for:
+ new users,
+ new kernel
+ parameters here must change to indicate:
+ new tty devices, max tty lines, tty letter changes
+ max users
+ new things to wait for
+ this program should be changed if:
+ proc structure makes this obsolete
+ etc
+ recompilation should occur if:
+ kernel structures and or paramters (nproc etc.) change
+ any above changes of course
+
+ flags are:
+ a - show all processes that have pgrps except shells
+ b - show background (not detached)
+ c - show child times instead of process times
+ d - show detached processes inherited by init
+ e - show the environment with the args
+ f - show foreground jobs, connected to tty
+ g - show processes in given pgrps
+ h - unused
+ i - perform initialization (implies 'n')
+ j,k - unused
+ l - print long format. includes most good stuff
+ m - specify different memory file (file is next arg)
+ n - show no processes
+ o - unused
+ p - show only processes whose id's are in list (following args)
+ q - unused
+ r - repeat indefinitely (number of r's = seconds or r#)
+ s - show stopped processes
+ t - show only processes associated with ttys in list (following)
+ u - show only processes (or ancestors of) for users in list
+ v - be verbose - show the most information
+ w - wide format, show entire argument list (up to 512 chars)
+ x - show unattached processes - no pgrp. a+x gives shells also
+ y - unused
+ z - show zombies
+ A - show ALL information possible
+ B - show busy processes
+ F - go fast, avoid swap space.
+ G - print pgrp
+ U - use different UNIX file (next arg)
+ S - show size
+ T - show tty information
+ W - print wait channels in hex
+*/
+
+#include <signal.h>
+#include <h/param.h>
+#include <h/dir.h>
+#include <h/user.h>
+#include <h/proc.h>
+#include <h/pte.h>
+#include <h/vm.h>
+#include <h/inode.h>
+#include <h/file.h>
+#include <h/buf.h>
+#include <h/text.h>
+#include <h/tty.h>
+#include <h/conf.h>
+#include <nlist.h>
+#include <sys/stat.h>
+#include <stdio.h>
+#include <pwd.h>
+
+
+#define TRUE 1
+#define FALSE 0
+#define INTPPG (NBPG/sizeof(int))
+#define MAXARGPG 5
+
+#define Usrptmap ((struct pte *)info.kaddr[ausrptmap])
+#define usrpt ((struct pte *)info.kaddr[ausrpt])
+#define cswitch ((struct cdevsw *)info.kaddr[acdevsw])
+struct proc *proc, *kproc;
+struct text *text, *ktext;
+struct buf *buf, *swbuf;
+struct inode *inode;
+int nproc, ntext, hz, nbuf, ninode, nfile, nswbuf;
+union {
+ struct user user;
+ char upages[UPAGES][NBPG];
+} user;
+int pad1; /* supposedly to aviod hardware problem reading /dev/mem */
+struct pte pagetable[UPAGES + MAXARGPG]; /* for users page table */
+int pad2; /* supposedly to aviod hardware problem reading /dev/mem */
+
+#define u user.user
+#define MSPID 2 /* max system pid, not to considered BUSY */
+
+#define MAXUSERS 256 /* total different users */
+#define UNAMELENGTH 8 /* length of a user name */
+#define NSPEC 15 /* number of specified things (proc, user, tty */
+#define MAXTTYS 100
+
+/* definitions to reuse uninteresting proc table entries for linked lists */
+
+struct procinfo { /* structure to use for */
+ char *pi_cmd; /* attaching a time */
+ struct ttyline *pi_tty;
+ long pi_time; /* and an arg string to a proc */
+};
+
+#define p_next p_link /* pointer to next proc in global list */
+#define p_bro p_rlink /* next process with same parent */
+#define p_son p_xlink /* first child of this process */
+#define pinfo(p) (*((struct procinfo **)&p->p_sig))
+#define procsize(p) ((p)->p_tsize + (p)->p_dsize + (p)->p_ssize)
+ /* size of process */
+#define ABS(x) ((int)(x) & ~0x80000000) /* clear top bit - type int */
+#define K 1024
+#define KSHIFT 10
+
+#define msize(x) (x >> (KSHIFT-PGSHIFT))
+
+#define USERPAGE 0 /* flag for pread - read user page */
+#define TOPMEM 1 /* flag for pread - read top of mem */
+
+struct proc *plist;
+int mypid; /* pid of this process */
+
+char Aflag, aflag, Bflag, bflag, cflag, dflag, eflag, fflag, Fflag;
+char Gflag, iflag, lflag, mflag, nflag, rflag, Sflag, sflag, Tflag;
+char Uflag, uflag, vflag, wflag, xflag, nxflag, Wflag, zflag;
+int select; /* flag indicating process selection */
+
+int ntotal, nbusy, nloaded, nswapped;
+int ktotal, kbusy, kloaded, kswapped;
+
+/* specified users, ttys, pids, pgrps */
+union numptr {
+ int nm_int;
+ char *nm_ptr;
+};
+
+union ttyptr {
+ struct ttyline *ty_line;
+ char *ty_ptr;
+};
+
+union numptr pids[NSPEC], *ppids = pids; /* specified process ids */
+union numptr grps[NSPEC], *pgrps = grps; /* specified groups */
+union numptr uids[NSPEC], *puids = uids; /* specified user ids */
+union ttyptr ttys[NSPEC], *pttys = ttys; /* specified ttys */
+
+/* files needed by ps */
+
+char *memf = "/dev/mem"; /* default memory file */
+int mem; /* memory file descriptor */
+char *kmemf = "/dev/kmem"; /* virtual memory file */
+int kmem; /* virtual memory file descriptor */
+char *symf = "/vmunix"; /* default symbol file */
+char *swapf = "/dev/swap"; /* default swap file */
+int swap; /* swap area file descriptor */
+char *infof = "/etc/spsinfo"; /* default info save file */
+int infofd; /* info file descriptor */
+
+/* variables read from the kernel */
+
+struct nlist namelist[] = {
+#define aproc 0
+ {"_proc"},
+#define aswapdev 1
+ {"_swapdev"},
+#define aswplo 2
+ {"_swplo"},
+#define answbuf 3
+ {"_nswbuf"},
+#define atext 4
+ {"_text"},
+#define abuf 5
+ {"_buf"},
+#define abfreeli 6
+ {"_bfreelist"},
+#define akl11 7
+ {"_kl11"},
+#define adh11 8
+ {"_dh11"},
+#define alpdt 9
+ {"_lp_softc"},
+#define albolt 10
+ {"_lbolt"},
+#define atout 11
+ {"_tout"},
+#define arunin 12
+ {"_runin"},
+#define arunout 13
+ {"_runout"},
+#define aipc 14
+ {"_ipc"},
+#define afile 15
+ {"_file"},
+#define ainode 16
+ {"_inode"},
+#define amaplock 17
+ {"_maplock"},
+#define acoremap 18
+ {"_coremap"},
+#define aswapmap 19
+ {"_swapmap"},
+#define au 20
+ {"_u"},
+#define adz11 21
+ {"_dz_tty"},
+#define aetext 22
+ {"_etext"},
+#define ausrptmap 23
+ {"_Usrptmap"},
+#define ausrpt 24
+ {"_usrpt"},
+#define achtbuf 25
+ {"_chtbuf"},
+#define arhtbuf 26
+ {"_rhtbuf"},
+#define ahpbuf 27
+ {"_hpbuf"},
+#define aswbuf 28
+ {"_swbuf"},
+#define arswbuf 29
+ {"_rswbuf"},
+#define acons 30
+ {"_cons"},
+#define ark7 31
+ {"_rrk7buf"},
+#define achrfclist 32
+ {"_Chrfclist"},
+#define anproc 33
+ {"_nproc"},
+#define antext 34
+ {"_ntext"},
+#define anbuf 35
+ {"_nbuf"},
+#define ahz 36
+ {"_hz"},
+#define aninode 37
+ {"_ninode"},
+#define anfile 38
+ {"_nfile"},
+#define answap 39
+ {"_nswap"},
+#define acdevsw 40
+ {"_cdevsw"},
+#define aChconntab 41
+ {"_Chconntab"},
+#define MAXSYMBOLS 42
+ {"", 0, 0},
+};
+
+/* this structure is read from info file or initialized (iflag) */
+
+struct {
+ caddr_t kaddr[MAXSYMBOLS]; /* useful kernel addresses */
+ char unames[MAXUSERS][UNAMELENGTH]; /* user names */
+ struct ttyline {
+ struct tty *l_addr; /* address of ttystruct */
+ unsigned l_pgrp; /* process group */
+ char l_name[2]; /* name */
+ dev_t l_dev; /* device number */
+ } ttyline[MAXTTYS];
+
+} info;
+int swapdev; /* major, minor of swap device */
+int swplo; /* unix swap disk offset */
+int nswap; /* unix swap space size */
+
+struct ttyline notty = {0, 0, {"- "}};
+
+/* flags for once only activities (once per repeat) */
+
+int heading;
+int coreinit, core;
+char *topmem;
+int arglength;
+char *getcore(), *store(), *waitingfor(), *getcmd(), *strcat(), *brk();
+
+main(argc,argv)
+char *argv[];
+{
+ register char *cp, **ap;
+ register int i;
+ int myuid;
+ extern char _sobuf[];
+
+ if ((myuid = getuid()) == 0)
+ nice(-100);
+
+ setbuf(stdout, _sobuf);
+ select = 0;
+ for (ap = &argv[1]; --argc; ap++) {
+ for (cp = *ap; *cp;) {
+ switch (*cp++) {
+ case '-':
+ continue;
+ case 'A': /* EVERYTHING */
+ Aflag++;
+ continue;
+ case 'a': /* all procs attached to ttys */
+ bflag++; /* include background */
+ fflag++; /* include foreground */
+ dflag++; /* include detached */
+ aflag++; /* include shells */
+ select++;
+ continue;
+ case 'b': /* all background processes */
+ bflag++;
+ select++;
+ continue;
+ case 'B': /* all busy processes */
+ Bflag++;
+ select++;
+ lflag++;
+ continue;
+ case 'c':
+ cflag++;
+ lflag++;
+ continue;
+ case 'd': /* detached processes */
+ dflag++;
+ select++;
+ continue;
+ case 'e':
+ eflag++;
+ continue;
+ case 'f': /* foreground only */
+ fflag++;
+ select++;
+ continue;
+ case 'F': /* go fast, don't touch swap */
+ Fflag++;
+ continue;
+ case 'G': /* print pgrp */
+ Gflag++;
+ continue;
+ case 'g': /* specify process gourp */
+ select++;
+ while (argc > 1) {
+ if (**++ap == '-') {
+ ap--;
+ break;
+ }
+ --argc;
+ if (pgrps >= &grps[NSPEC])
+ prexit("%a: too many groups\n");
+ (pgrps++)->nm_int = atoi(*ap);
+ }
+ if (pgrps == grps)
+ (pgrps++)->nm_int = getpgrp();
+ continue;
+ case 'i': /* initialize info file */
+ if (myuid != 0) /* must be super user */
+ goto def;
+ iflag++;
+ nflag++;
+ Uflag++;
+ continue;
+ case 'l': /* long output */
+ lflag++;
+ continue;
+ case 'm': /* use designated memory file */
+ if (myuid != 0) /* must be super user */
+ goto def;
+ if (argc-- < 2 || **++ap == '-')
+ prexit("%a: missing memory file\n");
+ memf = *ap;
+ mflag++;
+ continue;
+ case 'n':
+ select++;
+ nflag++;
+ continue;
+ case 'p': /* only designated processes */
+ select++;
+ while (argc > 1) {
+ if (**++ap == '-') {
+ ap--;
+ break;
+ }
+ --argc;
+ if (ppids >= &pids[NSPEC])
+ prexit("%a: too many pids\n");
+ (ppids++)->nm_int = atoi(*ap);
+ }
+ continue;
+ case 'r': /* repeat every <number> seconds */
+ if (myuid != 0)
+ goto def;
+ rflag++;
+ for (i = 0; *cp >= '0' && *cp <= '9'; cp++)
+ i = i * 10 + *cp - '0';
+ if (i)
+ rflag = i;
+ continue;
+ case 'U': /* use designated symbol file */
+ if (myuid != 0)
+ goto def;
+ if (argc-- < 2 || **++ap == '-')
+ prexit("%a: missing symbol file\n");
+ symf = *ap;
+ Uflag++;
+ continue;
+ case 's':
+ sflag++;
+ select++;
+ continue;
+ case 'S':
+ Sflag++;
+ continue;
+ case 'T':
+ Tflag++;
+ continue;
+ case 't': /* on designated tty(s) */
+ select++;
+ while (argc > 1) {
+ if (**++ap == '-') {
+ ap--;
+ break;
+ }
+ --argc;
+ if (pttys >= &ttys[NSPEC])
+ prexit("%a: too many ttys\n");
+ (pttys++)->ty_ptr = *ap;
+ }
+ if (pttys == ttys) {
+ char *ttyname();
+
+ if ( (pttys->ty_ptr = ttyname(2)) == 0)
+ prexit("%a: unknown tty\n");
+ else if (strcmp("/dev/console", pttys->ty_ptr) == 0)
+ (pttys++)->ty_ptr = "co";
+ else
+ (pttys++)->ty_ptr +=
+ sizeof("/dev/tty") - 1;
+ }
+ continue;
+ case 'u': /* specific user name */
+ aflag++;
+ select++;
+ puids = &uids[0];
+ while (argc > 1) {
+ if (**++ap == '-') {
+ ap--;
+ break;
+ }
+ --argc;
+ if (puids >= &uids[NSPEC])
+ prexit("%a: too many users\n");
+ (puids++)->nm_ptr = *ap;
+ }
+ if (puids == &uids[0])
+ (puids++)->nm_int = myuid;
+ continue;
+ case 'v': /* most verbose output */
+ vflag++;
+ lflag++;
+ continue;
+ case 'W':
+ Wflag++;
+ continue;
+ case 'w': /* wide form (all arguments) */
+ wflag++;
+ continue;
+ case 'x': /* include un-owned procs */
+ xflag++;
+ select++;
+ continue;
+ case 'z': /* include only zombies */
+ zflag++;
+ select++;
+ continue;
+ def:
+ default:
+ prexit("%a: unknown switch: %c\n", *--cp);
+ }
+ break;
+ }
+ }
+
+/* these lengths are kludgely tuned to make things not exceed 79 columns */
+ arglength = 60;
+ if (lflag)
+ arglength -= 28;
+ if (vflag)
+ arglength -= 14;
+ if ((mem = open(memf, 0)) < 0)
+ prexit("%a: cannot read system memory: %s\n", memf);
+ if ((kmem = open(kmemf, 0)) < 0)
+ prexit("%a: cannot read system virtural memory: %s\n", kmemf);
+ if (!Fflag && (swap = open(swapf, 0)) <0)
+ prexit("%a: cannot read swap device: %s\n", swapf);
+
+ if (!iflag)
+ if ((i = open(infof, 0)) < 0)
+ prexit("%a: cannot open info file\n");
+ else if (read(i, &info, sizeof info) != sizeof info)
+ prexit("%a: cannot read info file\n");
+ else
+ close(i);
+ if (Uflag) {
+ struct nlist *np;
+ if ((i = open(symf, 0)) < 0)
+ prexit("%a: can't read symbol file\n");
+ close(i);
+ nlist(symf, namelist);
+ for (np = namelist; np < &namelist[MAXSYMBOLS]; np++)
+ if (np->n_value == 0)
+ fprintf(stderr, "%a: can't find symbol: %s\n",
+ np->n_name);
+ if (namelist[0].n_value == -1)
+ prexit("%a: cannot read symbol file: %s\n", symf);
+ for (i = 0; i < MAXSYMBOLS; i++)
+ info.kaddr[i] = (caddr_t)namelist[i].n_value;
+ info.kaddr[aetext] = (caddr_t)( ((unsigned)info.kaddr[aetext] + 63) & ~63);
+ }
+ if (iflag) {
+ readusers();
+ ttyinit();
+ if ((infofd = creat(infof, 0600)) < 0)
+ prexit("%a: cannot create info file\n");
+ if ((i = write(infofd, &info, sizeof info)) != sizeof info) {
+ if (i == -1)
+ perror(0);
+ prexit("%a: cannot write info file: %d\n", i);
+ }
+ close(infofd);
+ }
+ lseek(kmem, (long)info.kaddr[aswapdev], 0);
+ read(kmem, &swapdev, sizeof(swapdev) );
+ lseek(kmem, (long)info.kaddr[aswplo], 0);
+ read(kmem, &swplo, sizeof(swplo) );
+ lseek(kmem, (long)info.kaddr[answap], 0);
+ read(kmem, &nswap, sizeof(nswap) );
+ lseek(kmem, (long)info.kaddr[anproc], 0);
+ read(kmem, &nproc, sizeof(nproc) );
+ lseek(kmem, (long)info.kaddr[antext], 0);
+ read(kmem, &ntext, sizeof(ntext) );
+ lseek(kmem, (long)info.kaddr[anbuf], 0);
+ read(kmem, &nbuf, sizeof(nbuf) );
+ lseek(kmem, (long)info.kaddr[abuf], 0);
+ read(kmem, &buf, sizeof(buf) );
+ lseek(kmem, (long)info.kaddr[answbuf], 0);
+ read(kmem, &nswbuf, sizeof(nswbuf) );
+ lseek(kmem, (long)info.kaddr[aswbuf], 0);
+ read(kmem, &swbuf, sizeof(swbuf) );
+ lseek(kmem, (long)info.kaddr[aninode], 0);
+ read(kmem, &ninode, sizeof(ninode) );
+ lseek(kmem, (long)info.kaddr[ainode], 0);
+ read(kmem, &inode, sizeof(inode) );
+ lseek(kmem, (long)info.kaddr[ahz], 0);
+ read(kmem, &hz, sizeof(hz) );
+ lseek(kmem, (long)info.kaddr[aproc], 0);
+ read(kmem, &kproc, sizeof(kproc));
+ lseek(kmem, (long)info.kaddr[atext], 0);
+ read(kmem, &ktext, sizeof(ktext));
+ proc = (struct proc *)getcore(nproc * sizeof(struct proc));
+ text = (struct text *)getcore(ntext * sizeof(struct text));
+ if (puids != &uids[0] && uids[0].nm_int != myuid)
+ usersetup();
+ if (!select) {
+ mypid = getpid();
+ (puids++)->nm_int = myuid;
+ nxflag++;
+ select++;
+ }
+ ttysetup();
+ topmem = 0;
+ do {
+ heading = 0; /* reset heading flag (for repeat) */
+ core = coreinit = 0; /* reset core flag (for repeat) */
+ lseek(kmem, (long)kproc, 0);
+ read(kmem, proc, nproc * sizeof(struct proc));
+ lseek(kmem, (long)ktext, 0);
+ read(kmem, text, ntext * sizeof(struct text));
+ needed();
+ mktree();
+ action (plist, 0);
+ printf("%d processes (%dkb), %d busy (%dkb), %d loaded (%dkb)\n",
+ ntotal, (ctob(ktotal) + 1023) / 1024,
+ nbusy, (ctob(kbusy) + 1023) / 1024,
+ nloaded, (ctob(kloaded) + 1023) / 1024);
+ fflush(stdout);
+ } while (rflag && sleep(rflag) == 0);
+ exit(0);
+}
+
+/* read the passwd file and fill in the user name arrays */
+readusers()
+{
+ register struct passwd *pw;
+ struct passwd *getpwent();
+
+ while((pw = getpwent()) != 0) {
+ if(info.unames[pw->pw_uid][0] == '\0')
+ strcpyn(info.unames[pw->pw_uid], pw->pw_name, UNAMELENGTH);
+ }
+ endpwent();
+}
+
+/* check for specified user names */
+
+usersetup()
+{
+ register int i;
+ register union numptr *ip;
+
+ for (ip = uids; ip < puids; ip++) {
+ for (i = 0; i < MAXUSERS; i++)
+ if (equalu(ip->nm_ptr, info.unames[i]))
+ goto cont2;
+ prexit("%a: unknown user: %s\n", ip->nm_ptr);
+ cont2:
+ ip->nm_int = i;
+ }
+}
+
+/* compare a fixed length user name */
+
+equalu(u1, u2)
+register char *u1, *u2;
+{
+ register int i = 0;
+
+ while (*u1++ == *u2)
+ if (!*u2++ || ++i == UNAMELENGTH)
+ return 1;
+ return 0;
+}
+
+/*
+ * Initialize the tty part of the info structure
+ */
+ttyinit()
+{
+ struct direct dir;
+ struct stat sbuf;
+ int fd;
+ register struct ttyline *lp = info.ttyline;
+
+ if ((fd = open("/dev", 0)) < 0)
+ prexit("%a: can't open /dev\n");
+ chdir("/dev");
+ while (read(fd, (char *)&dir, sizeof(dir)) == sizeof(dir)) {
+ if (dir.d_ino == 0 ||
+ strncmp("tty", dir.d_name, 3) != 0 &&
+ strcmp("console", dir.d_name) != 0)
+ continue;
+ if (dir.d_name[sizeof("tty") - 1] == 'C')
+ continue;
+ if (lp >= &info.ttyline[MAXTTYS])
+ prexit("%a: too many ttys in /dev\n");
+ if (dir.d_name[0] == 'c') {
+ lp->l_name[0] = 'c';
+ lp->l_name[1] = 'o';
+ } else {
+ lp->l_name[0] = dir.d_name[3];
+ lp->l_name[1] = dir.d_name[4];
+ }
+ stat(dir.d_name, &sbuf);
+ lp->l_dev = sbuf.st_rdev;
+ lseek(kmem, (long)&cswitch[major(sbuf.st_rdev)].d_ttys, 0);
+ read(kmem, (char *)&lp->l_addr, sizeof(lp->l_addr));
+ lp->l_addr += minor(sbuf.st_rdev);
+ lp++;
+ }
+ close(fd);
+}
+ttysetup()
+{
+ register struct ttyline *lp;
+ register char *cp;
+ union ttyptr *tp;
+ struct tty tty;
+
+ for (lp = info.ttyline; lp->l_name[0]; lp++) {
+ lseek(kmem, (long)lp->l_addr, 0);
+ if (read(kmem, &tty, sizeof tty) != sizeof tty)
+ prexit("%a: read error in kmem\n");
+ lp->l_pgrp = tty.t_pgrp;
+ if (Tflag)
+ printf("tty%-.2s: dev:%2d,%2d addr:%6x, rawq:%4d, canq:%d, outq:%4d, pgrp:%5d\n",
+ lp->l_name, major(lp->l_dev), minor(lp->l_dev),
+ ABS(lp->l_addr), tty.t_rawq.c_cc,
+ tty.t_canq.c_cc, tty.t_outq.c_cc,
+ tty.t_pgrp);
+ }
+#ifdef CHAOS
+ mkchttys(lp);
+#endif
+ /* now fix up specified ttys */
+
+ for (tp = &ttys[0]; tp < pttys; tp++) {
+ for (lp = info.ttyline; lp->l_name[0]; lp++)
+ if (strcmpn(tp->ty_ptr, lp->l_name, 2) == 0) {
+ tp->ty_line = lp;
+ goto cont2;
+ }
+ prexit("%a: unknown tty name: %c\n", tp->ty_ptr);
+ cont2:;
+ }
+}
+
+/*
+ * Determine which procs are needed for the printout
+ * and add these to a list of needed processes (plist)
+ */
+needed()
+{
+ register struct proc *p, *pp;
+ register struct text *tp;
+ struct ttyline *lp;
+ int ok;
+
+ plist = 0;
+ nswapped = ntotal = nbusy = nloaded = 0;
+ kswapped = ktotal = kbusy = kloaded = 0;
+
+ for (tp = text; tp < text + ntext; tp++)
+ if (tp->x_count) {
+ ktotal += tp->x_size;
+ if (!(tp->x_ccount))
+ kswapped += tp->x_size;
+ }
+
+ for (p = proc; p < proc + nproc; p++) {
+ if (!p->p_stat)
+ continue;
+ if (p->p_textp)
+ p->p_textp = &text[p->p_textp - ktext];
+ if (p->p_pptr) {
+ p->p_pptr = &proc[p->p_pptr - kproc];
+ if (p->p_pptr < proc || p->p_pptr >= &proc[nproc]) {
+ fprintf(stderr, "proc %d bad pptr\n", p->p_pid);
+ p->p_pptr = proc;
+ }
+ } else
+ p->p_pptr = proc;
+ }
+ for (p = &proc[0]; p < &proc[nproc]; p++) {
+ if (!p->p_stat)
+ continue;
+ ntotal++;
+ ktotal += procsize(p);
+ if (p->p_flag != SZOMB)
+ if (p->p_flag & SLOAD) {
+ nloaded++;
+ kloaded += procsize(p);
+ if ((tp = p->p_textp) && tp->x_count) {
+ tp->x_count = 0;
+ kloaded += tp->x_size;
+ }
+ } else {
+ nswapped++;
+ kswapped += procsize(p);
+ }
+ ok = FALSE;
+ if (p->p_stat == SRUN ||
+ p->p_stat == SSLEEP && (p->p_pri < PZERO && p->p_pid > MSPID)) {
+ nbusy++;
+ kbusy += procsize(p);
+ if ((tp = p->p_textp) && tp->x_ccount) {
+ tp->x_ccount = 0;
+ kbusy += tp->x_size;
+ }
+ if (Bflag)
+ ok = TRUE;
+ }
+ if (nflag)
+ continue;
+ if (zflag && p->p_stat == SZOMB)
+ ok = TRUE;
+ if (sflag && p->p_stat == SSTOP)
+ ok = TRUE;
+ if (select == 0 && mypid && p->p_pid == mypid)
+ continue;
+ if (p->p_pgrp == 0)
+ if (xflag)
+ ok = TRUE;
+ else if (nxflag)
+ continue;
+ if (dflag && p->p_pgrp != 0 && (p->p_flag & SDETACH) != 0)
+ ok = TRUE;
+ if (aflag && xflag && p->p_pgrp != 0 && (p->p_flag & SDETACH) == 0 &&
+ p->p_pptr == &proc[1])
+ ok = TRUE;
+ if (puids != uids) {
+ register union numptr *ip;
+
+ for (pp = p; pp > &proc[1]; pp = pp->p_pptr)
+ for (ip = uids; ip < puids; ip++)
+ if ((pp->p_uid & 0377) == ip->nm_int){
+ ok = TRUE;
+ goto uidok;
+ }
+ }
+ uidok:
+ if (pgrps != grps) {
+ register union numptr *ip;
+
+ for (pp = p; pp > &proc[1]; pp = pp->p_pptr)
+ for (ip = grps; ip < pgrps; ip++)
+ if (pp->p_pgrp == ip->nm_int) {
+ ok = TRUE;
+ goto pgrpok;
+ }
+ }
+ pgrpok:
+ if (ppids != pids) {
+ register union numptr *ip;
+
+ for (ip = pids; ip < ppids; ip++)
+ if (ip->nm_int == p->p_pid) {
+ ok = TRUE;
+ goto procok;
+ }
+ }
+ procok:
+ if (select && pttys == ttys && !fflag && !bflag && !ok)
+ continue;
+ if (getu(p) == 0) {
+ static struct procinfo fakep = {"--no upage--", ¬ty, 0};
+
+ if (select && !ok)
+ continue;
+ pinfo(p) = &fakep;
+ goto putonlist;
+ }
+ if (pttys != ttys && p->p_pgrp != 0) {
+ union ttyptr *ip;
+
+ for (ip = ttys; ip < pttys; ip++)
+ if (p->p_pgrp && p->p_pgrp == ip->ty_line->l_pgrp ||
+ p->p_stat == SSLEEP &&
+ p->p_wchan >= (char *)ip->ty_line->l_addr &&
+ p->p_wchan < (char *)ip->ty_line->l_addr +
+ sizeof (struct tty) ||
+ u.u_ttyd == ip->ty_line->l_dev) {
+ ok = TRUE;
+ break;
+ }
+ }
+ if (p->p_pgrp == 0)
+ lp = ¬ty;
+ else {
+ for (lp = info.ttyline; lp->l_name[0] != 0; lp++)
+ if (lp->l_dev == u.u_ttyd)
+ break;
+ if (lp->l_name[0] == 0)
+ lp = ¬ty;
+ else if (p->p_pptr != &proc[1]) {
+ if (fflag && p->p_pgrp == lp->l_pgrp)
+ ok = TRUE;
+ if (bflag && p->p_pgrp != lp->l_pgrp &&
+ (p->p_flag & SDETACH) == 0 &&
+ p->p_stat != SSTOP)
+ ok = TRUE;
+ }
+ }
+ if (select && !ok)
+ continue;
+ pinfo(p) = (struct procinfo *)getcore(sizeof (struct procinfo));
+ pinfo(p)->pi_time = u.u_vm.vm_utime + u.u_vm.vm_stime;
+ pinfo(p)->pi_tty = lp;
+ pinfo(p)->pi_cmd = getcmd(p);
+ putonlist:
+ /* we have a needed proc! */
+
+ p->p_next = plist;
+ plist = p;
+ p->p_son = p->p_bro = 0;
+ }
+}
+/*
+ * mktree - sort the needed processes by subtree and at the top by user
+ */
+mktree()
+{
+ register struct proc *p, *pp, *lp;
+ struct proc *op;
+ struct proc proot;
+
+ proot.p_bro = 0;
+
+ for (p = plist; p; p = p->p_next) { /* for all needed processes */
+ if (p->p_pptr > &proc[1]) {
+ for (pp = plist; pp; pp = pp->p_next)
+ if (pp == p->p_pptr) { /* if my parent */
+ if (lp = pp->p_son) { /* if siblings */
+ for (op = 0; lp && lp->p_pid <
+ p->p_pid;
+ lp = (op = lp)->p_bro)
+ ;
+ if (op) {
+ p->p_bro = lp;
+ op->p_bro = p;
+ break;
+ }
+ }
+ p->p_bro = lp; /* here if first or only */
+ pp->p_son = p;
+ break;
+ }
+ if (pp) /* if we found the parent */
+ continue;
+ }
+
+ /* we have a top level process, sort into top level list */
+
+ for (pp = (lp = &proot)->p_bro; pp; pp = (lp = pp)->p_bro)
+ if ((p->p_uid & 0377) < (pp->p_uid & 0377) ||
+ (p->p_uid & 0377) == (pp->p_uid & 0377) &&
+ p->p_pid < pp->p_pid)
+ break;
+ p->p_bro = lp->p_bro;
+ lp->p_bro = p;
+ }
+ plist = proot.p_bro;
+}
+
+action(p, md)
+register struct proc *p;
+register int md;
+{
+
+ if (p) {
+ printp(p, md);
+ if (p->p_son)
+ action(p->p_son, md+1);
+ if (p->p_bro)
+ action(p->p_bro, md);
+ }
+}
+
+/*
+ * Pretty print the output according to the switches.
+ */
+printp(p, md)
+register struct proc *p;
+{
+ register char *cp, *cp1;
+ char stat[10];
+ static int lastuid;
+ static char *statnames[] = {"Unk ", "Wait", "Wait", "Run ",
+ "Init", "Exit", "Stop"};
+
+ if (!heading) {
+ heading++;
+ printf("Ty User ");
+ if (lflag) {
+ printf("Stat");
+ if (vflag) printf(" Flgs Nice Pri ");
+ else printf(" ");
+ printf("Memory-kb Time Wait? ");
+ }
+ if (Aflag)
+ printf("Address Proc. Clock Alarm ");
+ if (Sflag)
+ printf("Size ");
+ if (Gflag)
+ printf("Group ");
+ printf("Proc# Command\n");
+ }
+ printf("%.2s%c", pinfo(p)->pi_tty->l_name,
+ p->p_pgrp == 0 ? ' ' :
+ p->p_flag & SDETACH ? '_' :
+ p->p_pgrp == pinfo(p)->pi_tty->l_pgrp ? '.' :
+ ' ');
+
+ if (md == 0) {
+ lastuid = p->p_uid & 0377;
+ cp = info.unames[lastuid];
+ if (*cp)
+ printf("%-8.8s ", cp);
+ else
+ printf("user%-4.4d ", lastuid);
+ } else {
+ if (md > 8)
+ md = 8;
+ printf("%*s*", md, "");
+ if ((p->p_uid & 0377) != lastuid) { /* setuid process! */
+ lastuid = p->p_uid & 0377;
+ cp = info.unames[lastuid];
+ } else
+ cp = "";
+ md = 8 - md;
+ printf("%-*.*s", md, md, cp);
+ }
+ if (lflag) {
+ cp = statnames[p->p_stat];
+ if (p->p_flag&SLOAD) {
+ for (cp1 = stat; *cp1 = *cp; cp1++, cp++)
+ if (*cp >= 'a' && *cp <= 'z')
+ *cp1 -= 'a' - 'A';
+ cp = stat;
+ }
+ printf("%-4.4s ", cp);
+ if (vflag) {
+ cp = stat;
+ if (p->p_flag & SSYS) *cp++ = 'U';
+ if (p->p_flag&SLOCK) *cp++ = 'L';
+ if (p->p_flag&STRC) *cp++ = 'T';
+ if (p->p_flag&SWTED) *cp++ = 'W';
+ if (p->p_flag&SSWAP) *cp++ = 'S';
+ while(cp < &stat[5]) *cp++ = ' ';
+ *cp = 0;
+ printf("%-4.4s ",stat);
+ if (p->p_nice != NZERO)
+ printf("%4d", p->p_nice - NZERO);
+ else
+ printf(" ");
+ if (p->p_stat != SZOMB)
+ printf("%4d ", p->p_pri);
+ else
+ printf(" ");
+ }
+ if (p->p_stat != SZOMB) {
+ printf("%4d", msize(procsize(p)) );
+ if (p->p_textp)
+ printf("+%4d ", msize(p->p_textp->x_size));
+ else
+ printf(" ");
+ prcpu(pinfo(p)->pi_time);
+ } else
+ printf(" ");
+ if (p->p_stat != SZOMB && p->p_stat != SRUN && p->p_stat != SSTOP)
+ if (!Wflag && (cp = waitingfor(p)))
+ printf("%-6.6s ", cp);
+ else printf("%6x ", ABS((int)p->p_wchan));
+ else printf(" ");
+ }
+ if (Aflag)
+ printf("%6x %6x %6d%6d ", p->p_addr,
+ (p - proc) * sizeof (struct proc) + info.kaddr[aproc],
+ p->p_time, p->p_clktim);
+ if (Sflag)
+ printf("%5x ", procsize(p) );
+ if (Gflag)
+ printf("%5D ", p->p_pgrp);
+ printf("%5D ", p->p_pid);
+ if (wflag)
+ printf("%s\n", pinfo(p)->pi_cmd);
+ else
+ printf("%-.*s\n", arglength, pinfo(p)->pi_cmd);
+}
+
+/* print cpu time */
+
+prcpu(time)
+long time;
+{
+ register unsigned i;
+
+ if (time < 0)
+ printf(" ---- ");
+ else if (time < (long)hz * 60 * 10) /* less than 10 minutes */
+ printf("%3d.%1d ",
+ (int)(time / hz),
+ (int)(time % hz / (hz / 10)));
+ else if (time < (long)hz * 60 * 60 * 10)/* less than 10 hours */
+ printf("%3d M ",
+ (int)((time + (hz * 60) / 2) / (hz * 60)));
+ else {
+ i = (time + ((long)hz * 60 * 60) / 2) /
+ ((long)hz * 60 * 60);
+ if (i < 1000)
+ printf("%3d H ", i);
+ else
+ printf(" ---- ");
+ }
+}
+/* Determine what a process is waiting for and describe it. */
+
+char *
+waitingfor(p)
+register struct proc *p;
+{
+ register caddr_t w;
+ register struct ttyline *lp;
+ register char *cp;
+
+ w = p->p_wchan;
+ if (w == (caddr_t)0)
+ return "null";
+ if (w >= (char *)kproc && w < (char *)(kproc + nproc))
+ return "child";
+ if (w >= (char *)swbuf && w < (char *)(swbuf + nswbuf))
+ return "swap";
+ if (w == info.kaddr[arswbuf])
+ return "rswap";
+ if (w >= (char *)buf && w < (char *)(buf + nbuf))
+ return "diskio";
+ if (w >= info.kaddr[afile] && w < info.kaddr[afile] + sizeof(struct file) * nfile)
+ return "file";
+ if (w >= (char *)inode && w < (char *)(inode + ninode))
+ switch((w - (char *)inode) % sizeof(struct inode)) {
+ case 1:
+ return "wpipe";
+ case 2:
+ return "rpipe";
+ case 3:
+ return "mutex";
+ case (int)&((struct inode *)0)->i_un.i_group.g_datq:
+ return "rmux";
+ default:
+ return "inode";
+ }
+ if (w == info.kaddr[achtbuf])
+ return "tapecn";
+ if (w == info.kaddr[ahpbuf])
+ return "rpdisk";
+ if (w == info.kaddr[ark7])
+ return "rkdisk";
+ if (w == info.kaddr[arhtbuf])
+ return "tapeio";
+ if (w == info.kaddr[alpdt])
+ return "printr";
+ if (w == info.kaddr[albolt])
+ return "lbolt";
+ if (w == info.kaddr[arunin])
+ return "runin";
+ if (w == info.kaddr[arunout])
+ return "runout";
+ if (w == info.kaddr[atout])
+ return "sleep";
+ if (w == info.kaddr[aipc])
+ return "ptrace";
+ if (w == info.kaddr[abfreeli])
+ return "buffer";
+ if (w == info.kaddr[amaplock])
+ return "ubmap";
+ if (w == info.kaddr[au])
+ return "pause";
+ if (w == info.kaddr[achrfclist])
+ return "chrfc";
+ for (lp = info.ttyline; lp->l_name[0]; lp++)
+ if (w >= (char *)lp->l_addr && w < (char *)lp->l_addr + sizeof (struct tty)) {
+#define TTY0 ((struct tty *)0)
+ switch(w - (char *)lp->l_addr) {
+ case (int)&TTY0->t_rawq:
+ cp = "rtty??";
+ break;
+ case (int)&TTY0->t_outq:
+ cp = "wtty??";
+ break;
+ case (int)&TTY0->t_state:
+ cp = "otty??";
+ break;
+ default:
+ cp = "?tty??";
+ }
+ cp[4] = lp->l_name[0];
+ cp[5] = lp->l_name[1];
+ return cp;
+ }
+ return 0;
+}
+
+getu(mproc)
+register struct proc *mproc;
+{
+ struct pte *pteaddr, apte;
+ register int i;
+ int ncl, size;
+
+ size = Sflag ? ctob(UPAGES) : sizeof (struct user);
+ if ((mproc->p_flag & SLOAD) == 0) {
+ lseek(swap, (long)ctob(mproc->p_swaddr), 0);
+ if (read(swap, (char *)&user.user, size) != size) {
+ fprintf(stderr, "%a: cant read u for pid %d from %s\n",
+ mproc->p_pid, swapf);
+ return (0);
+ }
+ return (1);
+ }
+ pteaddr = &Usrptmap[btokmx(mproc->p_p0br) + mproc->p_szpt - 1];
+ lseek(kmem, (long)(mflag ? ABS(pteaddr) : (int)pteaddr), 0);
+ if (read(kmem, (char *)&apte, sizeof(apte)) != sizeof(apte)) {
+ printf("%a: cant read indir pte to get u for pid %d from %s\n",
+ mproc->p_pid, swapf);
+ return (0);
+ }
+ lseek(mem, (long)
+ (ctob(apte.pg_pfnum+1) - (UPAGES+MAXARGPG) * sizeof (struct pte)),
+ 0);
+ if (read(mem, (char *)pagetable, sizeof(pagetable)) != sizeof(pagetable)) {
+ printf("%a: cant read page table for u of pid %d from %s\n",
+ mproc->p_pid, swapf);
+ return (0);
+ }
+ ncl = (size + NBPG*CLSIZE - 1) / (NBPG*CLSIZE);
+ while (--ncl >= 0) {
+ i = ncl * CLSIZE;
+ lseek(mem, (long)ctob(pagetable[MAXARGPG+i].pg_pfnum), 0);
+ if (read(mem, user.upages[i], CLSIZE*NBPG) != CLSIZE*NBPG) {
+ printf("%a: cant read page %d of u of pid %d from %s\n",
+ pagetable[MAXARGPG+i].pg_pfnum, mproc->p_pid, memf);
+ return(0);
+ }
+ }
+ return (1);
+}
+char *
+getcmd(p)
+register struct proc *p;
+{
+ struct pte apte;
+ char argbuf[MAXARGPG * NBPG], *argptr;
+ register int *ip;
+ register char *cp, *cp1;
+ int cc, nbad, i;
+
+ if (p->p_stat == SZOMB)
+ return "--Defunct--";
+ if ((p->p_flag&SLOAD) == 0 && Fflag)
+ return "--Swapped--";
+ if (p->p_flag & SSYS)
+ return p->p_pid == 0 ? "UNIX Swapper" :
+ p->p_pid == 2 ? "UNIX Pager" : "UNIX";
+ for (i = 0; i < MAXARGPG; i++) {
+ argptr = &argbuf[(MAXARGPG - 1 - i) * NBPG];
+ apte = pagetable[MAXARGPG - 1 - i];
+ if ((p->p_flag & SLOAD) && apte.pg_fod == 0 && apte.pg_pfnum ) {
+ lseek(mem, (long)ctob(apte.pg_pfnum), 0);
+ if (read(mem, argptr, NBPG) != NBPG)
+ return "---Mem read error (args)---";
+ } else if (Fflag)
+ goto cheap;
+ else {
+ lseek(swap, (long)ctob(u.u_smap.dm_map[0] + DMMIN - 1 - i), 0);
+ if (read(swap, argptr, NBPG) != NBPG)
+ return "---Swap read error (args)---";
+ }
+ /* Here block of stack is at argptr */
+ ip = (int *)&argptr[NBPG];
+ if (i == 0) {
+ *--ip = 0;
+ ip--;
+ }
+ while (ip > (int *)argptr && *--ip != 0)
+ ;
+ if (ip > (int *)argptr || *ip == 0)
+ break;
+ }
+ if (i >= MAXARGPG) {
+cheap:
+ argbuf[0] = '(';
+ strncpy(&argbuf[1], u.u_comm, sizeof(u.u_comm));
+ strcat(argbuf, ")");
+ return store(argbuf);
+ }
+ cp = (char *)(ip + 1);
+ if (*cp == '\0')
+ cp++;
+ nbad = 0;
+ for (cp1 = cp; cp1 < &argbuf[MAXARGPG*NBPG]; cp1++) {
+ cc = *cp1 & 0177;
+ if (cc == 0)
+ *cp1 = ' ';
+ else if (cc < ' ' || cc == 0177) {
+ if (++nbad >= 5) {
+ *cp1++ = ' ';
+ break;
+ }
+ *cp1 = '?';
+ } else if (!eflag && cc == '=') {
+ *cp1 = 0;
+ while (cp1 > cp && *--cp1 != ' ')
+ *cp1 = 0;
+ break;
+ }
+ }
+ while (*--cp1 == ' ')
+ *cp1 = 0;
+ if (!wflag && &cp[arglength] < (char *)&argbuf[MAXARGPG*NBPG - 1])
+ cp[arglength] = 0;
+ return store(cp);
+}
+
+/*
+ * Store a string in core for later use.
+ */
+char *
+store(cp)
+char *cp;
+{
+ register char *src, *dst, *svdst;
+
+ src = cp;
+ while (*src++);
+ svdst = getcore(src - cp);
+ dst = svdst;
+ src = cp;
+ while (*dst++ = *src++);
+ return(svdst);
+}
+
+/*
+ * Allocate and return a pointer to the asked for amount of core
+ */
+char *
+getcore(cnt)
+register int cnt;
+{
+ static char *corep;
+ register char *ip;
+ register int incr;
+ char *sbrk();
+
+ if (cnt > core) {
+ if (coreinit == 0) {
+ coreinit++;
+ if (topmem)
+ brk(topmem); /* after repeat!! */
+ else
+ topmem = sbrk(0);
+ corep = topmem;
+ }
+ incr = cnt > 4096 ? cnt : 4096;
+ if (sbrk(incr) == 0)
+ prexit("%a: out of memory!\n");
+ core += incr;
+ }
+ ip = corep;
+ core -= cnt;
+ corep += cnt;
+ return(ip);
+}
+#ifdef CHAOS
+#include "chunix/chsys.h"
+#include <chaos/chaos.h>
+
+mkchttys(lp)
+register struct ttyline *lp;
+{
+ register struct connection **cnp;
+ register int i;
+ struct tty tty;
+ struct connection *Chconntab[CHNCONNS];
+ struct connection conn;
+
+ lseek(kmem, (long)info.kaddr[aChconntab], 0);
+ read(kmem, (char *)Chconntab, sizeof(Chconntab));
+ for (i = 0, cnp = Chconntab; cnp < &Chconntab[CHNCONNS]; i++, cnp++) {
+ if (!*cnp)
+ continue;
+ lseek(kmem, (long)*cnp, 0);
+ read(kmem, (char *)&conn, sizeof(conn));
+ if ((conn.cn_flags & CHTTY) == 0)
+ continue;
+ lseek(kmem, (long)conn.cn_ttyp, 0);
+ read(kmem, (char *)&tty, sizeof(tty));
+ if (lp >= &info.ttyline[MAXTTYS])
+ prexit("%a: too many ttys\n");
+ lp->l_addr = conn.cn_ttyp;
+ lp->l_pgrp = tty.t_pgrp;
+ lp->l_dev = tty.t_dev;
+ lp->l_name[0] = 'C';
+ lp->l_name[1] = i < 10 ? '0' + i :
+ i - 10 <= 'z' - 'a' ? i - 10 + 'a' :
+ i - 10 - ('z' - 'a') + 'A';
+ if (Tflag)
+ printf("tty%-.2s: dev:%2d,%2d addr:%6x, rawq:%4d, canq:%d, outq:%4d, pgrp:%5d\n",
+ lp->l_name, major(lp->l_dev), minor(lp->l_dev),
+ ABS(lp->l_addr), tty.t_rawq.c_cc,
+ tty.t_canq.c_cc, tty.t_outq.c_cc,
+ tty.t_pgrp);
+ lp++;
+ }
+}
+#endif
projects / unix-history / commitdiff