![[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] / 43BSDReno / bin / ps|
Return to ps.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / bin / ps |
1.1 root 1: /*-
2: * Copyright (c) 1990 The Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms are permitted provided
6: * that: (1) source distributions retain this entire copyright notice and
7: * comment, and (2) distributions including binaries display the following
8: * acknowledgement: ``This product includes software developed by the
9: * University of California, Berkeley and its contributors'' in the
10: * documentation or other materials provided with the distribution and in
11: * all advertising materials mentioning features or use of this software.
12: * Neither the name of the University nor the names of its contributors may
13: * be used to endorse or promote products derived from this software without
14: * specific prior written permission.
15: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
16: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
17: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
18: */
19:
20: #ifndef lint
21: char copyright[] =
22: "@(#) Copyright (c) 1990 The Regents of the University of California.\n\
23: All rights reserved.\n";
24: #endif /* not lint */
25:
26: #ifndef lint
27: static char sccsid[] = "@(#)ps.c 5.28 (Berkeley) 6/26/90";
28: #endif /* not lint */
29:
30: #include <machine/pte.h>
31:
32: #include <sys/param.h>
33: #include <sys/ioctl.h>
34: #include <sys/tty.h>
35: #include <sys/user.h>
36: #include <sys/proc.h>
37: #include <sys/vm.h>
38: #include <sys/text.h>
39: #include <sys/stat.h>
40: #include <sys/mbuf.h>
41: #include <nlist.h>
42: #include <pwd.h>
43: #include <math.h>
44: #include <errno.h>
45: #include <stdio.h>
46: #include <ctype.h>
47: #include <kvm.h>
48:
49: struct usave {
50: struct proc *u_procp;
51: struct timeval u_start;
52: struct rusage u_ru;
53: struct rusage u_cru;
54: short u_cmask;
55: char u_acflag;
56: };
57:
58: /*
59: * to compute offset in common structures
60: */
61: #define POFF(x) ((int)&((struct proc *)0)->x)
62: #define EOFF(x) ((int)&((struct eproc *)0)->x)
63: #define UOFF(x) ((int)&((struct usave *)0)->x)
64: #define ROFF(x) ((int)&((struct rusage *)0)->x)
65:
66: enum type { CHAR, UCHAR, SHORT, USHORT, LONG, ULONG, KPTR };
67:
68: #define UIDFMT "u"
69: #define UIDLEN 5
70: #define PIDFMT "d"
71: #define PIDLEN 5
72: #define USERLEN 8
73:
74: int needuser, needcomm, neednlist;
75:
76: int command(), ucomm(), logname(), pvar(), evar(), uvar(), rvar(), uname(),
77: runame(), state(), pri(), tdev(), tname(), longtname(), started(),
78: lstarted(), wchan(), vsize(), rssize(), p_rssize(), cputime(),
79: pmem(), pcpu(), pagein(), maxrss(), tsize(), trss();
80: /**
81: utime(), stime(), ixrss(), idrss(), isrss();
82: **/
83:
84: struct usave *saveuser();
85: char *saveargs();
86:
87: struct var {
88: char *name[8]; /* name(s) of variable */
89: char *header; /* default header */
90: int flag;
91: #define USER 0x01 /* requires user structure */
92: #define LJUST 0x02 /* right adjust on output */
93: #define COMM 0x04 /* requires exec arguments and environment (XXX) */
94: #define NLIST 0x08 /* requires nlist to get extra variables */
95: int (*oproc)(); /* output routine */
96: short width; /* printing width */
97: /*
98: * The following (optional) elements are hooks for passing information
99: * to the generic output routines: pvar, evar, uvar (those which print
100: * simple elements from well known structures: proc, eproc, usave)
101: */
102: int off; /* offset in structure */
103: enum type type; /* type of element */
104: char *fmt; /* printf format */
105: /*
106: * glue to link selected fields together
107: */
108: struct var *next;
109: } var[] = {
110: {{"command", "comm", "args"}, "COMMAND", USER|LJUST|COMM,
111: command, 16},
112: {{"ucomm"}, "COMMAND", LJUST, ucomm, MAXCOMLEN},
113: {{"logname"}, "LOGNAME", LJUST, logname, MAXLOGNAME},
114: {{"flag", "f"}, "F", 0, pvar, 7, POFF(p_flag), LONG, "x"},
115: {{"uid"}, "UID", 0, pvar, UIDLEN, POFF(p_uid),USHORT, UIDFMT},
116: {{"ruid"}, "RUID", 0, pvar, UIDLEN, POFF(p_ruid), USHORT, UIDFMT},
117: {{"svuid"}, "SVUID", 0, pvar, UIDLEN, POFF(p_svuid), USHORT, UIDFMT},
118: {{"rgid"}, "RGID", 0, pvar, UIDLEN, POFF(p_rgid), USHORT, UIDFMT},
119: {{"svgid"}, "SVGID", 0, pvar, UIDLEN, POFF(p_svgid), USHORT, UIDFMT},
120: {{"pid"}, "PID", 0, pvar, PIDLEN, POFF(p_pid),SHORT, PIDFMT},
121: {{"ppid"}, "PPID", 0, pvar, PIDLEN, POFF(p_ppid), SHORT, PIDFMT},
122: {{"cp", "cpu"}, "CP", 0, pvar, 3, POFF(p_cpu), UCHAR, "d"},
123: {{"xstat"}, "XSTAT", 0, pvar, 4, POFF(p_xstat), USHORT, "x"},
124: {{"poip"}, "POIP", 0, pvar, 4, POFF(p_poip), SHORT, "d"},
125: {{"nwchan"}, "WCHAN", 0, pvar, 6, POFF(p_wchan), KPTR, "x"},
126: {{"wchan"}, "WCHAN", LJUST, wchan, 6},
127: {{"rlink"}, "RLINK", 0, pvar, 8, POFF(p_rlink), KPTR, "x"},
128: {{"ktrace", "traceflag"}, "KTRACE",
129: 0, pvar, 8, POFF(p_traceflag), LONG, "x"},
130: {{"ktracep", "tracep"}, "KTRACEP",
131: 0, pvar, 8, POFF(p_tracep), LONG, "x"},
132: {{"sig", "pending"}, "PENDING",
133: 0, pvar, 8, POFF(p_sig), LONG, "x"},
134: {{"sigmask", "blocked"}, "BLOCKED",
135: 0, pvar, 8, POFF(p_sigmask), LONG, "x"},
136: {{"sigignore", "ignored"}, "IGNORED",
137: 0, pvar, 8, POFF(p_sigignore), LONG, "x"},
138: {{"sigcatch", "caught"}, "CAUGHT",
139: 0, pvar, 8, POFF(p_sigcatch), LONG, "x"},
140: {{"user", "uname"}, "USER", LJUST, uname, USERLEN},
141: {{"ruser", "runame"}, "RUSER", LJUST, runame, USERLEN},
142: {{"pgid"}, "PGID", 0, evar, PIDLEN, EOFF(e_pgid), USHORT, PIDFMT},
143: {{"jobc"}, "JOBC", 0, evar, 4, EOFF(e_jobc), SHORT, "d"},
144: {{"sess", "session"}, "SESS", 0, evar, 6, EOFF(e_sess), KPTR, "x"},
145: {{"tdev", "dev"}, "TDEV", 0, tdev, 4},
146: {{"tname", "tty", "tt"}, "TT", LJUST, tname, 3},
147: {{"longtname", "longtty"}, "TT", LJUST, longtname, 8},
148: {{"tpgid"}, "TPGID", 0, evar, 4, EOFF(e_tpgid), USHORT, PIDFMT},
149: {{"tsession", "tsess"}, "TSESS",
150: 0, evar, 6, EOFF(e_tsess), KPTR, "x"},
151: {{"paddr", "procaddr"}, "PADDR",
152: 0, evar, 6, EOFF(e_paddr), KPTR, "x"},
153: {{"state", "stat"}, "STAT", 0, state, 4},
154: {{"pri"}, "PRI", 0, pri, 3},
155: {{"usrpri"}, "UPR", 0, pvar, 3, POFF(p_usrpri), CHAR, "d"},
156: {{"nice", "ni"}, "NI", 0, pvar, 2, POFF(p_nice), CHAR, "d"},
157: {{"vsize", "vsz"}, "VSZ", 0, vsize, 5},
158: {{"rssize", "rsz"}, "RSZ", 0, rssize, 4},
159: {{"rss", "p_rss"}, "RSS", 0, p_rssize, 4},
160: {{"u_procp", "uprocp"}, "UPROCP",
161: USER, uvar, 6, UOFF(u_procp), KPTR, "x"},
162: {{"umask", "u_cmask"}, "UMASK",
163: USER, uvar, 3, UOFF(u_cmask), CHAR, "#o"},
164: {{"acflag", "acflg"}, "ACFLG",
165: USER, uvar, 3, UOFF(u_acflag), SHORT, "x"},
166: {{"start"}, "STARTED", USER|LJUST, started, 8},
167: {{"lstart"}, "STARTED", USER|LJUST, lstarted, 28},
168: {{"cputime", "time"}, "TIME", USER, cputime, 9},
169: {{"p_ru"}, "P_RU", 0, pvar, 6, POFF(p_ru), KPTR, "x"},
170: {{"pcpu", "%cpu"}, "%CPU", NLIST, pcpu, 4},
171: {{"pmem", "%mem"}, "%MEM", NLIST, pmem, 4},
172: {{"sl", "slp", "slptime"}, "SL",
173: 0, pvar, 3, POFF(p_slptime), CHAR, "d"},
174: {{"re", "resident"}, "RE",
175: 0, pvar, 3, POFF(p_time), CHAR, "d"},
176: {{"pagein", "majflt"}, "PAGEIN", USER, pagein, 6},
177: {{"lim", "maxrss"}, "LIM", 0, maxrss, 5},
178: {{"tsiz"}, "TSIZ", 0, tsize, 4},
179: {{"trs"}, "TRS", 0, trss, 3},
180: /***
181: {{"utime"}, "UTIME", USER, utime, 4},
182: {{"stime"}, "STIME", USER, stime, 4},
183: {{"ixrss"}, "IXRSS", USER, ixrss, 4},
184: {{"idrss"}, "IDRSS", USER, idrss, 4},
185: {{"isrss"}, "ISRSS", USER, isrss, 4},
186: ***/
187: {{"minflt"}, "MINFLT",
188: USER, rvar, 4, ROFF(ru_minflt), LONG, "d"},
189: {{"majflt"}, "MAJFLT",
190: USER, rvar, 4, ROFF(ru_majflt), LONG, "d"},
191: {{"nswap"}, "NSWAP",
192: USER, rvar, 4, ROFF(ru_nswap), LONG, "d"},
193: {{"inblock", "inblk"}, "INBLK",
194: USER, rvar, 4, ROFF(ru_inblock), LONG, "d"},
195: {{"oublock", "oublk"}, "OUBLK",
196: USER, rvar, 4, ROFF(ru_oublock), LONG, "d"},
197: {{"msgsnd"}, "MSGSND",
198: USER, rvar, 4, ROFF(ru_msgsnd), LONG, "d"},
199: {{"msgrcv"}, "MSGRCV",
200: USER, rvar, 4, ROFF(ru_msgrcv), LONG, "d"},
201: {{"nsignals", "nsigs"}, "NSIGS",
202: USER, rvar, 4, ROFF(ru_nsignals), LONG, "d"},
203: {{"nvcsw", "vcsw"}, "VCSW",
204: USER, rvar, 5, ROFF(ru_nvcsw), LONG, "d"},
205: {{"nivcsw", "ivcsw"}, "IVCSW",
206: USER, rvar, 5, ROFF(ru_nivcsw), LONG, "d"},
207: NULL
208: };
209:
210: /*
211: * combination variables
212: */
213: struct combovar {
214: char *name;
215: char *replace;
216: } combovar[] = {
217: "RUSAGE", "minflt majflt nswap inblock oublock \
218: msgsnd msgrcv nsigs nvcsw nivcsw",
219: 0, 0
220: };
221: #define DFMT "pid tname state cputime comm"
222: #define LFMT \
223: "uid pid ppid cp pri nice vsz rss wchan state tname cputime comm"
224: #define JFMT "user pid ppid pgid sess jobc state tname cputime comm"
225: #define SFMT "uid pid sig sigmask sigignore sigcatch stat tname comm"
226: #define VFMT \
227: "pid tt state time sl re pagein vsz rss lim tsiz trs %cpu %mem comm"
228: #define UFMT \
229: "uname pid %cpu %mem vsz rss tt state start time comm"
230:
231: struct kinfo {
232: struct proc *ki_p; /* proc structure */
233: struct eproc *ki_e; /* extra stuff */
234: struct usave *ki_u; /* interesting parts of user */
235: char *ki_args; /* exec args (should be char **) */
236: char *ki_env; /* environment (should be char **) */
237: } *kinfo;
238:
239: struct var *vhead, *vtail;
240: int termwidth; /* width of screen (0 == infinity) */
241: #define UNLIMITED 0
242: int totwidth; /* calculated width of requested variables */
243: int sumrusage;
244: int rawcpu;
245: int sortby;
246: #define SORTMEM 1
247: #define SORTCPU 2
248:
249: int uid = -1;
250: dev_t ttydev = NODEV;
251: int pid = -1;
252: int all;
253: int xflg;
254: int prtheader;
255: int lineno;
256:
257: /*
258: * variables retrieved via nlist
259: */
260: struct nlist psnl[] = {
261: {"_ecmx"},
262: #define X_ECMX 0
263: {"_fscale"},
264: #define X_FSCALE 1
265: {"_ccpu"},
266: #define X_CCPU 2
267: {NULL}
268: };
269: int fscale;
270: int ecmx;
271: fixpt_t ccpu;
272:
273: #define USAGE "ps [ -(o|O) fmt ] [ -wlvujnsaxSCLmcr ] [ -p pid ] [ -t tty ]"
274:
275: main (argc, argv)
276: char *argv[];
277: {
278: extern char *optarg;
279: extern int optind;
280: int ch;
281: register i;
282: register struct var *v;
283: register struct proc *p;
284: struct winsize ws;
285: struct kinfo_proc *kprocs;
286: int nentries;
287: int fmt = 0;
288: int pscomp();
289: int what, flag;
290: char *kludge_oldps_options();
291:
292: if ((ioctl(1, TIOCGWINSZ, &ws) == -1 &&
293: ioctl(2, TIOCGWINSZ, &ws) == -1 &&
294: ioctl(0, TIOCGWINSZ, &ws) == -1) ||
295: ws.ws_col == 0)
296: termwidth = 79;
297: else
298: termwidth = ws.ws_col - 1;
299: if (argc > 1)
300: argv[1] = kludge_oldps_options(argv[1]);
301:
302: while ((ch = getopt(argc, argv, "o:O:wlvujnsaxt:p:SCLmrhTg")) != EOF)
303: switch((char)ch) {
304: case 'o':
305: parsefmt(optarg);
306: fmt++;
307: break;
308: case 'O':
309: parsefmt("pid");
310: parsefmt(optarg);
311: parsefmt("state tt time command");
312: fmt++;
313: break;
314: case 'w':
315: if (termwidth < 131)
316: termwidth = 131;
317: else
318: termwidth = UNLIMITED;
319: break;
320: case 'l':
321: parsefmt(LFMT);
322: fmt++;
323: break;
324: case 'v':
325: parsefmt(VFMT);
326: sortby = SORTMEM;
327: fmt++;
328: break;
329: case 'u':
330: parsefmt(UFMT);
331: sortby = SORTCPU;
332: fmt++;
333: break;
334: case 'j':
335: parsefmt(JFMT);
336: fmt++;
337: break;
338: case 's':
339: parsefmt(SFMT);
340: fmt++;
341: break;
342: case 'T':
343: case 't': {
344: struct stat stbuf;
345: char *tname, *ttyname();
346: char termname[MAXPATHLEN+1];
347:
348: if (ch == 'T') {
349: if ((tname = ttyname(0)) == NULL)
350: error("<stdin>: not a terminal");
351: } else
352: tname = optarg;
353: if (strlen(tname) == 2) {
354: if (strcmp(tname, "co") == 0)
355: strcpy(termname, "/dev/console");
356: else {
357: strcpy(termname, "/dev/tty");
358: strcat(termname, tname);
359: }
360: } else if (*tname != '/') {
361: strcpy(termname, "/dev/");
362: strcat(termname, tname);
363: } else
364: strcpy(termname, tname);
365: if (stat(termname, &stbuf) == -1)
366: syserror(termname);
367: if ((stbuf.st_mode & S_IFMT) != S_IFCHR)
368: error("%s: not a terminal", termname);
369: ttydev = stbuf.st_rdev;
370: break;
371: }
372: case 'p':
373: pid = atoi(optarg);
374: xflg++;
375: break;
376: case 'S':
377: sumrusage++;
378: break;
379: case 'C':
380: rawcpu++;
381: break;
382: case 'L': {
383: int i = 0;
384: struct combovar *cb = &combovar[0];
385: char *cp;
386:
387: v = &var[0];
388: for (;;) {
389: if (v->name[0] != NULL) {
390: cp = v->name[0];
391: v++;
392: } else if (cb->name != NULL) {
393: cp = cb->name;
394: cb++;
395: } else
396: break;
397: if (termwidth &&
398: (i += strlen(cp)+1) > termwidth)
399: i = strlen(cp), printf("\n");
400: printf("%s ", cp);
401: }
402: printf("\n");
403: exit(0);
404: }
405: case 'a':
406: all++;
407: break;
408: case 'x':
409: xflg++;
410: break;
411: case 'm':
412: sortby = SORTMEM;
413: break;
414: case 'r':
415: sortby = SORTCPU;
416: break;
417: case 'h':
418: prtheader = ws.ws_row > 5 ? ws.ws_row : 22;
419: break;
420: case 'g':
421: break; /* no-op */
422: case '?':
423: default:
424: fprintf(stderr, "usage: %s\n", USAGE);
425: exit(1);
426: }
427: argc -= optind;
428: argv += optind;
429:
430: if (*argv) {
431: char *nlistf, *memf = NULL, *swapf = NULL;
432:
433: nlistf = *argv++;
434: if (*argv) {
435: memf = *argv++;
436: if (*argv)
437: swapf = *argv++;
438: }
439: if (kvm_openfiles(nlistf, memf, swapf) == -1)
440: error("kvm_openfiles: %s", kvm_geterr());
441: }
442:
443: if (!fmt)
444: parsefmt(DFMT);
445:
446: if (!all && ttydev == NODEV && pid == -1) /* XXX - should be cleaner */
447: uid = getuid();
448:
449: /*
450: * scan requested variables, noting what structures are needed,
451: * and adjusting header widths as appropiate.
452: */
453: scanvars();
454: #ifdef notdef
455: if (sortby == SORTCPU)
456: neednlist = 1;
457: #endif
458: if (neednlist)
459: donlist();
460: /*
461: * get proc list
462: */
463: if (uid != -1) {
464: what = KINFO_PROC_UID;
465: flag = uid;
466: } else if (ttydev != NODEV) {
467: what = KINFO_PROC_TTY;
468: flag = ttydev;
469: } else if (pid != -1) {
470: what = KINFO_PROC_PID;
471: flag = pid;
472: } else
473: what = KINFO_PROC_ALL;
474: /*
475: * select procs
476: */
477: if ((nentries = kvm_getprocs(what, flag)) == -1) {
478: fprintf(stderr, "ps: %s\n", kvm_geterr());
479: exit(1);
480: }
481: kinfo = (struct kinfo *)malloc(nentries * sizeof (struct kinfo));
482: if (kinfo == NULL)
483: error("out of memory");
484: i = 0;
485: while ((p = kvm_nextproc()) != NULL) {
486: kinfo[i].ki_p = p;
487: kinfo[i].ki_e = kvm_geteproc(p);
488: if (needuser)
489: saveuser(&kinfo[i]);
490: i++;
491: }
492: nentries = i;
493: /*
494: * print header
495: */
496: printheader();
497: if (nentries == 0)
498: exit(0);
499: /*
500: * sort proc list
501: */
502: qsort(kinfo, nentries, sizeof (struct kinfo), pscomp);
503: /*
504: * for each proc, call each variable output function.
505: */
506: for (i = 0; i < nentries; i++) {
507: if (xflg == 0 && (kinfo[i].ki_e->e_tdev == NODEV ||
508: (kinfo[i].ki_p->p_flag & SCTTY ) == 0))
509: continue;
510: for (v = vhead; v != NULL; v = v->next) {
511: (*v->oproc)(&kinfo[i], v);
512: if (v->next != NULL)
513: putchar(' ');
514: }
515: putchar('\n');
516: if (prtheader && lineno++ == prtheader-4) {
517: putchar('\n');
518: printheader();
519: lineno = 0;
520: }
521: }
522:
523: exit(0);
524: }
525:
526: #define FMTSEP " \t,\n"
527:
528: parsefmt(fmt)
529: char *fmt;
530: {
531: register char *f = fmt, *cp, *hp;
532: struct var *v;
533: char *strtok(), *index();
534: char newbuf[1024], *nb = newbuf; /* XXX */
535: char *lookupcombo();
536: struct var *lookupvar();
537:
538: /*
539: * strtok is not &^%^& re-entrant, so we have
540: * only one level of expansion, looking for combo
541: * variables once here, and expanding the string
542: * before really parsing it. With strtok_r,
543: * you would move the expansion to before the
544: * lookupvar inside the 2nd while loop with a
545: * recursive call to parsefmt.
546: */
547: while ((cp = strtok(f, FMTSEP)) != NULL) {
548: if ((hp = lookupcombo(cp)) == NULL);
549: hp = cp;
550: if (((nb + strlen(hp)) - newbuf) >= 1024)
551: error("format too large");
552: strcpy(nb, hp);
553: while (*nb)
554: nb++;
555: *nb++ = ' ';
556: *nb = '\0';
557: f = NULL;
558: }
559: f = newbuf;
560: while ((cp = strtok(f, FMTSEP)) != NULL) {
561: if (hp = index(cp, '='))
562: *hp++ = '\0';
563: v = lookupvar(cp);
564: if (v == NULL)
565: error("unknown variable in format: %s", cp);
566: if (v->next != NULL || vtail == v)
567: error("can't specify a variable twice: %s", cp);
568: if (hp)
569: v->header = hp;
570: if (vhead == NULL)
571: vhead = vtail = v;
572: else {
573: vtail->next = v;
574: vtail = v;
575: }
576: f = NULL; /* for strtok */
577: }
578:
579: }
580:
581: scanvars()
582: {
583: register i;
584: register struct var *v;
585:
586: for (v = vhead; v != NULL; v = v->next) {
587: i = strlen(v->header);
588: if (v->width < i)
589: v->width = i;
590: totwidth += v->width + 1; /* +1 for space */
591: if (v->flag & USER)
592: needuser = 1;
593: if (v->flag & COMM)
594: needcomm = 1;
595: if (v->flag & NLIST)
596: neednlist = 1;
597: }
598: totwidth--;
599: }
600: printheader()
601: {
602: register struct var *v;
603:
604: for (v = vhead; v != NULL; v = v->next) {
605: if (v->flag & LJUST) {
606: if (v->next == NULL) /* last one */
607: printf("%s", v->header);
608: else
609: printf("%-*s",v->width, v->header);
610: } else
611: printf("%*s",v->width, v->header);
612: if (v->next != NULL)
613: putchar(' ');
614: }
615: putchar('\n');
616: }
617:
618: command(k, v)
619: struct kinfo *k;
620: struct var *v;
621: {
622:
623: if (v->next == NULL) {
624: /* last field */
625: if (termwidth == UNLIMITED)
626: printf("%s", k->ki_args);
627: else {
628: register left = termwidth - (totwidth - v->width);
629: register char *cp = k->ki_args;
630:
631: if (left < 1) /* already wrapped, just use std width */
632: left = v->width;
633: while (left-- && *cp)
634: putchar(*cp++);
635: }
636: } else
637: printf("%-*.*s", v->width, v->width, k->ki_args);
638:
639: }
640:
641: ucomm(k, v)
642: struct kinfo *k;
643: struct var *v;
644: {
645:
646: printf("%-*s", v->width, k->ki_p->p_comm);
647: }
648:
649: logname(k, v)
650: struct kinfo *k;
651: struct var *v;
652: {
653:
654: printf("%-*s", v->width, k->ki_p->p_logname);
655: }
656:
657: state(k, v)
658: struct kinfo *k;
659: struct var *v;
660: {
661: char buf[16];
662: register char *cp = buf;
663: register struct proc *p = k->ki_p;
664: register flag = p->p_flag;
665:
666: switch (p->p_stat) {
667:
668: case SSTOP:
669: *cp = 'T';
670: break;
671:
672: case SSLEEP:
673: if (flag & SSINTR) /* interuptable (long) */
674: *cp = p->p_slptime >= MAXSLP ? 'I' : 'S';
675: else
676: *cp = (flag & SPAGE) ? 'P' : 'D';
677: break;
678:
679: case SRUN:
680: case SIDL:
681: *cp = 'R';
682: break;
683:
684: case SZOMB:
685: *cp = 'Z';
686: break;
687:
688: default:
689: *cp = '?';
690: }
691: cp++;
692: if (flag & SLOAD) {
693: if (p->p_rssize > p->p_maxrss)
694: *cp++ = '>';
695: } else
696: *cp++ = 'W';
697: if (p->p_nice < NZERO)
698: *cp++ = '<';
699: else if (p->p_nice > NZERO)
700: *cp++ = 'N';
701: if (flag & SUANOM)
702: *cp++ = 'A';
703: else if (flag & SSEQL)
704: *cp++ = 'S';
705: if (flag & STRC)
706: *cp++ = 'X';
707: if (flag & SWEXIT)
708: *cp++ = 'E';
709: if (flag & SVFORK)
710: *cp++ = 'V';
711: if (flag & (SSYS|SLOCK|SULOCK|SKEEP|SPHYSIO))
712: *cp++ = 'L';
713: if (k->ki_e->e_flag & EPROC_SLEADER)
714: *cp++ = 's';
715: if ((flag & SCTTY) && k->ki_e->e_pgid == k->ki_e->e_tpgid)
716: *cp++ = '+';
717: *cp = '\0';
718: printf("%-*s", v->width, buf);
719: }
720:
721: pri(k, v)
722: struct kinfo *k;
723: struct var *v;
724: {
725:
726: printf("%*d", v->width, k->ki_p->p_pri - PZERO);
727: }
728:
729: uname(k, v)
730: struct kinfo *k;
731: struct var *v;
732: {
733:
734: printf("%-*s", v->width, user_from_uid(k->ki_p->p_uid, 0));
735: }
736:
737: runame(k, v)
738: struct kinfo *k;
739: struct var *v;
740: {
741:
742: printf("%-*s", v->width, user_from_uid(k->ki_p->p_ruid, 0));
743: }
744:
745: tdev(k, v)
746: struct kinfo *k;
747: struct var *v;
748: {
749: dev_t dev = k->ki_e->e_tdev;
750:
751: if (dev == NODEV)
752: printf("%*s", v->width, "??");
753: else {
754: char buff[16];
755:
756: sprintf(buff, "%d/%d", major(dev), minor(dev));
757: printf("%*s", v->width, buff);
758: }
759: }
760:
761: extern char *devname();
762:
763: tname(k, v)
764: struct kinfo *k;
765: struct var *v;
766: {
767: dev_t dev = k->ki_e->e_tdev;
768: char *tname;
769:
770: if (dev == NODEV || (tname = devname(dev, S_IFCHR)) == NULL)
771: printf("%-*s", v->width, "??");
772: else {
773: if (strncmp(tname, "tty", 3) == 0)
774: tname += 3;
775: printf("%*.*s%c", v->width-1, v->width-1, tname,
776: k->ki_e->e_flag & EPROC_CTTY ? ' ' : '-');
777: }
778: }
779:
780: longtname(k, v)
781: struct kinfo *k;
782: struct var *v;
783: {
784: dev_t dev = k->ki_e->e_tdev;
785: char *tname;
786:
787: if (dev == NODEV || (tname = devname(dev, S_IFCHR)) == NULL)
788: printf("%-*s", v->width, "??");
789: else
790: printf("%-*s", v->width, tname);
791: }
792:
793: #include <sys/time.h>
794:
795: started(k, v)
796: struct kinfo *k;
797: struct var *v;
798: {
799: extern char *attime();
800:
801: printf("%-*s", v->width, k->ki_u ?
802: attime(&k->ki_u->u_start.tv_sec) : "-");
803:
804: }
805:
806: lstarted(k, v)
807: struct kinfo *k;
808: struct var *v;
809: {
810: extern char *ctime();
811: char *tp;
812:
813: if (k->ki_u)
814: (tp = ctime(&k->ki_u->u_start.tv_sec))[24] = '\0';
815: else
816: tp = "-";
817: printf("%-*s", v->width, tp);
818: }
819:
820: wchan(k, v)
821: struct kinfo *k;
822: struct var *v;
823: {
824:
825: if (k->ki_p->p_wchan) {
826: if (k->ki_p->p_pri > PZERO)
827: printf("%-*.*s", v->width, v->width, k->ki_e->e_wmesg);
828: else
829: printf("%*x", v->width,
830: (int)k->ki_p->p_wchan &~ KERNBASE);
831: } else
832: printf("%-*s", v->width, "-");
833: }
834:
835: #define pgtok(a) (((a)*NBPG)/1024)
836: #define pgtok(a) (((a)*NBPG)/1024)
837:
838: vsize(k, v)
839: struct kinfo *k;
840: struct var *v;
841: {
842:
843: printf("%*d", v->width,
844: pgtok(k->ki_p->p_dsize + k->ki_p->p_ssize + k->ki_e->e_xsize));
845: }
846:
847: rssize(k, v)
848: struct kinfo *k;
849: struct var *v;
850: {
851:
852: printf("%*d", v->width,
853: pgtok(k->ki_p->p_rssize + (k->ki_e->e_xccount ?
854: (k->ki_e->e_xrssize / k->ki_e->e_xccount) : 0)));
855: }
856:
857: p_rssize(k, v) /* doesn't account for text */
858: struct kinfo *k;
859: struct var *v;
860: {
861:
862: printf("%*d", v->width, pgtok(k->ki_p->p_rssize));
863: }
864:
865: cputime(k, v)
866: struct kinfo *k;
867: struct var *v;
868: {
869: long secs;
870: long psecs; /* "parts" of a second. first micro, then centi */
871: char obuff[128];
872:
873: if (k->ki_p->p_stat == SZOMB || k->ki_u == NULL) {
874: secs = 0;
875: psecs = 0;
876: } else {
877: secs = k->ki_p->p_utime.tv_sec +
878: k->ki_p->p_stime.tv_sec;
879: psecs = k->ki_p->p_utime.tv_usec +
880: k->ki_p->p_stime.tv_usec;
881: if (sumrusage) {
882: secs += k->ki_u->u_cru.ru_utime.tv_sec +
883: k->ki_u->u_cru.ru_stime.tv_sec;
884: psecs += k->ki_u->u_cru.ru_utime.tv_usec +
885: k->ki_u->u_cru.ru_stime.tv_usec;
886: }
887: /*
888: * round and scale to 100's
889: */
890: psecs = (psecs + 5000) / 10000;
891: if (psecs >= 100) {
892: psecs -= 100;
893: secs++;
894: }
895: }
896: sprintf(obuff, "%3ld:%02ld.%02ld", secs/60, secs%60, psecs);
897: printf("%*s", v->width, obuff);
898: }
899:
900: double
901: getpcpu(k)
902: struct kinfo *k;
903: {
904: /*
905: * note: this routine requires ccpu and fscale
906: * be initialized. If you call this routine from
907: * somewhere new, insure that the "neednlist" flag
908: * gets set.
909: */
910: struct proc *p = k->ki_p;
911: #define fxtofl(fixpt) ((double)(fixpt) / fscale)
912:
913: if (p->p_time == 0 || (p->p_flag & SLOAD) == 0) /* XXX - I don't like this */
914: return (0.0);
915: if (rawcpu)
916: return (100.0 * fxtofl(p->p_pctcpu));
917: return (100.0 * fxtofl(p->p_pctcpu) /
918: (1.0 - exp(p->p_time * log(fxtofl(ccpu)))));
919: }
920:
921: pcpu(k, v)
922: struct kinfo *k;
923: struct var *v;
924: {
925:
926: printf("%*.1f", v->width, getpcpu(k));
927: }
928:
929: double
930: getpmem(k, v)
931: struct kinfo *k;
932: struct var *v;
933: {
934: struct proc *p = k->ki_p;
935: struct eproc *e = k->ki_e;
936: double fracmem;
937: int szptudot;
938: /*
939: * note: this routine requires that ecmx
940: * be initialized. If you call this routine from
941: * somewhere new, insure that the "neednlist" flag
942: * gets set.
943: */
944:
945: if (p->p_flag & SLOAD == 0)
946: return (0.0);
947: szptudot = UPAGES + clrnd(ctopt(p->p_dsize + p->p_ssize + e->e_xsize));
948: fracmem = ((float)p->p_rssize + szptudot)/CLSIZE/ecmx;
949: if (p->p_textp && e->e_xccount)
950: fracmem += ((float)e->e_xrssize)/CLSIZE/e->e_xccount/ecmx;
951: return (100.0 * fracmem);
952: }
953:
954: pmem(k, v)
955: struct kinfo *k;
956: struct var *v;
957: {
958:
959: printf("%*.1f", v->width, getpmem(k));
960: }
961:
962: pagein(k, v)
963: struct kinfo *k;
964: struct var *v;
965: {
966:
967: printf("%*d", v->width, k->ki_u ? k->ki_u->u_ru.ru_majflt : 0);
968: }
969:
970: maxrss(k, v)
971: struct kinfo *k;
972: struct var *v;
973: {
974:
975: if (k->ki_p->p_maxrss != (RLIM_INFINITY/NBPG))
976: printf("%*d", v->width, pgtok(k->ki_p->p_maxrss));
977: else
978: printf("%*s", v->width, "-");
979: }
980:
981: tsize(k, v)
982: struct kinfo *k;
983: struct var *v;
984: {
985:
986: printf("%*d", v->width, pgtok(k->ki_e->e_xsize));
987: }
988:
989: trss(k, v)
990: struct kinfo *k;
991: struct var *v;
992: {
993:
994: printf("%*d", v->width, pgtok(k->ki_e->e_xrssize));
995: }
996:
997: /*
998: * Generic output routines. Print fields from various prototype
999: * structures.
1000: */
1001: pvar(k, v)
1002: struct kinfo *k;
1003: struct var *v;
1004: {
1005:
1006: printval((char *)((char *)k->ki_p + v->off), v);
1007: }
1008:
1009: evar(k, v)
1010: struct kinfo *k;
1011: struct var *v;
1012: {
1013:
1014: printval((char *)((char *)k->ki_e + v->off), v);
1015: }
1016:
1017: uvar(k, v)
1018: struct kinfo *k;
1019: struct var *v;
1020: {
1021:
1022: if (k->ki_u)
1023: printval((char *)((char *)k->ki_u + v->off), v);
1024: else
1025: printf("%*s", v->width, "-");
1026: }
1027:
1028: rvar(k, v)
1029: struct kinfo *k;
1030: struct var *v;
1031: {
1032:
1033: if (k->ki_u)
1034: printval((char *)((char *)(&k->ki_u->u_ru) + v->off), v);
1035: else
1036: printf("%*s", v->width, "-");
1037: }
1038:
1039: char *
1040: lookupcombo(cp)
1041: char *cp;
1042: {
1043: register struct combovar *cv = &combovar[0];
1044:
1045: for (; cv->name; cv++)
1046: if (strcmp(cp, cv->name) == 0)
1047: return (cv->replace);
1048: return (NULL);
1049: }
1050:
1051: struct var *
1052: lookupvar(cp)
1053: char *cp;
1054: {
1055: register int i, j;
1056:
1057: for (i=0; var[i].name[0] != NULL; i++)
1058: for (j=0; var[i].name[j] != NULL; j++)
1059: if (strcmp(cp, var[i].name[j]) == 0)
1060: return (&var[i]);
1061: return (NULL);
1062: }
1063:
1064: printval(bp, v)
1065: char *bp;
1066: struct var *v;
1067: {
1068: static char ofmt[32] = "%";
1069: register char *cp = ofmt+1, *fcp = v->fmt;
1070:
1071: if (v->flag & LJUST)
1072: *cp++ = '-';
1073: *cp++ = '*';
1074: while (*cp++ = *fcp++)
1075: ;
1076:
1077: switch (v->type) {
1078: case CHAR:
1079: printf(ofmt, v->width, *(char *)bp);
1080: break;
1081:
1082: case UCHAR:
1083: printf(ofmt, v->width, *(u_char *)bp);
1084: break;
1085:
1086: case SHORT:
1087: printf(ofmt, v->width, *(short *)bp);
1088: break;
1089:
1090: case USHORT:
1091: printf(ofmt, v->width, *(u_short *)bp);
1092: break;
1093:
1094: case LONG:
1095: printf(ofmt, v->width, *(long *)bp);
1096: break;
1097:
1098: case ULONG:
1099: printf(ofmt, v->width, *(u_long *)bp);
1100: break;
1101:
1102: case KPTR:
1103: printf(ofmt, v->width, *(u_long *)bp &~ KERNBASE);
1104: break;
1105:
1106: default:
1107: error("unknown type %d", v->type);
1108: }
1109: }
1110:
1111: /* XXX - redo */
1112: struct usave *
1113: saveuser(ki)
1114: struct kinfo *ki;
1115: {
1116: register struct usave *usp;
1117: register struct user *up;
1118:
1119: if ((usp = (struct usave *)calloc(1, sizeof (struct usave))) == NULL) {
1120: fprintf(stderr, "ps: out of memory\n");
1121: exit(1);
1122: }
1123: ki->ki_u = usp;
1124: up = kvm_getu(ki->ki_p);
1125: /*
1126: * save arguments if needed
1127: */
1128: if (needcomm)
1129: ki->ki_args = saveargs(ki->ki_p, up);
1130: else
1131: ki->ki_args = NULL;
1132: if (up != NULL) {
1133: /*
1134: * save important fields
1135: */
1136: usp->u_procp = up->u_procp;
1137: usp->u_start = up->u_start;
1138: usp->u_ru = up->u_ru;
1139: usp->u_cru = up->u_cru;
1140: usp->u_cmask = up->u_cmask;
1141: usp->u_acflag = up->u_acflag;
1142: }
1143: return;
1144: }
1145:
1146: char *
1147: saveargs(p, up)
1148: struct proc *p;
1149: struct user *up;
1150: {
1151: char *savestr();
1152:
1153: return(savestr(kvm_getargs(p, up)));
1154: }
1155:
1156:
1157: pscomp(k1, k2)
1158: struct kinfo *k1, *k2;
1159: {
1160: int i;
1161: #define VSIZE(k) ((k)->ki_p->p_dsize + (k)->ki_p->p_ssize + (k)->ki_e->e_xsize)
1162:
1163: if (sortby == SORTCPU)
1164: return (getpcpu(k2) - getpcpu(k1));
1165: #ifdef notyet
1166: if (sortby == SORTRUN)
1167: return (proc_compare(k1->ki_p, k2->ki_p));
1168: #endif
1169: if (sortby == SORTMEM)
1170: return (VSIZE(k2) - VSIZE(k1));
1171: i = k1->ki_e->e_tdev - k2->ki_e->e_tdev;
1172: if (i == 0)
1173: i = k1->ki_p->p_pid - k2->ki_p->p_pid;
1174: return (i);
1175: }
1176:
1177: donlist()
1178: {
1179: if (kvm_nlist(psnl) != 0)
1180: error("can't get namelist");
1181: if (kvm_read(psnl[X_FSCALE].n_value, &fscale, sizeof(int)) !=
1182: sizeof (int))
1183: error("error reading fscale: %s", kvm_geterr());
1184: if (kvm_read(psnl[X_ECMX].n_value, &ecmx, sizeof(int)) !=
1185: sizeof (int))
1186: error("error reading ecmx: %s", kvm_geterr());
1187: if (kvm_read(psnl[X_CCPU].n_value, &ccpu, sizeof(fixpt_t)) !=
1188: sizeof (fixpt_t))
1189: error("error reading ccpu: %s", kvm_geterr());
1190: }
1191:
1192: char *
1193: savestr(cp)
1194: char *cp;
1195: {
1196: register unsigned len;
1197: register char *dp;
1198:
1199: len = strlen(cp);
1200: dp = (char *)calloc(len+1, sizeof (char));
1201: (void) strcpy(dp, cp);
1202: return (dp);
1203: }
1204:
1205: error(a, b, c, d, e)
1206: char *a, *b, *c, *d, *e;
1207: {
1208: fprintf(stderr, "ps: ");
1209: fprintf(stderr, a, b, c, d, e);
1210: fprintf(stderr, "\n");
1211: exit(1);
1212: }
1213:
1214: syserror(a)
1215: char *a;
1216: {
1217: extern errno;
1218:
1219: error("%s: %s", a, strerror(errno));
1220: }
1221:
1222: /*
1223: * ICK (all for getopt), would rather hide the ugliness
1224: * here than taint the main code.
1225: *
1226: * ps foo -> ps -foo
1227: * ps 34 -> ps -p34
1228: *
1229: * The old convention that 't' with no trailing tty arg means the users
1230: * tty, is only supported if argv[1] doesn't begin with a '-'. This same
1231: * feature is available with the option 'T', which takes no argument.
1232: */
1233: char *
1234: kludge_oldps_options(s)
1235: char *s;
1236: {
1237: int len = strlen(s), numlen = 0;
1238: char *newopts, *ns, *cp;
1239:
1240: if ((newopts = ns = (char *)malloc(len+2)) == NULL)
1241: error("out of memory");
1242: /*
1243: * options begin with '-'
1244: */
1245: if (*s != '-')
1246: *ns++ = '-'; /* add option flag */
1247: /*
1248: * gaze to end of argv[1]
1249: */
1250: cp = s + len - 1;
1251: /*
1252: * if last letter is a 't' flag with no argument (in the context
1253: * of the oldps options -- option string NOT starting with a '-' --
1254: * then convert to 'T' (meaning *this* terminal, i.e. ttyname(0).
1255: */
1256: if (*cp == 't' && *s != '-')
1257: *cp = 'T';
1258: else {
1259: /*
1260: * otherwise check for trailing number, which *may* be a
1261: * pid.
1262: */
1263: while (isdigit(*cp)) {
1264: --cp;
1265: numlen++;
1266: }
1267: }
1268: cp++;
1269: bcopy(s, ns, cp - s); /* copy everything up to trailing number */
1270: while (*ns)
1271: ns++;
1272: /*
1273: * if there's a trailing number, and not a preceding 'p' (pid) or
1274: * 't' (tty) flag, then assume it's a pid and insert a 'p' flag.
1275: */
1276: if (isdigit(*cp) && (cp == s || *(cp-1) != 't' && *(cp-1) != 'p' &&
1277: ((cp-1) == s || *(cp-2) != 't')))
1278: *ns++ = 'p';
1279: strcat(ns, cp); /* and append the number */
1280:
1281: return (newopts);
1282: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.