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