/* $NetBSD: main.c,v 1.28 2010/06/10 06:28:33 dholland Exp $ */

/*
* Copyright (c) 1994 Christopher G. Demetriou
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
*    must display the following acknowledgement:
*          This product includes software developed for the
*          NetBSD Project.  See http://www.NetBSD.org/ for
*          information about NetBSD.
* 4. The name of the author may not be used to endorse or promote products
*    derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* <<Id: LICENSE,v 1.2 2000/06/14 15:57:33 cgd Exp>>
*/

#include <sys/cdefs.h>
#ifndef lint
__COPYRIGHT("@(#) Copyright (c) 1994\
Christopher G. Demetriou.  All rights reserved.");

__RCSID("$NetBSD: main.c,v 1.28 2010/06/10 06:28:33 dholland Exp $");
#endif

/*
* sa:  system accounting
*/

#include <sys/types.h>
#include <sys/acct.h>
#include <ctype.h>
#include <err.h>
#include <vis.h>
#include <fcntl.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "extern.h"
#include "pathnames.h"

static int acct_load(const char *, int);
static u_quad_t decode_comp_t(comp_t);
static int cmp_comm(const char *, const char *);
static int cmp_usrsys(const DBT *, const DBT *);
static int cmp_avgusrsys(const DBT *, const DBT *);
static int cmp_dkio(const DBT *, const DBT *);
static int cmp_avgdkio(const DBT *, const DBT *);
static int cmp_cpumem(const DBT *, const DBT *);
static int cmp_avgcpumem(const DBT *, const DBT *);
static int cmp_calls(const DBT *, const DBT *);
static void usage(void) __dead;

int aflag, bflag, cflag, dflag, Dflag, fflag, iflag, jflag, kflag;
int Kflag, lflag, mflag, qflag, rflag, sflag, tflag, uflag, vflag;
int cutoff = 1;

static const char       *dfltargv[] = { _PATH_ACCT };
static const int        dfltargc = (sizeof(dfltargv)/sizeof(char *));

/* default to comparing by sum of user + system time */
cmpf_t   sa_cmp = cmp_usrsys;

