![[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 [Research Unix] / researchv10no / cmd|
Return to sa.c CVS log | Up to [Research Unix] / researchv10no / cmd |
1.1 root 1: static char *sccsid = "@(#)sa.c 4.2 (Berkeley) 81/02/28";
2:
3: /*
4: * Extensive modifications to internal data structures
5: * to allow arbitrary number of different commands and users added.
6: *
7: * Also allowed the digit option on the -v flag (interactive
8: * threshold compress) to be a digit string, so one can
9: * set the threshold > 9.
10: *
11: * Also added the -f flag, to force no interactive threshold
12: * compression with the -v flag.
13: *
14: * Robert Henry
15: * UC Berkeley
16: * 31jan81
17: */
18: #include <stdio.h>
19: #include <sys/types.h>
20: #include <sys/acct.h>
21: #include <signal.h>
22: #include <utmp.h>
23: #include <pwd.h>
24:
25: /* interpret command time accounting */
26:
27: #define NC sizeof(acctbuf.ac_comm)
28:
29: struct acct acctbuf;
30: int aflg; /* put stuff under `***other' */
31: int bflg; /* sort by (user+sys)/ncalls */
32: int cflg; /* add pct of total for each command */
33: int Dflg; /* sort by total disk i/o */
34: int dflg; /* sort by avg disk i/o */
35: int eflg; /* use argv + 1 for prefix */
36: int fflg; /* force no interaction */
37: int gflg; /* ignore ACCT */
38: int iflg; /* ignore summaries */
39: int jflg; /* seconds per call replaces total minutes */
40: int Kflg; /* sort by cpu-storage integral */
41: int kflg; /* sort by cpu * avg mem */
42: int lflg; /* separate sys & user time */
43: int mflg; /* print # procs, cpu, disk i/o, memory seconds for each user */
44: int nflg; /* sort by number of calls */
45: int oflg; /* ? */
46: int rflg; /* reverse order of sort */
47: int sflg; /* merge data to summary file */
48: int tflg; /* print ratio of real to (user+sys) */
49: int uflg; /* print uid & command only */
50: int vflg; /* set `**junk**' limit */
51: int thres = 1; /* to thres */
52:
53: struct utmp utmp;
54: #define NAMELG (sizeof(utmp.ut_name)+1)
55:
56: struct Olduser{
57: int Us_cnt;
58: double Us_ctime;
59: double Us_io;
60: double Us_imem;
61: };
62:
63: struct user {
64: char name[NC]; /* this is <\001><user id><\000> */
65: struct Olduser oldu;
66: char us_name[NAMELG];
67: };
68: #define us_cnt oldu.Us_cnt
69: #define us_ctime oldu.Us_ctime
70: #define us_io oldu.Us_io
71: #define us_imem oldu.Us_imem
72:
73: /*
74: * We protect ourselves from preposterous user id's by looking
75: * through the passwd file for the highest uid allocated, and
76: * then adding 10 to that.
77: * This prevents the user structure from growing too large.
78: */
79: #define USERSLOP 10
80: int maxuser; /* highest uid from /etc/passwd, + 10 for slop*/
81:
82: struct process {
83: char name[NC];
84: int count;
85: double realt;
86: double cput;
87: double syst;
88: double imem;
89: double io;
90: };
91:
92: union Tab{
93: struct process p;
94: struct user u;
95: };
96:
97: typedef union Tab cell;
98:
99: int (*cmp)(); /* compares 2 cells; set to appropriate func */
100: cell *enter();
101: struct user *finduser();
102: struct user *wasuser();
103:
104: /*
105: * Table elements are keyed by the name of the file exec'ed.
106: * Because on large systems, many files can be exec'ed,
107: * a static table size may grow to be too large.
108: *
109: * Table elements are allocated in chunks dynamically, linked
110: * together so that they may be retrieved sequentially.
111: *
112: * An index into the table structure is provided by hashing through
113: * a seperate hash table.
114: * The hash table is segmented, and dynamically extendable.
115: * Realize that the hash table and accounting information is kept
116: * in different segments!
117: *
118: * We have a linked list of hash table segments; within each
119: * segment we use a quadratic rehash that touches no more than 1/2
120: * of the buckets in the hash table when probing.
121: * If the probe does not find the desired symbol, it moves to the
122: * next segment, or allocates a new segment.
123: *
124: * Hash table segments are kept on the linked list with the first
125: * segment always first (that will probably contain the
126: * most frequently executed commands) and
127: * the last added segment immediately after the first segment,
128: * to hopefully gain something by locality of reference.
129: *
130: * We store the per user information in the same structure as
131: * the per exec'ed file information. This allows us to use the
132: * same managers for both, as the number of user id's may be very
133: * large.
134: * User information is keyed by the first character in the name
135: * being a '\001', followed by four bytes of (long extended)
136: * user id number, followed by a null byte.
137: * The actual user names are kept in a seperate field of the
138: * user structure, and is filled in upon demand later.
139: * Iteration through all users by low user id to high user id
140: * is done by just probing the table, which is gross.
141: */
142: #define USERKEY '\001'
143: #define ISPROCESS(tp) (tp->p.name[0] && (tp->p.name[0] != USERKEY))
144: #define ISUSER(tp) (tp->p.name[0] && (tp->p.name[0] == USERKEY))
145:
146: #define TABDALLOP 500
147: struct allocbox{
148: struct allocbox *nextalloc;
149: cell tabslots[TABDALLOP];
150: };
151:
152: struct allocbox *allochead; /*head of chunk list*/
153: struct allocbox *alloctail; /*tail*/
154: struct allocbox *newbox; /*for creating a new chunk*/
155: cell *nexttab; /*next table element that is free*/
156: int tabsleft; /*slots left in current chunk*/
157: int ntabs;
158: /*
159: * Iterate through all symbols in the symbol table in declaration
160: * order.
161: * struct allocbox *allocwalk;
162: * cell *sp, *ub;
163: *
164: * sp points to the desired item, allocwalk and ub are there
165: * to make the iteration go.
166: */
167:
168: #define DECLITERATE(allocwalk, walkpointer, ubpointer) \
169: for(allocwalk = allochead; \
170: allocwalk != 0; \
171: allocwalk = allocwalk->nextalloc) \
172: for (walkpointer = &allocwalk->tabslots[0],\
173: ubpointer = &allocwalk->tabslots[TABDALLOP], \
174: ubpointer = ubpointer > ( (cell *)alloctail) \
175: ? nexttab : ubpointer ;\
176: walkpointer < ubpointer; \
177: walkpointer++ )
178:
179: #define TABCHUNKS(allocwalk, tabptr, size) \
180: for (allocwalk = allochead; \
181: allocwalk != 0; \
182: allocwalk = allocwalk->nextalloc) \
183: if ( \
184: (tabptr = &allocwalk->tabslots[0]), \
185: (size = \
186: ( (&allocwalk->tabslots[TABDALLOP]) \
187: > ((cell *)alloctail) \
188: ) \
189: ? (nexttab - tabptr) : TABDALLOP \
190: ), \
191: 1 \
192: )
193: #define PROCESSITERATE(allocwalk, walkpointer, ubpointer) \
194: DECLITERATE(allocwalk, walkpointer, ubpointer) \
195: if (ISPROCESS(walkpointer))
196:
197: #define USERITERATE(allocwalk, walkpointer, ubpointer) \
198: DECLITERATE(allocwalk, walkpointer, ubpointer) \
199: if (ISUSER(walkpointer))
200: /*
201: * When we have to sort the segmented accounting table, we
202: * create a vector of sorted queues that is merged
203: * to sort the entire accounting table.
204: */
205: struct chunkdesc {
206: cell *chunk_tp;
207: int chunk_n;
208: };
209:
210: /*
211: * Hash table segments and manager
212: */
213: #define NHASH 1103
214: struct hashdallop {
215: int h_nused;
216: struct hashdallop *h_next;
217: cell *h_tab[NHASH];
218: };
219: struct hashdallop *htab; /* head of the list */
220: int htabinstall; /* install the symbol */
221:
222: double treal;
223: double tcpu;
224: double tsys;
225: double tio;
226: double timem;
227: cell *junkp;
228: char *sname;
229: double ncom;
230: double expand();
231: char *getname();
232:
233: /*
234: * usracct saves records of type Olduser.
235: * There is one record for every possible uid less than
236: * the largest uid seen in the previous usracct or in savacct.
237: * uid's that had no activity correspond to zero filled slots;
238: * thus one can index the file and get the user record out.
239: * It would be better to save only user information for users
240: * that the system knows about to save space, but that is not
241: * upward compatabile with the old system.
242: *
243: * In the old version of sa, uid's greater than 999 were not handled
244: * properly; this system will do that.
245: */
246:
247: char * USRACCT = "usracct";
248: char * SAVACCT = "savacct";
249: char * ACCT = "acct";
250: char * ACCTDIR = "/usr/adm/\0"; /* padded with an extra null! */
251:
252: int cellcmp();
253: cell *junkp = 0;
254: int htabinstall = 1;
255: int maxuser = -1;
256: int (*cmp)();
257:
258: main(argc, argv)
259: char **argv;
260: {
261: FILE *ff;
262: int i, j;
263: extern tcmp(), ncmp(), bcmp(), dcmp(), Dcmp(), kcmp(), Kcmp();
264: extern double sum();
265: double ft;
266: register struct allocbox *allocwalk;
267: register cell *tp, *ub;
268: int size;
269: int nchunks;
270: struct chunkdesc *chunkvector;
271: int smallest;
272: int c;
273: extern char * optarg;
274: extern int optind;
275:
276: setbuf(stdout, NULL);
277: setbuf(stderr, NULL);
278: maxuser = USERSLOP + getmaxuid();
279:
280: tabinit();
281: cmp = tcmp;
282: while ((c = getopt(argc, argv, "abcdDe:fgijkKlmnorstuv:")) != EOF)
283: {
284: switch (c)
285: {
286: case 'a': aflg++; break;
287: case 'b': bflg++; cmp = bcmp; break;
288: case 'c': cflg++; break;
289: case 'd': dflg++; cmp = dcmp; break;
290: case 'D': Dflg++; cmp = Dcmp; break;
291: case 'e': ACCTDIR = optarg; break;
292: case 'f': fflg++; break;
293: case 'g': gflg++; break;
294: case 'i': iflg++; break;
295: case 'j': jflg++; break;
296: case 'k': kflg++; cmp = kcmp; break;
297: case 'K': Kflg++; cmp = Kcmp; break;
298: case 'l': lflg++; break;
299: case 'm': mflg++; break;
300: case 'n': nflg++; cmp = ncmp; break;
301: case 'o': oflg++; break;
302: case 'r': rflg++; break;
303: case 's': sflg++; aflg++; break;
304: case 't': tflg++; break;
305: case 'u': uflg++; break;
306: case 'v': vflg++; thres = atoi(optarg); break;
307: default:
308: case '?': fprintf(stderr, "sa: bad option: %c\n", c);
309: }
310: }
311: argv += optind;
312: argc -= optind;
313: if (thres == 0)
314: thres = 1;
315: if (iflg==0)
316: init();
317: if (argc < 1 && !gflg)
318: {
319: static char fname[BUFSIZ];
320:
321: sprintf(fname, "%s%s", ACCTDIR, ACCT);
322: doacct(fname);
323: }
324: else
325: while (*argv)
326: doacct(*argv++);
327: if (uflg)
328: return;
329:
330: /*
331: * cleanup pass
332: * put junk together
333: */
334:
335: if (vflg)
336: strip();
337: if(!aflg)
338: PROCESSITERATE(allocwalk, tp, ub){
339: for(j=0; j<NC; j++)
340: if(tp->p.name[j] == '?')
341: goto yes;
342: if(tp->p.count != 1)
343: continue;
344: yes:
345: if(junkp == 0)
346: junkp = enter("***other");
347: junkp->p.count += tp->p.count;
348: junkp->p.realt += tp->p.realt;
349: junkp->p.cput += tp->p.cput;
350: junkp->p.syst += tp->p.syst;
351: junkp->p.imem += tp->p.imem;
352: junkp->p.io += tp->p.io;
353: tp->p.name[0] = 0;
354: }
355: if (sflg) {
356: static char fname[BUFSIZ];
357:
358: sprintf(fname, "%s%s", ACCTDIR, USRACCT);
359: signal(SIGINT, SIG_IGN);
360: if ((ff = fopen(fname, "w")) != NULL) {
361: static struct user ZeroUser = {0};
362: struct user *up;
363: int uid;
364: /*
365: * Write out just enough user slots,
366: * filling with zero slots for users that
367: * weren't found.
368: * The file can be indexed directly by uid
369: * to get the correct record.
370: */
371: for (uid = 0; uid < maxuser; uid++){
372: if ( (up = wasuser(uid)) != 0)
373: fwrite((char *)&(up->oldu),
374: sizeof(struct Olduser),1,ff);
375: else
376: fwrite((char *)&(ZeroUser.oldu),
377: sizeof(struct Olduser),1,ff);
378: }
379: }
380: (void) fclose(ff);
381: sprintf(fname, "%s%s", ACCTDIR, SAVACCT);
382: if ((ff = fopen(fname, "w")) == NULL) {
383: printf("Can't save\n");
384: exit(0);
385: }
386: PROCESSITERATE(allocwalk, tp, ub)
387: fwrite((char *)&(tp->p), sizeof(struct process), 1, ff);
388: (void) fclose(ff);
389: creat(sname, 0644);
390: signal(SIGINT, SIG_DFL);
391: }
392: /*
393: * sort and print
394: */
395: if (mflg) {
396: printmoney();
397: exit(0);
398: }
399: column(ncom, treal, tcpu, tsys, timem, tio);
400: printf("\n");
401:
402: /*
403: * the fragmented table is sorted by sorting each fragment
404: * and then merging.
405: */
406: nchunks = 0;
407: TABCHUNKS(allocwalk, tp, size){
408: qsort(tp, size, sizeof(cell), cellcmp);
409: nchunks ++;
410: }
411: chunkvector = (struct chunkdesc *)calloc(nchunks,
412: sizeof(struct chunkdesc));
413: nchunks = 0;
414: TABCHUNKS(allocwalk, tp, size){
415: chunkvector[nchunks].chunk_tp = tp;
416: chunkvector[nchunks].chunk_n = size;
417: nchunks++;
418: }
419: for(; nchunks; ){
420: /*
421: * Find the smallest element at the head of the queues.
422: */
423: smallest = 0;
424: for (i = 1; i < nchunks; i++){
425: if (cellcmp(chunkvector[i].chunk_tp,
426: chunkvector[smallest].chunk_tp) < 0)
427: smallest = i;
428: }
429: tp = chunkvector[smallest].chunk_tp++;
430: /*
431: * If this queue is drained, drop the chunk count,
432: * and readjust the queues.
433: */
434: if (--chunkvector[smallest].chunk_n == 0){
435: nchunks--;
436: for (i = smallest; i < nchunks; i++)
437: chunkvector[i] = chunkvector[i+1];
438: }
439: if (ISPROCESS(tp)){
440: ft = tp->p.count;
441: column(ft, tp->p.realt, tp->p.cput,
442: tp->p.syst, tp->p.imem, tp->p.io);
443: printf(" %.14s\n", tp->p.name);
444: }
445: } /* iterate to merge the lists */
446: }
447:
448: printmoney()
449: {
450: register i;
451: register char *cp;
452: register struct user *up;
453:
454: getnames(); /* fetches all of the names! */
455: for (i = 0; i < maxuser; i++) {
456: if ( (up = wasuser(i)) != 0){
457: if (up->us_cnt) {
458: if (up->us_name[0])
459: printf("%-8s", up->us_name);
460: else
461: printf("%-8d", i);
462: printf("%7u %9.2fcpu %10.0ftio %12.0fk*sec\n",
463: up->us_cnt, up->us_ctime/60,
464: up->us_io,
465: up->us_imem / (60 * 2));
466: }
467: }
468: }
469: }
470:
471: column(n, a, b, c, d, e)
472: double n, a, b, c, d, e;
473: {
474:
475: printf("%8.0f", n);
476: if(cflg) {
477: if(n == ncom)
478: printf("%9s", ""); else
479: printf("%8.2f%%", 100.*n/ncom);
480: }
481: col(n, a, treal, "re");
482: if (oflg)
483: col(n, 3600*(b/(b+c)), tcpu+tsys, "u/s");
484: else if(lflg) {
485: col(n, b, tcpu, "u");
486: col(n, c, tsys, "s");
487: } else
488: col(n, b+c, tcpu+tsys, "cp");
489: if(tflg)
490: printf("%8.1f", a/(b+c), "re/cp");
491: if(dflg || !Dflg)
492: printf("%10.0favio", e/(n?n:1));
493: else
494: printf("%10.0ftio", e);
495: if (kflg || !Kflg)
496: printf("%10.0fk", d/(2*((b+c)!=0.0?(b+c):1.0)));
497: else
498: printf("%10.0fk*sec", d/(2*60));
499: }
500:
501: col(n, a, m, cp)
502: double n, a, m;
503: char *cp;
504: {
505:
506: if(jflg)
507: printf("%11.2f%s", a/(n*60.), cp); else
508: printf("%11.2f%s", a/3600., cp);
509: if(cflg) {
510: if(a == m)
511: printf("%9s", ""); else
512: printf("%8.2f%%", 100.*a/m);
513: }
514: }
515:
516: doacct(f)
517: char *f;
518: {
519: FILE *ff;
520: long x, y, z;
521: struct acct fbuf;
522: register char *cp;
523: register int c;
524: register struct user *up;
525: register cell *tp;
526: int nrecords = 0;
527:
528: if (sflg && sname) {
529: printf("Only 1 file with -s\n");
530: exit(0);
531: }
532: if (sflg)
533: {
534: sname = f;
535: }
536: if ((ff = fopen(f, "r"))==NULL) {
537: printf("Can't open %s\n", f);
538: return;
539: }
540: while (fread((char *)&fbuf, sizeof(fbuf), 1, ff) == 1) {
541: ++nrecords;
542: #ifdef DEBUG
543: if (nrecords % 1000 == 0)
544: printf("Input record from %s number %d\n",
545: f, nrecords);
546: #endif DEBUG
547: if (fbuf.ac_comm[0]==0) {
548: fbuf.ac_comm[0] = '?';
549: }
550: for (cp = fbuf.ac_comm; cp < &fbuf.ac_comm[NC]; cp++) {
551: c = *cp & 0377;
552: if (c && (c < ' ' || c >= 0200)) {
553: *cp = '?';
554: }
555: }
556: if (fbuf.ac_flag&AFORK) {
557: for (cp=fbuf.ac_comm; cp < &fbuf.ac_comm[NC]; cp++)
558: if (*cp==0) {
559: *cp = '*';
560: break;
561: }
562: }
563: x = expand(fbuf.ac_utime) + expand(fbuf.ac_stime);
564: y = fbuf.ac_mem;
565: z = expand(fbuf.ac_io);
566: if (uflg) {
567: printf("%5d %6.1fcp %6dmem %6dio %.*s\n",
568: fbuf.ac_uid, x/60.0, y, z,
569: NC, fbuf.ac_comm);
570: continue;
571: }
572: up = finduser(fbuf.ac_uid);
573: if (up == 0)
574: {
575: fprintf(stderr,"sa: Invalid record #%d\n", nrecords);
576: dumprec(&fbuf);
577: continue; /* preposterous user id */
578: }
579: up->us_cnt++;
580: up->us_ctime += x/60.;
581: up->us_imem += x * y;
582: up->us_io += z;
583: ncom += 1.0;
584:
585: tp = enter(fbuf.ac_comm);
586: tp->p.imem += x * y;
587: timem += x * y;
588: tp->p.count++;
589: x = expand(fbuf.ac_etime)*60;
590: tp->p.realt += x;
591: treal += x;
592: x = expand(fbuf.ac_utime);
593: tp->p.cput += x;
594: tcpu += x;
595: x = expand(fbuf.ac_stime);
596: tp->p.syst += x;
597: tsys += x;
598: tp->p.io += z;
599: tio += z;
600: }
601: fclose(ff);
602: }
603:
604: /*
605: * Generalized cell compare routine, to cast out users
606: */
607: cellcmp(p1, p2)
608: cell *p1, *p2;
609: {
610: if (ISPROCESS(p1)){
611: if (ISPROCESS(p2))
612: return(cmp(p1, p2));
613: return(-1);
614: }
615: if (ISPROCESS(p2))
616: return(1);
617: return(0);
618: }
619: ncmp(p1, p2)
620: cell *p1, *p2;
621: {
622:
623: if(p1->p.count == p2->p.count)
624: return(tcmp(p1, p2));
625: if(rflg)
626: return(p1->p.count - p2->p.count);
627: return(p2->p.count - p1->p.count);
628: }
629:
630: bcmp(p1, p2)
631: cell *p1, *p2;
632: {
633: double f1, f2;
634: double sum();
635:
636: f1 = sum(p1)/p1->p.count;
637: f2 = sum(p2)/p2->p.count;
638: if(f1 < f2) {
639: if(rflg)
640: return(-1);
641: return(1);
642: }
643: if(f1 > f2) {
644: if(rflg)
645: return(1);
646: return(-1);
647: }
648: return(0);
649: }
650:
651: Kcmp(p1, p2)
652: cell *p1, *p2;
653: {
654:
655: if (p1->p.imem < p2->p.imem) {
656: if(rflg)
657: return(-1);
658: return(1);
659: }
660: if (p1->p.imem > p2->p.imem) {
661: if(rflg)
662: return(1);
663: return(-1);
664: }
665: return(0);
666: }
667:
668: kcmp(p1, p2)
669: cell *p1, *p2;
670: {
671: double a1, a2;
672:
673: a1 = p1->p.imem / ((p1->p.cput+p1->p.syst)?(p1->p.cput+p1->p.syst):1);
674: a2 = p2->p.imem / ((p2->p.cput+p2->p.syst)?(p2->p.cput+p2->p.syst):1);
675: if (a1 < a2) {
676: if(rflg)
677: return(-1);
678: return(1);
679: }
680: if (a1 > a2) {
681: if(rflg)
682: return(1);
683: return(-1);
684: }
685: return(0);
686: }
687:
688: dcmp(p1, p2)
689: cell *p1, *p2;
690: {
691: double a1, a2;
692:
693: a1 = p1->p.io / (p1->p.count?p1->p.count:1);
694: a2 = p2->p.io / (p2->p.count?p2->p.count:1);
695: if (a1 < a2) {
696: if(rflg)
697: return(-1);
698: return(1);
699: }
700: if (a1 > a2) {
701: if(rflg)
702: return(1);
703: return(-1);
704: }
705: return(0);
706: }
707:
708: Dcmp(p1, p2)
709: cell *p1, *p2;
710: {
711:
712: if (p1->p.io < p2->p.io) {
713: if(rflg)
714: return(-1);
715: return(1);
716: }
717: if (p1->p.io > p2->p.io) {
718: if(rflg)
719: return(1);
720: return(-1);
721: }
722: return(0);
723: }
724:
725: tcmp(p1, p2)
726: cell *p1, *p2;
727: {
728: extern double sum();
729: double f1, f2;
730:
731: f1 = sum(p1);
732: f2 = sum(p2);
733: if(f1 < f2) {
734: if(rflg)
735: return(-1);
736: return(1);
737: }
738: if(f1 > f2) {
739: if(rflg)
740: return(1);
741: return(-1);
742: }
743: return(0);
744: }
745:
746: double sum(p)
747: cell *p;
748: {
749:
750: if(p->p.name[0] == 0)
751: return(0.0);
752: return( p->p.cput + p->p.syst);
753: }
754:
755: init()
756: {
757: struct user userbuf;
758: struct process tbuf;
759: register cell *tp;
760: register struct user *up;
761: int uid;
762: FILE *f;
763: static char fname[BUFSIZ];
764:
765: sprintf(fname, "%s%s", ACCTDIR, SAVACCT);
766: if ((f = fopen(fname, "r")) == NULL)
767: goto gshm;
768: while (fread((char *)&tbuf, sizeof(struct process), 1, f) == 1) {
769: tp = enter(tbuf.name);
770: ncom += tbuf.count;
771: tp->p.count = tbuf.count;
772: treal += tbuf.realt;
773: tp->p.realt = tbuf.realt;
774: tcpu += tbuf.cput;
775: tp->p.cput = tbuf.cput;
776: tsys += tbuf.syst;
777: tp->p.syst = tbuf.syst;
778: tio += tbuf.io;
779: tp->p.io = tbuf.io;
780: timem += tbuf.imem;
781: tp->p.imem = tbuf.imem;
782: }
783: fclose(f);
784: gshm:
785: sprintf(fname, "%s%s", ACCTDIR, USRACCT);
786: if ((f = fopen(fname, "r")) == NULL)
787: return;
788: for(uid = 0;
789: fread((char *)&(userbuf.oldu), sizeof(struct Olduser), 1, f) == 1;
790: uid++){
791: if (userbuf.us_cnt){
792: up = finduser(uid);
793: if (up == 0)
794: continue; /* preposterous user id */
795: up->oldu = userbuf.oldu;
796: }
797: }
798: fclose(f);
799: }
800:
801: strip()
802: {
803: int c;
804: register struct allocbox *allocwalk;
805: register cell *tp, *ub, *junkp;
806:
807: if (fflg)
808: printf("Categorizing commands used %d times or fewer as **junk**\n",
809: thres);
810: junkp = enter("**junk**");
811: PROCESSITERATE(allocwalk, tp, ub){
812: if (tp->p.name[0] && tp->p.count <= thres) {
813: if (!fflg)
814: printf("%.14s--", tp->p.name);
815: if (fflg || ((c=getchar())=='y')) {
816: tp->p.name[0] = '\0';
817: junkp->p.count += tp->p.count;
818: junkp->p.realt += tp->p.realt;
819: junkp->p.cput += tp->p.cput;
820: junkp->p.syst += tp->p.syst;
821: junkp->p.imem += tp->p.imem;
822: junkp->p.io += tp->p.io;
823: }
824: if (!fflg)
825: while (c && c!='\n')
826: c = getchar();
827: }
828: }
829: }
830:
831: double
832: expand(t)
833: unsigned short t;
834: {
835: register double nt;
836:
837: nt = t&017777;
838: t >>= 13;
839: while (t!=0) {
840: t--;
841: nt *= 8.0;
842: }
843: return(nt);
844: }
845:
846: static char UserKey[NAMELG + 2];
847: char *makekey(uid)
848: int uid;
849: {
850: sprintf(UserKey+1, "%04x", uid);
851: UserKey[0] = USERKEY;
852: return(UserKey);
853: }
854:
855: struct user *wasuser(uid)
856: int uid;
857: {
858: struct user *tp;
859: htabinstall = 0;
860: tp = finduser(uid);
861: htabinstall = 1;
862: return(tp);
863: }
864: /*
865: * Only call this if you really want to insert it in the table!
866: */
867: struct user *finduser(uid)
868: int uid;
869: {
870: if (uid > maxuser){
871: fprintf(stderr, "Preposterous user id, %d: ignored\n", uid);
872: return(0);
873: } else {
874: return((struct user*)enter(makekey(uid)));
875: }
876: }
877:
878: /*
879: * Set the names of all users in the password file.
880: * We will later not print those that didn't do anything.
881: */
882: getnames()
883: {
884: register struct user *tp;
885: register struct passwd *pw;
886: struct passwd *getpwent();
887:
888: setpwent();
889: while (pw = getpwent()){
890: if ( (tp = wasuser(pw->pw_uid)) != 0)
891: strncpy(tp->us_name, pw->pw_name, NAMELG);
892: }
893: endpwent();
894: }
895:
896: int getmaxuid()
897: {
898: register struct user *tp;
899: register struct passwd *pw;
900: struct passwd *getpwent();
901: int maxuid = -1;
902:
903: setpwent();
904: while(pw = getpwent()){
905: if (pw->pw_uid > maxuid)
906: maxuid = pw->pw_uid;
907: }
908: endpwent();
909: return(maxuid);
910: }
911:
912: tabinit()
913: {
914: allochead = 0;
915: alloctail = 0;
916: nexttab = 0;
917: tabsleft = 0;
918: htab = 0;
919: ntabs = 0;
920: htaballoc(); /* get the first part of the hash table */
921: }
922:
923: #define ALLOCQTY sizeof (struct allocbox)
924: cell *taballoc()
925: {
926: if (tabsleft == 0){
927: newbox = (struct allocbox *)calloc(1, ALLOCQTY);
928: tabsleft = TABDALLOP;
929: nexttab = &newbox->tabslots[0];
930: if (alloctail == 0){
931: allochead = alloctail = newbox;
932: } else {
933: alloctail->nextalloc = newbox;
934: alloctail = newbox;
935: }
936: }
937: --tabsleft;
938: ++ntabs;
939: #ifdef DEBUG
940: if (ntabs % 100 == 0)
941: printf("##Accounting table slot # %d\n", ntabs);
942: #endif DEBUG
943: return(nexttab++);
944: }
945:
946: htaballoc()
947: {
948: register struct hashdallop *new;
949: #ifdef DEBUG
950: static int ntables = 0;
951: printf("%%%New hash table chunk allocated, number %d\n", ++ntables);
952: #endif DEBUG
953: new = (struct hashdallop *)calloc(1, sizeof (struct hashdallop));
954: if (htab == 0)
955: htab = new;
956: else { /* add AFTER the 1st slot */
957: new->h_next = htab->h_next;
958: htab->h_next = new;
959: }
960: }
961:
962: #define HASHCLOGGED (NHASH / 2)
963: /*
964: * Lookup a symbol passed in as the argument.
965: *
966: * We take pains to avoid function calls; this function
967: * is called quite frequently, and the calling overhead
968: * contributes significantly to the overall execution speed of sa.
969: */
970: cell *
971: enter(name)
972: char *name;
973: {
974: static int initialprobe;
975: register cell **hp;
976: register char *from;
977: register char *to;
978: register int len;
979: register int nprobes;
980: static struct hashdallop *hdallop;
981: static cell **emptyslot;
982: static struct hashdallop *emptyhd;
983: static cell **hp_ub;
984:
985: emptyslot = 0;
986: for (nprobes = 0, from = name, len = 0;
987: *from && len < NC;
988: nprobes <<= 2, nprobes += *from++, len++)
989: continue;
990: nprobes += from[-1] << 5;
991: nprobes %= NHASH;
992: if (nprobes < 0)
993: nprobes += NHASH;
994:
995: initialprobe = nprobes;
996: for (hdallop = htab; hdallop != 0; hdallop = hdallop->h_next){
997: for (hp = &(hdallop->h_tab[initialprobe]),
998: nprobes = 1,
999: hp_ub = &(hdallop->h_tab[NHASH]);
1000: (*hp) && (nprobes < NHASH);
1001: hp += nprobes,
1002: hp -= (hp >= hp_ub) ? NHASH:0,
1003: nprobes += 2)
1004: {
1005: from = name;
1006: to = (*hp)->p.name;
1007:
1008: for (len = 0; (len<NC) && *from; len++)
1009: if (*from++ != *to++)
1010: goto nextprobe;
1011: if (len >= NC) /*both are maximal length*/
1012: return(*hp);
1013: if (*to == 0) /*assert *from == 0*/
1014: return(*hp);
1015: nextprobe: ;
1016: }
1017: if (*hp == 0 && emptyslot == 0 &&
1018: hdallop->h_nused < HASHCLOGGED) {
1019: emptyslot = hp;
1020: emptyhd = hdallop;
1021: }
1022: }
1023: if (emptyslot == 0) {
1024: htaballoc();
1025: hdallop = htab->h_next; /* aren't we smart! */
1026: hp = &hdallop->h_tab[initialprobe];
1027: } else {
1028: hdallop = emptyhd;
1029: hp = emptyslot;
1030: }
1031: if (htabinstall){
1032: *hp = taballoc();
1033: hdallop->h_nused++;
1034: for(len = 0, from = name, to = (*hp)->p.name; (len<NC); len++)
1035: if ((*to++ = *from++) == '\0')
1036: break;
1037: return(*hp);
1038: }
1039: return(0);
1040: } /*end of lookup*/
1041:
1042: dumprec(ap)
1043: struct acct *ap;
1044: {
1045: fprintf(stderr, "ac_comm:<%-*.*s>; ", sizeof ap->ac_comm,
1046: sizeof ap->ac_comm, ap->ac_comm);
1047: fprintf(stderr, "ac_utime:%g; ", expand(ap->ac_utime));
1048: fprintf(stderr, "ac_stime:%g; ", expand(ap->ac_stime));
1049: fprintf(stderr, "ac_etime:%g\n", expand(ap->ac_etime));
1050: fprintf(stderr, "ac_btime:%-24.24s; ", ctime(&ap->ac_btime));
1051: fprintf(stderr, "ac_uid:%5hd; ", ap->ac_uid);
1052: fprintf(stderr, "ac_gid:%5hd; ", ap->ac_gid);
1053: fprintf(stderr, "ac_mem:%5hd\n", ap->ac_mem);
1054: fprintf(stderr, "ac_io:%g; ", expand(ap->ac_io));
1055: fprintf(stderr, "ac_tty:0x%4hX; ", ap->ac_tty);
1056: fprintf(stderr, "ac_flag:0x%X\n", ap->ac_flag);
1057: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.