[apple/system_cmds.git] / zprint.tproj / zprint.c

/*
 * @OSF_COPYRIGHT@
 */
/* 
 * Mach Operating System
 * Copyright (c) 1991,1990,1989 Carnegie Mellon University
 * All Rights Reserved.
 * 
 * Permission to use, copy, modify and distribute this software and its
 * documentation is hereby granted, provided that both the copyright
 * notice and this permission notice appear in all copies of the
 * software, derivative works or modified versions, and any portions
 * thereof, and that both notices appear in supporting documentation.
 * 
 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS 
 * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
 * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
 * 
 * Carnegie Mellon requests users of this software to return to
 * 
 *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
 *  School of Computer Science
 *  Carnegie Mellon University
 *  Pittsburgh PA 15213-3890
 * 
 * any improvements or extensions that they make and grant Carnegie the
 * rights to redistribute these changes.
 */
/*
 *	zprint.c
 *
 *	utility for printing out zone structures
 *
 *	With no arguments, prints information on all zone structures.
 *	With an argument, prints information only on those zones for
 *	which the given name is a substring of the zone's name.
 *	With a "-w" flag, calculates how much much space is allocated
 *	to zones but not currently in use.
 */

#include <stdio.h>
#include <string.h>
#include <mach/mach.h>
#include <mach_debug/mach_debug.h>
#include <mach/mach_error.h>

#define streql(a, b)		(strcmp((a), (b)) == 0)
#define strneql(a, b, n)	(strncmp((a), (b), (n)) == 0)

static void printzone();
static void colprintzone();
static void colprintzoneheader();
static void printk();
static int strnlen();
static boolean_t substr();

static char *program;

static boolean_t ShowWasted = FALSE;
static boolean_t SortZones = FALSE;
static boolean_t ColFormat = TRUE;
static boolean_t PrintHeader = TRUE;

static unsigned int totalsize = 0;
static unsigned int totalused = 0;

static void
usage()
{
	fprintf(stderr, "usage: %s [-w] [-s] [-c] [-h] [name]\n", program);
	exit(1);
}

main(argc, argv)
	int	argc;
	char	*argv[];
{
	zone_name_t name_buf[1024];
	zone_name_t *name = name_buf;
	unsigned int nameCnt = sizeof name_buf/sizeof name_buf[0];
	zone_info_t info_buf[1024];
	zone_info_t *info = info_buf;
	unsigned int infoCnt = sizeof info_buf/sizeof info_buf[0];

	char		*zname = NULL;
	int		znamelen;

	kern_return_t	kr;
	int		i, j;

	program = strrchr(argv[0], '/');
	if (program == NULL)
		program = argv[0];
	else
		program++;

	for (i = 1; i < argc; i++) {
		if (streql(argv[i], "-w"))
			ShowWasted = TRUE;
		else if (streql(argv[i], "-W"))
			ShowWasted = FALSE;
		else if (streql(argv[i], "-s"))
			SortZones = TRUE;
		else if (streql(argv[i], "-S"))
			SortZones = FALSE;
		else if (streql(argv[i], "-c"))
			ColFormat = TRUE;
		else if (streql(argv[i], "-C"))
			ColFormat = FALSE;
		else if (streql(argv[i], "-H"))
			PrintHeader = FALSE;
		else if (streql(argv[i], "--")) {
			i++;
			break;
		} else if (argv[i][0] == '-')
			usage();
		else
			break;
	}

	switch (argc - i) {
	    case 0:
		zname = "";
		znamelen = 0;
		break;

	    case 1:
		zname = argv[i];
		znamelen = strlen(zname);
		break;

	    default:
		usage();
	}

	kr = host_zone_info(mach_host_self(),
			    &name, &nameCnt, &info, &infoCnt);
	if (kr != KERN_SUCCESS) {
		fprintf(stderr, "%s: host_zone_info: %s\n",
		     program, mach_error_string(kr));
		exit(1);
	}
	else if (nameCnt != infoCnt) {
		fprintf(stderr, "%s: host_zone_info: counts not equal?\n",
			program);
		exit(1);
	}

	if (SortZones) {
		for (i = 0; i < nameCnt-1; i++)
			for (j = i+1; j < nameCnt; j++) {
				int wastei, wastej;

				wastei = (info[i].zi_cur_size -
					  (info[i].zi_elem_size *
					   info[i].zi_count));
				wastej = (info[j].zi_cur_size -
					  (info[j].zi_elem_size *
					   info[j].zi_count));

				if (wastej > wastei) {
					zone_info_t tinfo;
					zone_name_t tname;

					tinfo = info[i];
					info[i] = info[j];
					info[j] = tinfo;

					tname = name[i];
					name[i] = name[j];
					name[j] = tname;
				}
			}
	}

	if (ColFormat) {
		colprintzoneheader();
	}
	for (i = 0; i < nameCnt; i++)
		if (substr(zname, znamelen, name[i].zn_name,
			   strnlen(name[i].zn_name, sizeof name[i].zn_name)))
		    	if (ColFormat)
				colprintzone(&name[i], &info[i]);
			else
				printzone(&name[i], &info[i]);

	if ((name != name_buf) && (nameCnt != 0)) {
		kr = vm_deallocate(mach_task_self(), (vm_address_t) name,
				   (vm_size_t) (nameCnt * sizeof *name));
		if (kr != KERN_SUCCESS) {
			fprintf(stderr, "%s: vm_deallocate: %s\n",
			     program, mach_error_string(kr));
			exit(1);
		}
	}

	if ((info != info_buf) && (infoCnt != 0)) {
		kr = vm_deallocate(mach_task_self(), (vm_address_t) info,
				   (vm_size_t) (infoCnt * sizeof *info));
		if (kr != KERN_SUCCESS) {
			fprintf(stderr, "%s: vm_deallocate: %s\n",
			     program, mach_error_string(kr));
			exit(1);
		}
	}

	if (ShowWasted && PrintHeader) {
		printf("TOTAL SIZE   = %u\n", totalsize);
		printf("TOTAL USED   = %u\n", totalused);
		printf("TOTAL WASTED = %d\n", totalsize - totalused);
	}

	exit(0);
}

