usr.sbin/sa/main.c

   1 /* $NetBSD: main.c,v 1.24 2009/04/28 08:32:56 lukem Exp $ */
   2
   3 /*
   4  * Copyright (c) 1994 Christopher G. Demetriou
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. All advertising materials mentioning features or use of this software
  16  *    must display the following acknowledgement:
  17  *          This product includes software developed for the
  18  *          NetBSD Project.  See http://www.NetBSD.org/ for
  19  *          information about NetBSD.
  20  * 4. The name of the author may not be used to endorse or promote products
  21  *    derived from this software without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  24  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  25  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  26  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  27  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  28  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  29  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  30  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  31  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  32  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  33  *
  34  * <<Id: LICENSE,v 1.2 2000/06/14 15:57:33 cgd Exp>>
  35  */
  36
  37 #include <sys/cdefs.h>
  38 #ifndef lint
  39 __COPYRIGHT("@(#) Copyright (c) 1994\
  40  Christopher G. Demetriou.  All rights reserved.");
  41
  42 __RCSID("$NetBSD: main.c,v 1.24 2009/04/28 08:32:56 lukem Exp $");
  43 #endif
  44
  45 /*
  46  * sa:  system accounting
  47  */
  48
  49 #include <sys/types.h>
  50 #include <sys/acct.h>
  51 #include <ctype.h>
  52 #include <err.h>
  53 #include <vis.h>
  54 #include <fcntl.h>
  55 #include <signal.h>
  56 #include <stdio.h>
  57 #include <stdlib.h>
  58 #include <string.h>
  59 #include <unistd.h>
  60 #include "extern.h"
  61 #include "pathnames.h"
  62
  63 static int      acct_load       __P((char *, int));
  64 static u_quad_t decode_comp_t   __P((comp_t));
  65 static int      cmp_comm        __P((const char *, const char *));
  66 static int      cmp_usrsys      __P((const DBT *, const DBT *));
  67 static int      cmp_avgusrsys   __P((const DBT *, const DBT *));
  68 static int      cmp_dkio        __P((const DBT *, const DBT *));
  69 static int      cmp_avgdkio     __P((const DBT *, const DBT *));
  70 static int      cmp_cpumem      __P((const DBT *, const DBT *));
  71 static int      cmp_avgcpumem   __P((const DBT *, const DBT *));
  72 static int      cmp_calls       __P((const DBT *, const DBT *));
  73 static void     usage           __P((void)) __dead;
  74
  75 int aflag, bflag, cflag, dflag, Dflag, fflag, iflag, jflag, kflag;
  76 int Kflag, lflag, mflag, qflag, rflag, sflag, tflag, uflag, vflag;
  77 int cutoff = 1;
  78
  79 static const char       *dfltargv[] = { _PATH_ACCT };
  80 static const int        dfltargc = (sizeof(dfltargv)/sizeof(char *));
  81
  82 /* default to comparing by sum of user + system time */
  83 cmpf_t   sa_cmp = cmp_usrsys;
  84
  85 int
  86 main(argc, argv)
  87         int argc;
  88         char **argv;
  89 {
  90         int ch;
  91         int error;
  92
  93         error = 0;
  94         while ((ch = getopt(argc, argv, "abcdDfijkKlmnqrstuv:")) != -1)
  95                 switch (ch) {
  96                 case 'a':
  97                         /* print all commands */
  98                         aflag = 1;
  99                         break;
 100                 case 'b':
 101                         /* sort by per-call user/system time average */
 102                         bflag = 1;
 103                         sa_cmp = cmp_avgusrsys;
 104                         break;
 105                 case 'c':
 106                         /* print percentage total time */
 107                         cflag = 1;
 108                         break;
 109                 case 'd':
 110                         /* sort by averge number of disk I/O ops */
 111                         dflag = 1;
 112                         sa_cmp = cmp_avgdkio;
 113                         break;
 114                 case 'D':
 115                         /* print and sort by total disk I/O ops */
 116                         Dflag = 1;
 117                         sa_cmp = cmp_dkio;
 118                         break;
 119                 case 'f':
 120                         /* force no interactive threshold comprison */
 121                         fflag = 1;
 122                         break;
 123                 case 'i':
 124                         /* do not read in summary file */
 125                         iflag = 1;
 126                         break;
 127                 case 'j':
 128                         /* instead of total minutes, give sec/call */
 129                         jflag = 1;
 130                         break;
 131                 case 'k':
 132                         /* sort by CPU-time average memory usage */
 133                         kflag = 1;
 134                         sa_cmp = cmp_avgcpumem;
 135                         break;
 136                 case 'K':
 137                         /* print and sort by CPU-storage integral */
 138                         sa_cmp = cmp_cpumem;
 139                         Kflag = 1;
 140                         break;
 141                 case 'l':
 142                         /* separate system and user time */
 143                         lflag = 1;
 144                         break;
 145                 case 'm':
 146                         /* print procs and time per-user */
 147                         mflag = 1;
 148                         break;
 149                 case 'n':
 150                         /* sort by number of calls */
 151                         sa_cmp = cmp_calls;
 152                         break;
 153                 case 'q':
 154                         /* quiet; error messages only */
 155                         qflag = 1;
 156                         break;
 157                 case 'r':
 158                         /* reverse order of sort */
 159                         rflag = 1;
 160                         break;
 161                 case 's':
 162                         /* merge accounting file into summaries */
 163                         sflag = 1;
 164                         break;
 165                 case 't':
 166                         /* report ratio of user and system times */
 167                         tflag = 1;
 168                         break;
 169                 case 'u':
 170                         /* first, print uid and command name */
 171                         uflag = 1;
 172                         break;
 173                 case 'v':
 174                         /* cull junk */
 175                         vflag = 1;
 176                         cutoff = atoi(optarg);
 177                         break;
 178                 case '?':
 179                 default:
 180                         usage();
 181                         /*NOTREACHED*/
 182                 }
 183
 184         argc -= optind;
 185         argv += optind;
 186
 187         /* various argument checking */
 188         if (fflag && !vflag)
 189                 errx(1, "only one of -f requires -v");
 190         if (fflag && aflag)
 191                 errx(1, "only one of -a and -v may be specified");
 192         /* XXX need more argument checking */
 193
 194         if (!uflag) {
 195                 /* initialize tables */
 196                 if ((sflag || (!mflag && !qflag)) && pacct_init() != 0)
 197                         errx(1, "process accounting initialization failed");
 198                 if ((sflag || (mflag && !qflag)) && usracct_init() != 0)
 199                         errx(1, "user accounting initialization failed");
 200         }
 201
 202         if (argc == 0) {
 203                 argc = dfltargc;
 204                 argv = __UNCONST(dfltargv);
 205         }
 206
 207         /* for each file specified */
 208         for (; argc > 0; argc--, argv++) {
 209                 int     fd;
 210
 211                 /*
 212                  * load the accounting data from the file.
 213                  * if it fails, go on to the next file.
 214                  */
 215                 fd = acct_load(argv[0], sflag);
 216                 if (fd < 0)
 217                         continue;
 218
 219                 if (!uflag && sflag) {
 220 #ifndef DEBUG
 221                         sigset_t nmask, omask;
 222                         int unmask = 1;
 223
 224                         /*
 225                          * block most signals so we aren't interrupted during
 226                          * the update.
 227                          */
 228                         if (sigfillset(&nmask) == -1) {
 229                                 warn("sigfillset");
 230                                 unmask = 0;
 231                                 error = 1;
 232                         }
 233                         if (unmask &&
 234                             (sigprocmask(SIG_BLOCK, &nmask, &omask) == -1)) {
 235                                 warn("couldn't set signal mask ");
 236                                 unmask = 0;
 237                                 error = 1;
 238                         }
 239 #endif /* DEBUG */
 240
 241                         /*
 242                          * truncate the accounting data file ASAP, to avoid
 243                          * losing data.  don't worry about errors in updating
 244                          * the saved stats; better to underbill than overbill,
 245                          * but we want every accounting record intact.
 246                          */
 247                         if (ftruncate(fd, 0) == -1) {
 248                                 warn("couldn't truncate %s", *argv);
 249                                 error = 1;
 250                         }
 251
 252                         /*
 253                          * update saved user and process accounting data.
 254                          * note errors for later.
 255                          */
 256                         if (pacct_update() != 0 || usracct_update() != 0)
 257                                 error = 1;
 258
 259 #ifndef DEBUG
 260                         /*
 261                          * restore signals
 262                          */
 263                         if (unmask &&
 264                             (sigprocmask(SIG_SETMASK, &omask, NULL) == -1)) {
 265                                 warn("couldn't restore signal mask");
 266                                 error = 1;
 267                         }
 268 #endif /* DEBUG */
 269                 }
 270
 271                 /*
 272                  * close the opened accounting file
 273                  */
 274                 if (close(fd) == -1) {
 275                         warn("close %s", *argv);
 276                         error = 1;
 277                 }
 278         }
 279
 280         if (!uflag && !qflag) {
 281                 /* print any results we may have obtained. */
 282                 if (!mflag)
 283                         pacct_print();
 284                 else
 285                         usracct_print();
 286         }
 287
 288         if (!uflag) {
 289                 /* finally, deallocate databases */
 290                 if (sflag || (!mflag && !qflag))
 291                         pacct_destroy();
 292                 if (sflag || (mflag && !qflag))
 293                         usracct_destroy();
 294         }
 295
 296         exit(error);
 297 }
 298
 299 static int
 300 acct_load(pn, wr)
 301         char *pn;
 302         int wr;
 303 {
 304         struct acct ac;
 305         struct cmdinfo ci;
 306         size_t i;
 307         FILE *fp;
 308
 309         /*
 310          * open the file
 311          */
 312         fp = fopen(pn, wr ? "r+" : "r");
 313         if (fp == NULL) {
 314                 warn("open %s %s", pn, wr ? "for read/write" : "read-only");
 315                 return (-1);
 316         }
 317
 318         /*
 319          * read all we can; don't stat and open because more processes
 320          * could exit, and we'd miss them
 321          */
 322         for (;;) {
 323                 /* get one accounting entry and punt if there's an error */
 324                 if (fread(&ac, sizeof(struct acct), 1, fp) != 1) {
 325                         if (feof(fp))
 326                                 break;
 327                         if (ferror(fp))
 328                                 warn("error reading %s", pn);
 329                         else
 330                                 warnx("short read of accounting data in %s",
 331                                     pn);
 332                         break;
 333                 }
 334
 335                 /* decode it */
 336                 ci.ci_calls = 1;
 337                 for (i = 0; i < sizeof(ac.ac_comm) && ac.ac_comm[i] != '\0';
 338                     i++) {
 339                         char c = ac.ac_comm[i];
 340
 341                         if (!isascii(c) || iscntrl((unsigned char)c)) {
 342                                 ci.ci_comm[i] = '?';
 343                                 ci.ci_flags |= CI_UNPRINTABLE;
 344                         } else
 345                                 ci.ci_comm[i] = c;
 346                 }
 347                 if (ac.ac_flag & AFORK)
 348                         ci.ci_comm[i++] = '*';
 349                 ci.ci_comm[i++] = '\0';
 350                 ci.ci_etime = decode_comp_t(ac.ac_etime);
 351                 ci.ci_utime = decode_comp_t(ac.ac_utime);
 352                 ci.ci_stime = decode_comp_t(ac.ac_stime);
 353                 ci.ci_uid = ac.ac_uid;
 354                 ci.ci_mem = ac.ac_mem;
 355                 ci.ci_io = decode_comp_t(ac.ac_io) / AHZ;
 356
 357                 if (!uflag) {
 358                         /* and enter it into the usracct and pacct databases */
 359                         if (sflag || (!mflag && !qflag))
 360                                 pacct_add(&ci);
 361                         if (sflag || (mflag && !qflag))
 362                                 usracct_add(&ci);
 363                 } else if (!qflag)
 364                         printf("%6u %12.2f CPU %12lluk mem %12llu io %s\n",
 365                             ci.ci_uid,
 366                             (ci.ci_utime + ci.ci_stime) / (double) AHZ,
 367                             (unsigned long long)ci.ci_mem,
 368                             (unsigned long long)ci.ci_io, ci.ci_comm);
 369         }
 370
 371         /* finally, return the file descriptor for possible truncation */
 372         return (fileno(fp));
 373 }
 374
 375 static u_quad_t
 376 decode_comp_t(comp_t comp)
 377 {
 378         u_quad_t rv;
 379
 380         /*
 381          * for more info on the comp_t format, see:
 382          *      /usr/src/sys/kern/kern_acct.c
 383          *      /usr/src/sys/sys/acct.h
 384          *      /usr/src/usr.bin/lastcomm/lastcomm.c
 385          */
 386         rv = comp & 0x1fff;     /* 13 bit fraction */
 387         comp >>= 13;            /* 3 bit base-8 exponent */
 388         while (comp--)
 389                 rv <<= 3;
 390
 391         return (rv);
 392 }
 393
 394 /* sort commands, doing the right thing in terms of reversals */
 395 static int
 396 cmp_comm(s1, s2)
 397         const char *s1, *s2;
 398 {
 399         int rv;
 400
 401         rv = strcmp(s1, s2);
 402         if (rv == 0)
 403                 rv = -1;
 404         return (rflag ? rv : -rv);
 405 }
 406
 407 /* sort by total user and system time */
 408 static int
 409 cmp_usrsys(d1, d2)
 410         const DBT *d1, *d2;
 411 {
 412         struct cmdinfo c1, c2;
 413         u_quad_t t1, t2;
 414
 415         memcpy(&c1, d1->data, sizeof(c1));
 416         memcpy(&c2, d2->data, sizeof(c2));
 417
 418         t1 = c1.ci_utime + c1.ci_stime;
 419         t2 = c2.ci_utime + c2.ci_stime;
 420
 421         if (t1 < t2)
 422                 return -1;
 423         else if (t1 == t2)
 424                 return (cmp_comm(c1.ci_comm, c2.ci_comm));
 425         else
 426                 return 1;
 427 }
 428
 429 /* sort by average user and system time */
 430 static int
 431 cmp_avgusrsys(d1, d2)
 432         const DBT *d1, *d2;
 433 {
 434         struct cmdinfo c1, c2;
 435         double t1, t2;
 436
 437         memcpy(&c1, d1->data, sizeof(c1));
 438         memcpy(&c2, d2->data, sizeof(c2));
 439
 440         t1 = c1.ci_utime + c1.ci_stime;
 441         t1 /= (double) (c1.ci_calls ? c1.ci_calls : 1);
 442
 443         t2 = c2.ci_utime + c2.ci_stime;
 444         t2 /= (double) (c2.ci_calls ? c2.ci_calls : 1);
 445
 446         if (t1 < t2)
 447                 return -1;
 448         else if (t1 == t2)
 449                 return (cmp_comm(c1.ci_comm, c2.ci_comm));
 450         else
 451                 return 1;
 452 }
 453
 454 /* sort by total number of disk I/O operations */
 455 static int
 456 cmp_dkio(d1, d2)
 457         const DBT *d1, *d2;
 458 {
 459         struct cmdinfo c1, c2;
 460
 461         memcpy(&c1, d1->data, sizeof(c1));
 462         memcpy(&c2, d2->data, sizeof(c2));
 463
 464         if (c1.ci_io < c2.ci_io)
 465                 return -1;
 466         else if (c1.ci_io == c2.ci_io)
 467                 return (cmp_comm(c1.ci_comm, c2.ci_comm));
 468         else
 469                 return 1;
 470 }
 471
 472 /* sort by average number of disk I/O operations */
 473 static int
 474 cmp_avgdkio(d1, d2)
 475         const DBT *d1, *d2;
 476 {
 477         struct cmdinfo c1, c2;
 478         double n1, n2;
 479
 480         memcpy(&c1, d1->data, sizeof(c1));
 481         memcpy(&c2, d2->data, sizeof(c2));
 482
 483         n1 = (double) c1.ci_io / (double) (c1.ci_calls ? c1.ci_calls : 1);
 484         n2 = (double) c2.ci_io / (double) (c2.ci_calls ? c2.ci_calls : 1);
 485
 486         if (n1 < n2)
 487                 return -1;
 488         else if (n1 == n2)
 489                 return (cmp_comm(c1.ci_comm, c2.ci_comm));
 490         else
 491                 return 1;
 492 }
 493
 494 /* sort by the CPU-storage integral */
 495 static int
 496 cmp_cpumem(d1, d2)
 497         const DBT *d1, *d2;
 498 {
 499         struct cmdinfo c1, c2;
 500
 501         memcpy(&c1, d1->data, sizeof(c1));
 502         memcpy(&c2, d2->data, sizeof(c2));
 503
 504         if (c1.ci_mem < c2.ci_mem)
 505                 return -1;
 506         else if (c1.ci_mem == c2.ci_mem)
 507                 return (cmp_comm(c1.ci_comm, c2.ci_comm));
 508         else
 509                 return 1;
 510 }
 511
 512 /* sort by the CPU-time average memory usage */
 513 static int
 514 cmp_avgcpumem(d1, d2)
 515         const DBT *d1, *d2;
 516 {
 517         struct cmdinfo c1, c2;
 518         u_quad_t t1, t2;
 519         double n1, n2;
 520
 521         memcpy(&c1, d1->data, sizeof(c1));
 522         memcpy(&c2, d2->data, sizeof(c2));
 523
 524         t1 = c1.ci_utime + c1.ci_stime;
 525         t2 = c2.ci_utime + c2.ci_stime;
 526
 527         n1 = (double) c1.ci_mem / (double) (t1 ? t1 : 1);
 528         n2 = (double) c2.ci_mem / (double) (t2 ? t2 : 1);
 529
 530         if (n1 < n2)
 531                 return -1;
 532         else if (n1 == n2)
 533                 return (cmp_comm(c1.ci_comm, c2.ci_comm));
 534         else
 535                 return 1;
 536 }
 537
 538 /* sort by the number of invocations */
 539 static int
 540 cmp_calls(d1, d2)
 541         const DBT *d1, *d2;
 542 {
 543         struct cmdinfo c1, c2;
 544
 545         memcpy(&c1, d1->data, sizeof(c1));
 546         memcpy(&c2, d2->data, sizeof(c2));
 547
 548         if (c1.ci_calls < c2.ci_calls)
 549                 return -1;
 550         else if (c1.ci_calls == c2.ci_calls)
 551                 return (cmp_comm(c1.ci_comm, c2.ci_comm));
 552         else
 553                 return 1;
 554 }
 555
 556 static void
 557 usage()
 558 {
 559
 560         (void)fprintf(stderr,
 561             "usage: %s [-abcdDfijkKlmnqrstu] [-v cutoff] [file ...]\n",
 562             getprogname());
 563         exit(0);
 564 }
 565
 566 const char *
 567 fmt(key)
 568         const DBT *key;
 569 {
 570         static char *buf = NULL;
 571         static size_t len = 0;
 572         char *nbuf;
 573
 574         if (len < key->size * 4 + 1) {
 575                 nbuf = realloc(buf, key->size * 4 + 1);
 576                 if (!nbuf)
 577                         err(1, "realloc");
 578                 buf = nbuf;
 579                 len = key->size * 4 + 1;
 580         }
 581         (void)strvisx(buf, key->data, key->size, 0);
 582         return buf;
 583 }