int
main(int argc, char **argv)
{
       int ch;
       int error;

       error = 0;
       while ((ch = getopt(argc, argv, "abcdDfijkKlmnqrstuv:")) != -1)
               switch (ch) {
               case 'a':
                       /* print all commands */
                       aflag = 1;
                       break;
               case 'b':
                       /* sort by per-call user/system time average */
                       bflag = 1;
                       sa_cmp = cmp_avgusrsys;
                       break;
               case 'c':
                       /* print percentage total time */
                       cflag = 1;
                       break;
               case 'd':
                       /* sort by averge number of disk I/O ops */
                       dflag = 1;
                       sa_cmp = cmp_avgdkio;
                       break;
               case 'D':
                       /* print and sort by total disk I/O ops */
                       Dflag = 1;
                       sa_cmp = cmp_dkio;
                       break;
               case 'f':
                       /* force no interactive threshold comprison */
                       fflag = 1;
                       break;
               case 'i':
                       /* do not read in summary file */
                       iflag = 1;
                       break;
               case 'j':
                       /* instead of total minutes, give sec/call */
                       jflag = 1;
                       break;
               case 'k':
                       /* sort by CPU-time average memory usage */
                       kflag = 1;
                       sa_cmp = cmp_avgcpumem;
                       break;
               case 'K':
                       /* print and sort by CPU-storage integral */
                       sa_cmp = cmp_cpumem;
                       Kflag = 1;
                       break;
               case 'l':
                       /* separate system and user time */
                       lflag = 1;
                       break;
               case 'm':
                       /* print procs and time per-user */
                       mflag = 1;
                       break;
               case 'n':
                       /* sort by number of calls */
                       sa_cmp = cmp_calls;
                       break;
               case 'q':
                       /* quiet; error messages only */
                       qflag = 1;
                       break;
               case 'r':
                       /* reverse order of sort */
                       rflag = 1;
                       break;
               case 's':
                       /* merge accounting file into summaries */
                       sflag = 1;
                       break;
               case 't':
                       /* report ratio of user and system times */
                       tflag = 1;
                       break;
               case 'u':
                       /* first, print uid and command name */
                       uflag = 1;
                       break;
               case 'v':
                       /* cull junk */
                       vflag = 1;
                       cutoff = atoi(optarg);
                       break;
               case '?':
               default:
                       usage();
                       /*NOTREACHED*/
               }

       argc -= optind;
       argv += optind;

       /* various argument checking */
       if (fflag && !vflag)
               errx(1, "only one of -f requires -v");
       if (fflag && aflag)
               errx(1, "only one of -a and -v may be specified");
       /* XXX need more argument checking */

       if (!uflag) {
               /* initialize tables */
               if ((sflag || (!mflag && !qflag)) && pacct_init() != 0)
                       errx(1, "process accounting initialization failed");
               if ((sflag || (mflag && !qflag)) && usracct_init() != 0)
                       errx(1, "user accounting initialization failed");
       }

       if (argc == 0) {
               argc = dfltargc;
               argv = __UNCONST(dfltargv);
       }

       /* for each file specified */
       for (; argc > 0; argc--, argv++) {
               int     fd;

               /*
                * load the accounting data from the file.
                * if it fails, go on to the next file.
                */
               fd = acct_load(argv[0], sflag);
               if (fd < 0)
                       continue;

               if (!uflag && sflag) {
#ifndef DEBUG
                       sigset_t nmask, omask;
                       int unmask = 1;

                       /*
                        * block most signals so we aren't interrupted during
                        * the update.
                        */
                       if (sigfillset(&nmask) == -1) {
                               warn("sigfillset");
                               unmask = 0;
                               error = 1;
                       }
                       if (unmask &&
                           (sigprocmask(SIG_BLOCK, &nmask, &omask) == -1)) {
                               warn("couldn't set signal mask ");
                               unmask = 0;
                               error = 1;
                       }
#endif /* DEBUG */

                       /*
                        * truncate the accounting data file ASAP, to avoid
                        * losing data.  don't worry about errors in updating
                        * the saved stats; better to underbill than overbill,
                        * but we want every accounting record intact.
                        */
                       if (ftruncate(fd, 0) == -1) {
                               warn("couldn't truncate %s", *argv);
                               error = 1;
                       }

                       /*
                        * update saved user and process accounting data.
                        * note errors for later.
                        */
                       if (pacct_update() != 0 || usracct_update() != 0)
                               error = 1;

#ifndef DEBUG
                       /*
                        * restore signals
                        */
                       if (unmask &&
                           (sigprocmask(SIG_SETMASK, &omask, NULL) == -1)) {
                               warn("couldn't restore signal mask");
                               error = 1;
                       }
#endif /* DEBUG */
               }

               /*
                * close the opened accounting file
                */
               if (close(fd) == -1) {
                       warn("close %s", *argv);
                       error = 1;
               }
       }

       if (!uflag && !qflag) {
               /* print any results we may have obtained. */
               if (!mflag)
                       pacct_print();
               else
                       usracct_print();
       }

       if (!uflag) {
               /* finally, deallocate databases */
               if (sflag || (!mflag && !qflag))
                       pacct_destroy();
               if (sflag || (mflag && !qflag))
                       usracct_destroy();
       }

       exit(error);
}