static int
strnlen(s, n)
	char *s;
	int n;
{
	int len = 0;

	while ((len < n) && (*s++ != '\0'))
		len++;

	return len;
}

static boolean_t
substr(a, alen, b, blen)
	char *a;
	int alen;
	char *b;
	int blen;
{
	int i;

	for (i = 0; i <= blen - alen; i++)
		if (strneql(a, b+i, alen))
			return TRUE;

	return FALSE;
}

static void
printzone(name, info)
	zone_name_t *name;
	zone_info_t *info;
{
	unsigned int used, size;

	printf("%.*s zone:\n", sizeof name->zn_name, name->zn_name);
	printf("\tcur_size:    %dK bytes (%d elements)\n",
	       info->zi_cur_size/1024,
	       info->zi_cur_size/info->zi_elem_size);
	printf("\tmax_size:    %dK bytes (%d elements)\n",
	       info->zi_max_size/1024,
	       info->zi_max_size/info->zi_elem_size);
	printf("\telem_size:   %d bytes\n",
	       info->zi_elem_size);
	printf("\t# of elems:  %d\n",
	       info->zi_count);
	printf("\talloc_size:  %dK bytes (%d elements)\n",
	       info->zi_alloc_size/1024,
	       info->zi_alloc_size/info->zi_elem_size);
	if (info->zi_pageable)
		printf("\tPAGEABLE\n");
	if (info->zi_collectable)
		printf("\tCOLLECTABLE\n");

	if (ShowWasted) {
		totalused += used = info->zi_elem_size * info->zi_count;
		totalsize += size = info->zi_cur_size;
		printf("\t\t\t\t\tWASTED: %d\n", size - used);
	}
}

static void
printk(fmt, i)
	char *fmt;
	int i;
{
	printf(fmt, i / 1024);
	putchar('K');
}

