[apple/system_cmds.git] / sa.tproj / pdb.c

/*
 * 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.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD: src/usr.sbin/sa/pdb.c,v 1.14 2007/05/22 06:51:38 dds Exp $");

#include <sys/types.h>
#include <sys/acct.h>
#include <err.h>
#include <errno.h>
#include <fcntl.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include "extern.h"
#include "pathnames.h"

static int check_junk(const struct cmdinfo *);
static void add_ci(const struct cmdinfo *, struct cmdinfo *);
static void print_ci(const struct cmdinfo *, const struct cmdinfo *);

static DB	*pacct_db;

/* Legacy format in AHZV1 units. */
struct cmdinfov1 {
	char		ci_comm[MAXCOMLEN+2];	/* command name (+ '*') */
	uid_t		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 */
};

/*
 * Convert a v1 data record into the current version.
 * Return 0 if OK, -1 on error, setting errno.
 */
static int
v1_to_v2(DBT *key __unused, DBT *data)
{
	struct cmdinfov1 civ1;
	static struct cmdinfo civ2;

	if (data->size != sizeof(civ1)) {
		errno = EFTYPE;
		return (-1);
	}
	memcpy(&civ1, data->data, data->size);
	memset(&civ2, 0, sizeof(civ2));
	memcpy(civ2.ci_comm, civ1.ci_comm, sizeof(civ2.ci_comm));
	civ2.ci_uid = civ1.ci_uid;
	civ2.ci_calls = civ1.ci_calls;
	civ2.ci_etime = ((double)civ1.ci_etime / AHZV1) * 1000000;
	civ2.ci_utime = ((double)civ1.ci_utime / AHZV1) * 1000000;
	civ2.ci_stime = ((double)civ1.ci_stime / AHZV1) * 1000000;
	civ2.ci_mem = civ1.ci_mem;
	civ2.ci_io = civ1.ci_io;
	civ2.ci_flags = civ1.ci_flags;
	data->size = sizeof(civ2);
	data->data = &civ2;
	return (0);
}

/* Copy pdb_file to in-memory pacct_db. */
int
pacct_init(void)
{
	return (db_copy_in(&pacct_db, pdb_file, "process accounting",
	    NULL, v1_to_v2));
}

void
pacct_destroy(void)
{
	db_destroy(pacct_db, "process accounting");
}

int
pacct_add(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);
}

/* Copy in-memory pacct_db to pdb_file. */
int
pacct_update(void)
{
	return (db_copy_out(pacct_db, pdb_file, "process accounting",
	    NULL));
}