static int
acct_load(const char *pn, int wr)
{
       struct acct ac;
       struct cmdinfo ci;
       size_t i;
       FILE *fp;

       /*
        * open the file
        */
       fp = fopen(pn, wr ? "r+" : "r");
       if (fp == NULL) {
               warn("open %s %s", pn, wr ? "for read/write" : "read-only");
               return (-1);
       }

       /*
        * read all we can; don't stat and open because more processes
        * could exit, and we'd miss them
        */
       for (;;) {
               /* get one accounting entry and punt if there's an error */
               if (fread(&ac, sizeof(struct acct), 1, fp) != 1) {
                       if (feof(fp))
                               break;
                       if (ferror(fp))
                               warn("error reading %s", pn);
                       else
                               warnx("short read of accounting data in %s",
                                   pn);
                       break;
               }

               /* decode it */
               ci.ci_calls = 1;
               for (i = 0; i < sizeof(ac.ac_comm) && ac.ac_comm[i] != '\0';
                   i++) {
                       char c = ac.ac_comm[i];

                       if (!isascii(c) || iscntrl((unsigned char)c)) {
                               ci.ci_comm[i] = '?';
                               ci.ci_flags |= CI_UNPRINTABLE;
                       } else
                               ci.ci_comm[i] = c;
               }
               if (ac.ac_flag & AFORK)
                       ci.ci_comm[i++] = '*';
               ci.ci_comm[i++] = '\0';
               ci.ci_etime = decode_comp_t(ac.ac_etime);
               ci.ci_utime = decode_comp_t(ac.ac_utime);
               ci.ci_stime = decode_comp_t(ac.ac_stime);
               ci.ci_uid = ac.ac_uid;
               ci.ci_mem = ac.ac_mem;
               ci.ci_io = decode_comp_t(ac.ac_io) / AHZ;

               if (!uflag) {
                       /* and enter it into the usracct and pacct databases */
                       if (sflag || (!mflag && !qflag))
                               pacct_add(&ci);
                       if (sflag || (mflag && !qflag))
                               usracct_add(&ci);
               } else if (!qflag)
                       printf("%6u %12.2f CPU %12lluk mem %12llu io %s\n",
                           ci.ci_uid,
                           (ci.ci_utime + ci.ci_stime) / (double) AHZ,
                           (unsigned long long)ci.ci_mem,
                           (unsigned long long)ci.ci_io, ci.ci_comm);
       }

       /* finally, return the file descriptor for possible truncation */
       return (fileno(fp));
}

static u_quad_t
decode_comp_t(comp_t comp)
{
       u_quad_t rv;

       /*
        * for more info on the comp_t format, see:
        *      /usr/src/sys/kern/kern_acct.c
        *      /usr/src/sys/sys/acct.h
        *      /usr/src/usr.bin/lastcomm/lastcomm.c
        */
       rv = comp & 0x1fff;     /* 13 bit fraction */
       comp >>= 13;            /* 3 bit base-8 exponent */
       while (comp--)
               rv <<= 3;

       return (rv);
}

/* sort commands, doing the right thing in terms of reversals */
static int
cmp_comm(const char *s1, const char *s2)
{
       int rv;

       rv = strcmp(s1, s2);
       if (rv == 0)
               rv = -1;
       return (rflag ? rv : -rv);
}

/* sort by total user and system time */
static int
cmp_usrsys(const DBT *d1, const DBT *d2)
{
       struct cmdinfo c1, c2;
       u_quad_t t1, t2;

       memcpy(&c1, d1->data, sizeof(c1));
       memcpy(&c2, d2->data, sizeof(c2));

       t1 = c1.ci_utime + c1.ci_stime;
       t2 = c2.ci_utime + c2.ci_stime;

       if (t1 < t2)
               return -1;
       else if (t1 == t2)
               return (cmp_comm(c1.ci_comm, c2.ci_comm));
       else
               return 1;
}

/* sort by average user and system time */
static int
cmp_avgusrsys(const DBT *d1, const DBT *d2)
{
       struct cmdinfo c1, c2;
       double t1, t2;

       memcpy(&c1, d1->data, sizeof(c1));
       memcpy(&c2, d2->data, sizeof(c2));

       t1 = c1.ci_utime + c1.ci_stime;
       t1 /= (double) (c1.ci_calls ? c1.ci_calls : 1);

       t2 = c2.ci_utime + c2.ci_stime;
       t2 /= (double) (c2.ci_calls ? c2.ci_calls : 1);

       if (t1 < t2)
               return -1;
       else if (t1 == t2)
               return (cmp_comm(c1.ci_comm, c2.ci_comm));
       else
               return 1;
}