static void
colprintzone(zone_name, info)
	zone_name_t *zone_name;
	zone_info_t *info;
{
	char *name = zone_name->zn_name;
	int j, namewidth, retval;
	unsigned int used, size;

	namewidth = 25;
	if (ShowWasted) {
		namewidth -= 7;
	}
	for (j = 0; j < namewidth - 1 && name[j]; j++) {
		if (name[j] == ' ') {
			putchar('.');
		} else {
			putchar(name[j]);
		}
	}
	if (j == namewidth - 1) {
		if (name[j]) {
			putchar('$');
		} else {
			putchar(' ');
		}
	} else {
		for (; j < namewidth; j++) {
			putchar(' ');
		}
	}
	printf("%5d", info->zi_elem_size);
	printk("%6d", info->zi_cur_size);
	if (info->zi_max_size >= 99999 * 1024) {
		printf("   ----");
	} else {
		printk("%6d", info->zi_max_size);
	}
	printf("%7d", info->zi_cur_size / info->zi_elem_size);
	if (info->zi_max_size >= 99999 * 1024) {
		printf("   ----");
	} else {
		printf("%7d", info->zi_max_size / info->zi_elem_size);
	}
	printf("%6d", info->zi_count);
	printk("%5d", info->zi_alloc_size);
	printf("%6d", info->zi_alloc_size / info->zi_elem_size);

	totalused += used = info->zi_elem_size * info->zi_count;
	totalsize += size = info->zi_cur_size;
	if (ShowWasted) {
		printf("%7d", size - used);
	}

	printf("%c%c\n",
	       (info->zi_pageable ? 'P' : ' '),
	       (info->zi_collectable ? 'C' : ' '));
}

static void
colprintzoneheader()
{
	if (! PrintHeader) {
		return;
	}
	if (ShowWasted) {
		printf("                   elem    cur    max    cur    max%s",
		       "   cur alloc alloc\n");
		printf("zone name          size   size   size  #elts  #elts%s",
		       " inuse  size count wasted\n");
	} else {
		printf("                          elem    cur    max    cur%s",
		       "    max   cur alloc alloc\n");
		printf("zone name                 size   size   size  #elts%s",
		       "  #elts inuse  size count\n");
	}
	printf("-----------------------------------------------%s",
	       "--------------------------------\n");
}
Commit	Line	Data
1815bff5 A	1	/*
	2	* @OSF_COPYRIGHT@
	3	*/
	4	/*
	5	* Mach Operating System
	6	* Copyright (c) 1991,1990,1989 Carnegie Mellon University
	7	* All Rights Reserved.
	8	*
	9	* Permission to use, copy, modify and distribute this software and its
	10	* documentation is hereby granted, provided that both the copyright
	11	* notice and this permission notice appear in all copies of the
	12	* software, derivative works or modified versions, and any portions
	13	* thereof, and that both notices appear in supporting documentation.
	14	*
	15	* CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS
	16	* CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
	17	* ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
	18	*
	19	* Carnegie Mellon requests users of this software to return to
	20	*
	21	* Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
	22	* School of Computer Science
	23	* Carnegie Mellon University
	24	* Pittsburgh PA 15213-3890
	25	*
	26	* any improvements or extensions that they make and grant Carnegie the
	27	* rights to redistribute these changes.
	28	*/
	29	/*
	30	* zprint.c
	31	*
	32	* utility for printing out zone structures
	33	*
	34	* With no arguments, prints information on all zone structures.
	35	* With an argument, prints information only on those zones for
	36	* which the given name is a substring of the zone's name.
	37	* With a "-w" flag, calculates how much much space is allocated
	38	* to zones but not currently in use.
	39	*/
	40
	41	#include <stdio.h>
	42	#include <string.h>
	43	#include <mach/mach.h>
	44	#include <mach_debug/mach_debug.h>
	45	#include <mach/mach_error.h>
	46
	47	#define streql(a, b) (strcmp((a), (b)) == 0)
	48	#define strneql(a, b, n) (strncmp((a), (b), (n)) == 0)
	49
	50	static void printzone();
	51	static void colprintzone();
	52	static void colprintzoneheader();
	53	static void printk();
	54	static int strnlen();
	55	static boolean_t substr();
	56
	57	static char *program;
	58
	59	static boolean_t ShowWasted = FALSE;
	60	static boolean_t SortZones = FALSE;
	61	static boolean_t ColFormat = TRUE;
	62	static boolean_t PrintHeader = TRUE;
	63
	64	static unsigned int totalsize = 0;
