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