![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sa.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / bin|
Return to sa.c CVS log | Up to [MW Coherent from dump] / coherent / b / bin |
1.1 root 1: /*
2: * sa.c
3: * System accounting of command execution
4: * (in conjuction with acct system call.)
5: */
6:
7: #include <stdio.h>
8: #include <ctype.h>
9: #include <pwd.h>
10: #include <acct.h>
11: #include <sys/times.h>
12: #include <sys/const.h>
13: #include <dirent.h>
14:
15: #define MIN 60 /* Seconds in a minute */
16: #define MINHZ (MIN*HZ) /* HZ in a minute */
17: #define CPUTIME 0 /* Sort by CPU time */
18: #define PERCALL 1 /* Sort by CPU time per call */
19: #define CALLS 2 /* Sort by numbers of calls */
20:
21: #define NUSER 100 /* Maximum number of users */
22: #define NCOMM 500 /* Maximum number of commands */
23: #define NSORT NUSER
24: #define NCNAME (sizeof(ac.ac_comm)) /* Size of a command name) */
25:
26: #define DIRSIZ 14
27:
28: struct acct ac;
29:
30: /*
31: * structure of /usr/adm/usracct
32: * for per-user type of `sa' information.
33: */
34: struct svu {
35: unsigned svu_count; /* Number of processes measured */
36: short svu_uid; /* User number */
37: time_t svu_stime; /* Total system time (HZ) */
38: time_t svu_utime; /* Total user time */
39: time_t svu_etime; /* Total elapsed time (sec.)*/
40: } svu[NUSER];
41:
42: /*
43: * For per command information as
44: * is stored in /usr/adm/savacct.
45: */
46: struct svc {
47: unsigned svc_count; /* Number of calls */
48: char svc_comm[NCNAME]; /* Command name */
49: time_t svc_stime;
50: time_t svc_utime;
51: time_t svc_etime;
52: } svc[NCOMM];
53: struct svc *junkp, *otherp;
54:
55: /*
56: * For the final sort. This is
57: * the combined information of
58: * the two structures above.
59: * I.e. either one or the other.
60: */
61: struct sort {
62: unsigned s_count; /* Number of calls */
63: char s_comm[NCNAME]; /* Command name */
64: short s_uid; /* User number */
65: time_t s_key; /* Sort key */
66: time_t s_stime; /* System time */
67: time_t s_utime; /* User time */
68: time_t s_etime; /* Elapsed time */
69: } sort[NSORT];
70:
71: char *acctf = "/usr/adm/acct"; /* Raw accounting file */
72: char *sacctf = "/usr/adm/savacct"; /* Summary file */
73: char *uacctf = "/usr/adm/usracct"; /* Per-user summary */
74: char junk[NCNAME] = "**junk**";
75: char other[NCNAME] = "***other";
76:
77: int aflag; /* Move unlikely commands to "**other" */
78: int cflag; /* Give percentage of total time */
79: int jflag; /* Give seconds instead of minutes/call */
80: int lflag; /* Separate system & user times */
81: int mflag; /* Number of processes and CPU min. per user */
82: int rflag; /* Reverse sort order */
83: int sflag; /* Merge accounting file when done */
84: int tflag; /* Print ratio of real to CPU time */
85: int uflag; /* Print user-id and command name */
86: int vflag; /* Prompt if used fewer than `n' times */
87: int sortflag = CPUTIME; /* Sort mode */
88:
89: long ctol();
90: time_t units();
91: struct svc *make();
92: struct svc *move();
93: char *uname();
94: int compar();
95:
96: main(argc, argv)
97: char *argv[];
98: {
99: register char *ap;
100:
101: while (argc>1 && *argv[1]=='-') {
102: for (ap = &argv[1][1]; *ap != '\0'; ap++)
103: switch (*ap) {
104: case 'a':
105: aflag = 1;
106: break;
107:
108: case 'b':
109: sortflag = PERCALL;
110: break;
111:
112: case 'c':
113: cflag = 1;
114: break;
115:
116: case 'j':
117: jflag = 1;
118: break;
119:
120: case 'l':
121: lflag = 1;
122: break;
123:
124: case 'm':
125: mflag = 1;
126: break;
127:
128: case 'n':
129: sortflag = CALLS;
130: break;
131:
132: case 'r':
133: rflag = 1;
134: break;
135:
136: case 's':
137: sflag = 1;
138: break;
139:
140: case 't':
141: tflag = 1;
142: break;
143:
144: case 'u':
145: uflag = 1;
146: break;
147:
148: case 'v':
149: if (ap[1]>='0' && ap[1]<='9')
150: vflag = *++ap - '0';
151: break;
152:
153: default:
154: usage();
155: }
156: argc--;
157: argv++;
158: }
159: if (argc == 2)
160: acctf = argv[1];
161: else if (argc > 2)
162: usage();
163: if (!uflag)
164: rsummary();
165: rraw(acctf);
166: if (sflag && !uflag)
167: samerge();
168: if (!uflag)
169: saprint();
170: exit(0);
171: }
172:
173: /*
174: * Read the summary file of old accounting information
175: * from both user and command saved accounting files.
176: */
177: rsummary()
178: {
179: register FILE *fp;
180:
181: if ((fp = fopen(sacctf, "r")) != NULL) {
182: register struct svc *svcp;
183:
184: for (svcp = svc; svcp < &svc[NCOMM]; svcp++)
185: if (fread(svcp, sizeof *svcp, 1, fp) != 1)
186: break;
187: if (svcp >= &svc[NCOMM])
188: fprintf(stderr, "%s is too large\n", sacctf);
189: fclose(fp);
190: }
191: if ((fp = fopen(uacctf, "r")) != NULL) {
192: register struct svu *svup;
193:
194: for (svup = svu; svup < &svu[NUSER]; svup++)
195: if (fread(svup, sizeof *svup, 1, fp) != 1)
196: break;
197: if (svup >= &svu[NUSER])
198: fprintf(stderr, "%s is too large\n", uacctf);
199: fclose(fp);
200: }
201: }
202:
203: /*
204: * Read the raw accounting.
205: */
206: rraw(af)
207: char *af;
208: {
209: FILE *afp;
210: register struct svc *svcp;
211:
212: if ((afp = fopen(af, "r")) == NULL) {
213: fprintf(stderr, "Cannot open raw accounting file `%s'\n", af);
214: exit(1);
215: }
216: while (fread(&ac, sizeof ac, 1, afp) == 1) {
217: if (uflag)
218: printf("%-*s %.*s\n", DIRSIZ, uname(ac.ac_uid),
219: NCNAME, ac.ac_comm);
220: else {
221: senter(&ac);
222: uenter(&ac);
223: }
224: }
225: fclose(afp);
226: /*
227: * Create (if not there) junk and other classes.
228: */
229: if (aflag) {
230: otherp = make(other);
231: for (svcp = svc; svcp<&svc[NCOMM] && svcp->svc_count; svcp++) {
232: if (svcp == otherp)
233: continue;
234: if (svcp->svc_count==1 || unprintable(svcp->svc_comm))
235: otherp = move(svcp--, otherp);
236: }
237: }
238: if (vflag) {
239: junkp = make(junk);
240: for (svcp = svc; svcp<&svc[NCOMM] && svcp->svc_count; svcp++) {
241: if (svcp == junkp)
242: continue;
243: if (svcp->svc_count<=vflag && yes(svcp->svc_comm))
244: junkp = move(svcp--, junkp);
245: }
246: }
247: }
248:
249: /*
250: * Merge system accounting info back
251: * into the two merged files and
252: * truncate the raw accounting file.
253: * Accounting probably should be
254: * turned off when `sa' is called
255: * if this is to be done.
256: */
257: samerge()
258: {
259: register FILE *fp;
260:
261: if ((fp = fopen(sacctf, "w")) != NULL) {
262: register struct svc *svcp;
263:
264: for (svcp = svc; svcp<&svc[NCOMM] && svcp->svc_count; svcp++)
265: if (fwrite(svcp, sizeof *svcp, 1, fp) != 1)
266: saerr("%s: write error", sacctf);
267: fclose(fp);
268: } else
269: saerr("cannot rewrite %s", sacctf);
270: if ((fp = fopen(uacctf, "w")) != NULL) {
271: register struct svu *svup;
272:
273: for (svup = svu; svup<&svu[NUSER] && svup->svu_count; svup++)
274: if (fwrite(svup, sizeof *svup, 1, fp) != 1)
275: saerr("%s: write error", uacctf);
276: fclose(fp);
277: } else
278: saerr("cannot rewrite %s", uacctf);
279: if ((fp = fopen(acctf, "w")) == NULL)
280: saerr("cannot truncate %s", acctf);
281: fclose(fp);
282: }
283:
284: /*
285: * Output the accounting
286: * information according to
287: * sorting and printing options.
288: */
289: saprint()
290: {
291: register struct sort *sp;
292: time_t tottime;
293:
294: if (mflag)
295: userenter();
296: else
297: commenter();
298: for (sp = sort; sp<&sort[NSORT] && sp->s_count; sp++)
299: if (sortflag == CPUTIME)
300: sp->s_key = sp->s_stime+sp->s_utime;
301: else if (sortflag == PERCALL)
302: sp->s_key = (sp->s_stime+sp->s_utime)/sp->s_count;
303: else /* # calls */
304: sp->s_key = sp->s_count;
305: qsort(sort, sp-sort, sizeof *sp, compar);
306: if (mflag)
307: printf("%-*s #PROC", DIRSIZ, "");
308: else
309: printf("%-*s #CALL", NCNAME, "");
310: if (lflag)
311: printf(" USER SYS");
312: else
313: printf(" CPU");
314: printf(" REAL");
315: if (cflag)
316: printf(" CPU %% ");
317: if (tflag)
318: printf(" CPU/REAL %%");
319: putchar('\n');
320: if (cflag) {
321: tottime = 0;
322: for (sp = sort; sp<&sort[NSORT] && sp->s_count; sp++) {
323: tottime += sp->s_stime;
324: tottime += sp->s_utime;
325: }
326: }
327: for (sp = sort; sp<&sort[NSORT] && sp->s_count; sp++) {
328: if (mflag)
329: printf("%-*s", DIRSIZ, uname(sp->s_uid));
330: else
331: printf("%-*s", NCNAME, sp->s_comm);
332: printf(" %5d", sp->s_count);
333: if (lflag)
334: printf(" %5ld %5ld", units(sp->s_utime, sp),
335: units(sp->s_stime, sp));
336: else
337: printf(" %5ld", units(sp->s_utime+sp->s_stime, sp));
338: printf(" %5ld", units(sp->s_etime*HZ, sp));
339: if (cflag)
340: percent(sp->s_utime+sp->s_stime, tottime);
341: if (tflag) {
342: printf(" ");
343: percent(sp->s_utime+sp->s_stime, sp->s_etime*HZ);
344: }
345: putchar('\n');
346: }
347: }
348:
349: /*
350: * Enter user information for the sort.
351: */
352: userenter()
353: {
354: register struct sort *sp;
355: register struct svu *svup;
356:
357: sp = sort;
358: svup = svu;
359: while (svup < &svu[NCOMM] && svup->svu_count) {
360: sp->s_count = svup->svu_count;
361: sp->s_uid = svup->svu_uid;
362: sp->s_stime = svup->svu_stime;
363: sp->s_utime = svup->svu_utime;
364: sp->s_etime = svup->svu_etime;
365: sp++;
366: svup++;
367: }
368: /*
369: free(svc);
370: */
371: }
372:
373: /*
374: * Enter the commands into the list for
375: * sorting.
376: */
377: commenter()
378: {
379: register struct sort *sp;
380: register struct svc *svcp;
381:
382: sp = sort;
383: svcp = svc;
384: while (svcp < &svc[NCOMM] && svcp->svc_count) {
385: sp->s_count = svcp->svc_count;
386: strncpy(sp->s_comm, svcp->svc_comm, NCNAME);
387: sp->s_stime = svcp->svc_stime;
388: sp->s_utime = svcp->svc_utime;
389: sp->s_etime = svcp->svc_etime;
390: sp++;
391: svcp++;
392: }
393: /*
394: free(svu);
395: */
396: }
397:
398: /*
399: * Enter this accounting entry into
400: * the command table for savacct.
401: */
402: senter(ap)
403: register struct acct *ap;
404: {
405: register struct svc *svcp;
406:
407: for (svcp = svc; svcp<&svc[NCOMM] && svcp->svc_count; svcp++)
408: if (strncmp(svcp->svc_comm, ap->ac_comm, NCNAME) == 0)
409: break;
410: if (svcp >= &svc[NCOMM])
411: saerr("Command table overflow");
412: if (svcp->svc_count++ == 0)
413: strncpy(svcp->svc_comm, ap->ac_comm, NCNAME);
414: svcp->svc_stime += ctol(ap->ac_stime);
415: svcp->svc_utime += ctol(ap->ac_utime);
416: svcp->svc_etime += ctol(ap->ac_etime);
417: }
418:
419: /*
420: * Enter this accounting entry into
421: * the user table for usracct.
422: */
423: uenter(ap)
424: register struct acct *ap;
425: {
426: register struct svu *svup;
427:
428: for (svup = svu; svup<&svu[NUSER] && svup->svu_count; svup++)
429: if (svup->svu_uid == ap->ac_uid)
430: break;
431: if (svup >= &svu[NUSER])
432: saerr("User table overflow");
433: svup->svu_count++;
434: svup->svu_uid = ap->ac_uid;
435: svup->svu_stime += ctol(ap->ac_stime);
436: svup->svu_utime += ctol(ap->ac_utime);
437: svup->svu_etime += ctol(ap->ac_etime);
438: }
439:
440: /*
441: * Make a new zero entry with
442: * the indicated name.
443: */
444: struct svc *
445: make(name)
446: register char *name;
447: {
448: register struct svc *svcp;
449:
450: for (svcp = svc; svcp<&svc[NCOMM] && svcp->svc_count; svcp++)
451: if (strncmp(name, svcp->svc_comm, NCNAME) == 0)
452: return (svcp);
453: if (svcp >= &svc[NCOMM])
454: saerr("out of room for %s", name);
455: strncpy(svcp->svc_comm, name, NCNAME);
456: return (svcp);
457: }
458:
459: /*
460: * Move an entry to one of the deprecated
461: * places.
462: */
463: struct svc *
464: move(svcp, depp)
465: register struct svc *svcp;
466: struct svc *depp;
467: {
468:
469: depp->svc_count += svcp->svc_count;
470: depp->svc_stime += svcp->svc_stime;
471: depp->svc_utime += svcp->svc_utime;
472: depp->svc_etime += svcp->svc_etime;
473: while (svcp->svc_count) {
474: if (svcp == depp)
475: depp--;
476: bcopy(svcp+1, svcp, sizeof *svcp);
477: svcp++;
478: }
479: (svcp-1)->svc_count = 0;
480: return (depp);
481: }
482:
483: /*
484: * Return the user-name for
485: * a user-ID.
486: */
487: char *
488: uname(uid)
489: short uid;
490: {
491: register struct passwd *pwp;
492: static char ubuf[15];
493:
494: if ((pwp = getpwuid(uid)) != NULL)
495: return (pwp->pw_name);
496: return (sprintf(ubuf, "%d", uid));
497: }
498:
499: /*
500: * Block copy of `n' bytes.
501: */
502: bcopy(f, t, n)
503: register char *f, *t;
504: register unsigned n;
505: {
506: if (n)
507: do {
508: *t++ = *f++;
509: } while (--n);
510: }
511:
512: /*
513: * Return non-zero if an NCNAME-length string
514: * is unprintable.
515: */
516: unprintable(s)
517: register char *s;
518: {
519: register int n = NCNAME;
520: register int c;
521:
522: do {
523: if ((c = *s++) == '\0')
524: break;
525: if (!isascii(c) || !isprint(c))
526: return (1);
527: } while (--n);
528: return (0);
529: }
530:
531: /*
532: * Ask whether or not to delete and
533: * entry. Return 1 if yes.
534: */
535: yes(s)
536: register char *s;
537: {
538: register int c, ans = 0;
539:
540: printf("%.*s ? ", NCNAME, s);
541: if ((c = getchar()) == 'y')
542: ans = 1;
543: while (c!='\n' && c!=EOF)
544: c = getchar();
545: return (ans);
546: }
547:
548: /*
549: * Qsort compare routine.
550: */
551: compar(sp1, sp2)
552: register struct sort *sp1, *sp2;
553: {
554: register int rval;
555:
556: if (sp1->s_key == sp2->s_key)
557: return (0);
558: rval = 1;
559: if (sp1->s_key > sp2->s_key)
560: rval = -1;
561: if (rflag)
562: return (-rval);
563: return (rval);
564: }
565:
566: /*
567: * Return the number of CPU minutes from CPU HZ.
568: * or if `-j', return seconds/call.
569: */
570: time_t
571: units(hz, sp)
572: time_t hz;
573: register struct sort *sp;
574: {
575: if (jflag)
576: return ((hz + HZ/2) / (HZ*sp->s_count));
577: else
578: return ((hz + MINHZ/2) / MINHZ);
579: }
580:
581: /*
582: * Print the percentage of
583: * `t' out of `total'.
584: */
585: percent(t, total)
586: time_t t, total;
587: {
588: if (total == (time_t)0)
589: t = total = (time_t)1;
590: t *= 100;
591: printf("%3ld.", t/total);
592: t %= total;
593: if (t < 0)
594: t = -t;
595: printf("%1ld ", t*10/total);
596: }
597:
598: usage()
599: {
600: fprintf(stderr, "Usage: sa [-abcjlmnrstu] [-v[n]] [file]\n");
601: exit(1);
602: }
603:
604: /* VARARGS */
605: saerr(x)
606: {
607: fprintf(stderr, "sa: %r", &x);
608: putc('\n', stderr);
609: exit(1);
610: }
611:
612: /* end of sa.c */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.