void
pacct_print(void)
{
	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(const struct cmdinfo *cip)
{
	char *cp;
	size_t len;

	fprintf(stderr, "%s (%ju) -- ", cip->ci_comm, (uintmax_t)cip->ci_calls);
	cp = fgetln(stdin, &len);

	return (cp && (cp[0] == 'y' || cp[0] == 'Y')) ? 1 : 0;
}

static void
add_ci(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;
}

#ifdef __APPLE__
static void
print_ci(const struct cmdinfo *cip, const struct cmdinfo *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("%8ju ", (uintmax_t)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("*ignore*      ");
	}

	if (Dflag)
		printf("%10jutio ", (uintmax_t)cip->ci_io);
	else
		printf("%8.0favio ", cip->ci_io / c);

	if (Kflag)
		printf("%10juk*sec ", (uintmax_t)cip->ci_mem);
	else
		printf("%8.0fk ", cip->ci_mem / t);

	printf("  %s\n", cip->ci_comm);
}
#else
static void
print_ci(const struct cmdinfo *cip, const struct cmdinfo *totalcip)
{
	double t, c;
	int uflow;

	c = cip->ci_calls ? cip->ci_calls : 1;
	t = (cip->ci_utime + cip->ci_stime) / 1000000;
	if (t < 0.01) {
		t = 0.01;
		uflow = 1;
	} else
		uflow = 0;

	printf("%8ju ", (uintmax_t)cip->ci_calls);
	if (cflag) {
		if (cip != totalcip)
			printf(" %4.1f%%  ", cip->ci_calls /
			    (double)totalcip->ci_calls * 100);
		else
			printf(" %4s   ", "");
	}

	if (jflag)
		printf("%11.3fre ", cip->ci_etime / (1000000 * c));
	else
		printf("%11.3fre ", cip->ci_etime / (60.0 * 1000000));
	if (cflag) {
		if (cip != totalcip)
			printf(" %4.1f%%  ", cip->ci_etime /
			    totalcip->ci_etime * 100);
		else
			printf(" %4s   ", "");
	}

	if (!lflag) {
		if (jflag)
			printf("%11.3fcp ", t / (double) cip->ci_calls);
		else
			printf("%11.2fcp ", t / 60.0);
		if (cflag) {
			if (cip != totalcip)
				printf(" %4.1f%%  ",
				    (cip->ci_utime + cip->ci_stime) /
				    (totalcip->ci_utime + totalcip->ci_stime) *
				    100);
			else
				printf(" %4s   ", "");
		}
	} else {
		if (jflag)
			printf("%11.3fu ", cip->ci_utime / (1000000 * c));
		else
			printf("%11.2fu ", cip->ci_utime / (60.0 * 1000000));
		if (cflag) {
			if (cip != totalcip)
				printf(" %4.1f%%  ", cip->ci_utime /
				    (double)totalcip->ci_utime * 100);
			else
				printf(" %4s   ", "");
		}
		if (jflag)
			printf("%11.3fs ", cip->ci_stime / (1000000 * c));
		else
			printf("%11.2fs ", cip->ci_stime / (60.0 * 1000000));
		if (cflag) {
			if (cip != totalcip)
				printf(" %4.1f%%  ", cip->ci_stime /
				    (double)totalcip->ci_stime * 100);
			else
				printf(" %4s   ", "");
		}
	}

	if (tflag) {
		if (!uflow)
			printf("%8.2fre/cp ",
			    cip->ci_etime /
			    (cip->ci_utime + cip->ci_stime));
		else
			printf("*ignore*      ");
	}

	if (Dflag)
		printf("%10.0fio ", cip->ci_io);
	else
		printf("%8.0favio ", cip->ci_io / c);

	if (Kflag)
		printf("%10.0fk*sec ", cip->ci_mem);
	else
		printf("%8.0fk ", cip->ci_mem / t);

	printf("  %s\n", cip->ci_comm);
}
#endif
Commit	Line	Data
2fc1e207 A	1	/*
	2	* Copyright (c) 1994 Christopher G. Demetriou
	3	* All rights reserved.
	4	*
	5	* Redistribution and use in source and binary forms, with or without
	6	* modification, are permitted provided that the following conditions
	7	* are met:
	8	* 1. Redistributions of source code must retain the above copyright
	9	* notice, this list of conditions and the following disclaimer.
	10	* 2. Redistributions in binary form must reproduce the above copyright
	11	* notice, this list of conditions and the following disclaimer in the
	12	* documentation and/or other materials provided with the distribution.
	13	* 3. All advertising materials mentioning features or use of this software
	14	* must display the following acknowledgement:
	15	* This product includes software developed by Christopher G. Demetriou.
	16	* 4. The name of the author may not be used to endorse or promote products
	17	* derived from this software without specific prior written permission
	18	*
	19	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
	20	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
	21	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
	22	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
	23	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	24	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	25	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	26	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	27	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
	28	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	29	*/
	30
ef8ad44b A	31	#include <sys/cdefs.h>
ef8ad44b A	32	__FBSDID("$FreeBSD: src/usr.sbin/sa/pdb.c,v 1.14 2007/05/22 06:51:38 dds Exp $");
2fc1e207 A	33
	34	#include <sys/types.h>
	35	#include <sys/acct.h>
	36	#include <err.h>
	37	#include <errno.h>
	38	#include <fcntl.h>
ef8ad44b	39	#include <stdbool.h>
2fc1e207 A	40	#include <stdint.h>
	41	#include <stdio.h>
	42	#include <string.h>
	43	#include "extern.h"
	44	#include "pathnames.h"
	45
ef8ad44b A	46	static int check_junk(const struct cmdinfo *);
	47	static void add_ci(const struct cmdinfo , struct cmdinfo );
	48	static void print_ci(const struct cmdinfo , const struct cmdinfo );
2fc1e207 A	49
	50	static DB *pacct_db;
	51
ef8ad44b A	52	/* Legacy format in AHZV1 units. */
	53	struct cmdinfov1 {
	54	char ci_comm[MAXCOMLEN+2]; /* command name (+ '') /
	55	uid_t ci_uid; /* user id */
	56	u_quad_t ci_calls; /* number of calls */
	57	u_quad_t ci_etime; /* elapsed time */
	58	u_quad_t ci_utime; /* user time */
	59	u_quad_t ci_stime; /* system time */
	60	u_quad_t ci_mem; /* memory use */
	61	u_quad_t ci_io; /* number of disk i/o ops */
	62	u_int ci_flags; /* flags; see below */
	63	};
	64
	65	/*
	66	* Convert a v1 data record into the current version.
	67	* Return 0 if OK, -1 on error, setting errno.
	68	*/
	69	static int
	70	v1_to_v2(DBT key __unused, DBT data)
2fc1e207	71	{
ef8ad44b A	72	struct cmdinfov1 civ1;
ef8ad44b A	73	static struct cmdinfo civ2;
2fc1e207	74
ef8ad44b A	75	if (data->size != sizeof(civ1)) {
ef8ad44b A	76	errno = EFTYPE;
2fc1e207	77	return (-1);
2fc1e207	78	}
ef8ad44b A	79	memcpy(&civ1, data->data, data->size);
	80	memset(&civ2, 0, sizeof(civ2));
	81	memcpy(civ2.ci_comm, civ1.ci_comm, sizeof(civ2.ci_comm));
	82	civ2.ci_uid = civ1.ci_uid;
	83	civ2.ci_calls = civ1.ci_calls;
	84	civ2.ci_etime = ((double)civ1.ci_etime / AHZV1) * 1000000;
	85	civ2.ci_utime = ((double)civ1.ci_utime / AHZV1) * 1000000;
	86	civ2.ci_stime = ((double)civ1.ci_stime / AHZV1) * 1000000;
	87	civ2.ci_mem = civ1.ci_mem;
	88	civ2.ci_io = civ1.ci_io;
	89	civ2.ci_flags = civ1.ci_flags;
	90	data->size = sizeof(civ2);
	91	data->data = &civ2;
	92	return (0);
	93	}
2fc1e207	94
ef8ad44b A	95	/* Copy pdb_file to in-memory pacct_db. */
ef8ad44b A	96	int
cf37c299	97	pacct_init(void)
ef8ad44b A	98	{
	99	return (db_copy_in(&pacct_db, pdb_file, "process accounting",
	100	NULL, v1_to_v2));
2fc1e207 A	101	}
	102
	103	void
cf37c299	104	pacct_destroy(void)
2fc1e207	105	{
ef8ad44b	106	db_destroy(pacct_db, "process accounting");
2fc1e207 A	107	}
	108
	109	int
ef8ad44b	110	pacct_add(const struct cmdinfo *ci)
2fc1e207 A	111	{
	112	DBT key, data;
	113	struct cmdinfo newci;
	114	char keydata[sizeof ci->ci_comm];
	115	int rv;
	116
	117	bcopy(ci->ci_comm, &keydata, sizeof keydata);
	118	key.data = &keydata;
	119	key.size = strlen(keydata);
	120
	121	rv = DB_GET(pacct_db, &key, &data, 0);
	122	if (rv < 0) {
	123	warn("get key %s from process accounting stats", ci->ci_comm);
	124	return (-1);
	125	} else if (rv == 0) { /* it's there; copy whole thing */
	126	/* XXX compare size if paranoid */
	127	/* add the old data to the new data */
	128	bcopy(data.data, &newci, data.size);
	129	} else { /* it's not there; zero it and copy the key */
	130	bzero(&newci, sizeof newci);
	131	bcopy(key.data, newci.ci_comm, key.size);
	132	}
	133
	134	add_ci(ci, &newci);
	135
	136	data.data = &newci;
	137	data.size = sizeof newci;
	138	rv = DB_PUT(pacct_db, &key, &data, 0);
	139	if (rv < 0) {
	140	warn("add key %s to process accounting stats", ci->ci_comm);
	141	return (-1);
	142	} else if (rv == 1) {
	143	warnx("duplicate key %s in process accounting stats",
	144	ci->ci_comm);
	145	return (-1);
	146	}
	147
	148	return (0);
	149	}
	150
ef8ad44b	151	/* Copy in-memory pacct_db to pdb_file. */
2fc1e207	152	int
cf37c299	153	pacct_update(void)
2fc1e207	154	{
ef8ad44b A	155	return (db_copy_out(pacct_db, pdb_file, "process accounting",
ef8ad44b A	156	NULL));
2fc1e207 A	157	}
	158
	159	void
cf37c299	160	pacct_print(void)
2fc1e207 A	161	{
	162	BTREEINFO bti;
	163	DBT key, data, ndata;
	164	DB *output_pacct_db;
	165	struct cmdinfo *cip, ci, ci_total, ci_other, ci_junk;
	166	int rv;
	167
	168	bzero(&ci_total, sizeof ci_total);
	169	strcpy(ci_total.ci_comm, "");
	170	bzero(&ci_other, sizeof ci_other);
	171	strcpy(ci_other.ci_comm, "***other");
	172	bzero(&ci_junk, sizeof ci_junk);
	173	strcpy(ci_junk.ci_comm, "junk");
	174
	175	/*
	176	* Retrieve them into new DB, sorted by appropriate key.
	177	* At the same time, cull 'other' and 'junk'
	178	*/
	179	bzero(&bti, sizeof bti);
	180	bti.compare = sa_cmp;
	181	output_pacct_db = dbopen(NULL, O_RDWR, 0, DB_BTREE, &bti);
	182	if (output_pacct_db == NULL) {
	183	warn("couldn't sort process accounting stats");
	184	return;
	185	}
	186
	187	ndata.data = NULL;
	188	ndata.size = 0;
	189	rv = DB_SEQ(pacct_db, &key, &data, R_FIRST);
	190	if (rv < 0)
	191	warn("retrieving process accounting stats");
	192	while (rv == 0) {
	193	cip = (struct cmdinfo *) data.data;
	194	bcopy(cip, &ci, sizeof ci);
	195
	196	/* add to total */
	197	add_ci(&ci, &ci_total);
	198
	199	if (vflag && ci.ci_calls <= cutoff &&
	200	(fflag \|\| check_junk(&ci))) {
	201	/* put it into junk */
	202	add_ci(&ci, &ci_junk);
	203	goto next;
	204	}
	205	if (!aflag &&
	206	((ci.ci_flags & CI_UNPRINTABLE) != 0 \|\| ci.ci_calls <= 1)) {
	207	/* put into **other /
	208	add_ci(&ci, &ci_other);
	209	goto next;
	210	}
	211	rv = DB_PUT(output_pacct_db, &data, &ndata, 0);
	212	if (rv < 0)
	213	warn("sorting process accounting stats");
	214
	215	next: rv = DB_SEQ(pacct_db, &key, &data, R_NEXT);
	216	if (rv < 0)
	217	warn("retrieving process accounting stats");
	218	}
	219
	220	/* insert junk and **other /
	221	if (ci_junk.ci_calls != 0) {
	222	data.data = &ci_junk;
	223	data.size = sizeof ci_junk;
	224	rv = DB_PUT(output_pacct_db, &data, &ndata, 0);
225	if (rv < 0)
226	warn("sorting process accounting stats");
227	}
228	if (ci_other.ci_calls != 0) {
229	data.data = &ci_other;
230	data.size = sizeof ci_other;
231	rv = DB_PUT(output_pacct_db, &data, &ndata, 0);
232	if (rv < 0)
233	warn("sorting process accounting stats");
234	}
235
236	/* print out the total */
237	print_ci(&ci_total, &ci_total);
238
239	/* print out; if reversed, print first (smallest) first */
240	rv = DB_SEQ(output_pacct_db, &data, &ndata, rflag ? R_FIRST : R_LAST);
241	if (rv < 0)
242	warn("retrieving process accounting report");
243	while (rv == 0) {
244	cip = (struct cmdinfo *) data.data;
245	bcopy(cip, &ci, sizeof ci);
246
247	print_ci(&ci, &ci_total);
248
249	rv = DB_SEQ(output_pacct_db, &data, &ndata,
250	rflag ? R_NEXT : R_PREV);
251	if (rv < 0)
252	warn("retrieving process accounting report");
253	}
254	DB_CLOSE(output_pacct_db);
255	}
256
257	static int
ef8ad44b	258	check_junk(const struct cmdinfo *cip)
2fc1e207 A	259	{
	260	char *cp;
	261	size_t len;
	262
	263	fprintf(stderr, "%s (%ju) -- ", cip->ci_comm, (uintmax_t)cip->ci_calls);
	264	cp = fgetln(stdin, &len);
	265
	266	return (cp && (cp[0] == 'y' \|\| cp[0] == 'Y')) ? 1 : 0;
	267	}
	268
	269	static void
ef8ad44b	270	add_ci(const struct cmdinfo fromcip, struct cmdinfo tocip)
2fc1e207 A	271	{
	272	tocip->ci_calls += fromcip->ci_calls;
	273	tocip->ci_etime += fromcip->ci_etime;
	274	tocip->ci_utime += fromcip->ci_utime;
	275	tocip->ci_stime += fromcip->ci_stime;
	276	tocip->ci_mem += fromcip->ci_mem;
	277	tocip->ci_io += fromcip->ci_io;
	278	}
	279
ef8ad44b	280	#ifdef __APPLE__
2fc1e207	281	static void
ef8ad44b	282	print_ci(const struct cmdinfo cip, const struct cmdinfo totalcip)
2fc1e207 A	283	{
	284	double t, c;
	285	int uflow;
	286
	287	c = cip->ci_calls ? cip->ci_calls : 1;
	288	t = (cip->ci_utime + cip->ci_stime) / (double) AHZ;
	289	if (t < 0.01) {
	290	t = 0.01;
	291	uflow = 1;
	292	} else
	293	uflow = 0;
	294
	295	printf("%8ju ", (uintmax_t)cip->ci_calls);
	296	if (cflag) {
	297	if (cip != totalcip)
	298	printf(" %4.2f%% ",
	299	cip->ci_calls / (double) totalcip->ci_calls);
	300	else
	301	printf(" %4s ", "");
	302	}
	303
	304	if (jflag)
	305	printf("%11.2fre ", cip->ci_etime / (double) (AHZ * c));
	306	else
	307	printf("%11.2fre ", cip->ci_etime / (60.0 * AHZ));
	308	if (cflag) {
	309	if (cip != totalcip)
	310	printf(" %4.2f%% ",
	311	cip->ci_etime / (double) totalcip->ci_etime);
	312	else
	313	printf(" %4s ", "");
	314	}
	315
	316	if (!lflag) {
	317	if (jflag)
	318	printf("%11.2fcp ", t / (double) cip->ci_calls);
	319	else
	320	printf("%11.2fcp ", t / 60.0);
	321	if (cflag) {
	322	if (cip != totalcip)
	323	printf(" %4.2f%% ",
	324	(cip->ci_utime + cip->ci_stime) / (double)
	325	(totalcip->ci_utime + totalcip->ci_stime));
	326	else
	327	printf(" %4s ", "");
	328	}
	329	} else {
	330	if (jflag)
	331	printf("%11.2fu ", cip->ci_utime / (double) (AHZ * c));
	332	else
	333	printf("%11.2fu ", cip->ci_utime / (60.0 * AHZ));
	334	if (cflag) {
	335	if (cip != totalcip)
	336	printf(" %4.2f%% ", cip->ci_utime / (double) totalcip->ci_utime);
	337	else
	338	printf(" %4s ", "");
	339	}
	340	if (jflag)
	341	printf("%11.2fs ", cip->ci_stime / (double) (AHZ * c));
	342	else
	343	printf("%11.2fs ", cip->ci_stime / (60.0 * AHZ));
	344	if (cflag) {
	345	if (cip != totalcip)
	346	printf(" %4.2f%% ", cip->ci_stime / (double) totalcip->ci_stime);
347	else
348	printf(" %4s ", "");
349	}
350	}
351
352	if (tflag) {
353	if (!uflow)
354	printf("%8.2fre/cp ",
355	cip->ci_etime /
356	(double) (cip->ci_utime + cip->ci_stime));
357	else
358	printf("ignore ");
359	}
360
361	if (Dflag)
362	printf("%10jutio ", (uintmax_t)cip->ci_io);
363	else
364	printf("%8.0favio ", cip->ci_io / c);
365
366	if (Kflag)
367	printf("%10juk*sec ", (uintmax_t)cip->ci_mem);
368	else
369	printf("%8.0fk ", cip->ci_mem / t);
370
371	printf(" %s\n", cip->ci_comm);
372	}
ef8ad44b A	373	#else
	374	static void
	375	print_ci(const struct cmdinfo cip, const struct cmdinfo totalcip)
	376	{
	377	double t, c;
	378	int uflow;
	379
	380	c = cip->ci_calls ? cip->ci_calls : 1;
	381	t = (cip->ci_utime + cip->ci_stime) / 1000000;
	382	if (t < 0.01) {
	383	t = 0.01;
	384	uflow = 1;
	385	} else
	386	uflow = 0;
	387
	388	printf("%8ju ", (uintmax_t)cip->ci_calls);
	389	if (cflag) {
	390	if (cip != totalcip)
	391	printf(" %4.1f%% ", cip->ci_calls /
	392	(double)totalcip->ci_calls * 100);
	393	else
	394	printf(" %4s ", "");
	395	}
	396
	397	if (jflag)
	398	printf("%11.3fre ", cip->ci_etime / (1000000 * c));
	399	else
	400	printf("%11.3fre ", cip->ci_etime / (60.0 * 1000000));
	401	if (cflag) {
	402	if (cip != totalcip)
	403	printf(" %4.1f%% ", cip->ci_etime /
	404	totalcip->ci_etime * 100);
	405	else
	406	printf(" %4s ", "");
	407	}
	408
	409	if (!lflag) {
	410	if (jflag)
	411	printf("%11.3fcp ", t / (double) cip->ci_calls);
	412	else
	413	printf("%11.2fcp ", t / 60.0);
	414	if (cflag) {
	415	if (cip != totalcip)
	416	printf(" %4.1f%% ",
	417	(cip->ci_utime + cip->ci_stime) /
	418	(totalcip->ci_utime + totalcip->ci_stime) *
	419	100);
	420	else
	421	printf(" %4s ", "");
	422	}
	423	} else {
	424	if (jflag)
	425	printf("%11.3fu ", cip->ci_utime / (1000000 * c));
	426	else
	427	printf("%11.2fu ", cip->ci_utime / (60.0 * 1000000));
	428	if (cflag) {
	429	if (cip != totalcip)
	430	printf(" %4.1f%% ", cip->ci_utime /
	431	(double)totalcip->ci_utime * 100);
	432	else
	433	printf(" %4s ", "");
	434	}
	435	if (jflag)
	436	printf("%11.3fs ", cip->ci_stime / (1000000 * c));
437	else
438	printf("%11.2fs ", cip->ci_stime / (60.0 * 1000000));
439	if (cflag) {
440	if (cip != totalcip)
441	printf(" %4.1f%% ", cip->ci_stime /
442	(double)totalcip->ci_stime * 100);
443	else
444	printf(" %4s ", "");
445	}
446	}
447
448	if (tflag) {
449	if (!uflow)
450	printf("%8.2fre/cp ",
451	cip->ci_etime /
452	(cip->ci_utime + cip->ci_stime));
453	else
454	printf("ignore ");
455	}
456
457	if (Dflag)
458	printf("%10.0fio ", cip->ci_io);
459	else
460	printf("%8.0favio ", cip->ci_io / c);
461
462	if (Kflag)
463	printf("%10.0fk*sec ", cip->ci_mem);
464	else
465	printf("%8.0fk ", cip->ci_mem / t);
466
467	printf(" %s\n", cip->ci_comm);
468	}
cf37c299	469	#endif