![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to w.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 40BSD / cmd|
Return to w.c CVS log | Up to [CSRG BSD Unix] / 40BSD / cmd |
1.1 root 1: static char *sccsid = "@(#)w.c 4.1 (Berkeley) 10/1/80";
2: /*
3: * w - print system status (who and what)
4: *
5: * This program is similar to the systat command on Tenex/Tops 10/20
6: * It needs read permission on /dev/mem, /dev/kmem, and /dev/drum.
7: */
8: #include <sys/param.h>
9: #include <nlist.h>
10: #include <stdio.h>
11: #include <ctype.h>
12: #include <utmp.h>
13: #include <time.h>
14: #include <sys/stat.h>
15: #include <sys/dir.h>
16: #include <sys/user.h>
17: #include <sys/proc.h>
18: #include <sys/pte.h>
19: #include <sys/vm.h>
20:
21: #define NMAX sizeof(utmp.ut_name)
22: #define LMAX sizeof(utmp.ut_line)
23:
24: #define ARGWIDTH 33 /* # chars left on 80 col crt for args */
25:
26: struct smproc {
27: short w_pid; /* proc.p_pid */
28: char w_flag; /* proc.p_flag */
29: short w_size; /* proc.p_size */
30: long w_seekaddr; /* where to find args */
31: long w_lastpg; /* disk address of stack */
32: int w_igintr; /* INTR+3*QUIT, 0=die, 1=ign, 2=catch */
33: time_t w_time; /* CPU time used by this process */
34: time_t w_ctime; /* CPU time used by children */
35: dev_t w_tty; /* tty device of process */
36: char w_comm[15]; /* user.u_comm, null terminated */
37: char w_args[ARGWIDTH+1]; /* args if interesting process */
38: } pr[NPROC];
39:
40: struct nlist nl[] = {
41: { "_proc" },
42: #define X_PROC 0
43: { "_swapdev" },
44: #define X_SWAPDEV 1
45: { "_Usrptmap" },
46: #define X_USRPTMA 2
47: { "_usrpt" },
48: #define X_USRPT 3
49: { "_nswap" },
50: #define X_NSWAP 4
51: { "_avenrun" },
52: #define X_AVENRUN 5
53: { "_bootime" },
54: #define X_BOOTIME 6
55: { 0 },
56: };
57:
58: FILE *ps;
59: FILE *ut;
60: FILE *bootfd;
61: int kmem;
62: int mem;
63: int swap; /* /dev/kmem, mem, and swap */
64: int nswap;
65: dev_t tty;
66: char doing[520]; /* process attached to terminal */
67: time_t proctime; /* cpu time of process in doing */
68: double avenrun[3];
69:
70: #define DIV60(t) ((t+30)/60) /* x/60 rounded */
71: #define TTYEQ (tty == pr[i].w_tty)
72: #define IGINT (1+3*1) /* ignoring both SIGINT & SIGQUIT */
73:
74: char *getargs();
75: char *fread();
76: char *ctime();
77: char *rindex();
78: FILE *popen();
79: struct tm *localtime();
80:
81: int debug; /* true if -d flag: debugging output */
82: int header = 1; /* true if -h flag: don't print heading */
83: int lflag = 1; /* true if -l flag: long style output */
84: int login; /* true if invoked as login shell */
85: int idle; /* number of minutes user is idle */
86: int nusers; /* number of users logged in now */
87: char * sel_user; /* login of particular user selected */
88: char firstchar; /* first char of name of prog invoked as */
89: time_t jobtime; /* total cpu time visible */
90: time_t now; /* the current time of day */
91: struct tm *nowt; /* current time as time struct */
92: time_t bootime, uptime; /* time of last reboot & elapsed time since */
93: int np; /* number of processes currently active */
94: struct utmp utmp;
95: struct proc mproc;
96: struct user up;
97: char fill[512];
98:
99: main(argc, argv)
100: char **argv;
101: {
102: int days, hrs, mins;
103: register int i, j;
104: char *cp;
105: register int curpid, empty;
106: char obuf[BUFSIZ];
107:
108: setbuf(stdout, obuf);
109: login = (argv[0][0] == '-');
110: cp = rindex(argv[0], '/');
111: firstchar = login ? argv[0][1] : (cp==0) ? argv[0][0] : cp[1];
112: cp = argv[0]; /* for Usage */
113:
114: while (argc > 1) {
115: if (argv[1][0] == '-') {
116: for (i=1; argv[1][i]; i++) {
117: switch(argv[1][i]) {
118:
119: case 'd':
120: debug++;
121: break;
122:
123: case 'h':
124: header = 0;
125: break;
126:
127: case 'l':
128: lflag++;
129: break;
130:
131: case 's':
132: lflag = 0;
133: break;
134:
135: case 'u':
136: case 'w':
137: firstchar = argv[1][1];
138: break;
139:
140: default:
141: printf("Bad flag %s\n", argv[1]);
142: exit(1);
143: }
144: }
145: } else {
146: if (!isalnum(argv[1][0]) || argc > 2) {
147: printf("Usage: %s [ -hlsuw ] [ user ]\n", cp);
148: exit(1);
149: } else
150: sel_user = argv[1];
151: }
152: argc--; argv++;
153: }
154:
155: if ((kmem = open("/dev/kmem", 0)) < 0) {
156: fprintf(stderr, "No kmem\n");
157: exit(1);
158: }
159: nlist("/vmunix", nl);
160: if (nl[0].n_type==0) {
161: fprintf(stderr, "No namelist\n");
162: exit(1);
163: }
164:
165: if (firstchar != 'u')
166: readpr();
167:
168: ut = fopen("/etc/utmp","r");
169: if (header) {
170: /* Print time of day */
171: time(&now);
172: nowt = localtime(&now);
173: prtat(nowt);
174:
175: /*
176: * Print how long system has been up.
177: * (Found by looking for "bootime" in kernel)
178: */
179: lseek(kmem, (long)nl[X_BOOTIME].n_value, 0);
180: read(kmem, &bootime, sizeof (bootime));
181:
182: uptime = now - bootime;
183: days = uptime / (60*60*24);
184: uptime %= (60*60*24);
185: hrs = uptime / (60*60);
186: uptime %= (60*60);
187: mins = DIV60(uptime);
188:
189: printf(" up");
190: if (days > 0)
191: printf(" %d day%s,", days, days>1?"s":"");
192: if (hrs > 0 && mins > 0) {
193: printf(" %2d:%02d,", hrs, mins);
194: } else {
195: if (hrs > 0)
196: printf(" %d hr%s,", hrs, hrs>1?"s":"");
197: if (mins > 0)
198: printf(" %d min%s,", mins, mins>1?"s":"");
199: }
200:
201: /* Print number of users logged in to system */
202: while (fread(&utmp, sizeof(utmp), 1, ut)) {
203: if (utmp.ut_name[0] != '\0')
204: nusers++;
205: }
206: rewind(ut);
207: printf(" %d users", nusers);
208:
209: /*
210: * Print 1, 5, and 15 minute load averages.
211: * (Found by looking in kernel for avenrun).
212: */
213: printf(", load average:");
214: lseek(kmem, (long)nl[X_AVENRUN].n_value, 0);
215: read(kmem, avenrun, sizeof(avenrun));
216: for (i = 0; i < (sizeof(avenrun)/sizeof(avenrun[0])); i++) {
217: if (i > 0)
218: printf(",");
219: printf(" %.2f", avenrun[i]);
220: }
221: printf("\n");
222: if (firstchar == 'u')
223: exit(0);
224:
225: /* Headers for rest of output */
226: if (lflag)
227: printf("User tty login@ idle JCPU PCPU what\n");
228: else
229: printf("User tty idle what\n");
230: fflush(stdout);
231: }
232:
233:
234: for (;;) { /* for each entry in utmp */
235: if (fread(&utmp, sizeof(utmp), 1, ut) == NULL) {
236: fclose(ut);
237: exit(0);
238: }
239: if (utmp.ut_name[0] == '\0')
240: continue; /* that tty is free */
241: if (sel_user && strcmpn(utmp.ut_name, sel_user, NMAX) != 0)
242: continue; /* we wanted only somebody else */
243:
244: gettty();
245: jobtime = 0;
246: proctime = 0;
247: strcpy(doing, "-"); /* default act: normally never prints */
248: empty = 1;
249: curpid = -1;
250: idle = findidle();
251: for (i=0; i<np; i++) { /* for each process on this tty */
252: if (!(TTYEQ))
253: continue;
254: jobtime += pr[i].w_time + pr[i].w_ctime;
255: proctime += pr[i].w_time;
256: if (debug) {
257: printf("\t\t%d\t%s", pr[i].w_pid, pr[i].w_args);
258: if ((j=pr[i].w_igintr) > 0)
259: if (j==IGINT)
260: printf(" &");
261: else
262: printf(" & %d %d", j%3, j/3);
263: printf("\n");
264: }
265: if (empty && pr[i].w_igintr!=IGINT) {
266: empty = 0;
267: curpid = -1;
268: }
269: if(pr[i].w_pid>curpid && (pr[i].w_igintr!=IGINT || empty)){
270: curpid = pr[i].w_pid;
271: strcpy(doing, lflag ? pr[i].w_args : pr[i].w_comm);
272: #ifdef notdef
273: if (doing[0]==0 || doing[0]=='-' && doing[1]<=' ' || doing[0] == '?') {
274: strcat(doing, " (");
275: strcat(doing, pr[i].w_comm);
276: strcat(doing, ")");
277: }
278: #endif
279: }
280: }
281: putline();
282: }
283: }
284:
285: /* figure out the major/minor device # pair for this tty */
286: gettty()
287: {
288: char ttybuf[20];
289: struct stat statbuf;
290:
291: ttybuf[0] = 0;
292: strcpy(ttybuf, "/dev/");
293: strcat(ttybuf, utmp.ut_line);
294: stat(ttybuf, &statbuf);
295: tty = statbuf.st_rdev;
296: }
297:
298: /*
299: * putline: print out the accumulated line of info about one user.
300: */
301: putline()
302: {
303: register int tm;
304:
305: /* print login name of the user */
306: printf("%-*.*s ", NMAX, NMAX, utmp.ut_name);
307:
308: /* print tty user is on */
309: if (lflag)
310: /* long form: all (up to) LMAX chars */
311: printf("%-*.*s", LMAX, LMAX, utmp.ut_line);
312: else {
313: /* short form: 2 chars, skipping 'tty' if there */
314: if (utmp.ut_line[0]=='t' && utmp.ut_line[1]=='t' && utmp.ut_line[2]=='y')
315: printf("%-2.2s", &utmp.ut_line[3]);
316: else
317: printf("%-2.2s", utmp.ut_line);
318: }
319:
320: if (lflag)
321: /* print when the user logged in */
322: prtat(localtime(&utmp.ut_time));
323:
324: /* print idle time */
325: prttime(idle," ");
326:
327: if (lflag) {
328: /* print CPU time for all processes & children */
329: prttime(DIV60(jobtime)," ");
330: /* print cpu time for interesting process */
331: prttime(DIV60(proctime)," ");
332: }
333:
334: /* what user is doing, either command tail or args */
335: printf(" %-.32s\n",doing);
336: fflush(stdout);
337: }
338:
339: /* find & return number of minutes current tty has been idle */
340: findidle()
341: {
342: struct stat stbuf;
343: long lastaction, diff;
344: char ttyname[20];
345:
346: strcpy(ttyname, "/dev/");
347: strcatn(ttyname, utmp.ut_line, LMAX);
348: stat(ttyname, &stbuf);
349: time(&now);
350: lastaction = stbuf.st_atime;
351: diff = now - lastaction;
352: diff = DIV60(diff);
353: if (diff < 0) diff = 0;
354: return(diff);
355: }
356:
357: /*
358: * prttime prints a time in hours and minutes.
359: * The character string tail is printed at the end, obvious
360: * strings to pass are "", " ", or "am".
361: */
362: prttime(tim, tail)
363: time_t tim;
364: char *tail;
365: {
366: register int didhrs = 0;
367:
368: if (tim >= 60) {
369: printf("%3d:", tim/60);
370: didhrs++;
371: } else {
372: printf(" ");
373: }
374: tim %= 60;
375: if (tim > 0 || didhrs) {
376: printf(didhrs&&tim<10 ? "%02d" : "%2d", tim);
377: } else {
378: printf(" ");
379: }
380: printf("%s", tail);
381: }
382:
383: /* prtat prints a 12 hour time given a pointer to a time of day */
384: prtat(p)
385: struct tm *p;
386: {
387: register int t, pm;
388:
389: t = p -> tm_hour;
390: pm = (t > 11);
391: if (t > 11)
392: t -= 12;
393: if (t == 0)
394: t = 12;
395: prttime(t*60 + p->tm_min, pm ? "pm" : "am");
396: }
397:
398: /*
399: * readpr finds and reads in the array pr, containing the interesting
400: * parts of the proc and user tables for each live process.
401: */
402: readpr()
403: {
404: int pn, mf, addr, c;
405: int szpt, pfnum, i;
406: struct pte *Usrptma, *usrpt, *pte, apte;
407: struct dblock db;
408:
409: Usrptma = (struct pte *) nl[X_USRPTMA].n_value;
410: usrpt = (struct pte *) nl[X_USRPT].n_value;
411: if((mem = open("/dev/mem", 0)) < 0) {
412: fprintf(stderr, "No mem\n");
413: exit(1);
414: }
415: if ((swap = open("/dev/drum", 0)) < 0) {
416: fprintf(stderr, "No drum\n");
417: exit(1);
418: }
419: /*
420: * read mem to find swap dev.
421: */
422: lseek(kmem, (long)nl[X_SWAPDEV].n_value, 0);
423: read(kmem, &nl[X_SWAPDEV].n_value, sizeof(nl[X_SWAPDEV].n_value));
424: /*
425: * Find base of swap
426: */
427: lseek(kmem, (long)nl[X_NSWAP].n_value, 0);
428: read(kmem, &nswap, sizeof(nswap));
429: /*
430: * Locate proc table
431: */
432: np = 0;
433: for (pn=0; pn<NPROC; pn++) {
434: lseek(kmem, (long)(nl[X_PROC].n_value + pn*(sizeof mproc)), 0);
435: read(kmem, &mproc, sizeof mproc);
436: /* decide if it's an interesting process */
437: if (mproc.p_stat==0 || mproc.p_pgrp==0)
438: continue;
439: if (mproc.p_flag&SDETACH)
440: continue;
441:
442: #ifdef notdef
443: /*
444: * The following speeds up w on systems with lots of ttys
445: * by ignoring inits and gettys, but loses on root login shells.
446: * On Ernie it reduced user and system time by .3 seconds,
447: * an insignificant amount. It is commented out since it
448: * will lose when root logs in.
449: */
450: if (mproc.p_uid == 0 & mproc.p_ppid == 1)
451: continue;
452: #endif
453:
454: /* find & read in the user structure */
455: if ((mproc.p_flag & SLOAD) == 0) {
456: /* not in memory - get from swap device */
457: addr = mproc.p_swaddr<<9;
458: lseek(swap, (long)addr, 0);
459: if (read(swap, &up, sizeof(up)) != sizeof(up)) {
460: continue;
461: }
462: } else {
463: int p0br, cc;
464: #define INTPPG (NBPG / sizeof (int))
465: struct pte pagetbl[NBPG / sizeof (struct pte)];
466: /* loaded, get each page from memory separately */
467: szpt = mproc.p_szpt;
468: p0br = (int)mproc.p_p0br;
469: pte = &Usrptma[btokmx(mproc.p_p0br) + szpt-1];
470: lseek(kmem, (long)pte, 0);
471: if (read(kmem, &apte, sizeof(apte)) != sizeof(apte))
472: continue;
473: lseek(mem, ctob(apte.pg_pfnum), 0);
474: if (read(mem,pagetbl,sizeof(pagetbl)) != sizeof(pagetbl))
475: cont:
476: continue;
477: for(cc=0; cc<UPAGES; cc++) { /* get u area */
478: int upage = pagetbl[NPTEPG-UPAGES+cc].pg_pfnum;
479: lseek(mem,ctob(upage),0);
480: if (read(mem,((int *)&up)+INTPPG*cc,NBPG) != NBPG)
481: goto cont;
482: }
483: szpt = up.u_pcb.pcb_szpt;
484: pr[np].w_seekaddr = ctob(apte.pg_pfnum);
485: }
486: vstodb(0, 1, &up.u_smap, &db, 1);
487: pr[np].w_lastpg = ctob(db.db_base);
488: if (up.u_ttyp == NULL)
489: continue;
490:
491: /* save the interesting parts */
492: pr[np].w_pid = mproc.p_pid;
493: pr[np].w_flag = mproc.p_flag;
494: pr[np].w_size = mproc.p_dsize + mproc.p_ssize;
495: pr[np].w_igintr = (((int)up.u_signal[2]==1) + 2*((int)up.u_signal[2]>1) + 3*((int)up.u_signal[3]==1)) + 6*((int)up.u_signal[3]>1);
496: pr[np].w_time = up.u_vm.vm_utime + up.u_vm.vm_stime;
497: pr[np].w_ctime = up.u_cvm.vm_utime + up.u_cvm.vm_stime;
498: pr[np].w_tty = up.u_ttyd;
499: up.u_comm[14] = 0; /* Bug: This bombs next field. */
500: strcpy(pr[np].w_comm, up.u_comm);
501: /*
502: * Get args if there's a chance we'll print it.
503: * Cant just save pointer: getargs returns static place.
504: * Cant use strcpyn: that crock blank pads.
505: */
506: pr[np].w_args[0] = 0;
507: strcatn(pr[np].w_args,getargs(&pr[np]),ARGWIDTH);
508: if (pr[np].w_args[0]==0 || pr[np].w_args[0]=='-' && pr[np].w_args[1]<=' ' || pr[np].w_args[0] == '?') {
509: strcat(pr[np].w_args, " (");
510: strcat(pr[np].w_args, pr[np].w_comm);
511: strcat(pr[np].w_args, ")");
512: }
513: np++;
514: }
515: }
516:
517: /*
518: * getargs: given a pointer to a proc structure, this looks at the swap area
519: * and tries to reconstruct the arguments. This is straight out of ps.
520: */
521: char *
522: getargs(p)
523: struct smproc *p;
524: {
525: int c, addr, nbad;
526: static int abuf[512/sizeof(int)];
527: struct pte pagetbl[NPTEPG];
528: register int *ip;
529: register char *cp, *cp1;
530:
531: if ((p->w_flag & SLOAD) == 0) {
532: lseek(swap, p->w_lastpg, 0);
533: if (read(swap, abuf, sizeof(abuf)) != sizeof(abuf))
534: return(p->w_comm);
535: } else {
536: c = p->w_seekaddr;
537: lseek(mem,c,0);
538: if (read(mem,pagetbl,NBPG) != NBPG)
539: return(p->w_comm);
540: if (pagetbl[NPTEPG-1-UPAGES].pg_fod==0 && pagetbl[NPTEPG-1-UPAGES].pg_pfnum) {
541: lseek(mem,ctob(pagetbl[NPTEPG-1-UPAGES].pg_pfnum),0);
542: if (read(mem,abuf,sizeof(abuf)) != sizeof(abuf))
543: return(p->w_comm);
544: } else {
545: lseek(swap, p->w_lastpg, 0);
546: if (read(swap, abuf, sizeof(abuf)) != sizeof(abuf))
547: return(p->w_comm);
548: }
549: }
550: abuf[127] = 0;
551: for (ip = &abuf[126]; ip > abuf;) {
552: /* Look from top for -1 or 0 as terminator flag. */
553: if (*--ip == -1 || *ip == 0) {
554: cp = (char *)(ip+1);
555: if (*cp==0)
556: cp++;
557: nbad = 0; /* up to 5 funny chars as ?'s */
558: for (cp1 = cp; cp1 < (char *)&abuf[128]; cp1++) {
559: c = *cp1&0177;
560: if (c==0) /* nulls between args => spaces */
561: *cp1 = ' ';
562: else if (c < ' ' || c > 0176) {
563: if (++nbad >= 5) {
564: *cp1++ = ' ';
565: break;
566: }
567: *cp1 = '?';
568: } else if (c=='=') { /* Oops - found an
569: * environment var, back
570: * over & erase it. */
571: *cp1 = 0;
572: while (cp1>cp && *--cp1!=' ')
573: *cp1 = 0;
574: break;
575: }
576: }
577: while (*--cp1==' ') /* strip trailing spaces */
578: *cp1 = 0;
579: return(cp);
580: }
581: }
582: return (p->w_comm);
583: }
584:
585: /*
586: * Given a base/size pair in virtual swap area,
587: * return a physical base/size pair which is the
588: * (largest) initial, physically contiguous block.
589: */
590: vstodb(vsbase, vssize, dmp, dbp, rev)
591: register int vsbase;
592: int vssize;
593: struct dmap *dmp;
594: register struct dblock *dbp;
595: {
596: register int blk = DMMIN;
597: register swblk_t *ip = dmp->dm_map;
598:
599: if (vsbase < 0 || vsbase + vssize > dmp->dm_size)
600: panic("vstodb");
601: while (vsbase >= blk) {
602: vsbase -= blk;
603: if (blk < DMMAX)
604: blk *= 2;
605: ip++;
606: }
607: if (*ip <= 0 || *ip + blk > nswap)
608: panic("vstodb *ip");
609: dbp->db_size = min(vssize, blk - vsbase);
610: dbp->db_base = *ip + (rev ? blk - (vsbase + dbp->db_size) : vsbase);
611: }
612:
613: panic(cp)
614: char *cp;
615: {
616:
617: /* printf("%s\n", cp); */
618: }
619:
620: min(a, b)
621: {
622:
623: return (a < b ? a : b);
624: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.