571 lines
13 KiB
C
571 lines
13 KiB
C
/* $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;
|
|
}
|