65	static unsigned int totalused = 0;
66
67	static void
68	usage()
69	{
70	fprintf(stderr, "usage: %s [-w] [-s] [-c] [-h] [name]\n", program);
71	exit(1);
72	}
73
74	main(argc, argv)
75	int argc;
76	char *argv[];
77	{
78	zone_name_t name_buf[1024];
79	zone_name_t *name = name_buf;
80	unsigned int nameCnt = sizeof name_buf/sizeof name_buf[0];
81	zone_info_t info_buf[1024];
82	zone_info_t *info = info_buf;
83	unsigned int infoCnt = sizeof info_buf/sizeof info_buf[0];
84
85	char *zname = NULL;
86	int znamelen;
87
88	kern_return_t kr;
89	int i, j;
90
91	program = strrchr(argv[0], '/');
92	if (program == NULL)
93	program = argv[0];
94	else
95	program++;
96
97	for (i = 1; i < argc; i++) {
98	if (streql(argv[i], "-w"))
99	ShowWasted = TRUE;
100	else if (streql(argv[i], "-W"))
101	ShowWasted = FALSE;
102	else if (streql(argv[i], "-s"))
103	SortZones = TRUE;
104	else if (streql(argv[i], "-S"))
105	SortZones = FALSE;
106	else if (streql(argv[i], "-c"))
107	ColFormat = TRUE;
108	else if (streql(argv[i], "-C"))
109	ColFormat = FALSE;
110	else if (streql(argv[i], "-H"))
111	PrintHeader = FALSE;
112	else if (streql(argv[i], "--")) {
113	i++;
114	break;
115	} else if (argv[i][0] == '-')
116	usage();
117	else
118	break;
119	}
120
121	switch (argc - i) {
122	case 0:
123	zname = "";
124	znamelen = 0;
125	break;
126
127	case 1:
128	zname = argv[i];
129	znamelen = strlen(zname);
130	break;
131
132	default:
133	usage();
134	}
135
136	kr = host_zone_info(mach_host_self(),
137	&name, &nameCnt, &info, &infoCnt);
138	if (kr != KERN_SUCCESS) {
139	fprintf(stderr, "%s: host_zone_info: %s\n",
140	program, mach_error_string(kr));
141	exit(1);
142	}
143	else if (nameCnt != infoCnt) {
144	fprintf(stderr, "%s: host_zone_info: counts not equal?\n",
145	program);
146	exit(1);
147	}
148
149	if (SortZones) {
150	for (i = 0; i < nameCnt-1; i++)
151	for (j = i+1; j < nameCnt; j++) {
152	int wastei, wastej;
153
154	wastei = (info[i].zi_cur_size -
155	(info[i].zi_elem_size *
156	info[i].zi_count));
157	wastej = (info[j].zi_cur_size -
158	(info[j].zi_elem_size *
159	info[j].zi_count));
160
161	if (wastej > wastei) {
162	zone_info_t tinfo;
163	zone_name_t tname;
164
165	tinfo = info[i];
166	info[i] = info[j];
167	info[j] = tinfo;
168
169	tname = name[i];
170	name[i] = name[j];
171	name[j] = tname;
172	}
173	}
174	}
175
176	if (ColFormat) {
177	colprintzoneheader();
178	}
179	for (i = 0; i < nameCnt; i++)
180	if (substr(zname, znamelen, name[i].zn_name,
181	strnlen(name[i].zn_name, sizeof name[i].zn_name)))
182	if (ColFormat)
183	colprintzone(&name[i], &info[i]);
184	else
185	printzone(&name[i], &info[i]);
186
187	if ((name != name_buf) && (nameCnt != 0)) {
188	kr = vm_deallocate(mach_task_self(), (vm_address_t) name,
189	(vm_size_t) (nameCnt * sizeof *name));
190	if (kr != KERN_SUCCESS) {
191	fprintf(stderr, "%s: vm_deallocate: %s\n",
192	program, mach_error_string(kr));
193	exit(1);
194	}
195	}
196
197	if ((info != info_buf) && (infoCnt != 0)) {
198	kr = vm_deallocate(mach_task_self(), (vm_address_t) info,
199	(vm_size_t) (infoCnt * sizeof *info));
200	if (kr != KERN_SUCCESS) {
201	fprintf(stderr, "%s: vm_deallocate: %s\n",
202	program, mach_error_string(kr));
203	exit(1);
204	}
205	}
206
207	if (ShowWasted && PrintHeader) {
208	printf("TOTAL SIZE = %u\n", totalsize);
209	printf("TOTAL USED = %u\n", totalused);
210	printf("TOTAL WASTED = %d\n", totalsize - totalused);
211	}
212
213	exit(0);
214	}
215
216	static int
217	strnlen(s, n)
218	char *s;
219	int n;
220	{
221	int len = 0;
222
223	while ((len < n) && (*s++ != '\0'))
224	len++;
225
226	return len;
227	}
228
229	static boolean_t
230	substr(a, alen, b, blen)
231	char *a;
232	int alen;
233	char *b;
234	int blen;
235	{
236	int i;
237
238	for (i = 0; i <= blen - alen; i++)
239	if (strneql(a, b+i, alen))
240	return TRUE;
241
242	return FALSE;
243	}
244
245	static void
246	printzone(name, info)
247	zone_name_t *name;
248	zone_info_t *info;
249	{
250	unsigned int used, size;
251
252	printf("%.*s zone:\n", sizeof name->zn_name, name->zn_name);
253	printf("\tcur_size: %dK bytes (%d elements)\n",
254	info->zi_cur_size/1024,
255	info->zi_cur_size/info->zi_elem_size);
256	printf("\tmax_size: %dK bytes (%d elements)\n",
257	info->zi_max_size/1024,
258	info->zi_max_size/info->zi_elem_size);
259	printf("\telem_size: %d bytes\n",
260	info->zi_elem_size);
261	printf("\t# of elems: %d\n",
262	info->zi_count);
263	printf("\talloc_size: %dK bytes (%d elements)\n",
264	info->zi_alloc_size/1024,
265	info->zi_alloc_size/info->zi_elem_size);
266	if (info->zi_pageable)
267	printf("\tPAGEABLE\n");
268	if (info->zi_collectable)
269	printf("\tCOLLECTABLE\n");
270
271	if (ShowWasted) {
272	totalused += used = info->zi_elem_size * info->zi_count;
273	totalsize += size = info->zi_cur_size;
274	printf("\t\t\t\t\tWASTED: %d\n", size - used);
275	}
276	}
277
278	static void
279	printk(fmt, i)
280	char *fmt;
281	int i;
282	{
283	printf(fmt, i / 1024);
284	putchar('K');
285	}
286
287	static void
288	colprintzone(zone_name, info)
289	zone_name_t *zone_name;
290	zone_info_t *info;
291	{
292	char *name = zone_name->zn_name;
293	int j, namewidth, retval;
294	unsigned int used, size;
295
296	namewidth = 25;
297	if (ShowWasted) {
298	namewidth -= 7;
299	}
300	for (j = 0; j < namewidth - 1 && name[j]; j++) {
301	if (name[j] == ' ') {
302	putchar('.');
303	} else {
304	putchar(name[j]);
305	}
306	}
307	if (j == namewidth - 1) {
308	if (name[j]) {
309	putchar('$');
310	} else {
311	putchar(' ');
312	}
313	} else {
314	for (; j < namewidth; j++) {
315	putchar(' ');
316	}
317	}
318	printf("%5d", info->zi_elem_size);
319	printk("%6d", info->zi_cur_size);
320	if (info->zi_max_size >= 99999 * 1024) {
321	printf(" ----");
322	} else {
323	printk("%6d", info->zi_max_size);
324	}
325	printf("%7d", info->zi_cur_size / info->zi_elem_size);
326	if (info->zi_max_size >= 99999 * 1024) {
327	printf(" ----");
328	} else {
329	printf("%7d", info->zi_max_size / info->zi_elem_size);
330	}
331	printf("%6d", info->zi_count);
332	printk("%5d", info->zi_alloc_size);
333	printf("%6d", info->zi_alloc_size / info->zi_elem_size);
334
335	totalused += used = info->zi_elem_size * info->zi_count;
336	totalsize += size = info->zi_cur_size;
337	if (ShowWasted) {
338	printf("%7d", size - used);
339	}
340
341	printf("%c%c\n",
342	(info->zi_pageable ? 'P' : ' '),
343	(info->zi_collectable ? 'C' : ' '));
344	}
345
346	static void
347	colprintzoneheader()
348	{
349	if (! PrintHeader) {
350	return;
351	}
352	if (ShowWasted) {
353	printf(" elem cur max cur max%s",
354	" cur alloc alloc\n");
355	printf("zone name size size size #elts #elts%s",
356	" inuse size count wasted\n");
357	} else {
358	printf(" elem cur max cur%s",
359	" max cur alloc alloc\n");
360	printf("zone name size size size #elts%s",
361	" #elts inuse size count\n");
362	}
363	printf("-----------------------------------------------%s",
364	"--------------------------------\n");
365	}