From dfadb8e7c459ae69d5a7f3f8d36f13f0a3974899 Mon Sep 17 00:00:00 2001 From: dg Date: Mon, 26 Sep 1994 21:22:57 +0000 Subject: Process accounting utility by Chris Demetriou. Obtained from: NetBSD --- usr.sbin/sa/Makefile | 7 + usr.sbin/sa/extern.h | 100 +++++++++ usr.sbin/sa/main.c | 542 ++++++++++++++++++++++++++++++++++++++++++++++++ usr.sbin/sa/pathnames.h | 35 ++++ usr.sbin/sa/pdb.c | 418 +++++++++++++++++++++++++++++++++++++ usr.sbin/sa/sa.8 | 246 ++++++++++++++++++++++ usr.sbin/sa/usrdb.c | 282 +++++++++++++++++++++++++ 7 files changed, 1630 insertions(+) create mode 100644 usr.sbin/sa/Makefile create mode 100644 usr.sbin/sa/extern.h create mode 100644 usr.sbin/sa/main.c create mode 100644 usr.sbin/sa/pathnames.h create mode 100644 usr.sbin/sa/pdb.c create mode 100644 usr.sbin/sa/sa.8 create mode 100644 usr.sbin/sa/usrdb.c (limited to 'usr.sbin') diff --git a/usr.sbin/sa/Makefile b/usr.sbin/sa/Makefile new file mode 100644 index 0000000..ee412a6 --- /dev/null +++ b/usr.sbin/sa/Makefile @@ -0,0 +1,7 @@ +# $Id: Makefile,v 1.1 1994/03/24 18:41:48 cgd Exp $ + +PROG= sa +MAN8= sa.0 +SRCS= main.c pdb.c usrdb.c + +.include diff --git a/usr.sbin/sa/extern.h b/usr.sbin/sa/extern.h new file mode 100644 index 0000000..6d52914 --- /dev/null +++ b/usr.sbin/sa/extern.h @@ -0,0 +1,100 @@ +/* + * 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 by Christopher G. Demetriou. + * 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: extern.h,v 1.1 1994/03/24 18:41:50 cgd Exp $ + */ + +#include +#include +#include + +/* structures */ + +struct cmdinfo { + char ci_comm[MAXCOMLEN+2]; /* command name (+ '*') */ + u_long ci_uid; /* user id */ + u_quad_t ci_calls; /* number of calls */ + u_quad_t ci_etime; /* elapsed time */ + u_quad_t ci_utime; /* user time */ + u_quad_t ci_stime; /* system time */ + u_quad_t ci_mem; /* memory use */ + u_quad_t ci_io; /* number of disk i/o ops */ + u_int ci_flags; /* flags; see below */ +}; +#define CI_UNPRINTABLE 0x0001 /* unprintable chars in name */ + +struct userinfo { + u_long ui_uid; /* user id; for consistency */ + u_quad_t ui_calls; /* number of invocations */ + u_quad_t ui_utime; /* user time */ + u_quad_t ui_stime; /* system time */ + u_quad_t ui_mem; /* memory use */ + u_quad_t ui_io; /* number of disk i/o ops */ +}; + +/* typedefs */ + +typedef int (*cmpf_t) __P((const DBT *, const DBT *)); + +/* external functions in sa.c */ +int main __P((int, char **)); + +/* external functions in pdb.c */ +int pacct_init __P((void)); +void pacct_destroy __P((void)); +int pacct_add __P((const struct cmdinfo *)); +int pacct_update __P((void)); +void pacct_print __P((void)); + +/* external functions in usrdb.c */ +int usracct_init __P((void)); +void usracct_destroy __P((void)); +int usracct_add __P((const struct cmdinfo *)); +int usracct_update __P((void)); +void usracct_print __P((void)); + +/* variables */ + +extern int aflag, bflag, cflag, dflag, Dflag, fflag, iflag, jflag, kflag; +extern int Kflag, lflag, mflag, qflag, rflag, sflag, tflag, uflag, vflag; +extern int cutoff; +extern cmpf_t sa_cmp; + +/* some #defines to help with db's stupidity */ + +#define DB_CLOSE(db) \ + ((*(db)->close)(db)) +#define DB_GET(db, key, data, flags) \ + ((*(db)->get)((db), (key), (data), (flags))) +#define DB_PUT(db, key, data, flags) \ + ((*(db)->put)((db), (key), (data), (flags))) +#define DB_SYNC(db, flags) \ + ((*(db)->sync)((db), (flags))) +#define DB_SEQ(db, key, data, flags) \ + ((*(db)->seq)((db), (key), (data), (flags))) diff --git a/usr.sbin/sa/main.c b/usr.sbin/sa/main.c new file mode 100644 index 0000000..dac2724 --- /dev/null +++ b/usr.sbin/sa/main.c @@ -0,0 +1,542 @@ +/* + * 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 by Christopher G. Demetriou. + * 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. + */ + +#ifndef LINT +static char copright[] = +"@(#) Copyright (c) 1994 Christopher G. Demetriou\n\ + All rights reserved.\n"; + +static char rcsid[] = "$Id: main.c,v 1.1 1994/03/24 18:41:51 cgd Exp $"; +#endif + +/* + * sa: system accounting + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "extern.h" +#include "pathnames.h" + +static int acct_load __P((char *, int)); +static u_quad_t decode_comp_t __P((comp_t)); +static int cmp_comm __P((const char *, const char *)); +static int cmp_usrsys __P((const DBT *, const DBT *)); +static int cmp_avgusrsys __P((const DBT *, const DBT *)); +static int cmp_dkio __P((const DBT *, const DBT *)); +static int cmp_avgdkio __P((const DBT *, const DBT *)); +static int cmp_cpumem __P((const DBT *, const DBT *)); +static int cmp_avgcpumem __P((const DBT *, const DBT *)); +static int cmp_calls __P((const DBT *, const DBT *)); + +int aflag, bflag, cflag, dflag, Dflag, fflag, iflag, jflag, kflag; +int Kflag, lflag, mflag, qflag, rflag, sflag, tflag, uflag, vflag; +int cutoff = 1; + +static char *dfltargv[] = { _PATH_ACCT }; +static int dfltargc = (sizeof dfltargv/sizeof(char *)); + +/* default to comparing by sum of user + system time */ +cmpf_t sa_cmp = cmp_usrsys; + +int +main(argc, argv) + int argc; + char **argv; +{ + char ch; + int error; + + 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': + /* seperate 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: + (void)fprintf(stderr, + "usage: sa [-abcdDfijkKlmnqrstu] [-v cutoff] [file ...]\n"); + exit(1); + } + + 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 = 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(pn, wr) + char *pn; + int wr; +{ + struct acct ac; + struct cmdinfo ci; + ssize_t rv; + int fd, i; + + /* + * open the file + */ + fd = open(pn, wr ? O_RDWR : O_RDONLY, 0); + if (fd == -1) { + 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 + */ + while (1) { + /* get one accounting entry and punt if there's an error */ + rv = read(fd, &ac, sizeof(struct acct)); + if (rv == -1) + warn("error reading %s", pn); + else if (rv > 0 && rv < sizeof(struct acct)) + warnx("short read of accounting data in %s", pn); + if (rv != sizeof(struct acct)) + 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(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.2lf cpu %12quk mem %12qu io %s\n", + ci.ci_uid, + (ci.ci_utime + ci.ci_stime) / (double) AHZ, + ci.ci_mem, ci.ci_io, ci.ci_comm); + } + + /* finally, return the file descriptor for possible truncation */ + return (fd); +} + +static u_quad_t +decode_comp_t(comp) + 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(s1, s2) + const char *s1, *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(d1, d2) + const DBT *d1, *d2; +{ + struct cmdinfo *c1, *c2; + u_quad_t t1, t2; + + c1 = (struct cmdinfo *) d1->data; + c2 = (struct cmdinfo *) d2->data; + + 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(d1, d2) + const DBT *d1, *d2; +{ + struct cmdinfo *c1, *c2; + double t1, t2; + + c1 = (struct cmdinfo *) d1->data; + c2 = (struct cmdinfo *) d2->data; + + 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(d1, d2) + const DBT *d1, *d2; +{ + struct cmdinfo *c1, *c2; + + c1 = (struct cmdinfo *) d1->data; + c2 = (struct cmdinfo *) d2->data; + + 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(d1, d2) + const DBT *d1, *d2; +{ + struct cmdinfo *c1, *c2; + double n1, n2; + + c1 = (struct cmdinfo *) d1->data; + c2 = (struct cmdinfo *) d2->data; + + 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(d1, d2) + const DBT *d1, *d2; +{ + struct cmdinfo *c1, *c2; + + c1 = (struct cmdinfo *) d1->data; + c2 = (struct cmdinfo *) d2->data; + + 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(d1, d2) + const DBT *d1, *d2; +{ + struct cmdinfo *c1, *c2; + u_quad_t t1, t2; + double n1, n2; + + c1 = (struct cmdinfo *) d1->data; + c2 = (struct cmdinfo *) d2->data; + + 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(d1, d2) + const DBT *d1, *d2; +{ + struct cmdinfo *c1, *c2; + + c1 = (struct cmdinfo *) d1->data; + c2 = (struct cmdinfo *) d2->data; + + 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; +} diff --git a/usr.sbin/sa/pathnames.h b/usr.sbin/sa/pathnames.h new file mode 100644 index 0000000..31721c2 --- /dev/null +++ b/usr.sbin/sa/pathnames.h @@ -0,0 +1,35 @@ +/* + * 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 by Christopher G. Demetriou. + * 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: pathnames.h,v 1.1 1994/03/24 18:41:53 cgd Exp $ + */ + +#define _PATH_ACCT "/var/account/acct" +#define _PATH_SAVACCT "/var/account/savacct" +#define _PATH_USRACCT "/var/account/usracct" diff --git a/usr.sbin/sa/pdb.c b/usr.sbin/sa/pdb.c new file mode 100644 index 0000000..083f9da --- /dev/null +++ b/usr.sbin/sa/pdb.c @@ -0,0 +1,418 @@ +/* + * 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 by Christopher G. Demetriou. + * 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. + */ + +#ifndef LINT +static char rcsid[] = "$Id: pdb.c,v 1.1 1994/03/24 18:41:54 cgd Exp $"; +#endif + +#include +#include +#include +#include +#include +#include +#include "extern.h" +#include "pathnames.h" + +static int check_junk __P((struct cmdinfo *)); +static void add_ci __P((const struct cmdinfo *, struct cmdinfo *)); +static void print_ci __P((const struct cmdinfo *, const struct cmdinfo *)); + +static DB *pacct_db; + +int +pacct_init() +{ + DB *saved_pacct_db; + int error; + + pacct_db = dbopen(NULL, O_RDWR, 0, DB_BTREE, NULL); + if (pacct_db == NULL) + return (-1); + + error = 0; + if (!iflag) { + DBT key, data; + int serr, nerr; + + saved_pacct_db = dbopen(_PATH_SAVACCT, O_RDONLY, 0, DB_BTREE, + NULL); + if (saved_pacct_db == NULL) { + error = errno == ENOENT ? 0 : -1; + if (error) + warn("retrieving process accounting summary"); + goto out; + } + + serr = DB_SEQ(saved_pacct_db, &key, &data, R_FIRST); + if (serr < 0) { + warn("retrieving process accounting summary"); + error = -1; + goto closeout; + } + while (serr == 0) { + nerr = DB_PUT(pacct_db, &key, &data, 0); + if (nerr < 0) { + warn("initializing process accounting stats"); + error = -1; + break; + } + + serr = DB_SEQ(saved_pacct_db, &key, &data, R_NEXT); + if (serr < 0) { + warn("retrieving process accounting summary"); + error = -1; + break; + } + } + +closeout: if (DB_CLOSE(saved_pacct_db) < 0) { + warn("closing process accounting summary"); + error = -1; + } + } + +out: if (error != 0) + pacct_destroy(); + return (error); +} + +void +pacct_destroy() +{ + if (DB_CLOSE(pacct_db) < 0) + warn("destroying process accounting stats"); +} + +int +pacct_add(ci) + const struct cmdinfo *ci; +{ + DBT key, data; + struct cmdinfo newci; + char keydata[sizeof ci->ci_comm]; + int rv; + + bcopy(ci->ci_comm, &keydata, sizeof keydata); + key.data = &keydata; + key.size = strlen(keydata); + + rv = DB_GET(pacct_db, &key, &data, 0); + if (rv < 0) { + warn("get key %s from process accounting stats", ci->ci_comm); + return (-1); + } else if (rv == 0) { /* it's there; copy whole thing */ + /* XXX compare size if paranoid */ + /* add the old data to the new data */ + bcopy(data.data, &newci, data.size); + } else { /* it's not there; zero it and copy the key */ + bzero(&newci, sizeof newci); + bcopy(key.data, newci.ci_comm, key.size); + } + + add_ci(ci, &newci); + + data.data = &newci; + data.size = sizeof newci; + rv = DB_PUT(pacct_db, &key, &data, 0); + if (rv < 0) { + warn("add key %s to process accounting stats", ci->ci_comm); + return (-1); + } else if (rv == 1) { + warnx("duplicate key %s in process accounting stats", + ci->ci_comm); + return (-1); + } + + return (0); +} + +int +pacct_update() +{ + DB *saved_pacct_db; + DBT key, data; + int error, serr, nerr; + + saved_pacct_db = dbopen(_PATH_SAVACCT, O_RDWR|O_CREAT|O_TRUNC, 0644, + DB_BTREE, NULL); + if (saved_pacct_db == NULL) { + warn("creating process accounting summary"); + return (-1); + } + + error = 0; + + serr = DB_SEQ(pacct_db, &key, &data, R_FIRST); + if (serr < 0) { + warn("retrieving process accounting stats"); + error = -1; + } + while (serr == 0) { + nerr = DB_PUT(saved_pacct_db, &key, &data, 0); + if (nerr < 0) { + warn("saving process accounting summary"); + error = -1; + break; + } + + serr = DB_SEQ(pacct_db, &key, &data, R_NEXT); + if (serr < 0) { + warn("retrieving process accounting stats"); + error = -1; + break; + } + } + + if (DB_SYNC(saved_pacct_db, 0) < 0) { + warn("syncing process accounting summary"); + error = -1; + } + if (DB_CLOSE(saved_pacct_db) < 0) { + warn("closing process accounting summary"); + error = -1; + } + return error; +} + +void +pacct_print() +{ + BTREEINFO bti; + DBT key, data, ndata; + DB *output_pacct_db; + struct cmdinfo *cip, ci, ci_total, ci_other, ci_junk; + int rv; + + bzero(&ci_total, sizeof ci_total); + strcpy(ci_total.ci_comm, ""); + bzero(&ci_other, sizeof ci_other); + strcpy(ci_other.ci_comm, "***other"); + bzero(&ci_junk, sizeof ci_junk); + strcpy(ci_junk.ci_comm, "**junk**"); + + /* + * Retrieve them into new DB, sorted by appropriate key. + * At the same time, cull 'other' and 'junk' + */ + bzero(&bti, sizeof bti); + bti.compare = sa_cmp; + output_pacct_db = dbopen(NULL, O_RDWR, 0, DB_BTREE, &bti); + if (output_pacct_db == NULL) { + warn("couldn't sort process accounting stats"); + return; + } + + ndata.data = NULL; + ndata.size = 0; + rv = DB_SEQ(pacct_db, &key, &data, R_FIRST); + if (rv < 0) + warn("retrieving process accounting stats"); + while (rv == 0) { + cip = (struct cmdinfo *) data.data; + bcopy(cip, &ci, sizeof ci); + + /* add to total */ + add_ci(&ci, &ci_total); + + if (vflag && ci.ci_calls <= cutoff && + (fflag || check_junk(&ci))) { + /* put it into **junk** */ + add_ci(&ci, &ci_junk); + goto next; + } + if (!aflag && + ((ci.ci_flags & CI_UNPRINTABLE) != 0 || ci.ci_calls <= 1)) { + /* put into ***other */ + add_ci(&ci, &ci_other); + goto next; + } + rv = DB_PUT(output_pacct_db, &data, &ndata, 0); + if (rv < 0) + warn("sorting process accounting stats"); + +next: rv = DB_SEQ(pacct_db, &key, &data, R_NEXT); + if (rv < 0) + warn("retrieving process accounting stats"); + } + + /* insert **junk** and ***other */ + if (ci_junk.ci_calls != 0) { + data.data = &ci_junk; + data.size = sizeof ci_junk; + rv = DB_PUT(output_pacct_db, &data, &ndata, 0); + if (rv < 0) + warn("sorting process accounting stats"); + } + if (ci_other.ci_calls != 0) { + data.data = &ci_other; + data.size = sizeof ci_other; + rv = DB_PUT(output_pacct_db, &data, &ndata, 0); + if (rv < 0) + warn("sorting process accounting stats"); + } + + /* print out the total */ + print_ci(&ci_total, &ci_total); + + /* print out; if reversed, print first (smallest) first */ + rv = DB_SEQ(output_pacct_db, &data, &ndata, rflag ? R_FIRST : R_LAST); + if (rv < 0) + warn("retrieving process accounting report"); + while (rv == 0) { + cip = (struct cmdinfo *) data.data; + bcopy(cip, &ci, sizeof ci); + + print_ci(&ci, &ci_total); + + rv = DB_SEQ(output_pacct_db, &data, &ndata, + rflag ? R_NEXT : R_PREV); + if (rv < 0) + warn("retrieving process accounting report"); + } + DB_CLOSE(output_pacct_db); +} + +static int +check_junk(cip) + struct cmdinfo *cip; +{ + char *cp; + size_t len; + + fprintf(stderr, "%s (%qu) -- ", cip->ci_comm, cip->ci_calls); + cp = fgetln(stdin, &len); + + return (cp && (cp[0] == 'y' || cp[0] == 'Y')) ? 1 : 0; +} + +static void +add_ci(fromcip, tocip) + const struct cmdinfo *fromcip; + struct cmdinfo *tocip; +{ + tocip->ci_calls += fromcip->ci_calls; + tocip->ci_etime += fromcip->ci_etime; + tocip->ci_utime += fromcip->ci_utime; + tocip->ci_stime += fromcip->ci_stime; + tocip->ci_mem += fromcip->ci_mem; + tocip->ci_io += fromcip->ci_io; +} + +static void +print_ci(cip, totalcip) + const struct cmdinfo *cip, *totalcip; +{ + double t, c; + int uflow; + + c = cip->ci_calls ? cip->ci_calls : 1; + t = (cip->ci_utime + cip->ci_stime) / (double) AHZ; + if (t < 0.01) { + t = 0.01; + uflow = 1; + } else + uflow = 0; + + printf("%8qu ", cip->ci_calls); + if (cflag) { + if (cip != totalcip) + printf(" %4.2f%% ", + cip->ci_calls / (double) totalcip->ci_calls); + else + printf(" %4s ", ""); + } + + if (jflag) + printf("%11.2fre ", cip->ci_etime / (double) (AHZ * c)); + else + printf("%11.2fre ", cip->ci_etime / (60.0 * AHZ)); + if (cflag) { + if (cip != totalcip) + printf(" %4.2f%% ", + cip->ci_etime / (double) totalcip->ci_etime); + else + printf(" %4s ", ""); + } + + if (!lflag) { + if (jflag) + printf("%11.2fcp ", t / (double) cip->ci_calls); + else + printf("%11.2fcp ", t / 60.0); + if (cflag) { + if (cip != totalcip) + printf(" %4.2f%% ", + (cip->ci_utime + cip->ci_stime) / (double) + (totalcip->ci_utime + totalcip->ci_stime)); + else + printf(" %4s ", ""); + } + } else { + if (jflag) + printf("%11.2fu ", cip->ci_utime / (double) (AHZ * c)); + else + printf("%11.2fu ", cip->ci_utime / (60.0 * AHZ)); + if (cflag) { + if (cip != totalcip) + printf(" %4.2f%% ", cip->ci_utime / (double) totalcip->ci_utime); + else + printf(" %4s ", ""); + } + if (jflag) + printf("%11.2fs ", cip->ci_stime / (double) (AHZ * c)); + else + printf("%11.2fs ", cip->ci_stime / (60.0 * AHZ)); + if (cflag) { + if (cip != totalcip) + printf(" %4.2f%% ", cip->ci_stime / (double) totalcip->ci_stime); + else + printf(" %4s ", ""); + } + } + + if (tflag) + if (!uflow) + printf("%8.2fre/cp ", cip->ci_etime / (double) (cip->ci_utime + cip->ci_stime)); + else + printf("%8 ", "*ignore*"); + + if (Dflag) + printf("%10qutio ", cip->ci_io); + else + printf("%8.0favio ", cip->ci_io / c); + + if (Kflag) + printf("%10quk*sec ", cip->ci_mem); + else + printf("%8.0fk ", cip->ci_mem / t); + + printf(" %s\n", cip->ci_comm); +} diff --git a/usr.sbin/sa/sa.8 b/usr.sbin/sa/sa.8 new file mode 100644 index 0000000..83ec1f4 --- /dev/null +++ b/usr.sbin/sa/sa.8 @@ -0,0 +1,246 @@ +.\" +.\" 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 by Christopher G. Demetriou. +.\" 3. 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: sa.8,v 1.1 1994/03/24 18:41:59 cgd Exp $ +.\" +.Dd February 25, 1994 +.Dt SA 8 +.Os NetBSD 0.9a +.Sh NAME +.Nm sa +.Nd print system accounting statistics +.Sh SYNOPSIS +.Nm sa +.Op Fl abcdDfijkKlmnqrstu +.Op Fl v Ar cutoff +.Op Ar +.Sh DESCRIPTION +The +.Nm sa +utility reports on, cleans up, +and generally maintains system +accounting files. +.Pp +.Nm Sa +is able to condense the the information in +.Pa /var/account/acct +into the summary files +.Pa /var/account/savacct +and +.Pa /var/account/usracct , +which contain system statistics according +to command name and login id, respectively. +This condensation is desirable because on a +large system, +.Pa /var/account/acct +can grow by hundreds of blocks per day. +The summary files are normally read before +the accounting file, so that reports include +all available information. +.Pp +If file names are supplied, they are read instead of +.Pa /var/account/account . +After each file is read, if the summary +files are being updated, an updated summary will +be saved to disk. Only one report is printed, +after the last file is processed. +.Pp +The labels used in the output indicate the following, except +where otherwise specified by individual options: +.Bl -tag -width k*sec +.It Dv avio +Average number of I/O operations per execution +.It Dv cp +Sum of user and system time, in minutes +.It Dv cpu +Same as +.Dv cp +.It Dv k +CPU-time averaged core usage, in 1k units +.It Dv k*sec +CPU storage integral, in 1k-core seconds +.It Dv re +Real time, in minutes +.It Dv s +System time, in minutes +.It Dv tio +Total number of I/O operations +.It Dv u +User time, in minutes +.El +.Pp +The options to +.Nm sa +are: +.Bl -tag -width Ds +.It Fl a +List all command names, including those containing unprintable +characters and those used only once. By default, +.Nm sa +places all names containing unprintable characters and +those used only once under the name ``***other''. +.It Fl b +If printing command statistics, sort output by the sum of user and system +time divided by number of calls. +.It Fl c +In addition to the number of calls and the user, system and real times +for each command, print their percentage of the total over all commands. +.It Fl d +If printing command statistics, sort by the average number of disk +I/O operations. If printing user statistics, print the average number of +disk I/O operations per user. +.It Fl D +If printing command statistics, sort and print by the total number +of disk I/O operations. +.It Fl f +Force no interactive threshold comparison with the +.Fl v +option. +.It Fl i +Do not read in the summary files. +.It Fl j +Instead of the total minutes per category, give seconds per call. +.It Fl k +If printing command statistics, sort by the cpu-time average memory +usage. If printing user statistics, print the cpu-time average +memory usage. +.It Fl K +If printing command statistics, print and sort by the cpu-storage integral. +.It Fl l +Separate system and user time; normally they are combined. +.It Fl m +Print per-user statistics rather than per-command statistics. +.It Fl n +Sort by number of calls. +.It Fl q +Create no output other than error messages. +.It Fl r +Reverse order of sort. +.It Fl s +Truncate the accounting files when done and merge their data +into the summary files. +.It Fl t +For each command, report the ratio of real time to the sum +of user and system cpu times. +If the cpu time is too small to report, ``*ignore*'' appears in +this field. +.It Fl u +Superseding all other flags, for each entry +in the accounting file, print the user ID, total seconds of cpu usage, +total memory usage, number of I/O operations performed, and +command name. +.It Fl v Ar cutoff +For each command used +.Ar cutoff +times or fewer, print the command name and await a reply +from the terminal. If the reply begins with ``y'', add +the command to the category ``**junk**''. This flag is +used to strip garbage from the report. +.El +.Pp +By default, per-command statistics will be printed. The number of +calls, the total elapsed time in minutes, total cpu and user time +in minutes, average number of I/O operations, and CPU-time +averaged core usage will be printed. If the +.Fl m +option is specified, per-user statistics will be printed, including +the user name, the number of commands invoked, total cpu time used +(in minutes), total number of I/O operations, and CPU storage integral +for each user. If the +.Fl u +option is specified, the uid, user and system time (in seconds), +CPU storage integral, I/O usage, and command name will be printed +for each entry in the accounting data file. +.Pp +If the +.Fl u +flag is specified, all flags other than +.Fl q +are ignored. If the +.Fl m +flag is specified, only the +.Fl b , +.Fl d , +.Fl i , +.Fl k , +.Fl q , +and +.Fl s +flags are honored. +.Pp +The +.Nm sa +utility exits 0 on success, and >0 if an error occurs. +.Sh FILES +.Bl -tag -width /var/account/usracct -compact +.It Pa /var/account/acct +raw accounting data file +.It Pa /var/account/savacct +per-command accounting summary database +.It Pa /var/account/usracct +per-user accounting summary database +.El +.Sh SEE ALSO +.Xr ac 8 , +.Xr acct 5 , +.Xr accton 8 , +.Xr lastcomm 1 +.Sh BUGS +The number of options to this program is absurd, especially considering +that there's not much logic behind their lettering. +.Pp +The field labels should be more consistent. +.Pp +NetBSD's VM system does not record the CPU storage integral. +.Sh CAVEATS +While the behavior of the options in this version of +.Nm sa +was modeled after the original version, there are some intentional +differences and undoubtedly some unintentional ones as well. In +particular, the +.Fl q +option has been added, and the +.Fl m +option now understands more options than it used to. +.Pp +The formats of the summary files created by this version of +.Nm sa +are very different than the those used by the original version. +This is not considered a problem, however, because the accounting record +format has changed as well (since user ids are now 32 bits). +.Sh HISTORY +.Nm Sa +was written for +.Nx 0.9a +from the specification provided by various systems' manual pages. +Its date of origin is unknown to the author. +.Sh AUTHOR +.Bl -tag +Chris G. Demetriou, cgd@postgres.berkeley.edu +.El diff --git a/usr.sbin/sa/usrdb.c b/usr.sbin/sa/usrdb.c new file mode 100644 index 0000000..af7d0fd --- /dev/null +++ b/usr.sbin/sa/usrdb.c @@ -0,0 +1,282 @@ +/* + * 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 by Christopher G. Demetriou. + * 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. + */ + +#ifndef LINT +static char rcsid[] = "$Id: usrdb.c,v 1.1 1994/03/24 18:42:01 cgd Exp $"; +#endif + +#include +#include +#include +#include +#include +#include "extern.h" +#include "pathnames.h" + +static int uid_compare __P((const DBT *, const DBT *)); + +static DB *usracct_db; + +int +usracct_init() +{ + DB *saved_usracct_db; + BTREEINFO bti; + int error; + + bzero(&bti, sizeof bti); + bti.compare = uid_compare; + + usracct_db = dbopen(NULL, O_RDWR, 0, DB_BTREE, &bti); + if (usracct_db == NULL) + return (-1); + + error = 0; + if (!iflag) { + DBT key, data; + int serr, nerr; + + saved_usracct_db = dbopen(_PATH_USRACCT, O_RDONLY, 0, DB_BTREE, + &bti); + if (saved_usracct_db == NULL) { + error = (errno == ENOENT) ? 0 : -1; + if (error) + warn("retrieving user accounting summary"); + goto out; + } + + serr = DB_SEQ(saved_usracct_db, &key, &data, R_FIRST); + if (serr < 0) { + warn("retrieving user accounting summary"); + error = -1; + goto closeout; + } + while (serr == 0) { + nerr = DB_PUT(usracct_db, &key, &data, 0); + if (nerr < 0) { + warn("initializing user accounting stats"); + error = -1; + break; + } + + serr = DB_SEQ(saved_usracct_db, &key, &data, R_NEXT); + if (serr < 0) { + warn("retrieving user accounting summary"); + error = -1; + break; + } + } + +closeout: + if (DB_CLOSE(saved_usracct_db) < 0) { + warn("closing user accounting summary"); + error = -1; + } + } + +out: + if (error != 0) + usracct_destroy(); + return (error); +} + +void +usracct_destroy() +{ + if (DB_CLOSE(usracct_db) < 0) + warn("destroying user accounting stats"); +} + +int +usracct_add(ci) + const struct cmdinfo *ci; +{ + DBT key, data; + struct userinfo newui; + u_long uid; + int rv; + + uid = ci->ci_uid; + key.data = &uid; + key.size = sizeof uid; + + rv = DB_GET(usracct_db, &key, &data, 0); + if (rv < 0) { + warn("get key %d from user accounting stats", uid); + return (-1); + } else if (rv == 0) { /* it's there; copy whole thing */ + /* add the old data to the new data */ + bcopy(data.data, &newui, data.size); + if (newui.ui_uid != uid) { + warnx("key %d != expected record number %d", + newui.ui_uid, uid); + warnx("inconsistent user accounting stats"); + return (-1); + } + } else { /* it's not there; zero it and copy the key */ + bzero(&newui, sizeof newui); + newui.ui_uid = ci->ci_uid; + } + + newui.ui_calls += ci->ci_calls; + newui.ui_utime += ci->ci_utime; + newui.ui_stime += ci->ci_stime; + newui.ui_mem += ci->ci_mem; + newui.ui_io += ci->ci_io; + + data.data = &newui; + data.size = sizeof newui; + rv = DB_PUT(usracct_db, &key, &data, 0); + if (rv < 0) { + warn("add key %d to user accounting stats", uid); + return (-1); + } else if (rv != 0) { + warnx("DB_PUT returned 1"); + return (-1); + } + + return (0); +} + +int +usracct_update() +{ + DB *saved_usracct_db; + DBT key, data; + BTREEINFO bti; + u_long uid; + int error, serr, nerr; + + bzero(&bti, sizeof bti); + bti.compare = uid_compare; + + saved_usracct_db = dbopen(_PATH_USRACCT, O_RDWR|O_CREAT|O_TRUNC, 0644, + DB_BTREE, &bti); + if (saved_usracct_db == NULL) { + warn("creating user accounting summary"); + return (-1); + } + + error = 0; + + serr = DB_SEQ(usracct_db, &key, &data, R_FIRST); + if (serr < 0) { + warn("retrieving user accounting stats"); + error = -1; + } + while (serr == 0) { + nerr = DB_PUT(saved_usracct_db, &key, &data, 0); + if (nerr < 0) { + warn("saving user accounting summary"); + error = -1; + break; + } + + serr = DB_SEQ(usracct_db, &key, &data, R_NEXT); + if (serr < 0) { + warn("retrieving user accounting stats"); + error = -1; + break; + } + } + + if (DB_SYNC(saved_usracct_db, 0) < 0) { + warn("syncing process accounting summary"); + error = -1; + } +out: + if (DB_CLOSE(saved_usracct_db) < 0) { + warn("closing process accounting summary"); + error = -1; + } + return error; +} + +void +usracct_print() +{ + DBT key, data; + struct userinfo *ui; + double t; + int rv; + + rv = DB_SEQ(usracct_db, &key, &data, R_FIRST); + if (rv < 0) + warn("retrieving user accounting stats"); + + while (rv == 0) { + ui = (struct userinfo *) data.data; + + printf("%-8s %9qu ", + user_from_uid(ui->ui_uid, 0), ui->ui_calls); + + t = (double) (ui->ui_utime + ui->ui_stime) / + (double) AHZ; + if (t < 0.0001) /* kill divide by zero */ + t = 0.0001; + + printf("%12.2lf%s ", t / 60.0, "cpu"); + + /* ui->ui_calls is always != 0 */ + if (dflag) + printf("%12qu%s", ui->ui_io / ui->ui_calls, "avio"); + else + printf("%12qu%s", ui->ui_io, "tio"); + + /* t is always >= 0.0001; see above */ + if (kflag) + printf("%12qu%s", ui->ui_mem / t, "k"); + else + printf("%12qu%s", ui->ui_mem, "k*sec"); + + printf("\n"); + + rv = DB_SEQ(usracct_db, &key, &data, R_NEXT); + if (rv < 0) + warn("retrieving user accounting stats"); + } +} + +static int +uid_compare(k1, k2) + const DBT *k1, *k2; +{ + u_long d1, d2; + + bcopy(k1->data, &d1, sizeof d1); + bcopy(k2->data, &d2, sizeof d2); + + if (d1 < d2) + return -1; + else if (d1 == d2) + return 0; + else + return 1; +} -- cgit v1.1