![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ps.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 41BSD / cmd|
Return to ps.c CVS log | Up to [CSRG BSD Unix] / 41BSD / cmd |
1.1 root 1: static char *sccsid = "@(#)ps.c 4.7 (Berkeley) 10/20/80";
2: /*
3: * ps; VAX 4BSD version
4: */
5:
6: #include <stdio.h>
7: #include <ctype.h>
8: #include <nlist.h>
9: #include <pwd.h>
10: #include <sys/param.h>
11: #include <sys/tty.h>
12: #include <sys/dir.h>
13: #include <sys/user.h>
14: #include <sys/proc.h>
15: #include <sys/pte.h>
16: #include <sys/vm.h>
17: #include <sys/text.h>
18: #include <sys/stat.h>
19: #include <math.h>
20:
21: struct nlist nl[] = {
22: { "_proc" },
23: #define X_PROC 0
24: { "_Usrptmap" },
25: #define X_USRPTMA 1
26: { "_usrpt" },
27: #define X_USRPT 2
28: { "_text" },
29: #define X_TEXT 3
30: { "_nswap" },
31: #define X_NSWAP 4
32: { "_maxslp" },
33: #define X_MAXSLP 5
34: { "_ccpu" },
35: #define X_CCPU 6
36: { "_ecmx" },
37: #define X_ECMX 7
38: { 0 },
39: };
40:
41: struct savcom {
42: union {
43: struct lsav *lp;
44: float u_pctcpu;
45: struct vsav *vp;
46: int s_ssiz;
47: } sun;
48: struct asav *ap;
49: } savcom[NPROC];
50:
51: struct asav {
52: char *a_cmdp;
53: int a_flag;
54: short a_stat, a_uid, a_pid, a_nice, a_pri, a_slptime, a_time;
55: size_t a_size, a_rss, a_tsiz, a_txtrss;
56: short a_xccount;
57: char a_tty[DIRSIZ+1];
58: dev_t a_ttyd;
59: time_t a_cpu;
60: };
61:
62: char *lhdr;
63: struct lsav {
64: short l_ppid;
65: char l_cpu;
66: int l_addr;
67: caddr_t l_wchan;
68: };
69:
70: char *uhdr;
71: char *shdr;
72:
73: char *vhdr;
74: struct vsav {
75: u_int v_majflt;
76: size_t v_swrss, v_txtswrss;
77: float v_pctcpu;
78: };
79:
80: struct proc proc[8]; /* 8 = a few, for less syscalls */
81: struct proc *mproc;
82: struct text *text;
83:
84: int paduser1; /* avoid hardware mem clobbering botch */
85: union {
86: struct user user;
87: char upages[UPAGES][NBPG];
88: } user;
89: #define u user.user
90: int paduser2; /* avoid hardware mem clobbering botch */
91:
92: #define clear(x) ((int)x & 0x7fffffff)
93:
94: int chkpid;
95: int aflg, cflg, eflg, gflg, kflg, lflg, sflg, uflg, vflg, xflg;
96: char *tptr;
97: char *gettty(), *getcmd(), *getname(), *savestr(), *alloc(), *state();
98: double pcpu(), pmem();
99: int pscomp();
100: int nswap, maxslp;
101: double ccpu;
102: int ecmx;
103: struct pte *Usrptma, *usrpt;
104:
105: struct ttys {
106: char name[DIRSIZ+1];
107: dev_t ttyd;
108: struct ttys *next;
109: struct ttys *cand;
110: } *allttys, *cand[16];
111:
112: struct savcom savcom[NPROC];
113: int npr;
114:
115: int cmdstart;
116: int twidth;
117: char *kmemf, *memf, *swapf, *nlistf;
118: int kmem, mem, swap;
119: int rawcpu, sumcpu;
120:
121: int pcbpf;
122: int argaddr;
123: extern char _sobuf[];
124:
125: main(argc, argv)
126: char **argv;
127: {
128: register int i, j;
129: register char *ap;
130: int uid;
131: off_t procp;
132:
133: if (chdir("/dev") < 0) {
134: perror("/dev");
135: exit(1);
136: }
137: twidth = 80;
138: setbuf(stdout, _sobuf);
139: argc--, argv++;
140: if (argc > 0) {
141: ap = argv[0];
142: while (*ap) switch (*ap++) {
143:
144: case 'C':
145: rawcpu++;
146: break;
147: case 'S':
148: sumcpu++;
149: break;
150: case 'a':
151: aflg++;
152: break;
153: case 'c':
154: cflg = !cflg;
155: break;
156: case 'e':
157: eflg++;
158: break;
159: case 'g':
160: gflg++;
161: break;
162: case 'k':
163: kflg++;
164: break;
165: case 'l':
166: lflg++;
167: break;
168: case 's':
169: sflg++;
170: break;
171: case 't':
172: if (*ap)
173: tptr = ap;
174: aflg++;
175: gflg++;
176: if (*tptr == '?')
177: xflg++;
178: while (*ap)
179: ap++;
180: break;
181: case 'u':
182: uflg++;
183: break;
184: case 'v':
185: cflg = 1;
186: vflg++;
187: break;
188: case 'w':
189: if (twidth == 80)
190: twidth = 132;
191: else
192: twidth = BUFSIZ;
193: break;
194: case 'x':
195: xflg++;
196: break;
197: default:
198: if (!isdigit(ap[-1]))
199: break;
200: chkpid = atoi(--ap);
201: *ap = 0;
202: aflg++;
203: xflg++;
204: break;
205: }
206: }
207: openfiles(argc, argv);
208: getkvars(argc, argv);
209: getdev();
210: uid = getuid();
211: printhdr();
212: procp = nl[X_PROC].n_value;
213: for (i=0; i<NPROC; i += 8) {
214: lseek(kmem, (char *)procp, 0);
215: j = NPROC - i;
216: if (j > 8)
217: j = 8;
218: j *= sizeof (struct proc);
219: if (read(kmem, (char *)proc, j) != j)
220: cantread("proc table", kmemf);
221: procp += j;
222: for (j = j / sizeof (struct proc) - 1; j >= 0; j--) {
223: mproc = &proc[j];
224: if (mproc->p_stat == 0 ||
225: mproc->p_pgrp == 0 && xflg == 0)
226: continue;
227: if (tptr == 0 && gflg == 0 && xflg == 0 &&
228: mproc->p_ppid == 1 && (mproc->p_flag&SDETACH) == 0)
229: continue;
230: if (uid != mproc->p_uid && aflg==0 ||
231: chkpid != 0 && chkpid != mproc->p_pid)
232: continue;
233: if (vflg && gflg == 0 && xflg == 0) {
234: if (mproc->p_stat == SZOMB ||
235: mproc->p_flag&SWEXIT)
236: continue;
237: if (mproc->p_slptime > MAXSLP &&
238: (mproc->p_stat == SSLEEP ||
239: mproc->p_stat == SSTOP))
240: continue;
241: }
242: save();
243: }
244: }
245: qsort(savcom, npr, sizeof(savcom[0]), pscomp);
246: for (i=0; i<npr; i++) {
247: register struct savcom *sp = &savcom[i];
248: if (lflg)
249: lpr(sp);
250: else if (vflg)
251: vpr(sp);
252: else if (uflg)
253: upr(sp);
254: else
255: spr(sp);
256: if (sp->ap->a_flag & SWEXIT)
257: printf(" <exiting>");
258: else if (sp->ap->a_stat == SZOMB)
259: printf(" <defunct>");
260: else if (sp->ap->a_pid == 0)
261: printf(" swapper");
262: else if (sp->ap->a_pid == 2)
263: printf(" pagedaemon");
264: else
265: printf(" %.*s", twidth - cmdstart - 2, sp->ap->a_cmdp);
266: printf("\n");
267: }
268: exit(npr == 0);
269: }
270:
271: openfiles(argc, argv)
272: char **argv;
273: {
274:
275: kmemf = "kmem";
276: if (kflg)
277: kmemf = argc > 1 ? argv[1] : "/vmcore";
278: kmem = open(kmemf, 0);
279: if (kmem < 0) {
280: perror(kmemf);
281: exit(1);
282: }
283: if (kflg) {
284: mem = kmem;
285: memf = kmemf;
286: } else {
287: memf = "mem";
288: mem = open(memf, 0);
289: if (mem < 0) {
290: perror(memf);
291: exit(1);
292: }
293: }
294: swapf = argc>2 ? argv[2]: "drum";
295: swap = open(swapf, 0);
296: if (swap < 0) {
297: perror(swapf);
298: exit(1);
299: }
300: }
301:
302: getkvars(argc, argv)
303: char **argv;
304: {
305: register struct nlist *nlp;
306:
307: nlistf = argc > 3 ? argv[3] : "/vmunix";
308: nlist(nlistf, nl);
309: if (nl[0].n_type == 0) {
310: fprintf(stderr, "%s: No namelist\n", nlistf);
311: exit(1);
312: }
313: if (kflg)
314: for (nlp = nl; nlp < &nl[sizeof (nl)/sizeof (nl[0])]; nlp++)
315: nlp->n_value = clear(nlp->n_value);
316: Usrptma = (struct pte *)nl[X_USRPTMA].n_value;
317: usrpt = (struct pte *)nl[X_USRPT].n_value;
318: lseek(kmem, (long)nl[X_NSWAP].n_value, 0);
319: if (read(kmem, &nswap, sizeof (nswap)) != sizeof (nswap)) {
320: cantread("nswap", kmemf);
321: exit(1);
322: }
323: lseek(kmem, (long)nl[X_MAXSLP].n_value, 0);
324: if (read(kmem, &maxslp, sizeof (maxslp)) != sizeof (maxslp)) {
325: cantread("maxslp", kmemf);
326: exit(1);
327: }
328: lseek(kmem, (long)nl[X_CCPU].n_value, 0);
329: if (read(kmem, &ccpu, sizeof (ccpu)) != sizeof (ccpu)) {
330: cantread("ccpu", kmemf);
331: exit(1);
332: }
333: lseek(kmem, (long)nl[X_ECMX].n_value, 0);
334: if (read(kmem, &ecmx, sizeof (ecmx)) != sizeof (ecmx)) {
335: cantread("ecmx", kmemf);
336: exit(1);
337: }
338: if (uflg || vflg) {
339: text = (struct text *)alloc(NTEXT * sizeof (struct text));
340: if (text == 0) {
341: fprintf(stderr, "no room for text table\n");
342: exit(1);
343: }
344: lseek(kmem, (long)nl[X_TEXT].n_value, 0);
345: if (read(kmem, (char *)text, NTEXT * sizeof (struct text))
346: != NTEXT * sizeof (struct text)) {
347: cantread("text table", kmemf);
348: exit(1);
349: }
350: }
351: }
352:
353: printhdr()
354: {
355: char *hdr;
356:
357: if (sflg+lflg+vflg+uflg > 1) {
358: fprintf(stderr, "ps: specify only one of s,l,v and u\n");
359: exit(1);
360: }
361: hdr = lflg ? lhdr : (vflg ? vhdr : (uflg ? uhdr : shdr));
362: if (lflg+vflg+uflg+sflg == 0)
363: hdr += strlen("SSIZ ");
364: cmdstart = strlen(hdr);
365: printf("%s COMMAND\n", hdr);
366: fflush(stdout);
367: }
368:
369: cantread(what, fromwhat)
370: char *what, *fromwhat;
371: {
372:
373: fprintf(stderr, "ps: error reading %s from %s", what, fromwhat);
374: }
375:
376: struct direct dbuf;
377: int dialbase;
378:
379: getdev()
380: {
381: register FILE *df;
382: register struct ttys *dp;
383:
384: dialbase = -1;
385: if ((df = fopen(".", "r")) == NULL) {
386: fprintf(stderr, "Can't open . in /dev\n");
387: exit(1);
388: }
389: while (fread((char *)&dbuf, sizeof(dbuf), 1, df) == 1) {
390: if (dbuf.d_ino == 0)
391: continue;
392: maybetty(dp);
393: }
394: fclose(df);
395: }
396:
397: /*
398: * Attempt to avoid stats by guessing minor device
399: * numbers from tty names. Console is known,
400: * know that r(hp|up|mt) are unlikely as are different mem's,
401: * floppy, null, tty, etc.
402: */
403: maybetty()
404: {
405: register char *cp = dbuf.d_name;
406: register struct ttys *dp;
407: int x;
408: struct stat stb;
409:
410: switch (cp[0]) {
411:
412: case 'c':
413: if (!strcmp(cp, "console")) {
414: x = 0;
415: goto donecand;
416: }
417: /* cu[la]? are possible!?! don't rule them out */
418: break;
419:
420: case 'd':
421: if (!strcmp(cp, "drum"))
422: return (0);
423: break;
424:
425: case 'f':
426: if (!strcmp(cp, "floppy"))
427: return (0);
428: break;
429:
430: case 'k':
431: cp++;
432: if (*cp == 'U')
433: cp++;
434: goto trymem;
435:
436: case 'r':
437: cp++;
438: if (*cp == 'r' || *cp == 'u' || *cp == 'h')
439: cp++;
440: #define is(a,b) cp[0] == 'a' && cp[1] == 'b'
441: if (is(r,p) || is(u,p) || is(r,k) || is(r,m) || is(m,t)) {
442: cp += 2;
443: if (isdigit(*cp) && cp[2] == 0)
444: return (0);
445: }
446: break;
447:
448: case 'm':
449: trymem:
450: if (cp[0] == 'm' && cp[1] == 'e' && cp[2] == 'm' && cp[3] == 0)
451: return (0);
452: break;
453:
454: case 'n':
455: if (!strcmp(cp, "null"))
456: return (0);
457: break;
458:
459: case 'v':
460: if ((cp[1] == 'a' || cp[1] == 'p') && isdigit(cp[2]) &&
461: cp[3] == 0)
462: return (0);
463: break;
464: }
465: mightbe:
466: cp = dbuf.d_name;
467: while (cp < &dbuf.d_name[DIRSIZ] && *cp)
468: cp++;
469: --cp;
470: x = 0;
471: if (cp[-1] == 'd') {
472: if (dialbase == -1) {
473: if (stat("ttyd0", &stb) == 0)
474: dialbase = stb.st_rdev & 017;
475: else
476: dialbase = -2;
477: }
478: if (dialbase == -2)
479: x = 0;
480: else
481: x = 11;
482: }
483: if (cp > dbuf.d_name && isdigit(cp[-1]) && isdigit(*cp))
484: x += 10 * (cp[-1] - ' ') + cp[0] - '0';
485: else if (*cp >= 'a' && *cp <= 'f')
486: x += 10 + *cp - 'a';
487: else if (isdigit(*cp))
488: x += *cp - '0';
489: else
490: x = -1;
491: donecand:
492: dp = (struct ttys *)alloc(sizeof (struct ttys));
493: strncpy(dp->name, dbuf.d_name, DIRSIZ);
494: dp->next = allttys;
495: dp->ttyd = -1;
496: allttys = dp;
497: if (x == -1)
498: return;
499: x &= 017;
500: dp->cand = cand[x];
501: cand[x] = dp;
502: }
503:
504: char *
505: gettty()
506: {
507: register char *p;
508: register struct ttys *dp;
509: struct stat stb;
510: int x;
511:
512: if (u.u_ttyp == 0)
513: return("?");
514: x = u.u_ttyd & 017;
515: for (dp = cand[x]; dp; dp = dp->cand) {
516: if (dp->ttyd == -1) {
517: if (stat(dp->name, &stb) == 0 &&
518: (stb.st_mode&S_IFMT)==S_IFCHR)
519: dp->ttyd = stb.st_rdev;
520: else
521: dp->ttyd = -2;
522: }
523: if (dp->ttyd == u.u_ttyd)
524: goto found;
525: }
526: /* ick */
527: for (dp = allttys; dp; dp = dp->next) {
528: if (dp->ttyd == -1) {
529: if (stat(dp->name, &stb) == 0)
530: dp->ttyd = stb.st_rdev;
531: else
532: dp->ttyd = -2;
533: }
534: if (dp->ttyd == u.u_ttyd)
535: goto found;
536: }
537: return ("?");
538: found:
539: p = dp->name;
540: if (p[0]=='t' && p[1]=='t' && p[2]=='y')
541: p += 3;
542: return (p);
543: }
544:
545: save()
546: {
547: register struct savcom *sp;
548: register struct asav *ap;
549: register char *cp;
550: register struct text *xp;
551: char *ttyp, *cmdp;
552:
553: if (mproc->p_stat != SZOMB && getu() == 0)
554: return;
555: ttyp = gettty();
556: if (xflg == 0 && ttyp[0] == '?' || tptr && strcmpn(tptr, ttyp, 2))
557: return;
558: sp = &savcom[npr];
559: cmdp = getcmd();
560: if (cmdp == 0)
561: return;
562: sp->ap = ap = (struct asav *)alloc(sizeof (struct asav));
563: sp->ap->a_cmdp = cmdp;
564: #define e(a,b) ap->a = mproc->b
565: e(a_flag, p_flag); e(a_stat, p_stat); e(a_nice, p_nice);
566: e(a_uid, p_uid); e(a_pid, p_pid); e(a_pri, p_pri);
567: e(a_slptime, p_slptime); e(a_time, p_time);
568: ap->a_tty[0] = ttyp[0];
569: ap->a_tty[1] = ttyp[1] ? ttyp[1] : ' ';
570: if (ap->a_stat == SZOMB) {
571: register struct xproc *xp = (struct xproc *)mproc;
572:
573: ap->a_cpu = xp->xp_vm.vm_utime + xp->xp_vm.vm_stime;
574: } else {
575: ap->a_size = mproc->p_dsize + mproc->p_ssize;
576: e(a_rss, p_rssize);
577: ap->a_ttyd = u.u_ttyd;
578: ap->a_cpu = u.u_vm.vm_utime + u.u_vm.vm_stime;
579: if (sumcpu)
580: ap->a_cpu += u.u_cvm.vm_utime + u.u_cvm.vm_stime;
581: if (mproc->p_textp && text) {
582: xp = &text[mproc->p_textp -
583: (struct text *)nl[X_TEXT].n_value];
584: ap->a_tsiz = xp->x_size;
585: ap->a_txtrss = xp->x_rssize;
586: ap->a_xccount = xp->x_ccount;
587: }
588: }
589: #undef e
590: ap->a_cpu /= HZ;
591: if (lflg) {
592: register struct lsav *lp;
593:
594: sp->sun.lp = lp = (struct lsav *)alloc(sizeof (struct lsav));
595: #define e(a,b) lp->a = mproc->b
596: e(l_ppid, p_ppid); e(l_cpu, p_cpu);
597: if (ap->a_stat != SZOMB)
598: e(l_wchan, p_wchan);
599: #undef e
600: lp->l_addr = pcbpf;
601: } else if (vflg) {
602: register struct vsav *vp;
603:
604: sp->sun.vp = vp = (struct vsav *)alloc(sizeof (struct vsav));
605: #define e(a,b) vp->a = mproc->b
606: if (ap->a_stat != SZOMB) {
607: e(v_swrss, p_swrss);
608: vp->v_majflt = u.u_vm.vm_majflt;
609: if (mproc->p_textp)
610: vp->v_txtswrss = xp->x_swrss;
611: }
612: vp->v_pctcpu = pcpu();
613: #undef e
614: } else if (uflg)
615: sp->sun.u_pctcpu = pcpu();
616: else if (sflg) {
617: if (ap->a_stat != SZOMB) {
618: for (cp = (char *)u.u_stack;
619: cp < &user.upages[UPAGES][NBPG]; )
620: if (*cp++)
621: break;
622: sp->sun.s_ssiz = (&user.upages[UPAGES][NBPG] - cp);
623: }
624: }
625: npr++;
626: }
627:
628: double
629: pmem(ap)
630: register struct asav *ap;
631: {
632: double fracmem;
633: int szptudot;
634:
635: if ((ap->a_flag&SLOAD) == 0)
636: fracmem = 0.0;
637: else {
638: szptudot = UPAGES + clrnd(ctopt(ap->a_size+ap->a_tsiz));
639: fracmem = ((float)ap->a_rss+szptudot)/CLSIZE/ecmx;
640: if (ap->a_xccount)
641: fracmem += ((float)ap->a_txtrss)/CLSIZE/
642: ap->a_xccount/ecmx;
643: }
644: return (100.0 * fracmem);
645: }
646:
647: double
648: pcpu()
649: {
650: time_t time;
651:
652: time = mproc->p_time;
653: if (time == 0 || (mproc->p_flag&SLOAD) == 0)
654: return (0.0);
655: if (rawcpu)
656: return (100.0 * mproc->p_pctcpu);
657: return (100.0 * mproc->p_pctcpu / (1.0 - exp(time * log(ccpu))));
658: }
659:
660: getu()
661: {
662: struct pte *pteaddr, apte;
663: int pad1; /* avoid hardware botch */
664: struct pte arguutl[UPAGES+CLSIZE];
665: int pad2; /* avoid hardware botch */
666: register int i;
667: int ncl, size;
668:
669: size = sflg ? ctob(UPAGES) : sizeof (struct user);
670: if ((mproc->p_flag & SLOAD) == 0) {
671: lseek(swap, ctob(mproc->p_swaddr), 0);
672: if (read(swap, (char *)&user.user, size) != size) {
673: fprintf(stderr, "ps: cant read u for pid %d from %s\n",
674: mproc->p_pid, swapf);
675: return (0);
676: }
677: pcbpf = 0;
678: argaddr = 0;
679: return (1);
680: }
681: pteaddr = &Usrptma[btokmx(mproc->p_p0br) + mproc->p_szpt - 1];
682: lseek(kmem, kflg ? clear(pteaddr) : (int)pteaddr, 0);
683: if (read(kmem, (char *)&apte, sizeof(apte)) != sizeof(apte)) {
684: printf("ps: cant read indir pte to get u for pid %d from %s\n",
685: mproc->p_pid, swapf);
686: return (0);
687: }
688: lseek(mem,
689: ctob(apte.pg_pfnum+1) - (UPAGES+CLSIZE) * sizeof (struct pte), 0);
690: if (read(mem, (char *)arguutl, sizeof(arguutl)) != sizeof(arguutl)) {
691: printf("ps: cant read page table for u of pid %d from %s\n",
692: mproc->p_pid, swapf);
693: return (0);
694: }
695: if (arguutl[0].pg_fod == 0 && arguutl[0].pg_pfnum)
696: argaddr = ctob(arguutl[0].pg_pfnum);
697: else
698: argaddr = 0;
699: pcbpf = arguutl[CLSIZE].pg_pfnum;
700: ncl = (size + NBPG*CLSIZE - 1) / (NBPG*CLSIZE);
701: while (--ncl >= 0) {
702: i = ncl * CLSIZE;
703: lseek(mem, ctob(arguutl[CLSIZE+i].pg_pfnum), 0);
704: if (read(mem, user.upages[i], CLSIZE*NBPG) != CLSIZE*NBPG) {
705: printf("ps: cant read page %d of u of pid %d from %s\n",
706: arguutl[CLSIZE+i].pg_pfnum, mproc->p_pid, memf);
707: return(0);
708: }
709: }
710: return (1);
711: }
712:
713: char *
714: getcmd()
715: {
716: char cmdbuf[BUFSIZ];
717: int pad1; /* avoid hardware botch */
718: union {
719: char argc[CLSIZE*NBPG];
720: int argi[CLSIZE*NBPG/sizeof (int)];
721: } argspac;
722: int pad2; /* avoid hardware botch */
723: register char *cp;
724: register int *ip;
725: char c;
726: int nbad;
727: struct dblock db;
728:
729: if (mproc->p_stat == SZOMB || mproc->p_flag&(SSYS|SWEXIT))
730: return ("");
731: if (cflg) {
732: strncpy(cmdbuf, u.u_comm, sizeof (u.u_comm));
733: return (savestr(cmdbuf));
734: }
735: if ((mproc->p_flag & SLOAD) == 0 || argaddr == 0) {
736: vstodb(0, CLSIZE, &u.u_smap, &db, 1);
737: lseek(swap, ctob(db.db_base), 0);
738: if (read(swap, (char *)&argspac, sizeof(argspac))
739: != sizeof(argspac))
740: goto bad;
741: } else {
742: lseek(mem, argaddr, 0);
743: if (read(mem, (char *)&argspac, sizeof (argspac))
744: != sizeof (argspac))
745: goto bad;
746: }
747: ip = &argspac.argi[CLSIZE*NBPG/sizeof (int)];
748: ip -= 2; /* last arg word and .long 0 */
749: while (*--ip)
750: if (ip == argspac.argi)
751: goto retucomm;
752: *(char *)ip = ' ';
753: ip++;
754: nbad = 0;
755: for (cp = (char *)ip; cp < &argspac.argc[CLSIZE*NBPG]; cp++) {
756: c = *cp & 0177;
757: if (c == 0)
758: *cp = ' ';
759: else if (c < ' ' || c > 0176) {
760: if (++nbad >= 5*(eflg+1)) {
761: *cp++ = ' ';
762: break;
763: }
764: *cp = '?';
765: } else if (eflg == 0 && c == '=') {
766: while (*--cp != ' ')
767: if (cp <= (char *)ip)
768: break;
769: break;
770: }
771: }
772: *cp = 0;
773: while (*--cp == ' ')
774: *cp = 0;
775: cp = (char *)ip;
776: strncpy(cmdbuf, cp, &argspac.argc[CLSIZE*NBPG] - cp);
777: if (cp[0] == '-' || cp[0] == '?' || cp[0] <= ' ') {
778: strcat(cmdbuf, " (");
779: strncat(cmdbuf, u.u_comm, sizeof(u.u_comm));
780: strcat(cmdbuf, ")");
781: }
782: /*
783: if (xflg == 0 && gflg == 0 && tptr == 0 && cp[0] == '-')
784: return (0);
785: */
786: return (savestr(cmdbuf));
787:
788: bad:
789: fprintf(stderr, "ps: error locating command name for pid %d\n",
790: mproc->p_pid);
791: retucomm:
792: strcpy(cmdbuf, " (");
793: strncat(cmdbuf, u.u_comm, sizeof (u.u_comm));
794: strcat(cmdbuf, ")");
795: return (savestr(cmdbuf));
796: }
797:
798: char *lhdr =
799: " F UID PID PPID CP PRI NI ADDR SZ RSS WCHAN STAT TT TIME";
800: lpr(sp)
801: struct savcom *sp;
802: {
803: register struct asav *ap = sp->ap;
804: register struct lsav *lp = sp->sun.lp;
805:
806: printf("%6x%4d%6u%6u%3d%4d%3d%5x%4d%5d",
807: ap->a_flag, ap->a_uid,
808: ap->a_pid, lp->l_ppid, lp->l_cpu&0377, ap->a_pri-PZERO,
809: ap->a_nice-NZERO, lp->l_addr, ap->a_size/2, ap->a_rss/2);
810: printf(lp->l_wchan ? " %5x" : " ", (int)lp->l_wchan&0xfffff);
811: printf(" %4.4s ", state(ap));
812: ptty(ap->a_tty);
813: ptime(ap);
814: }
815:
816: ptty(tp)
817: char *tp;
818: {
819:
820: printf("%-2.2s", tp);
821: }
822:
823: ptime(ap)
824: struct asav *ap;
825: {
826:
827: printf("%3ld:%02ld", ap->a_cpu / HZ, ap->a_cpu % HZ);
828: }
829:
830: char *uhdr =
831: "USER PID %CPU %MEM SZ RSS TT STAT TIME";
832: upr(sp)
833: struct savcom *sp;
834: {
835: register struct asav *ap = sp->ap;
836: int vmsize, rmsize;
837:
838: vmsize = (ap->a_size + ap->a_tsiz)/2;
839: rmsize = ap->a_rss/2;
840: if (ap->a_xccount)
841: rmsize += ap->a_txtrss/ap->a_xccount/2;
842: printf("%-8.8s %5d%5.1f%5.1f%5d%5d",
843: getname(ap->a_uid), ap->a_pid, sp->sun.u_pctcpu, pmem(ap),
844: vmsize, rmsize);
845: putchar(' ');
846: ptty(ap->a_tty);
847: printf(" %4.4s", state(ap));
848: ptime(ap);
849: }
850:
851: char *vhdr =
852: " PID TT STAT TIME SL RE PAGEIN SIZE RSS SRS TSIZ TRS %CPU %MEM";
853: vpr(sp)
854: struct savcom *sp;
855: {
856: register struct vsav *vp = sp->sun.vp;
857: register struct asav *ap = sp->ap;
858:
859: printf("%5u ", ap->a_pid);
860: ptty(ap->a_tty);
861: printf(" %4.4s", state(ap));
862: ptime(ap);
863: printf("%3d%3d%7d%5d%5d%5d%5d%4d%5.1f%5.1f",
864: ap->a_slptime, ap->a_time > 99 ? 99 : ap->a_time, vp->v_majflt,
865: ap->a_size/2, ap->a_rss/2, vp->v_swrss/2,
866: ap->a_tsiz/2, ap->a_txtrss/2, vp->v_pctcpu, pmem(ap));
867: }
868:
869: char *shdr =
870: "SSIZ PID TT STAT TIME";
871: spr(sp)
872: struct savcom *sp;
873: {
874: register struct asav *ap = sp->ap;
875:
876: if (sflg)
877: printf("%4d ", sp->sun.s_ssiz);
878: printf("%5u", ap->a_pid);
879: putchar(' ');
880: ptty(ap->a_tty);
881: printf(" %4.4s", state(ap));
882: ptime(ap);
883: }
884:
885: char *
886: state(ap)
887: register struct asav *ap;
888: {
889: char stat, load, nice, anom;
890: static char res[5];
891:
892: switch (ap->a_stat) {
893:
894: case SSTOP:
895: stat = 'T';
896: break;
897:
898: case SSLEEP:
899: if (ap->a_pri >= PZERO)
900: if (ap->a_slptime >= MAXSLP)
901: stat = 'I';
902: else
903: stat = 'S';
904: else if (ap->a_flag & SPAGE)
905: stat = 'P';
906: else
907: stat = 'D';
908: break;
909:
910: case SWAIT:
911: case SRUN:
912: case SIDL:
913: stat = 'R';
914: break;
915:
916: case SZOMB:
917: stat = 'Z';
918: break;
919:
920: default:
921: stat = '?';
922: }
923: load = ap->a_flag & SLOAD ? ' ' : 'W';
924: if (ap->a_nice < NZERO)
925: nice = '<';
926: else if (ap->a_nice > NZERO)
927: nice = 'N';
928: else
929: nice = ' ';
930: anom = ap->a_flag & (SANOM|SUANOM) ? 'A' : ' ';
931: res[0] = stat; res[1] = load; res[2] = nice; res[3] = anom;
932: return (res);
933: }
934:
935: /*
936: * Given a base/size pair in virtual swap area,
937: * return a physical base/size pair which is the
938: * (largest) initial, physically contiguous block.
939: */
940: vstodb(vsbase, vssize, dmp, dbp, rev)
941: register int vsbase;
942: int vssize;
943: struct dmap *dmp;
944: register struct dblock *dbp;
945: {
946: register int blk = DMMIN;
947: register swblk_t *ip = dmp->dm_map;
948:
949: if (vsbase < 0 || vsbase + vssize > dmp->dm_size)
950: panic("vstodb");
951: while (vsbase >= blk) {
952: vsbase -= blk;
953: if (blk < DMMAX)
954: blk *= 2;
955: ip++;
956: }
957: if (*ip <= 0 || *ip + blk > nswap)
958: panic("vstodb *ip");
959: dbp->db_size = min(vssize, blk - vsbase);
960: dbp->db_base = *ip + (rev ? blk - (vsbase + dbp->db_size) : vsbase);
961: }
962:
963: /*ARGSUSED*/
964: panic(cp)
965: char *cp;
966: {
967:
968: #ifdef DEBUG
969: printf("%s\n", cp);
970: #endif
971: }
972:
973: min(a, b)
974: {
975:
976: return (a < b ? a : b);
977: }
978:
979: pscomp(s1, s2)
980: struct savcom *s1, *s2;
981: {
982: register int i;
983:
984: if (uflg)
985: return (s2->sun.u_pctcpu > s1->sun.u_pctcpu ? 1 : -1);
986: if (vflg)
987: return (vsize(s2) - vsize(s1));
988: i = s1->ap->a_ttyd - s2->ap->a_ttyd;
989: if (i == 0)
990: i = s1->ap->a_pid - s2->ap->a_pid;
991: return (i);
992: }
993:
994: vsize(sp)
995: struct savcom *sp;
996: {
997: register struct asav *ap = sp->ap;
998: register struct vsav *vp = sp->sun.vp;
999:
1000: if (ap->a_flag & SLOAD)
1001: return (ap->a_rss +
1002: ap->a_txtrss / (ap->a_xccount ? ap->a_xccount : 1));
1003: return (vp->v_swrss + (ap->a_xccount ? 0 : vp->v_txtswrss));
1004: }
1005:
1006: #define NMAX 8
1007: #define NUID 2048
1008:
1009: char names[NUID][NMAX+1];
1010:
1011: /*
1012: * Stolen from ls...
1013: */
1014: char *
1015: getname(uid)
1016: {
1017: register struct passwd *pw;
1018: static init;
1019: struct passwd *getpwent();
1020:
1021: if (uid >= 0 && uid < NUID && names[uid][0])
1022: return (&names[uid][0]);
1023: if (init == 2)
1024: return (0);
1025: if (init == 0)
1026: setpwent(), init = 1;
1027: while (pw = getpwent()) {
1028: if (pw->pw_uid >= NUID)
1029: continue;
1030: if (names[pw->pw_uid][0])
1031: continue;
1032: strncpy(names[pw->pw_uid], pw->pw_name, NMAX);
1033: if (pw->pw_uid == uid)
1034: return (&names[uid][0]);
1035: }
1036: init = 2;
1037: endpwent();
1038: return (0);
1039: }
1040:
1041: char *freebase;
1042: int nleft;
1043:
1044: char *
1045: alloc(size)
1046: int size;
1047: {
1048: register char *cp;
1049: register int i;
1050:
1051: if (size > nleft) {
1052: freebase = (char *)sbrk(i = size > 2048 ? size : 2048);
1053: if (freebase == 0) {
1054: fprintf(stderr, "ps: ran out of memory\n");
1055: exit(1);
1056: }
1057: nleft = i - size;
1058: } else
1059: nleft -= size;
1060: cp = freebase;
1061: for (i = size; --i >= 0; )
1062: *cp++ = 0;
1063: freebase = cp;
1064: return (cp - size);
1065: }
1066:
1067: char *
1068: savestr(cp)
1069: char *cp;
1070: {
1071: register int len;
1072: register char *dp;
1073:
1074: len = strlen(cp);
1075: dp = (char *)alloc(len+1);
1076: strcpy(dp, cp);
1077: return (dp);
1078: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.