Process accounting utility by Chris Demetriou.

Obtained from:	NetBSD

7 files changed, 1630 insertions, 0 deletions

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 <bsd.prog.mk>
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 <sys/types.h>
+#include <sys/param.h>
+#include <db.h>
+
+/* 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 <sys/types.h>
+#include <sys/acct.h>
+#include <ctype.h>
+#include <err.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#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 <sys/types.h>
+#include <sys/acct.h>
+#include <err.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#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 <sys/types.h>
+#include <sys/acct.h>
+#include <err.h>
+#include <errno.h>
+#include <fcntl.h>
+#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;
+}