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