/* sort by total number of disk I/O operations */
static int
cmp_dkio(const DBT *d1, const DBT *d2)
{
       struct cmdinfo c1, c2;

       memcpy(&c1, d1->data, sizeof(c1));
       memcpy(&c2, d2->data, sizeof(c2));

       if (c1.ci_io < c2.ci_io)
               return -1;
       else if (c1.ci_io == c2.ci_io)
               return (cmp_comm(c1.ci_comm, c2.ci_comm));
       else
               return 1;
}

/* sort by average number of disk I/O operations */
static int
cmp_avgdkio(const DBT *d1, const DBT *d2)
{
       struct cmdinfo c1, c2;
       double n1, n2;

       memcpy(&c1, d1->data, sizeof(c1));
       memcpy(&c2, d2->data, sizeof(c2));

       n1 = (double) c1.ci_io / (double) (c1.ci_calls ? c1.ci_calls : 1);
       n2 = (double) c2.ci_io / (double) (c2.ci_calls ? c2.ci_calls : 1);

       if (n1 < n2)
               return -1;
       else if (n1 == n2)
               return (cmp_comm(c1.ci_comm, c2.ci_comm));
       else
               return 1;
}

/* sort by the CPU-storage integral */
static int
cmp_cpumem(const DBT *d1, const DBT *d2)
{
       struct cmdinfo c1, c2;

       memcpy(&c1, d1->data, sizeof(c1));
       memcpy(&c2, d2->data, sizeof(c2));

       if (c1.ci_mem < c2.ci_mem)
               return -1;
       else if (c1.ci_mem == c2.ci_mem)
               return (cmp_comm(c1.ci_comm, c2.ci_comm));
       else
               return 1;
}

/* sort by the CPU-time average memory usage */
static int
cmp_avgcpumem(const DBT *d1, const DBT *d2)
{
       struct cmdinfo c1, c2;
       u_quad_t t1, t2;
       double n1, n2;

       memcpy(&c1, d1->data, sizeof(c1));
       memcpy(&c2, d2->data, sizeof(c2));

       t1 = c1.ci_utime + c1.ci_stime;
       t2 = c2.ci_utime + c2.ci_stime;

       n1 = (double) c1.ci_mem / (double) (t1 ? t1 : 1);
       n2 = (double) c2.ci_mem / (double) (t2 ? t2 : 1);

       if (n1 < n2)
               return -1;
       else if (n1 == n2)
               return (cmp_comm(c1.ci_comm, c2.ci_comm));
       else
               return 1;
}

/* sort by the number of invocations */
static int
cmp_calls(const DBT *d1, const DBT *d2)
{
       struct cmdinfo c1, c2;

       memcpy(&c1, d1->data, sizeof(c1));
       memcpy(&c2, d2->data, sizeof(c2));

       if (c1.ci_calls < c2.ci_calls)
               return -1;
       else if (c1.ci_calls == c2.ci_calls)
               return (cmp_comm(c1.ci_comm, c2.ci_comm));
       else
               return 1;
}

static void
usage(void)
{

       (void)fprintf(stderr,
           "usage: %s [-abcdDfijkKlmnqrstu] [-v cutoff] [file ...]\n",
           getprogname());
       exit(0);
}

const char *
fmt(const DBT *key)
{
       static char *buf = NULL;
       static size_t len = 0;
       char *nbuf;

       if (len < key->size * 4 + 1) {
               nbuf = realloc(buf, key->size * 4 + 1);
               if (!nbuf)
                       err(1, "realloc");
               buf = nbuf;
               len = key->size * 4 + 1;
       }
       (void)strvisx(buf, key->data, key->size, 0);
       return buf;
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.