xref: /illumos-gate/usr/src/cmd/acct/acctcms.c (revision 2a8bcb4e)
17c478bd9Sstevel@tonic-gate /*
27c478bd9Sstevel@tonic-gate  * CDDL HEADER START
37c478bd9Sstevel@tonic-gate  *
47c478bd9Sstevel@tonic-gate  * The contents of this file are subject to the terms of the
57c478bd9Sstevel@tonic-gate  * Common Development and Distribution License, Version 1.0 only
67c478bd9Sstevel@tonic-gate  * (the "License").  You may not use this file except in compliance
77c478bd9Sstevel@tonic-gate  * with the License.
87c478bd9Sstevel@tonic-gate  *
97c478bd9Sstevel@tonic-gate  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
107c478bd9Sstevel@tonic-gate  * or http://www.opensolaris.org/os/licensing.
117c478bd9Sstevel@tonic-gate  * See the License for the specific language governing permissions
127c478bd9Sstevel@tonic-gate  * and limitations under the License.
137c478bd9Sstevel@tonic-gate  *
147c478bd9Sstevel@tonic-gate  * When distributing Covered Code, include this CDDL HEADER in each
157c478bd9Sstevel@tonic-gate  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
167c478bd9Sstevel@tonic-gate  * If applicable, add the following below this CDDL HEADER, with the
177c478bd9Sstevel@tonic-gate  * fields enclosed by brackets "[]" replaced with your own identifying
187c478bd9Sstevel@tonic-gate  * information: Portions Copyright [yyyy] [name of copyright owner]
197c478bd9Sstevel@tonic-gate  *
207c478bd9Sstevel@tonic-gate  * CDDL HEADER END
217c478bd9Sstevel@tonic-gate  */
227c478bd9Sstevel@tonic-gate /*
237c478bd9Sstevel@tonic-gate  * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
247c478bd9Sstevel@tonic-gate  * Use is subject to license terms.
257c478bd9Sstevel@tonic-gate  */
267c478bd9Sstevel@tonic-gate 
277c478bd9Sstevel@tonic-gate /*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
287c478bd9Sstevel@tonic-gate /*	  All Rights Reserved  	*/
297c478bd9Sstevel@tonic-gate 
307c478bd9Sstevel@tonic-gate /*
317c478bd9Sstevel@tonic-gate  *	acctcms [-a] [-c] [-j] [-n] [-s] [-p] [-o] [-t] [file...]
327c478bd9Sstevel@tonic-gate  *	summarize per-process accounting
337c478bd9Sstevel@tonic-gate  *	-a	output in ascii, rather than [pt]cms.h format
347c478bd9Sstevel@tonic-gate  *	-c	sort by total cpu, rather than total kcore-minutes
357c478bd9Sstevel@tonic-gate  *	-j	anything used only once -> ***other
367c478bd9Sstevel@tonic-gate  *	-n	sort by number of processes
377c478bd9Sstevel@tonic-gate  *	-s	any following files already in pcms.h format
387c478bd9Sstevel@tonic-gate  *      -p      output prime time command summary (only with -a)
397c478bd9Sstevel@tonic-gate  *      -o      output non-prime time (offshift) command summary (only
407c478bd9Sstevel@tonic-gate  *		with -a option)
417c478bd9Sstevel@tonic-gate  *	-t	process records in total (old) style (tcms.h) format
427c478bd9Sstevel@tonic-gate  *	file	file in [pt]cms.h (if -s seen already) or acct.h (if not)
437c478bd9Sstevel@tonic-gate  *	expected use:
447c478bd9Sstevel@tonic-gate  *	acctcms /var/adm/pacct? > today; acctcms -s old today >new
457c478bd9Sstevel@tonic-gate  *	cp new old; rm new
467c478bd9Sstevel@tonic-gate  *	acctcms -a today; acctcms -a old
477c478bd9Sstevel@tonic-gate  */
487c478bd9Sstevel@tonic-gate #include <stdio.h>
497c478bd9Sstevel@tonic-gate #include <sys/types.h>
507c478bd9Sstevel@tonic-gate #include <sys/param.h>
517c478bd9Sstevel@tonic-gate #include "acctdef.h"
527c478bd9Sstevel@tonic-gate #include <ctype.h>
53414388d7Ssl #include <string.h>
547c478bd9Sstevel@tonic-gate #include <sys/acct.h>
55414388d7Ssl #include <stdlib.h>
567c478bd9Sstevel@tonic-gate 
577c478bd9Sstevel@tonic-gate int	csize = CSIZE;
587c478bd9Sstevel@tonic-gate 
597c478bd9Sstevel@tonic-gate /*
607c478bd9Sstevel@tonic-gate  *  Total cms records format
617c478bd9Sstevel@tonic-gate  */
627c478bd9Sstevel@tonic-gate struct tcms {
637c478bd9Sstevel@tonic-gate 	char	tcm_comm[8];	/* command name */
647c478bd9Sstevel@tonic-gate 	long	tcm_pc;		/* number of processes */
657c478bd9Sstevel@tonic-gate 	float	tcm_cpu;	/* cpu time(min) */
667c478bd9Sstevel@tonic-gate 	float	tcm_real;	/* real time(min) */
677c478bd9Sstevel@tonic-gate 	float	tcm_kcore;	/* kcore-minutes */
687c478bd9Sstevel@tonic-gate 	ulong_t	tcm_io;		/* chars transferred */
697c478bd9Sstevel@tonic-gate 	ulong_t	tcm_rw;		/* blocks read */
707c478bd9Sstevel@tonic-gate } ;
717c478bd9Sstevel@tonic-gate struct tcms	*tcm;
727c478bd9Sstevel@tonic-gate /*
737c478bd9Sstevel@tonic-gate  * prime/nonprime CMS record format
747c478bd9Sstevel@tonic-gate  */
757c478bd9Sstevel@tonic-gate struct pcms {
767c478bd9Sstevel@tonic-gate 	char	pcm_comm[8];	/* command name */
777c478bd9Sstevel@tonic-gate 	long	pcm_pc[2];	/* number of processes */
787c478bd9Sstevel@tonic-gate 	float	pcm_cpu[2];	/* cpu time(min) */
797c478bd9Sstevel@tonic-gate 	float	pcm_real[2];	/* real time(min) */
807c478bd9Sstevel@tonic-gate 	float	pcm_kcore[2];	/* kcore-minutes */
817c478bd9Sstevel@tonic-gate 	float	pcm_io[2];	/* chars transferred */
827c478bd9Sstevel@tonic-gate 	float	pcm_rw[2];	/* blocks read */
837c478bd9Sstevel@tonic-gate } ;
847c478bd9Sstevel@tonic-gate struct pcms	*pcm;
857c478bd9Sstevel@tonic-gate struct  tcms    tcmtmp  = {{'*','*','*','o','t','h','e','r'}};
867c478bd9Sstevel@tonic-gate struct  pcms    pcmtmp  = {{'*','*','*','o','t','h','e','r'}};
877c478bd9Sstevel@tonic-gate int	aflg;
887c478bd9Sstevel@tonic-gate int	cflg;
897c478bd9Sstevel@tonic-gate int	jflg;
907c478bd9Sstevel@tonic-gate int	nflg;
917c478bd9Sstevel@tonic-gate int	sflg;
927c478bd9Sstevel@tonic-gate int	pflg;
937c478bd9Sstevel@tonic-gate int	oflg;
947c478bd9Sstevel@tonic-gate int	tflg;
957c478bd9Sstevel@tonic-gate int	errflg;
967c478bd9Sstevel@tonic-gate 
977c478bd9Sstevel@tonic-gate #ifdef uts
987c478bd9Sstevel@tonic-gate float   expand();
997c478bd9Sstevel@tonic-gate #else
1007c478bd9Sstevel@tonic-gate ulong_t	expand();
1017c478bd9Sstevel@tonic-gate #endif
1027c478bd9Sstevel@tonic-gate 
103414388d7Ssl void outputc(void);
104414388d7Ssl void totprnt(struct pcms *);
105414388d7Ssl void pprint(struct pcms *);
106414388d7Ssl void prnt(struct pcms *, int);
107414388d7Ssl void print(struct pcms *);
108414388d7Ssl void outputa(void);
109414388d7Ssl void toutptc(void);
110414388d7Ssl void tprint(struct tcms *);
111414388d7Ssl void toutpta(void);
112414388d7Ssl int ncmp(struct pcms *, struct pcms *);
113414388d7Ssl int tncmp(struct tcms *, struct tcms *);
114414388d7Ssl int tccmp(struct tcms *, struct tcms *);
115414388d7Ssl int tkcmp(struct tcms *, struct tcms *);
116414388d7Ssl int ccmp(struct pcms *, struct pcms *);
117414388d7Ssl int kcmp(struct pcms *, struct pcms *);
118414388d7Ssl void tdofile(char *);
119414388d7Ssl void dofile(char *);
120414388d7Ssl void tfixjunk(void);
121414388d7Ssl void fixjunk(void);
122414388d7Ssl void tcmadd(struct tcms *, struct tcms *);
123414388d7Ssl void pcmadd(struct pcms *, struct pcms *);
124414388d7Ssl void tsqueeze(void);
125414388d7Ssl void squeeze(void);
1267c478bd9Sstevel@tonic-gate 
1277c478bd9Sstevel@tonic-gate /*  Format specification for ASCII printing */
1287c478bd9Sstevel@tonic-gate 
1297c478bd9Sstevel@tonic-gate char	*fmtcmd =	"%-8.8s",
1307c478bd9Sstevel@tonic-gate 	*fmtcnt =	"%8ld",
1317c478bd9Sstevel@tonic-gate 	*fmtkcore =	" %11.2f",
1327c478bd9Sstevel@tonic-gate 	*fmtcpu =	" %9.2f",
1337c478bd9Sstevel@tonic-gate 	*fmtreal =	" %12.2f",
1347c478bd9Sstevel@tonic-gate 	*fmtmsz =	" %7.2f",
1357c478bd9Sstevel@tonic-gate 	*fmtmcpu =	" %6.2f",
1367c478bd9Sstevel@tonic-gate 	*fmthog =	" %5.2f",
1377c478bd9Sstevel@tonic-gate 	*fmtcharx =	" %12.0f",
1387c478bd9Sstevel@tonic-gate 	*fmtblkx =	" %10.0f" ;
1397c478bd9Sstevel@tonic-gate 
140414388d7Ssl int
main(int argc,char ** argv)141414388d7Ssl main(int argc, char **argv)
1427c478bd9Sstevel@tonic-gate {
1437c478bd9Sstevel@tonic-gate 	int	c;
1447c478bd9Sstevel@tonic-gate 
1457c478bd9Sstevel@tonic-gate 	while((c = getopt(argc, argv, "acjnspot")) != EOF)
1467c478bd9Sstevel@tonic-gate 	switch(c) {
1477c478bd9Sstevel@tonic-gate 		case 'a':
1487c478bd9Sstevel@tonic-gate 			aflg++;
1497c478bd9Sstevel@tonic-gate 			continue;
1507c478bd9Sstevel@tonic-gate 		case 'c':
1517c478bd9Sstevel@tonic-gate 			cflg++;
1527c478bd9Sstevel@tonic-gate 			continue;
1537c478bd9Sstevel@tonic-gate 		case 'j':
1547c478bd9Sstevel@tonic-gate 			jflg++;
1557c478bd9Sstevel@tonic-gate 			continue;
1567c478bd9Sstevel@tonic-gate 		case 'n':
1577c478bd9Sstevel@tonic-gate 			nflg++;
1587c478bd9Sstevel@tonic-gate 			continue;
1597c478bd9Sstevel@tonic-gate 		case 's':
1607c478bd9Sstevel@tonic-gate 			sflg++;
1617c478bd9Sstevel@tonic-gate 			continue;
1627c478bd9Sstevel@tonic-gate 		case 'p':
1637c478bd9Sstevel@tonic-gate 			pflg++;
1647c478bd9Sstevel@tonic-gate 			continue;
1657c478bd9Sstevel@tonic-gate 		case 'o':
1667c478bd9Sstevel@tonic-gate 			oflg++;
1677c478bd9Sstevel@tonic-gate 			continue;
1687c478bd9Sstevel@tonic-gate 		case 't':
1697c478bd9Sstevel@tonic-gate 			tflg++;
1707c478bd9Sstevel@tonic-gate 			continue;
1717c478bd9Sstevel@tonic-gate 		default:
1727c478bd9Sstevel@tonic-gate 			errflg++;
1737c478bd9Sstevel@tonic-gate 			continue;
1747c478bd9Sstevel@tonic-gate 	}
1757c478bd9Sstevel@tonic-gate 	if(errflg){
1767c478bd9Sstevel@tonic-gate 		fprintf(stderr, "Usage: %s [-acjnspot] [file ...]\n", argv[0]);
1777c478bd9Sstevel@tonic-gate 		exit(1);
1787c478bd9Sstevel@tonic-gate 	}
1797c478bd9Sstevel@tonic-gate 	if(tflg) {
1807c478bd9Sstevel@tonic-gate 		if( (tcm = (struct tcms *)calloc(CSIZE, sizeof(struct tcms))) == NULL) {
1817c478bd9Sstevel@tonic-gate 			fprintf(stderr, "%s: Cannot allocate memory\n", argv[0]);
1827c478bd9Sstevel@tonic-gate 			exit(5);
1837c478bd9Sstevel@tonic-gate 		}
1847c478bd9Sstevel@tonic-gate 		for(; optind < argc; optind++)
1857c478bd9Sstevel@tonic-gate 			tdofile(argv[optind]);
1867c478bd9Sstevel@tonic-gate 		if (jflg)
1877c478bd9Sstevel@tonic-gate 			tfixjunk();
1887c478bd9Sstevel@tonic-gate 		tsqueeze();
189414388d7Ssl 		qsort(tcm, csize, sizeof(tcm[0]),
190414388d7Ssl 		    (int (*)(const void *, const void *))
191414388d7Ssl 		     ( nflg ? tncmp: (cflg? tccmp: tkcmp)));
1927c478bd9Sstevel@tonic-gate 		if (aflg)
1937c478bd9Sstevel@tonic-gate 			toutpta();
1947c478bd9Sstevel@tonic-gate 		else
1957c478bd9Sstevel@tonic-gate 			toutptc();
1967c478bd9Sstevel@tonic-gate 	} else {
1977c478bd9Sstevel@tonic-gate 		if( (pcm = (struct pcms *)calloc(CSIZE, sizeof(struct pcms))) == NULL) {
1987c478bd9Sstevel@tonic-gate 			fprintf(stderr, "%s: Cannot allocate memory\n", argv[0]);
1997c478bd9Sstevel@tonic-gate 			exit(6);
2007c478bd9Sstevel@tonic-gate 		}
2017c478bd9Sstevel@tonic-gate 		for(; optind < argc; optind++)
2027c478bd9Sstevel@tonic-gate 			dofile(argv[optind]);
2037c478bd9Sstevel@tonic-gate 		if (jflg)
2047c478bd9Sstevel@tonic-gate 			fixjunk();
2057c478bd9Sstevel@tonic-gate 		squeeze();
206414388d7Ssl 		qsort(pcm, csize, sizeof(pcm[0]),
207414388d7Ssl 		    (int (*)(const void *, const void *))
208414388d7Ssl 		    (nflg? ncmp: (cflg? ccmp: kcmp)));
2097c478bd9Sstevel@tonic-gate 		if (aflg)
2107c478bd9Sstevel@tonic-gate 			outputa();
2117c478bd9Sstevel@tonic-gate 		else
2127c478bd9Sstevel@tonic-gate 			outputc();
2137c478bd9Sstevel@tonic-gate 	}
2147c478bd9Sstevel@tonic-gate 	exit(0);
2157c478bd9Sstevel@tonic-gate 
2167c478bd9Sstevel@tonic-gate }
2177c478bd9Sstevel@tonic-gate 
218414388d7Ssl void
tdofile(char * fname)219414388d7Ssl tdofile(char *fname)
2207c478bd9Sstevel@tonic-gate {
2217c478bd9Sstevel@tonic-gate 	struct tcms cmt;
2227c478bd9Sstevel@tonic-gate 	union {
2237c478bd9Sstevel@tonic-gate 		struct acct ab;		/* SVR4 acct structure */
2247c478bd9Sstevel@tonic-gate 		struct o_acct oab;	/* SVR3 acct structure */
2257c478bd9Sstevel@tonic-gate 	} acct;
2267c478bd9Sstevel@tonic-gate 	int ver = 0;
2277c478bd9Sstevel@tonic-gate 	ulong_t	mem;
2287c478bd9Sstevel@tonic-gate 	ulong_t	cpu;
2297c478bd9Sstevel@tonic-gate 	ulong_t	real;
2307c478bd9Sstevel@tonic-gate 
2317c478bd9Sstevel@tonic-gate 	if (freopen(fname, "r", stdin) == NULL) {
2327c478bd9Sstevel@tonic-gate 		fprintf(stderr,  "acctcms: cannot open %s\n", fname);
2337c478bd9Sstevel@tonic-gate 		return;
2347c478bd9Sstevel@tonic-gate 	}
2357c478bd9Sstevel@tonic-gate 
2367c478bd9Sstevel@tonic-gate 	if (sflg)
2377c478bd9Sstevel@tonic-gate 		while (fread(&cmt, sizeof(cmt), 1, stdin) == 1)
2387c478bd9Sstevel@tonic-gate 			tenter(&cmt);
2397c478bd9Sstevel@tonic-gate 	else {
2407c478bd9Sstevel@tonic-gate 		if (fread(&acct.ab, sizeof(acct.ab), 1, stdin) == 1)
2417c478bd9Sstevel@tonic-gate 			/* check for expanded account structure flag */
2427c478bd9Sstevel@tonic-gate 			if (acct.ab.ac_flag & AEXPND)
2437c478bd9Sstevel@tonic-gate 				ver = 2;		/* 4.0 acct file */
2447c478bd9Sstevel@tonic-gate 			else
2457c478bd9Sstevel@tonic-gate 				ver = 1;		/* SVR3.x acct file */
2467c478bd9Sstevel@tonic-gate 
2477c478bd9Sstevel@tonic-gate 		rewind(stdin);	/* reset file pointer */
2487c478bd9Sstevel@tonic-gate 
2497c478bd9Sstevel@tonic-gate  		switch(ver) {
2507c478bd9Sstevel@tonic-gate 
2517c478bd9Sstevel@tonic-gate 		default:
2527c478bd9Sstevel@tonic-gate 				/* this can't happen */
2537c478bd9Sstevel@tonic-gate 			fprintf(stderr, "acctcms: encountered bad version number\n");
2547c478bd9Sstevel@tonic-gate 			return;
2557c478bd9Sstevel@tonic-gate 		case 1 :
2567c478bd9Sstevel@tonic-gate 			while (fread(&acct.oab, sizeof(acct.oab), 1, stdin) == 1) {
2577c478bd9Sstevel@tonic-gate 				CPYN(cmt.tcm_comm, acct.oab.ac_comm);
2587c478bd9Sstevel@tonic-gate 				cmt.tcm_pc = 1;
2597c478bd9Sstevel@tonic-gate 				cpu = expand(acct.oab.ac_stime)+
2607c478bd9Sstevel@tonic-gate 					expand(acct.oab.ac_utime);
2617c478bd9Sstevel@tonic-gate 				cmt.tcm_cpu = MINT(cpu);
2627c478bd9Sstevel@tonic-gate 				real = expand(acct.oab.ac_etime);
2637c478bd9Sstevel@tonic-gate 				cmt.tcm_real = MINT(real);
2647c478bd9Sstevel@tonic-gate 				mem = expand(acct.oab.ac_mem);
2657c478bd9Sstevel@tonic-gate 				cmt.tcm_kcore = MINT(KCORE(mem));
2667c478bd9Sstevel@tonic-gate 				cmt.tcm_io = expand(acct.oab.ac_io);
2677c478bd9Sstevel@tonic-gate 				cmt.tcm_rw = expand(acct.oab.ac_rw);
2687c478bd9Sstevel@tonic-gate 				tenter(&cmt);
2697c478bd9Sstevel@tonic-gate 			}
2707c478bd9Sstevel@tonic-gate 			break;
2717c478bd9Sstevel@tonic-gate 		case 2 :
2727c478bd9Sstevel@tonic-gate 
2737c478bd9Sstevel@tonic-gate 			while (fread(&acct.ab, sizeof(acct.ab), 1, stdin) == 1) {
2747c478bd9Sstevel@tonic-gate 				CPYN(cmt.tcm_comm, acct.ab.ac_comm);
2757c478bd9Sstevel@tonic-gate 				cmt.tcm_pc = 1;
2767c478bd9Sstevel@tonic-gate 				cpu = expand(acct.oab.ac_stime)+
2777c478bd9Sstevel@tonic-gate 					expand(acct.oab.ac_utime);
2787c478bd9Sstevel@tonic-gate 				cmt.tcm_cpu = MINT(cpu);
2797c478bd9Sstevel@tonic-gate 				real = expand(acct.ab.ac_etime);
2807c478bd9Sstevel@tonic-gate 				cmt.tcm_real = MINT(real);
2817c478bd9Sstevel@tonic-gate 				mem = expand(acct.ab.ac_mem);
2827c478bd9Sstevel@tonic-gate 				cmt.tcm_kcore = MINT(KCORE(mem));
2837c478bd9Sstevel@tonic-gate 				cmt.tcm_io = expand(acct.ab.ac_io);
2847c478bd9Sstevel@tonic-gate 				cmt.tcm_rw = expand(acct.ab.ac_rw);
2857c478bd9Sstevel@tonic-gate 				tenter(&cmt);
2867c478bd9Sstevel@tonic-gate 			}
2877c478bd9Sstevel@tonic-gate 			break;
2887c478bd9Sstevel@tonic-gate 		}
2897c478bd9Sstevel@tonic-gate 	}
2907c478bd9Sstevel@tonic-gate }
2917c478bd9Sstevel@tonic-gate 
292414388d7Ssl void
dofile(char * fname)293414388d7Ssl dofile(char *fname)
2947c478bd9Sstevel@tonic-gate {
2957c478bd9Sstevel@tonic-gate 	union {
2967c478bd9Sstevel@tonic-gate 		struct acct ab;
2977c478bd9Sstevel@tonic-gate 		struct o_acct oab;
2987c478bd9Sstevel@tonic-gate 	} acct;
2997c478bd9Sstevel@tonic-gate 	struct pcms 	pcmt;
3007c478bd9Sstevel@tonic-gate 	double		ratio;
3017c478bd9Sstevel@tonic-gate 	long		elaps[2];
3027c478bd9Sstevel@tonic-gate 	ulong_t		etime;
3037c478bd9Sstevel@tonic-gate 	double	dtmp;
3047c478bd9Sstevel@tonic-gate 	unsigned long	ltmp;
3057c478bd9Sstevel@tonic-gate 	ulong_t	mem;
3067c478bd9Sstevel@tonic-gate 	ulong_t	cpu;
3077c478bd9Sstevel@tonic-gate 	ulong_t	real;
3087c478bd9Sstevel@tonic-gate 
3097c478bd9Sstevel@tonic-gate 	if (freopen(fname, "r", stdin) == NULL) {
3107c478bd9Sstevel@tonic-gate 		fprintf(stderr,  "acctcms: cannot open %s\n", fname);
3117c478bd9Sstevel@tonic-gate 		return;
3127c478bd9Sstevel@tonic-gate 	}
3137c478bd9Sstevel@tonic-gate 
3147c478bd9Sstevel@tonic-gate 	if (sflg)
3157c478bd9Sstevel@tonic-gate 		while (fread(&pcmt, sizeof(pcmt), 1, stdin) == 1)
3167c478bd9Sstevel@tonic-gate 			enter(&pcmt);
3177c478bd9Sstevel@tonic-gate 	else {
3187c478bd9Sstevel@tonic-gate 		int ver = 0;
3197c478bd9Sstevel@tonic-gate 
3207c478bd9Sstevel@tonic-gate 		if (fread(&acct.ab, sizeof(acct.ab), 1, stdin) == 1)
3217c478bd9Sstevel@tonic-gate 			/* check for expanded account structure flag */
3227c478bd9Sstevel@tonic-gate 			if (acct.ab.ac_flag & AEXPND)
3237c478bd9Sstevel@tonic-gate 				ver = 2;		/* 4.0 acct file */
3247c478bd9Sstevel@tonic-gate 			else
3257c478bd9Sstevel@tonic-gate 				ver = 1;		/* SVR3.x acct file */
3267c478bd9Sstevel@tonic-gate 
3277c478bd9Sstevel@tonic-gate 		rewind(stdin);	/* reset file pointer */
3287c478bd9Sstevel@tonic-gate 
3297c478bd9Sstevel@tonic-gate 		switch(ver) {
3307c478bd9Sstevel@tonic-gate 
3317c478bd9Sstevel@tonic-gate 		default :
3327c478bd9Sstevel@tonic-gate  				/* this can't happen */
3337c478bd9Sstevel@tonic-gate 			fprintf(stderr, "acctcms: encountered bad version number\n");
3347c478bd9Sstevel@tonic-gate 			return;
3357c478bd9Sstevel@tonic-gate 		case 1 :
336*2a8bcb4eSToomas Soome 
3377c478bd9Sstevel@tonic-gate 			while (fread(&acct.oab, sizeof(acct.oab), 1, stdin) == 1) {
3387c478bd9Sstevel@tonic-gate 				CPYN(pcmt.pcm_comm, acct.oab.ac_comm);
3397c478bd9Sstevel@tonic-gate 			/*
3407c478bd9Sstevel@tonic-gate 			** Approximate P/NP split as same as elapsed time
3417c478bd9Sstevel@tonic-gate 		 	*/
3427c478bd9Sstevel@tonic-gate 				if((etime = SECS(expand(acct.oab.ac_etime))) == 0)
3437c478bd9Sstevel@tonic-gate 					etime = 1;
3447c478bd9Sstevel@tonic-gate 				if (pnpsplit(acct.oab.ac_btime, etime, elaps)
3457c478bd9Sstevel@tonic-gate 				    == 0) {
3467c478bd9Sstevel@tonic-gate 					(void) fprintf(stderr, "acctcms: could "
3477c478bd9Sstevel@tonic-gate 					    "not calculate prime/non-prime "
3487c478bd9Sstevel@tonic-gate 					    "hours\n");
3497c478bd9Sstevel@tonic-gate 					exit(1);
3507c478bd9Sstevel@tonic-gate 				}
3517c478bd9Sstevel@tonic-gate 				ratio = (double)elaps[PRIME]/(double)etime;
3527c478bd9Sstevel@tonic-gate 				if(elaps[PRIME] > elaps[NONPRIME]) {
3537c478bd9Sstevel@tonic-gate 					pcmt.pcm_pc[PRIME] = 1;
3547c478bd9Sstevel@tonic-gate 					pcmt.pcm_pc[NONPRIME] = 0;
3557c478bd9Sstevel@tonic-gate 				} else {
3567c478bd9Sstevel@tonic-gate 					pcmt.pcm_pc[PRIME] = 0;
3577c478bd9Sstevel@tonic-gate 					pcmt.pcm_pc[NONPRIME] = 1;
3587c478bd9Sstevel@tonic-gate 				}
3597c478bd9Sstevel@tonic-gate 				cpu = expand(acct.oab.ac_stime)+
3607c478bd9Sstevel@tonic-gate 					expand(acct.oab.ac_utime);
3617c478bd9Sstevel@tonic-gate 				dtmp = MINT(cpu);
3627c478bd9Sstevel@tonic-gate 				pcmt.pcm_cpu[PRIME] = dtmp * ratio;
3637c478bd9Sstevel@tonic-gate 				pcmt.pcm_cpu[NONPRIME] = (ratio == 1.0) ? 0.0 :
3647c478bd9Sstevel@tonic-gate 					(dtmp - pcmt.pcm_cpu[PRIME]);
3657c478bd9Sstevel@tonic-gate 				real = expand(acct.oab.ac_etime);
3667c478bd9Sstevel@tonic-gate 				dtmp = MINT(real);
3677c478bd9Sstevel@tonic-gate 				pcmt.pcm_real[PRIME] = dtmp * ratio;
3687c478bd9Sstevel@tonic-gate 				pcmt.pcm_real[NONPRIME] = (ratio == 1.0) ? 0.0 :
3697c478bd9Sstevel@tonic-gate 					(dtmp - pcmt.pcm_real[PRIME]);
3707c478bd9Sstevel@tonic-gate 				mem = expand(acct.oab.ac_mem);
3717c478bd9Sstevel@tonic-gate 				dtmp = MINT(KCORE(mem));
3727c478bd9Sstevel@tonic-gate 				pcmt.pcm_kcore[PRIME] = dtmp * ratio;
3737c478bd9Sstevel@tonic-gate 				pcmt.pcm_kcore[NONPRIME] = (ratio == 1.0) ? 0.0 :
3747c478bd9Sstevel@tonic-gate 					(dtmp - pcmt.pcm_kcore[PRIME]);
3757c478bd9Sstevel@tonic-gate 				ltmp = expand(acct.oab.ac_io);
3767c478bd9Sstevel@tonic-gate 				pcmt.pcm_io[PRIME] = (double)ltmp * ratio;
3777c478bd9Sstevel@tonic-gate 				pcmt.pcm_io[NONPRIME] = (ratio == 1.0) ? 0.0 :
3787c478bd9Sstevel@tonic-gate 					((double)ltmp - pcmt.pcm_io[PRIME]);
3797c478bd9Sstevel@tonic-gate 				ltmp = expand(acct.oab.ac_rw);
3807c478bd9Sstevel@tonic-gate 				pcmt.pcm_rw[PRIME] = (double)ltmp * ratio;
3817c478bd9Sstevel@tonic-gate 				pcmt.pcm_rw[NONPRIME] = (ratio == 1.0) ? 0.0 :
3827c478bd9Sstevel@tonic-gate 					((double)ltmp - pcmt.pcm_rw[PRIME]);
3837c478bd9Sstevel@tonic-gate 				enter(&pcmt);
3847c478bd9Sstevel@tonic-gate 			}
3857c478bd9Sstevel@tonic-gate 
3867c478bd9Sstevel@tonic-gate 			break;
3877c478bd9Sstevel@tonic-gate 		case 2 :
3887c478bd9Sstevel@tonic-gate 			while (fread(&acct.ab, sizeof(acct.ab), 1, stdin) == 1) {
3897c478bd9Sstevel@tonic-gate 				CPYN(pcmt.pcm_comm, acct.ab.ac_comm);
3907c478bd9Sstevel@tonic-gate 				/*
3917c478bd9Sstevel@tonic-gate 				** Approximate P/NP split as same as elapsed time
3927c478bd9Sstevel@tonic-gate 		 		*/
3937c478bd9Sstevel@tonic-gate 				if((etime = SECS(expand(acct.ab.ac_etime))) == 0)
3947c478bd9Sstevel@tonic-gate 					etime = 1;
3957c478bd9Sstevel@tonic-gate 				if(pnpsplit(acct.ab.ac_btime, etime, elaps) == 0) {
3967c478bd9Sstevel@tonic-gate 					fprintf(stderr, "acctcms: could not calculate prime/non-prime hours\n");
3977c478bd9Sstevel@tonic-gate 					exit(1);
3987c478bd9Sstevel@tonic-gate 				}
3997c478bd9Sstevel@tonic-gate 				ratio = (double)elaps[PRIME]/(double)etime;
4007c478bd9Sstevel@tonic-gate 				if(elaps[PRIME] > elaps[NONPRIME]) {
4017c478bd9Sstevel@tonic-gate 					pcmt.pcm_pc[PRIME] = 1;
4027c478bd9Sstevel@tonic-gate 					pcmt.pcm_pc[NONPRIME] = 0;
4037c478bd9Sstevel@tonic-gate 				} else {
4047c478bd9Sstevel@tonic-gate 					pcmt.pcm_pc[PRIME] = 0;
4057c478bd9Sstevel@tonic-gate 					pcmt.pcm_pc[NONPRIME] = 1;
4067c478bd9Sstevel@tonic-gate 				}
4077c478bd9Sstevel@tonic-gate 				cpu = expand(acct.ab.ac_stime)+
4087c478bd9Sstevel@tonic-gate 					expand(acct.ab.ac_utime);
4097c478bd9Sstevel@tonic-gate 				dtmp = MINT(cpu);
4107c478bd9Sstevel@tonic-gate 				pcmt.pcm_cpu[PRIME] = dtmp * ratio;
4117c478bd9Sstevel@tonic-gate 				pcmt.pcm_cpu[NONPRIME] = (ratio == 1.0) ? 0.0 :
4127c478bd9Sstevel@tonic-gate 					(dtmp - pcmt.pcm_cpu[PRIME]);
4137c478bd9Sstevel@tonic-gate 				real = expand(acct.ab.ac_etime);
4147c478bd9Sstevel@tonic-gate 				dtmp = MINT(real);
4157c478bd9Sstevel@tonic-gate 				pcmt.pcm_real[PRIME] = dtmp * ratio;
4167c478bd9Sstevel@tonic-gate 				pcmt.pcm_real[NONPRIME] = (ratio == 1.0) ? 0.0 :
4177c478bd9Sstevel@tonic-gate 					(dtmp - pcmt.pcm_real[PRIME]);
4187c478bd9Sstevel@tonic-gate 				mem = expand(acct.ab.ac_mem);
4197c478bd9Sstevel@tonic-gate 				dtmp = MINT(KCORE(mem));
4207c478bd9Sstevel@tonic-gate 				pcmt.pcm_kcore[PRIME] = dtmp * ratio;
4217c478bd9Sstevel@tonic-gate 				pcmt.pcm_kcore[NONPRIME] = (ratio == 1.0) ? 0.0 :
4227c478bd9Sstevel@tonic-gate 					(dtmp - pcmt.pcm_kcore[PRIME]);
4237c478bd9Sstevel@tonic-gate 				ltmp = expand(acct.ab.ac_io);
4247c478bd9Sstevel@tonic-gate 				pcmt.pcm_io[PRIME] = (double)ltmp * ratio;
4257c478bd9Sstevel@tonic-gate 				pcmt.pcm_io[NONPRIME] = (ratio == 1.0) ? 0.0 :
4267c478bd9Sstevel@tonic-gate 					((double)ltmp - pcmt.pcm_io[PRIME]);
4277c478bd9Sstevel@tonic-gate 				ltmp = expand(acct.ab.ac_rw);
4287c478bd9Sstevel@tonic-gate 				pcmt.pcm_rw[PRIME] = (double)ltmp * ratio;
4297c478bd9Sstevel@tonic-gate 				pcmt.pcm_rw[NONPRIME] = (ratio == 1.0) ? 0.0 :
4307c478bd9Sstevel@tonic-gate 					((double)ltmp - pcmt.pcm_rw[PRIME]);
4317c478bd9Sstevel@tonic-gate 				enter(&pcmt);
4327c478bd9Sstevel@tonic-gate 			}
4337c478bd9Sstevel@tonic-gate 
4347c478bd9Sstevel@tonic-gate 			break;
4357c478bd9Sstevel@tonic-gate 		}
4367c478bd9Sstevel@tonic-gate 	}
4377c478bd9Sstevel@tonic-gate }
4387c478bd9Sstevel@tonic-gate 
439414388d7Ssl int
tenter(struct tcms * p)440414388d7Ssl tenter(struct tcms *p)
4417c478bd9Sstevel@tonic-gate {
442414388d7Ssl 	int i;
443414388d7Ssl 	int j;
444414388d7Ssl 	struct tcms *ntcm;
4457c478bd9Sstevel@tonic-gate 	for (i = j = 0; j < sizeof(p->tcm_comm); j++) {
4467c478bd9Sstevel@tonic-gate 		if (p->tcm_comm[j] && p->tcm_comm[j] <= 037)
4477c478bd9Sstevel@tonic-gate 			p->tcm_comm[j] = '?';
4487c478bd9Sstevel@tonic-gate 		i = i*7 + p->tcm_comm[j];	/* hash function */
4497c478bd9Sstevel@tonic-gate 	}
4507c478bd9Sstevel@tonic-gate 	if (i < 0)
4517c478bd9Sstevel@tonic-gate 		i = -i;
4527c478bd9Sstevel@tonic-gate 	for (i %= csize, j = 0; tcm[i].tcm_comm[0] && j != csize; i = (i+1)%csize, j++)
4537c478bd9Sstevel@tonic-gate 		if (EQN(p->tcm_comm, tcm[i].tcm_comm))
4547c478bd9Sstevel@tonic-gate 			break;
4557c478bd9Sstevel@tonic-gate 	if(j == csize) {
4567c478bd9Sstevel@tonic-gate 		if ((ntcm = (struct tcms *) realloc(tcm,
4577c478bd9Sstevel@tonic-gate 			(csize + CSIZE - 1) * sizeof (struct tcms))) == NULL) {
4587c478bd9Sstevel@tonic-gate 			fprintf(stderr,
4597c478bd9Sstevel@tonic-gate 				"acctcms: Cannot reallocate memory (tcm)\n");
4607c478bd9Sstevel@tonic-gate 			return(-1);
4617c478bd9Sstevel@tonic-gate 		} else {
4627c478bd9Sstevel@tonic-gate 			memset(&ntcm[csize], 0, CSIZE - 1);
4637c478bd9Sstevel@tonic-gate 			tcm = ntcm;
4647c478bd9Sstevel@tonic-gate 			if (!EQN(p->tcm_comm, tcm[i].tcm_comm))
4657c478bd9Sstevel@tonic-gate 				i = csize;
4667c478bd9Sstevel@tonic-gate 			csize = csize + CSIZE - 1;
4677c478bd9Sstevel@tonic-gate 		}
4687c478bd9Sstevel@tonic-gate 	}
4697c478bd9Sstevel@tonic-gate 	if (tcm[i].tcm_comm[0] == 0)
4707c478bd9Sstevel@tonic-gate 		CPYN(tcm[i].tcm_comm, p->tcm_comm);
4717c478bd9Sstevel@tonic-gate 	tcmadd(&tcm[i], p);
4727c478bd9Sstevel@tonic-gate 	return(i);
4737c478bd9Sstevel@tonic-gate }
474414388d7Ssl 
475414388d7Ssl int
enter(struct pcms * p)476414388d7Ssl enter(struct pcms *p)
4777c478bd9Sstevel@tonic-gate {
478414388d7Ssl 	int i;
479414388d7Ssl 	int j;
480414388d7Ssl 	struct pcms *npcm;
4817c478bd9Sstevel@tonic-gate 	for (i = j = 0; j < sizeof(p->pcm_comm); j++) {
4827c478bd9Sstevel@tonic-gate 		if (p->pcm_comm[j] && p->pcm_comm[j] <= 037)
4837c478bd9Sstevel@tonic-gate 			p->pcm_comm[j] = '?';
4847c478bd9Sstevel@tonic-gate 		i = i*7 + p->pcm_comm[j];	/* hash function */
4857c478bd9Sstevel@tonic-gate 	}
4867c478bd9Sstevel@tonic-gate 	if (i < 0)
4877c478bd9Sstevel@tonic-gate 		i = -i;
4887c478bd9Sstevel@tonic-gate 	for (i %= csize, j = 0; pcm[i].pcm_comm[0] && j != csize; i = (i+1)%csize, j++)
4897c478bd9Sstevel@tonic-gate 		if (EQN(p->pcm_comm, pcm[i].pcm_comm))
4907c478bd9Sstevel@tonic-gate 			break;
4917c478bd9Sstevel@tonic-gate 	if(j == csize) {
4927c478bd9Sstevel@tonic-gate 		if ((npcm = (struct pcms *) realloc(pcm,
4937c478bd9Sstevel@tonic-gate 			(csize + CSIZE - 1) * sizeof (struct pcms))) == NULL) {
4947c478bd9Sstevel@tonic-gate 			fprintf(stderr,
4957c478bd9Sstevel@tonic-gate 				"acctcms: Cannot reallocate memory (pcm)\n");
4967c478bd9Sstevel@tonic-gate 			return(-1);
4977c478bd9Sstevel@tonic-gate 		} else {
4987c478bd9Sstevel@tonic-gate 			memset(&npcm[csize], 0, CSIZE - 1);
4997c478bd9Sstevel@tonic-gate 			pcm = npcm;
5007c478bd9Sstevel@tonic-gate 			if (!EQN(p->pcm_comm, pcm[i].pcm_comm))
5017c478bd9Sstevel@tonic-gate 				i = csize;
5027c478bd9Sstevel@tonic-gate 			csize = csize + CSIZE - 1;
5037c478bd9Sstevel@tonic-gate 		}
5047c478bd9Sstevel@tonic-gate 	}
5057c478bd9Sstevel@tonic-gate 	if (pcm[i].pcm_comm[0] == 0)
5067c478bd9Sstevel@tonic-gate 		CPYN(pcm[i].pcm_comm, p->pcm_comm);
5077c478bd9Sstevel@tonic-gate 	pcmadd(&pcm[i], p);
5087c478bd9Sstevel@tonic-gate 	return(i);
5097c478bd9Sstevel@tonic-gate }
510414388d7Ssl 
511414388d7Ssl void
tfixjunk(void)512414388d7Ssl tfixjunk(void)	/* combine commands used only once */
5137c478bd9Sstevel@tonic-gate {
514414388d7Ssl 	int i, j;
515414388d7Ssl 	j = tenter(&tcmtmp);
5167c478bd9Sstevel@tonic-gate 	for (i = 0; i < csize; i++)
5177c478bd9Sstevel@tonic-gate 		if (i != j && tcm[i].tcm_comm[0] && tcm[i].tcm_pc <= 1) {
5187c478bd9Sstevel@tonic-gate 			tcmadd(&tcm[j], &tcm[i]);
5197c478bd9Sstevel@tonic-gate 			tcm[i].tcm_comm[0] = 0;
5207c478bd9Sstevel@tonic-gate 		}
5217c478bd9Sstevel@tonic-gate }
522414388d7Ssl 
523414388d7Ssl void
fixjunk(void)524414388d7Ssl fixjunk(void)	/* combine commands used only once */
5257c478bd9Sstevel@tonic-gate {
526414388d7Ssl 	int i, j;
5277c478bd9Sstevel@tonic-gate 	j = enter(&pcmtmp);
5287c478bd9Sstevel@tonic-gate 	for (i = 0; i < csize; i++)
5297c478bd9Sstevel@tonic-gate 		if (i != j && pcm[i].pcm_comm[0] && (pcm[i].pcm_pc[PRIME] + pcm[i].pcm_pc[NONPRIME]) <= 1) {
5307c478bd9Sstevel@tonic-gate 			pcmadd(&pcm[j], &pcm[i]);
5317c478bd9Sstevel@tonic-gate 			pcm[i].pcm_comm[0] = 0;
5327c478bd9Sstevel@tonic-gate 		}
5337c478bd9Sstevel@tonic-gate }
5347c478bd9Sstevel@tonic-gate 
535414388d7Ssl void
tcmadd(struct tcms * p1,struct tcms * p2)536414388d7Ssl tcmadd(struct tcms *p1, struct tcms *p2)
5377c478bd9Sstevel@tonic-gate {
5387c478bd9Sstevel@tonic-gate 	p1->tcm_pc += p2->tcm_pc;
5397c478bd9Sstevel@tonic-gate 	p1->tcm_cpu = p1->tcm_cpu + p2->tcm_cpu;
5407c478bd9Sstevel@tonic-gate 	p1->tcm_real = p1->tcm_real + p2->tcm_real;
5417c478bd9Sstevel@tonic-gate 	p1->tcm_kcore = p1->tcm_kcore + p2->tcm_kcore;
5427c478bd9Sstevel@tonic-gate 	p1->tcm_io += p2->tcm_io;
5437c478bd9Sstevel@tonic-gate 	p1->tcm_rw += p2->tcm_rw;
5447c478bd9Sstevel@tonic-gate }
545414388d7Ssl 
546414388d7Ssl void
pcmadd(struct pcms * p1,struct pcms * p2)547414388d7Ssl pcmadd(struct pcms *p1, struct pcms *p2)
5487c478bd9Sstevel@tonic-gate {
5497c478bd9Sstevel@tonic-gate 	p1->pcm_pc[PRIME] += p2->pcm_pc[PRIME];
5507c478bd9Sstevel@tonic-gate 	p1->pcm_pc[NONPRIME] += p2->pcm_pc[NONPRIME];
5517c478bd9Sstevel@tonic-gate 	p1->pcm_cpu[PRIME] += p2->pcm_cpu[PRIME];
5527c478bd9Sstevel@tonic-gate 	p1->pcm_cpu[NONPRIME] += p2->pcm_cpu[NONPRIME];
5537c478bd9Sstevel@tonic-gate 	p1->pcm_real[PRIME] += p2->pcm_real[PRIME];
5547c478bd9Sstevel@tonic-gate 	p1->pcm_real[NONPRIME] += p2->pcm_real[NONPRIME];
5557c478bd9Sstevel@tonic-gate 	p1->pcm_kcore[PRIME] += p2->pcm_kcore[PRIME];
5567c478bd9Sstevel@tonic-gate 	p1->pcm_kcore[NONPRIME] += p2->pcm_kcore[NONPRIME];
5577c478bd9Sstevel@tonic-gate 	p1->pcm_io[PRIME] += p2->pcm_io[PRIME];
5587c478bd9Sstevel@tonic-gate 	p1->pcm_io[NONPRIME] += p2->pcm_io[NONPRIME];
5597c478bd9Sstevel@tonic-gate 	p1->pcm_rw[PRIME] += p2->pcm_rw[PRIME];
5607c478bd9Sstevel@tonic-gate 	p1->pcm_rw[NONPRIME] += p2->pcm_rw[NONPRIME];
5617c478bd9Sstevel@tonic-gate }
5627c478bd9Sstevel@tonic-gate 
563414388d7Ssl void
tsqueeze(void)564414388d7Ssl tsqueeze(void)	/* get rid of holes in hash table */
5657c478bd9Sstevel@tonic-gate {
566414388d7Ssl 	int i, k;
5677c478bd9Sstevel@tonic-gate 
5687c478bd9Sstevel@tonic-gate 	for (i = k = 0; i < csize; i++)
5697c478bd9Sstevel@tonic-gate 		if (tcm[i].tcm_comm[0]) {
5707c478bd9Sstevel@tonic-gate 			CPYN(tcm[k].tcm_comm, tcm[i].tcm_comm);
5717c478bd9Sstevel@tonic-gate 			tcm[k].tcm_pc = tcm[i].tcm_pc;
5727c478bd9Sstevel@tonic-gate 			tcm[k].tcm_cpu = tcm[i].tcm_cpu;
5737c478bd9Sstevel@tonic-gate 			tcm[k].tcm_real = tcm[i].tcm_real;
5747c478bd9Sstevel@tonic-gate 			tcm[k].tcm_kcore = tcm[i].tcm_kcore;
5757c478bd9Sstevel@tonic-gate 			tcm[k].tcm_io = tcm[i].tcm_io;
5767c478bd9Sstevel@tonic-gate 			tcm[k].tcm_rw = tcm[i].tcm_rw;
5777c478bd9Sstevel@tonic-gate 			k++;
5787c478bd9Sstevel@tonic-gate 		}
5797c478bd9Sstevel@tonic-gate 	csize = k;
5807c478bd9Sstevel@tonic-gate }
581414388d7Ssl 
582414388d7Ssl void
squeeze(void)583414388d7Ssl squeeze(void)	/* get rid of holes in hash table */
5847c478bd9Sstevel@tonic-gate {
585414388d7Ssl 	int i, k;
5867c478bd9Sstevel@tonic-gate 
5877c478bd9Sstevel@tonic-gate 	for (i = k = 0; i < csize; i++)
5887c478bd9Sstevel@tonic-gate 		if (pcm[i].pcm_comm[0]) {
5897c478bd9Sstevel@tonic-gate 			CPYN(pcm[k].pcm_comm, pcm[i].pcm_comm);
5907c478bd9Sstevel@tonic-gate 			pcm[k].pcm_pc[PRIME] = pcm[i].pcm_pc[PRIME];
5917c478bd9Sstevel@tonic-gate 			pcm[k].pcm_pc[NONPRIME] = pcm[i].pcm_pc[NONPRIME];
5927c478bd9Sstevel@tonic-gate 			pcm[k].pcm_cpu[PRIME] = pcm[i].pcm_cpu[PRIME];
5937c478bd9Sstevel@tonic-gate 			pcm[k].pcm_cpu[NONPRIME] = pcm[i].pcm_cpu[NONPRIME];
5947c478bd9Sstevel@tonic-gate 			pcm[k].pcm_real[PRIME] = pcm[i].pcm_real[PRIME];
5957c478bd9Sstevel@tonic-gate 			pcm[k].pcm_real[NONPRIME] = pcm[i].pcm_real[NONPRIME];
5967c478bd9Sstevel@tonic-gate 			pcm[k].pcm_kcore[PRIME] = pcm[i].pcm_kcore[PRIME];
5977c478bd9Sstevel@tonic-gate 			pcm[k].pcm_kcore[NONPRIME] = pcm[i].pcm_kcore[NONPRIME];
5987c478bd9Sstevel@tonic-gate 			pcm[k].pcm_io[PRIME] = pcm[i].pcm_io[PRIME];
5997c478bd9Sstevel@tonic-gate 			pcm[k].pcm_io[NONPRIME] = pcm[i].pcm_io[NONPRIME];
6007c478bd9Sstevel@tonic-gate 			pcm[k].pcm_rw[PRIME] = pcm[i].pcm_rw[PRIME];
6017c478bd9Sstevel@tonic-gate 			pcm[k].pcm_rw[NONPRIME] = pcm[i].pcm_rw[NONPRIME];
6027c478bd9Sstevel@tonic-gate 			k++;
6037c478bd9Sstevel@tonic-gate 		}
6047c478bd9Sstevel@tonic-gate 	csize = k;
6057c478bd9Sstevel@tonic-gate }
6067c478bd9Sstevel@tonic-gate 
607414388d7Ssl int
tccmp(struct tcms * p1,struct tcms * p2)608414388d7Ssl tccmp(struct tcms *p1, struct tcms *p2)
6097c478bd9Sstevel@tonic-gate {
6107c478bd9Sstevel@tonic-gate 	if (p1->tcm_cpu == p2->tcm_cpu)
6117c478bd9Sstevel@tonic-gate 		return(0);
6127c478bd9Sstevel@tonic-gate 	return ((p2->tcm_cpu > p1->tcm_cpu)? 1 : -1);
6137c478bd9Sstevel@tonic-gate }
6147c478bd9Sstevel@tonic-gate 
615414388d7Ssl int
ccmp(struct pcms * p1,struct pcms * p2)616414388d7Ssl ccmp(struct pcms *p1, struct pcms *p2)
6177c478bd9Sstevel@tonic-gate {
618414388d7Ssl 	int	index;
6197c478bd9Sstevel@tonic-gate 
6207c478bd9Sstevel@tonic-gate 	if( (pflg && oflg) || (!pflg && !oflg) ) {
6217c478bd9Sstevel@tonic-gate 		if (p1->pcm_cpu[PRIME] + p1->pcm_cpu[NONPRIME] == p2->pcm_cpu[PRIME] + p2->pcm_cpu[NONPRIME])
6227c478bd9Sstevel@tonic-gate 			return(0);
6237c478bd9Sstevel@tonic-gate 		return ((p2->pcm_cpu[PRIME] + p2->pcm_cpu[NONPRIME] > p1->pcm_cpu[PRIME] + p1->pcm_cpu[NONPRIME])? 1 : -1);
6247c478bd9Sstevel@tonic-gate 	}
6257c478bd9Sstevel@tonic-gate 	index = pflg ? PRIME : NONPRIME;
6267c478bd9Sstevel@tonic-gate 	if (p1->pcm_cpu[index] == p2->pcm_cpu[index])
6277c478bd9Sstevel@tonic-gate 		return(0);
6287c478bd9Sstevel@tonic-gate 	return ((p2->pcm_cpu[index] > p1->pcm_cpu[index])? 1 : -1);
6297c478bd9Sstevel@tonic-gate }
6307c478bd9Sstevel@tonic-gate 
631414388d7Ssl int
tkcmp(struct tcms * p1,struct tcms * p2)632414388d7Ssl tkcmp(struct tcms *p1, struct tcms *p2)
6337c478bd9Sstevel@tonic-gate {
6347c478bd9Sstevel@tonic-gate 	if (p1->tcm_kcore == p2->tcm_kcore)
6357c478bd9Sstevel@tonic-gate 		return(0);
6367c478bd9Sstevel@tonic-gate 	return ((p2->tcm_kcore > p1->tcm_kcore)? 1 : -1);
6377c478bd9Sstevel@tonic-gate }
6387c478bd9Sstevel@tonic-gate 
639414388d7Ssl int
kcmp(struct pcms * p1,struct pcms * p2)640414388d7Ssl kcmp(struct pcms *p1, struct pcms *p2)
6417c478bd9Sstevel@tonic-gate {
642414388d7Ssl 	int	index;
6437c478bd9Sstevel@tonic-gate 
6447c478bd9Sstevel@tonic-gate 	if( (pflg && oflg) || (!pflg && !pflg) ){
6457c478bd9Sstevel@tonic-gate 		if (p1->pcm_kcore[PRIME] + p1->pcm_kcore[NONPRIME] == p2->pcm_kcore[PRIME] + p2->pcm_kcore[NONPRIME])
6467c478bd9Sstevel@tonic-gate 			return(0);
6477c478bd9Sstevel@tonic-gate 		return ((p2->pcm_kcore[PRIME] + p2->pcm_kcore[NONPRIME] > p1->pcm_kcore[PRIME] + p1->pcm_kcore[NONPRIME])? 1 : -1);
6487c478bd9Sstevel@tonic-gate 	}
6497c478bd9Sstevel@tonic-gate 	index = pflg ? PRIME : NONPRIME;
6507c478bd9Sstevel@tonic-gate 	if (p1->pcm_kcore[index] == p2->pcm_kcore[index])
6517c478bd9Sstevel@tonic-gate 		return(0);
6527c478bd9Sstevel@tonic-gate 	return ((p2->pcm_kcore[index] > p1->pcm_kcore[index])? 1 : -1);
6537c478bd9Sstevel@tonic-gate }
6547c478bd9Sstevel@tonic-gate 
655414388d7Ssl int
tncmp(struct tcms * p1,struct tcms * p2)656414388d7Ssl tncmp(struct tcms *p1, struct tcms *p2)
6577c478bd9Sstevel@tonic-gate {
6587c478bd9Sstevel@tonic-gate 	if (p1->tcm_pc == p2->tcm_pc)
6597c478bd9Sstevel@tonic-gate 		return(0);
6607c478bd9Sstevel@tonic-gate 	return ((p2->tcm_pc > p1->tcm_pc)? 1 : -1);
6617c478bd9Sstevel@tonic-gate }
6627c478bd9Sstevel@tonic-gate 
663414388d7Ssl int
ncmp(struct pcms * p1,struct pcms * p2)664414388d7Ssl ncmp(struct pcms *p1, struct pcms *p2)
6657c478bd9Sstevel@tonic-gate {
666414388d7Ssl 	int	index;
6677c478bd9Sstevel@tonic-gate 
6687c478bd9Sstevel@tonic-gate 	if( (pflg && oflg) || (!pflg && !oflg) ) {
6697c478bd9Sstevel@tonic-gate 		if (p1->pcm_pc[PRIME] + p1->pcm_pc[NONPRIME] == p2->pcm_pc[PRIME] + p2->pcm_pc[NONPRIME])
6707c478bd9Sstevel@tonic-gate 			return(0);
6717c478bd9Sstevel@tonic-gate 		return ((p2->pcm_pc[PRIME] + p2->pcm_pc[NONPRIME] > p1->pcm_pc[PRIME] + p1->pcm_pc[NONPRIME])? 1 : -1);
6727c478bd9Sstevel@tonic-gate 	}
6737c478bd9Sstevel@tonic-gate 	index =  pflg ? PRIME : NONPRIME;
6747c478bd9Sstevel@tonic-gate 	if (p1->pcm_pc[index] == p2->pcm_pc[index])
6757c478bd9Sstevel@tonic-gate 		return(0);
6767c478bd9Sstevel@tonic-gate 	return ((p2->pcm_pc[index] > p1->pcm_pc[index])? 1 : -1);
6777c478bd9Sstevel@tonic-gate }
6787c478bd9Sstevel@tonic-gate 
6797c478bd9Sstevel@tonic-gate char	thd1[] =
6807c478bd9Sstevel@tonic-gate "COMMAND   NUMBER      TOTAL       TOTAL       TOTAL   MEAN     MEAN     HOG      CHARS        BLOCKS\n";
6817c478bd9Sstevel@tonic-gate char	thd2[] =
6827c478bd9Sstevel@tonic-gate "NAME        CMDS    KCOREMIN     CPU-MIN     REAL-MIN SIZE-K  CPU-MIN  FACTOR   TRNSFD         READ\n";
683414388d7Ssl 
684414388d7Ssl void
toutpta(void)685414388d7Ssl toutpta(void)
6867c478bd9Sstevel@tonic-gate {
687414388d7Ssl 	int i;
6887c478bd9Sstevel@tonic-gate 
6897c478bd9Sstevel@tonic-gate 	printf(thd1);
6907c478bd9Sstevel@tonic-gate 	printf(thd2);
6917c478bd9Sstevel@tonic-gate 	printf("\n");
6927c478bd9Sstevel@tonic-gate 	for (i = 0; i < csize; i++)
6937c478bd9Sstevel@tonic-gate 		tcmadd(&tcmtmp, &tcm[i]);
6947c478bd9Sstevel@tonic-gate 	CPYN(tcmtmp.tcm_comm, "TOTALS");
6957c478bd9Sstevel@tonic-gate 	tprint(&tcmtmp);
6967c478bd9Sstevel@tonic-gate 	printf("\n");
6977c478bd9Sstevel@tonic-gate 	for (i = 0; i < csize; i++)
6987c478bd9Sstevel@tonic-gate 		tprint(&tcm[i]);
6997c478bd9Sstevel@tonic-gate }
7007c478bd9Sstevel@tonic-gate 
701414388d7Ssl void
tprint(struct tcms * p)702414388d7Ssl tprint(struct tcms *p)
7037c478bd9Sstevel@tonic-gate {
7047c478bd9Sstevel@tonic-gate 	printf("%-8.8s", p->tcm_comm);
7057c478bd9Sstevel@tonic-gate 	printf(" %7ld", p->tcm_pc);
7067c478bd9Sstevel@tonic-gate 	printf(" %11.2f", p->tcm_kcore);
7077c478bd9Sstevel@tonic-gate 	printf(" %10.2f", p->tcm_cpu);
7087c478bd9Sstevel@tonic-gate 	printf(" %12.2f", p->tcm_real);
7097c478bd9Sstevel@tonic-gate 	if(p->tcm_cpu == 0)  p->tcm_cpu = 1;
7107c478bd9Sstevel@tonic-gate 	printf(" %6.2f", p->tcm_kcore/p->tcm_cpu);
7117c478bd9Sstevel@tonic-gate 	if(p->tcm_pc == 0)  p->tcm_pc = 1;
7127c478bd9Sstevel@tonic-gate 	printf(" %7.2f", p->tcm_cpu/p->tcm_pc);
7137c478bd9Sstevel@tonic-gate 	if (p->tcm_real == 0)
7147c478bd9Sstevel@tonic-gate 		p->tcm_real = 1;
7157c478bd9Sstevel@tonic-gate 	printf(" %8.2f", p->tcm_cpu/p->tcm_real);
7167c478bd9Sstevel@tonic-gate 	printf(" %11lu", p->tcm_io);
7177c478bd9Sstevel@tonic-gate 	printf(" %11lu\n", p->tcm_rw);
7187c478bd9Sstevel@tonic-gate }
7197c478bd9Sstevel@tonic-gate 
720414388d7Ssl void
toutptc(void)721414388d7Ssl toutptc(void)
7227c478bd9Sstevel@tonic-gate {
723414388d7Ssl 	int i;
7247c478bd9Sstevel@tonic-gate 
7257c478bd9Sstevel@tonic-gate 	for (i = 0; i < csize; i++)
7267c478bd9Sstevel@tonic-gate 		fwrite(&tcm[i], sizeof(tcm[i]), 1, stdout);
7277c478bd9Sstevel@tonic-gate }
7287c478bd9Sstevel@tonic-gate 
7297c478bd9Sstevel@tonic-gate char	hd1[] =
7307c478bd9Sstevel@tonic-gate "COMMAND   NUMBER      TOTAL       TOTAL       TOTAL   MEAN    MEAN     HOG         CHARS     BLOCKS\n";
7317c478bd9Sstevel@tonic-gate char	hd2[] =
7327c478bd9Sstevel@tonic-gate "NAME        CMDS    KCOREMIN     CPU-MIN   REAL-MIN  SIZE-K  CPU-MIN  FACTOR      TRNSFD      READ\n";
7337c478bd9Sstevel@tonic-gate char	hd3[] =
7347c478bd9Sstevel@tonic-gate "COMMAND        NUMBER         TOTAL          CPU-MIN                 REAL-MIN        MEAN    MEAN      HOG       CHARS       BLOCKS\n";
7357c478bd9Sstevel@tonic-gate char	hd4[] =
7367c478bd9Sstevel@tonic-gate "NAME         (P)    (NP)   KCOREMIN       (P)      (NP)          (P)         (NP)  SIZE-K  CPU-MIN   FACTOR     TRNSFD        READ\n";
7377c478bd9Sstevel@tonic-gate char	hdprime[] =
7387c478bd9Sstevel@tonic-gate "                                   PRIME TIME COMMAND SUMMARY\n";
7397c478bd9Sstevel@tonic-gate char	hdnonprime[] =
7407c478bd9Sstevel@tonic-gate "                                  NON-PRIME TIME COMMAND SUMMARY\n";
7417c478bd9Sstevel@tonic-gate char	hdtot[] =
7427c478bd9Sstevel@tonic-gate "                                     TOTAL COMMAND SUMMARY\n";
7437c478bd9Sstevel@tonic-gate char	hdp[] =
7447c478bd9Sstevel@tonic-gate "                                PRIME/NON-PRIME TIME COMMAND SUMMARY\n";
7457c478bd9Sstevel@tonic-gate 
746414388d7Ssl void
outputa(void)747414388d7Ssl outputa(void)
7487c478bd9Sstevel@tonic-gate {
749414388d7Ssl 	int i;
7507c478bd9Sstevel@tonic-gate 
7517c478bd9Sstevel@tonic-gate 	if( pflg && oflg ) printf(hdp);
7527c478bd9Sstevel@tonic-gate 	else if(pflg) printf(hdprime);
7537c478bd9Sstevel@tonic-gate 	else if(oflg) printf(hdnonprime);
7547c478bd9Sstevel@tonic-gate 	else printf(hdtot);
7557c478bd9Sstevel@tonic-gate 	if( (!pflg && !oflg) || (pflg ^ oflg)) {
7567c478bd9Sstevel@tonic-gate 		printf(hd1);
7577c478bd9Sstevel@tonic-gate 		printf(hd2);
7587c478bd9Sstevel@tonic-gate 	}
7597c478bd9Sstevel@tonic-gate 	else {
7607c478bd9Sstevel@tonic-gate 		printf(hd3);
7617c478bd9Sstevel@tonic-gate 		printf(hd4);
7627c478bd9Sstevel@tonic-gate 	}
7637c478bd9Sstevel@tonic-gate 	printf("\n");
7647c478bd9Sstevel@tonic-gate 	for (i = 0; i < csize; i++)
7657c478bd9Sstevel@tonic-gate 		pcmadd(&pcmtmp, &pcm[i]);
7667c478bd9Sstevel@tonic-gate 	CPYN(pcmtmp.pcm_comm, "TOTALS");
7677c478bd9Sstevel@tonic-gate 	print(&pcmtmp);
7687c478bd9Sstevel@tonic-gate 	printf("\n");
7697c478bd9Sstevel@tonic-gate 	for (i = 0; i < csize; i++)
7707c478bd9Sstevel@tonic-gate 		print(&pcm[i]);
7717c478bd9Sstevel@tonic-gate }
7727c478bd9Sstevel@tonic-gate 
773414388d7Ssl void
print(struct pcms * p)774414388d7Ssl print(struct pcms *p)
7757c478bd9Sstevel@tonic-gate {
7767c478bd9Sstevel@tonic-gate 	if(pflg && oflg) pprint(p);
7777c478bd9Sstevel@tonic-gate 	else if(pflg || oflg) prnt(p, pflg ? PRIME : NONPRIME);
7787c478bd9Sstevel@tonic-gate 	else totprnt(p);
7797c478bd9Sstevel@tonic-gate }
7807c478bd9Sstevel@tonic-gate 
781414388d7Ssl void
prnt(struct pcms * p,int hr)782414388d7Ssl prnt(struct pcms *p, int hr)
7837c478bd9Sstevel@tonic-gate {
7847c478bd9Sstevel@tonic-gate 	if(p->pcm_pc[hr] == 0) return;
7857c478bd9Sstevel@tonic-gate 	printf(fmtcmd, p->pcm_comm);
7867c478bd9Sstevel@tonic-gate 	printf(fmtcnt, p->pcm_pc[hr]);
7877c478bd9Sstevel@tonic-gate 	printf(fmtkcore, p->pcm_kcore[hr]);
7887c478bd9Sstevel@tonic-gate 	printf(fmtcpu, p->pcm_cpu[hr]);
7897c478bd9Sstevel@tonic-gate 	printf(fmtreal, p->pcm_real[hr]);
7907c478bd9Sstevel@tonic-gate 	if(p->pcm_cpu[hr] == 0)  p->pcm_cpu[hr] = 1;
7917c478bd9Sstevel@tonic-gate 	printf(fmtmsz, p->pcm_kcore[hr]/p->pcm_cpu[hr]);
7927c478bd9Sstevel@tonic-gate 	if(p->pcm_pc[hr] == 0)  p->pcm_pc[hr] = 1;
7937c478bd9Sstevel@tonic-gate 	printf(fmtmcpu, p->pcm_cpu[hr]/p->pcm_pc[hr]);
7947c478bd9Sstevel@tonic-gate 	if (p->pcm_real[hr] == 0)
7957c478bd9Sstevel@tonic-gate 		p->pcm_real[hr] = 1;
7967c478bd9Sstevel@tonic-gate 	printf(fmthog, p->pcm_cpu[hr]/p->pcm_real[hr]);
7977c478bd9Sstevel@tonic-gate 	printf(fmtcharx,p->pcm_io[hr]);
7987c478bd9Sstevel@tonic-gate 	printf(fmtblkx,p->pcm_rw[hr]);
7997c478bd9Sstevel@tonic-gate 	printf("\n");
8007c478bd9Sstevel@tonic-gate }
8017c478bd9Sstevel@tonic-gate 
802414388d7Ssl void
pprint(struct pcms * p)803414388d7Ssl pprint(struct pcms *p)
8047c478bd9Sstevel@tonic-gate {
8057c478bd9Sstevel@tonic-gate 	printf(fmtcmd, p->pcm_comm);
8067c478bd9Sstevel@tonic-gate 	printf(fmtcnt, p->pcm_pc[PRIME]);
8077c478bd9Sstevel@tonic-gate 	printf(fmtcnt, p->pcm_pc[NONPRIME]);
8087c478bd9Sstevel@tonic-gate 	printf(fmtkcore, TOTAL(p->pcm_kcore));
8097c478bd9Sstevel@tonic-gate 	printf(fmtcpu, p->pcm_cpu[PRIME]);
8107c478bd9Sstevel@tonic-gate 	printf(fmtcpu, p->pcm_cpu[NONPRIME]);
8117c478bd9Sstevel@tonic-gate 	printf(fmtreal, p->pcm_real[PRIME]);
8127c478bd9Sstevel@tonic-gate 	printf(fmtreal, p->pcm_real[NONPRIME]);
8137c478bd9Sstevel@tonic-gate 	if(TOTAL(p->pcm_cpu) == 0)  p->pcm_cpu[PRIME] = 1;
8147c478bd9Sstevel@tonic-gate 	printf(fmtmsz, TOTAL(p->pcm_kcore)/TOTAL(p->pcm_cpu));
8157c478bd9Sstevel@tonic-gate 	if(TOTAL(p->pcm_pc) == 0)  p->pcm_pc[PRIME] = 1;
8167c478bd9Sstevel@tonic-gate 	printf(fmtmcpu, TOTAL(p->pcm_cpu)/TOTAL(p->pcm_pc));
8177c478bd9Sstevel@tonic-gate 	if ( TOTAL(p->pcm_real) == 0)
8187c478bd9Sstevel@tonic-gate 		p->pcm_real[PRIME] = 1;
8197c478bd9Sstevel@tonic-gate 	printf(fmthog, TOTAL(p->pcm_cpu)/TOTAL(p->pcm_real));
8207c478bd9Sstevel@tonic-gate 	printf(fmtcharx,TOTAL(p->pcm_io));
8217c478bd9Sstevel@tonic-gate 	printf(fmtblkx, TOTAL(p->pcm_rw));
8227c478bd9Sstevel@tonic-gate 	printf("\n");
8237c478bd9Sstevel@tonic-gate }
8247c478bd9Sstevel@tonic-gate 
825414388d7Ssl void
totprnt(struct pcms * p)826414388d7Ssl totprnt(struct pcms *p)
8277c478bd9Sstevel@tonic-gate {
8287c478bd9Sstevel@tonic-gate 	printf(fmtcmd, p->pcm_comm);
8297c478bd9Sstevel@tonic-gate 	printf(fmtcnt, TOTAL(p->pcm_pc));
8307c478bd9Sstevel@tonic-gate 	printf(fmtkcore, TOTAL(p->pcm_kcore));
8317c478bd9Sstevel@tonic-gate 	printf(fmtcpu, TOTAL(p->pcm_cpu));
8327c478bd9Sstevel@tonic-gate 	printf(fmtreal, TOTAL(p->pcm_real));
8337c478bd9Sstevel@tonic-gate 	if(TOTAL(p->pcm_cpu) == 0)  p->pcm_cpu[PRIME] = 1;
8347c478bd9Sstevel@tonic-gate 	printf(fmtmsz, TOTAL(p->pcm_kcore)/TOTAL(p->pcm_cpu));
8357c478bd9Sstevel@tonic-gate 	if(TOTAL(p->pcm_pc) == 0)  p->pcm_pc[PRIME] = 1;
8367c478bd9Sstevel@tonic-gate 	printf(fmtmcpu, TOTAL(p->pcm_cpu)/TOTAL(p->pcm_pc));
8377c478bd9Sstevel@tonic-gate 	if (TOTAL(p->pcm_real) == 0)
8387c478bd9Sstevel@tonic-gate 		p->pcm_real[PRIME] = 1;
8397c478bd9Sstevel@tonic-gate 	printf(fmthog, TOTAL(p->pcm_cpu)/TOTAL(p->pcm_real));
8407c478bd9Sstevel@tonic-gate 	printf(fmtcharx,TOTAL(p->pcm_io));
8417c478bd9Sstevel@tonic-gate 	printf(fmtblkx,TOTAL(p->pcm_rw));
8427c478bd9Sstevel@tonic-gate 	printf("\n");
8437c478bd9Sstevel@tonic-gate }
844414388d7Ssl 
845414388d7Ssl void
outputc(void)846414388d7Ssl outputc(void)
8477c478bd9Sstevel@tonic-gate {
848414388d7Ssl 	int i;
8497c478bd9Sstevel@tonic-gate 
8507c478bd9Sstevel@tonic-gate 	for (i = 0; i < csize; i++)
8517c478bd9Sstevel@tonic-gate 		fwrite(&pcm[i], sizeof(pcm[i]), 1, stdout);
8527c478bd9Sstevel@tonic-gate }
853