![[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 [CSRG BSD Unix] / 42BSD / etc|
Return to sa.c CVS log | Up to [CSRG BSD Unix] / 42BSD / etc |
1.1 root 1: #ifndef lint
2: static char *sccsid = "@(#)sa.c 4.4 (Berkeley) 83/08/11";
3: #endif
4:
5: /*
6: * Extensive modifications to internal data structures
7: * to allow arbitrary number of different commands and users added.
8: *
9: * Also allowed the digit option on the -v flag (interactive
10: * threshold compress) to be a digit string, so one can
11: * set the threshold > 9.
12: *
13: * Also added the -f flag, to force no interactive threshold
14: * compression with the -v flag.
15: *
16: * Robert Henry
17: * UC Berkeley
18: * 31jan81
19: */
20: #include <stdio.h>
21: #include <sys/types.h>
22: #include <sys/acct.h>
23: #include <signal.h>
24: #include <utmp.h>
25: #include <pwd.h>
26:
27: /* interpret command time accounting */
28:
29: #define NC sizeof(acctbuf.ac_comm)
30:
31: struct acct acctbuf;
32: int lflg;
33: int cflg;
34: int Dflg;
35: int dflg;
36: int iflg;
37: int jflg;
38: int Kflg;
39: int kflg;
40: int nflg;
41: int aflg;
42: int rflg;
43: int oflg;
44: int tflg;
45: int vflg;
46: int fflg;
47: int uflg;
48: int thres;
49: int sflg;
50: int bflg;
51: int mflg;
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: time_t 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: #ifdef DEBUG
248: #define USRACCT "./usracct"
249: #define SAVACCT "./savacct"
250: #define ACCT "./acct"
251: #else
252: #define USRACCT "/usr/adm/usracct"
253: #define SAVACCT "/usr/adm/savacct"
254: #define ACCT "/usr/adm/acct"
255: #endif DEBUG
256:
257:
258: int cellcmp();
259: cell *junkp = 0;
260: /*
261: * The threshold is built up from digits in the argv ;
262: * eg, -v1s0u1
263: * will build a value of thres of 101.
264: *
265: * If the threshold is zero after processing argv, it is set to 1
266: */
267: int thres = 0;
268: int htabinstall = 1;
269: int maxuser = -1;
270: int (*cmp)();
271:
272: extern tcmp(), ncmp(), bcmp(), dcmp(), Dcmp(), kcmp(), Kcmp();
273: extern double sum();
274:
275: main(argc, argv)
276: char **argv;
277: {
278: FILE *ff;
279: double ft;
280: register struct allocbox *allocwalk;
281: register cell *tp, *ub;
282: int i, j, size, nchunks, smallest;
283: struct chunkdesc *chunkvector;
284:
285: maxuser = USERSLOP + getmaxuid();
286:
287: tabinit();
288: cmp = tcmp;
289: if (argc>1)
290: if (argv[1][0]=='-') {
291: argv++;
292: argc--;
293: for(i=1; argv[0][i]; i++)
294: switch(argv[0][i]) {
295:
296: case 'o':
297: oflg++;
298: break;
299:
300: case 'i':
301: iflg++;
302: break;
303:
304: case 'b':
305: bflg++;
306: cmp = bcmp;
307: break;
308:
309: case 'l':
310: lflg++;
311: break;
312:
313: case 'c':
314: cflg++;
315: break;
316:
317: case 'd':
318: dflg++;
319: cmp = dcmp;
320: break;
321:
322: case 'D':
323: Dflg++;
324: cmp = Dcmp;
325: break;
326:
327: case 'j':
328: jflg++;
329: break;
330:
331: case 'k':
332: kflg++;
333: cmp = kcmp;
334: break;
335:
336: case 'K':
337: Kflg++;
338: cmp = Kcmp;
339: break;
340:
341: case 'n':
342: nflg++;
343: cmp = ncmp;
344: break;
345:
346: case 'a':
347: aflg++;
348: break;
349:
350: case 'r':
351: rflg++;
352: break;
353:
354: case 't':
355: tflg++;
356: break;
357:
358: case 's':
359: sflg++;
360: aflg++;
361: break;
362:
363: case '0':
364: case '1':
365: case '2':
366: case '3':
367: case '4':
368: case '5':
369: case '6':
370: case '7':
371: case '8':
372: case '9':
373: thres = thres * 10 + (argv[0][i]-'0');
374: break;
375:
376: case 'v':
377: vflg++;
378: break;
379:
380: case 'f':
381: fflg++; /* force v option; no tty interaction */
382: break;
383:
384: case 'u':
385: uflg++;
386: break;
387:
388: case 'm':
389: mflg++;
390: break;
391: }
392: }
393: if (thres == 0)
394: thres = 1;
395: if (iflg==0)
396: init();
397: if (argc<2)
398: doacct(ACCT);
399: else while (--argc)
400: doacct(*++argv);
401: if (uflg) {
402: return;
403: }
404:
405: /*
406: * cleanup pass
407: * put junk together
408: */
409:
410: if (vflg)
411: strip();
412: if(!aflg)
413: PROCESSITERATE(allocwalk, tp, ub){
414: for(j=0; j<NC; j++)
415: if(tp->p.name[j] == '?')
416: goto yes;
417: if(tp->p.count != 1)
418: continue;
419: yes:
420: if(junkp == 0)
421: junkp = enter("***other");
422: junkp->p.count += tp->p.count;
423: junkp->p.realt += tp->p.realt;
424: junkp->p.cput += tp->p.cput;
425: junkp->p.syst += tp->p.syst;
426: junkp->p.imem += tp->p.imem;
427: junkp->p.io += tp->p.io;
428: tp->p.name[0] = 0;
429: }
430: if (sflg) {
431: signal(SIGINT, SIG_IGN);
432: if ((ff = fopen(USRACCT, "w")) != NULL) {
433: static struct user ZeroUser = {0};
434: struct user *up;
435: int uid;
436: /*
437: * Write out just enough user slots,
438: * filling with zero slots for users that
439: * weren't found.
440: * The file can be indexed directly by uid
441: * to get the correct record.
442: */
443: for (uid = 0; uid < maxuser; uid++){
444: if ( (up = wasuser(uid)) != 0)
445: fwrite((char *)&(up->oldu),
446: sizeof(struct Olduser),1,ff);
447: else
448: fwrite((char *)&(ZeroUser.oldu),
449: sizeof(struct Olduser),1,ff);
450: }
451: }
452: if ((ff = fopen(SAVACCT, "w")) == NULL) {
453: printf("Can't save\n");
454: exit(0);
455: }
456: PROCESSITERATE(allocwalk, tp, ub)
457: fwrite((char *)&(tp->p), sizeof(struct process), 1, ff);
458: fclose(ff);
459: creat(sname, 0644);
460: signal(SIGINT, SIG_DFL);
461: }
462: /*
463: * sort and print
464: */
465: if (mflg) {
466: printmoney();
467: exit(0);
468: }
469: column(ncom, treal, tcpu, tsys, timem, tio);
470: printf("\n");
471:
472: /*
473: * the fragmented table is sorted by sorting each fragment
474: * and then merging.
475: */
476: nchunks = 0;
477: TABCHUNKS(allocwalk, tp, size){
478: qsort(tp, size, sizeof(cell), cellcmp);
479: nchunks ++;
480: }
481: chunkvector = (struct chunkdesc *)calloc(nchunks,
482: sizeof(struct chunkdesc));
483: nchunks = 0;
484: TABCHUNKS(allocwalk, tp, size){
485: chunkvector[nchunks].chunk_tp = tp;
486: chunkvector[nchunks].chunk_n = size;
487: nchunks++;
488: }
489: for(; nchunks; ){
490: /*
491: * Find the smallest element at the head of the queues.
492: */
493: smallest = 0;
494: for (i = 1; i < nchunks; i++){
495: if (cellcmp(chunkvector[i].chunk_tp,
496: chunkvector[smallest].chunk_tp) < 0)
497: smallest = i;
498: }
499: tp = chunkvector[smallest].chunk_tp++;
500: /*
501: * If this queue is drained, drop the chunk count,
502: * and readjust the queues.
503: */
504: if (--chunkvector[smallest].chunk_n == 0){
505: nchunks--;
506: for (i = smallest; i < nchunks; i++)
507: chunkvector[i] = chunkvector[i+1];
508: }
509: if (ISPROCESS(tp)){
510: ft = tp->p.count;
511: column(ft, tp->p.realt, tp->p.cput,
512: tp->p.syst, tp->p.imem, tp->p.io);
513: printf(" %.14s\n", tp->p.name);
514: }
515: } /* iterate to merge the lists */
516: }
517:
518: printmoney()
519: {
520: register i;
521: register char *cp;
522: register struct user *up;
523:
524: getnames(); /* fetches all of the names! */
525: for (i = 0; i < maxuser; i++) {
526: if ( (up = wasuser(i)) != 0){
527: if (up->us_cnt) {
528: if (up->us_name[0])
529: printf("%-8s", up->us_name);
530: else
531: printf("%-8d", i);
532: printf("%7u %9.2fcpu %10.0ftio %12.0fk*sec\n",
533: up->us_cnt, up->us_ctime / 60,
534: up->us_io,
535: up->us_imem / (60 * 2));
536: }
537: }
538: }
539: }
540:
541: column(n, a, b, c, d, e)
542: double n, a, b, c, d, e;
543: {
544:
545: printf("%8.0f", n);
546: if(cflg) {
547: if(n == ncom)
548: printf("%9s", ""); else
549: printf("%8.2f%%", 100.*n/ncom);
550: }
551: col(n, a, treal, "re");
552: if (oflg)
553: col(n, 3600*(b/(b+c)), tcpu+tsys, "u/s");
554: else if(lflg) {
555: col(n, b, tcpu, "u");
556: col(n, c, tsys, "s");
557: } else
558: col(n, b+c, tcpu+tsys, "cp");
559: if(tflg)
560: printf("%8.1f", a/(b+c), "re/cp");
561: if(dflg || !Dflg)
562: printf("%10.0favio", e/(n?n:1));
563: else
564: printf("%10.0ftio", e);
565: if (kflg || !Kflg)
566: printf("%10.0fk", d/(2*((b+c)!=0.0?(b+c):1.0)));
567: else
568: printf("%10.0fk*sec", d/(2*60));
569: }
570:
571: col(n, a, m, cp)
572: double n, a, m;
573: char *cp;
574: {
575:
576: if(jflg)
577: printf("%11.2f%s", a/(n*60.), cp); else
578: printf("%11.2f%s", a/3600., cp);
579: if(cflg) {
580: if(a == m)
581: printf("%9s", ""); else
582: printf("%8.2f%%", 100.*a/m);
583: }
584: }
585:
586: doacct(f)
587: char *f;
588: {
589: FILE *ff;
590: long x, y, z;
591: struct acct fbuf;
592: register char *cp;
593: register int c;
594: register struct user *up;
595: register cell *tp;
596: #ifdef DEBUG
597: int nrecords = 0;
598: #endif DEBUG
599:
600: if (sflg && sname) {
601: printf("Only 1 file with -s\n");
602: exit(0);
603: }
604: if (sflg)
605: sname = f;
606: if ((ff = fopen(f, "r"))==NULL) {
607: printf("Can't open %s\n", f);
608: return;
609: }
610: while (fread((char *)&fbuf, sizeof(fbuf), 1, ff) == 1) {
611: #ifdef DEBUG
612: if (++nrecords % 1000 == 0)
613: printf("Input record from %s number %d\n",
614: f, nrecords);
615: #endif DEBUG
616: if (fbuf.ac_comm[0]==0) {
617: fbuf.ac_comm[0] = '?';
618: }
619: for (cp = fbuf.ac_comm; cp < &fbuf.ac_comm[NC]; cp++) {
620: c = *cp & 0377;
621: if (c && (c < ' ' || c >= 0200)) {
622: *cp = '?';
623: }
624: }
625: if (fbuf.ac_flag&AFORK) {
626: for (cp=fbuf.ac_comm; cp < &fbuf.ac_comm[NC]; cp++)
627: if (*cp==0) {
628: *cp = '*';
629: break;
630: }
631: }
632: x = expand(fbuf.ac_utime) + expand(fbuf.ac_stime);
633: y = fbuf.ac_mem;
634: z = expand(fbuf.ac_io);
635: if (uflg) {
636: printf("%3d%6.1fcp %6dmem %6dio %.14s\n",
637: fbuf.ac_uid, x, y, z, fbuf.ac_comm);
638: continue;
639: }
640: up = finduser(fbuf.ac_uid);
641: if (up == 0)
642: continue; /* preposterous user id */
643: up->us_cnt++;
644: up->us_ctime += x;
645: up->us_imem += x * y;
646: up->us_io += z;
647: ncom += 1.0;
648:
649: tp = enter(fbuf.ac_comm);
650: tp->p.imem += x * y;
651: timem += x * y;
652: tp->p.count++;
653: x = expand(fbuf.ac_etime);
654: tp->p.realt += x;
655: treal += x;
656: x = expand(fbuf.ac_utime);
657: tp->p.cput += x;
658: tcpu += x;
659: x = expand(fbuf.ac_stime);
660: tp->p.syst += x;
661: tsys += x;
662: tp->p.io += z;
663: tio += z;
664: }
665: fclose(ff);
666: }
667:
668: /*
669: * Generalized cell compare routine, to cast out users
670: */
671: cellcmp(p1, p2)
672: cell *p1, *p2;
673: {
674: if (ISPROCESS(p1)){
675: if (ISPROCESS(p2))
676: return((*cmp)(p1, p2));
677: return(-1);
678: }
679: if (ISPROCESS(p2))
680: return(1);
681: return(0);
682: }
683:
684: ncmp(p1, p2)
685: cell *p1, *p2;
686: {
687:
688: if(p1->p.count == p2->p.count)
689: return(tcmp(p1, p2));
690: if(rflg)
691: return(p1->p.count - p2->p.count);
692: return(p2->p.count - p1->p.count);
693: }
694:
695: bcmp(p1, p2)
696: cell *p1, *p2;
697: {
698: double f1, f2;
699: double sum();
700:
701: f1 = sum(p1)/p1->p.count;
702: f2 = sum(p2)/p2->p.count;
703: if(f1 < f2) {
704: if(rflg)
705: return(-1);
706: return(1);
707: }
708: if(f1 > f2) {
709: if(rflg)
710: return(1);
711: return(-1);
712: }
713: return(0);
714: }
715:
716: Kcmp(p1, p2)
717: cell *p1, *p2;
718: {
719:
720: if (p1->p.imem < p2->p.imem) {
721: if(rflg)
722: return(-1);
723: return(1);
724: }
725: if (p1->p.imem > p2->p.imem) {
726: if(rflg)
727: return(1);
728: return(-1);
729: }
730: return(0);
731: }
732:
733: kcmp(p1, p2)
734: cell *p1, *p2;
735: {
736: double a1, a2;
737:
738: a1 = p1->p.imem / ((p1->p.cput+p1->p.syst)?(p1->p.cput+p1->p.syst):1);
739: a2 = p2->p.imem / ((p2->p.cput+p2->p.syst)?(p2->p.cput+p2->p.syst):1);
740: if (a1 < a2) {
741: if(rflg)
742: return(-1);
743: return(1);
744: }
745: if (a1 > a2) {
746: if(rflg)
747: return(1);
748: return(-1);
749: }
750: return(0);
751: }
752:
753: dcmp(p1, p2)
754: cell *p1, *p2;
755: {
756: double a1, a2;
757:
758: a1 = p1->p.io / (p1->p.count?p1->p.count:1);
759: a2 = p2->p.io / (p2->p.count?p2->p.count:1);
760: if (a1 < a2) {
761: if(rflg)
762: return(-1);
763: return(1);
764: }
765: if (a1 > a2) {
766: if(rflg)
767: return(1);
768: return(-1);
769: }
770: return(0);
771: }
772:
773: Dcmp(p1, p2)
774: cell *p1, *p2;
775: {
776:
777: if (p1->p.io < p2->p.io) {
778: if(rflg)
779: return(-1);
780: return(1);
781: }
782: if (p1->p.io > p2->p.io) {
783: if(rflg)
784: return(1);
785: return(-1);
786: }
787: return(0);
788: }
789:
790: tcmp(p1, p2)
791: cell *p1, *p2;
792: {
793: extern double sum();
794: double f1, f2;
795:
796: f1 = sum(p1);
797: f2 = sum(p2);
798: if(f1 < f2) {
799: if(rflg)
800: return(-1);
801: return(1);
802: }
803: if(f1 > f2) {
804: if(rflg)
805: return(1);
806: return(-1);
807: }
808: return(0);
809: }
810:
811: double sum(p)
812: cell *p;
813: {
814:
815: if(p->p.name[0] == 0)
816: return(0.0);
817: return( p->p.cput + p->p.syst);
818: }
819:
820: init()
821: {
822: struct user userbuf;
823: struct process tbuf;
824: register cell *tp;
825: register struct user *up;
826: int uid;
827: FILE *f;
828:
829: if ((f = fopen(SAVACCT, "r")) == NULL)
830: goto gshm;
831: while (fread((char *)&tbuf, sizeof(struct process), 1, f) == 1) {
832: tp = enter(tbuf.name);
833: ncom += tbuf.count;
834: tp->p.count = tbuf.count;
835: treal += tbuf.realt;
836: tp->p.realt = tbuf.realt;
837: tcpu += tbuf.cput;
838: tp->p.cput = tbuf.cput;
839: tsys += tbuf.syst;
840: tp->p.syst = tbuf.syst;
841: tio += tbuf.io;
842: tp->p.io = tbuf.io;
843: timem += tbuf.imem;
844: tp->p.imem = tbuf.imem;
845: }
846: fclose(f);
847: gshm:
848: if ((f = fopen(USRACCT, "r")) == NULL)
849: return;
850: for(uid = 0;
851: fread((char *)&(userbuf.oldu), sizeof(struct Olduser), 1, f) == 1;
852: uid++){
853: if (userbuf.us_cnt){
854: up = finduser(uid);
855: if (up == 0)
856: continue; /* preposterous user id */
857: up->oldu = userbuf.oldu;
858: }
859: }
860: fclose(f);
861: }
862:
863: strip()
864: {
865: int c;
866: register struct allocbox *allocwalk;
867: register cell *tp, *ub, *junkp;
868:
869: if (fflg)
870: printf("Categorizing commands used %d times or fewer as **junk**\n",
871: thres);
872: junkp = enter("**junk**");
873: PROCESSITERATE(allocwalk, tp, ub){
874: if (tp->p.name[0] && tp->p.count <= thres) {
875: if (!fflg)
876: printf("%.14s--", tp->p.name);
877: if (fflg || ((c=getchar())=='y')) {
878: tp->p.name[0] = '\0';
879: junkp->p.count += tp->p.count;
880: junkp->p.realt += tp->p.realt;
881: junkp->p.cput += tp->p.cput;
882: junkp->p.syst += tp->p.syst;
883: junkp->p.imem += tp->p.imem;
884: junkp->p.io += tp->p.io;
885: }
886: if (!fflg)
887: while (c && c!='\n')
888: c = getchar();
889: }
890: }
891: }
892:
893: time_t
894: expand(t)
895: unsigned t;
896: {
897: register time_t nt;
898:
899: nt = t&017777;
900: t >>= 13;
901: while (t!=0) {
902: t--;
903: nt <<= 3;
904: }
905: return(nt);
906: }
907:
908: static char UserKey[NAMELG + 2];
909:
910: char *
911: makekey(uid)
912: int uid;
913: {
914: sprintf(UserKey+1, "%04x", uid);
915: UserKey[0] = USERKEY;
916: return(UserKey);
917: }
918:
919: struct user *
920: wasuser(uid)
921: int uid;
922: {
923: struct user *tp;
924:
925: htabinstall = 0;
926: tp = finduser(uid);
927: htabinstall = 1;
928: return(tp);
929: }
930:
931: /*
932: * Only call this if you really want to insert it in the table!
933: */
934: struct user *
935: finduser(uid)
936: int uid;
937: {
938:
939: if (uid > maxuser){
940: fprintf(stderr, "Preposterous user id, %d: ignored\n", uid);
941: return(0);
942: }
943: return((struct user*)enter(makekey(uid)));
944: }
945:
946: /*
947: * Set the names of all users in the password file.
948: * We will later not print those that didn't do anything.
949: */
950: getnames()
951: {
952: register struct user *tp;
953: register struct passwd *pw;
954: struct passwd *getpwent();
955:
956: setpwent();
957: while (pw = getpwent()){
958: if ( (tp = wasuser(pw->pw_uid)) != 0)
959: strncpy(tp->us_name, pw->pw_name, NAMELG);
960: }
961: endpwent();
962: }
963:
964: int
965: getmaxuid()
966: {
967: register struct user *tp;
968: register struct passwd *pw;
969: struct passwd *getpwent();
970: int maxuid = -1;
971:
972: setpwent();
973: while(pw = getpwent()){
974: if (pw->pw_uid > maxuid)
975: maxuid = pw->pw_uid;
976: }
977: endpwent();
978: return(maxuid);
979: }
980:
981: tabinit()
982: {
983: allochead = 0;
984: alloctail = 0;
985: nexttab = 0;
986: tabsleft = 0;
987: htab = 0;
988: ntabs = 0;
989: htaballoc(); /* get the first part of the hash table */
990: }
991:
992: #define ALLOCQTY sizeof (struct allocbox)
993: cell *
994: taballoc()
995: {
996:
997: if (tabsleft == 0){
998: newbox = (struct allocbox *)calloc(1, ALLOCQTY);
999: tabsleft = TABDALLOP;
1000: nexttab = &newbox->tabslots[0];
1001: if (alloctail == 0){
1002: allochead = alloctail = newbox;
1003: } else {
1004: alloctail->nextalloc = newbox;
1005: alloctail = newbox;
1006: }
1007: }
1008: --tabsleft;
1009: ++ntabs;
1010: #ifdef DEBUG
1011: if (ntabs % 100 == 0)
1012: printf("##Accounting table slot # %d\n", ntabs);
1013: #endif DEBUG
1014: return(nexttab++);
1015: }
1016:
1017: htaballoc()
1018: {
1019: register struct hashdallop *new;
1020: #ifdef DEBUG
1021: static int ntables = 0;
1022:
1023: printf("%%%New hash table chunk allocated, number %d\n", ++ntables);
1024: #endif DEBUG
1025: new = (struct hashdallop *)calloc(1, sizeof (struct hashdallop));
1026: if (htab == 0)
1027: htab = new;
1028: else { /* add AFTER the 1st slot */
1029: new->h_next = htab->h_next;
1030: htab->h_next = new;
1031: }
1032: }
1033:
1034: #define HASHCLOGGED (NHASH / 2)
1035: /*
1036: * Lookup a symbol passed in as the argument.
1037: *
1038: * We take pains to avoid function calls; this function
1039: * is called quite frequently, and the calling overhead
1040: * contributes significantly to the overall execution speed of sa.
1041: */
1042: cell *
1043: enter(name)
1044: char *name;
1045: {
1046: static int initialprobe;
1047: register cell **hp;
1048: register char *from, *to;
1049: register int len, nprobes;
1050: static struct hashdallop *hdallop, *emptyhd;
1051: static cell **emptyslot, **hp_ub;
1052:
1053: emptyslot = 0;
1054: for (nprobes = 0, from = name, len = 0;
1055: *from && len < NC;
1056: nprobes <<= 2, nprobes += *from++, len++)
1057: continue;
1058: nprobes += from[-1] << 5;
1059: nprobes %= NHASH;
1060: if (nprobes < 0)
1061: nprobes += NHASH;
1062:
1063: initialprobe = nprobes;
1064: for (hdallop = htab; hdallop != 0; hdallop = hdallop->h_next){
1065: for (hp = &(hdallop->h_tab[initialprobe]),
1066: nprobes = 1,
1067: hp_ub = &(hdallop->h_tab[NHASH]);
1068: (*hp) && (nprobes < NHASH);
1069: hp += nprobes,
1070: hp -= (hp >= hp_ub) ? NHASH:0,
1071: nprobes += 2)
1072: {
1073: from = name;
1074: to = (*hp)->p.name;
1075:
1076: for (len = 0; (len<NC) && *from; len++)
1077: if (*from++ != *to++)
1078: goto nextprobe;
1079: if (len >= NC) /*both are maximal length*/
1080: return(*hp);
1081: if (*to == 0) /*assert *from == 0*/
1082: return(*hp);
1083: nextprobe: ;
1084: }
1085: if (*hp == 0 && emptyslot == 0 &&
1086: hdallop->h_nused < HASHCLOGGED) {
1087: emptyslot = hp;
1088: emptyhd = hdallop;
1089: }
1090: }
1091: if (emptyslot == 0) {
1092: htaballoc();
1093: hdallop = htab->h_next; /* aren't we smart! */
1094: hp = &hdallop->h_tab[initialprobe];
1095: } else {
1096: hdallop = emptyhd;
1097: hp = emptyslot;
1098: }
1099: if (htabinstall){
1100: *hp = taballoc();
1101: hdallop->h_nused++;
1102: for(len = 0, from = name, to = (*hp)->p.name; (len<NC); len++)
1103: if ((*to++ = *from++) == '\0')
1104: break;
1105: return(*hp);
1106: }
1107: return(0);
1108: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.