Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.bin/systat/malloc.c	Lines:	0	121	0.0 %
Date:	2017-11-07	Branches:	0	60	0.0 %


/*	$OpenBSD: malloc.c,v 1.3 2015/01/16 00:03:37 deraadt Exp $	*/
/*
 * Copyright (c) 2008 Can Erkin Acar <canacar@openbsd.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/types.h>
#include <sys/signal.h>
#include <sys/sysctl.h>
#include <sys/malloc.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>

#include "systat.h"

void print_types(void);
void print_buckets(void);
int  read_types(void);
int  read_buckets(void);
void sort_types(void);
int  select_types(void);
int  select_buckets(void);
void showtype(int k);
void showbucket(int k);


/* qsort callbacks */
int sort_tname_callback(const void *s1, const void *s2);
int sort_treq_callback(const void *s1, const void *s2);
int sort_inuse_callback(const void *s1, const void *s2);
int sort_memuse_callback(const void *s1, const void *s2);

#define MAX_BUCKETS 16

struct type_info {
	const char *name;
	struct kmemstats stats;
	char buckets[MAX_BUCKETS];
};


struct type_info types[M_LAST];

struct kmembuckets buckets[MAX_BUCKETS];
int bucket_sizes[MAX_BUCKETS];

int num_types = 0;
int num_buckets = 0;

/*
 * These names are defined in <sys/malloc.h>.
 */
const char *kmemnames[] = INITKMEMNAMES;

field_def fields_malloc[] = {
	{"TYPE", 14, 32, 1, FLD_ALIGN_LEFT, -1, 0, 0, 0},
	{"INUSE", 6, 16, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
	{"MEMUSE", 6, 16, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
	{"HIGHUSE", 6, 16, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
	{"LIMIT", 6, 16, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
	{"REQUESTS", 8, 16, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
	{"TYPE LIMIT", 5, 12, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
	{"KERN LIMIT", 5, 12, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
	{"BUCKETS", MAX_BUCKETS, MAX_BUCKETS, 1, FLD_ALIGN_LEFT, -1, 0, 0, 0},

	{"BUCKET", 8, 8, 1, FLD_ALIGN_LEFT, -1, 0, 0, 0},
	{"REQUESTS", 8, 24, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
	{"INUSE", 8, 24, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
	{"FREE", 8, 24, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
	{"HIWAT", 8, 24, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
	{"COULDFREE", 8, 24, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
};


#define FLD_TYPE_NAME		FIELD_ADDR(fields_malloc,0)
#define FLD_TYPE_INUSE		FIELD_ADDR(fields_malloc,1)
#define FLD_TYPE_MEMUSE		FIELD_ADDR(fields_malloc,2)
#define FLD_TYPE_HIGHUSE	FIELD_ADDR(fields_malloc,3)
#define FLD_TYPE_LIMIT		FIELD_ADDR(fields_malloc,4)
#define FLD_TYPE_REQUESTS	FIELD_ADDR(fields_malloc,5)
#define FLD_TYPE_TLIMIT		FIELD_ADDR(fields_malloc,6)
#define FLD_TYPE_KLIMIT		FIELD_ADDR(fields_malloc,7)
#define FLD_TYPE_SIZES		FIELD_ADDR(fields_malloc,8)

#define FLD_BUCKET_SIZE		FIELD_ADDR(fields_malloc,9)
#define FLD_BUCKET_REQUESTS	FIELD_ADDR(fields_malloc,10)
#define FLD_BUCKET_INUSE	FIELD_ADDR(fields_malloc,11)
#define FLD_BUCKET_FREE		FIELD_ADDR(fields_malloc,12)
#define FLD_BUCKET_HIWAT	FIELD_ADDR(fields_malloc,13)
#define FLD_BUCKET_COULDFREE	FIELD_ADDR(fields_malloc,14)



/* Define views */
field_def *view_malloc_0[] = {
	FLD_TYPE_NAME, FLD_TYPE_INUSE, FLD_TYPE_MEMUSE,
	FLD_TYPE_HIGHUSE, FLD_TYPE_LIMIT, FLD_TYPE_REQUESTS,
	FLD_TYPE_TLIMIT, FLD_TYPE_KLIMIT, FLD_TYPE_SIZES, NULL
};

field_def *view_malloc_1[] = {
	FLD_BUCKET_SIZE, FLD_BUCKET_REQUESTS, FLD_BUCKET_INUSE,
	FLD_BUCKET_FREE, FLD_BUCKET_HIWAT, FLD_BUCKET_COULDFREE, NULL
};

order_type type_order_list[] = {
	{"name", "name", 'N', sort_tname_callback},
	{"inuse", "in use", 'U', sort_inuse_callback},
	{"memuse", "mem use", 'S', sort_memuse_callback},
	{"requests", "requests", 'Q', sort_treq_callback},
	{NULL, NULL, 0, NULL}
};

/* Define view managers */
struct view_manager types_mgr = {
	"Types", select_types, read_types, sort_types, print_header,
	print_types, keyboard_callback, type_order_list, type_order_list
};

struct view_manager buckets_mgr = {
	"Buckets", select_buckets, read_buckets, NULL, print_header,
	print_buckets, keyboard_callback, NULL, NULL
};

field_view views_malloc[] = {
	{view_malloc_0, "malloc", '6', &types_mgr},
	{view_malloc_1, "buckets", '7', &buckets_mgr},
	{NULL, NULL, 0, NULL}
};


int
sort_tname_callback(const void *s1, const void *s2)
{
	struct type_info *t1, *t2;
	t1 = (struct type_info *)s1;
	t2 = (struct type_info *)s2;

	return strcmp(t1->name, t2->name) * sortdir;
}

int
sort_treq_callback(const void *s1, const void *s2)
{
	struct type_info *t1, *t2;
	t1 = (struct type_info *)s1;
	t2 = (struct type_info *)s2;

	if (t1->stats.ks_calls <  t2->stats.ks_calls)
		return sortdir;
	if (t1->stats.ks_calls >  t2->stats.ks_calls)
		return -sortdir;

	return sort_tname_callback(s1, s2);
}

int
sort_inuse_callback(const void *s1, const void *s2)
{
	struct type_info *t1, *t2;
	t1 = (struct type_info *)s1;
	t2 = (struct type_info *)s2;

	if (t1->stats.ks_inuse <  t2->stats.ks_inuse)
		return sortdir;
	if (t1->stats.ks_inuse >  t2->stats.ks_inuse)
		return -sortdir;

	return sort_tname_callback(s1, s2);
}

int
sort_memuse_callback(const void *s1, const void *s2)
{
	struct type_info *t1, *t2;
	t1 = (struct type_info *)s1;
	t2 = (struct type_info *)s2;

	if (t1->stats.ks_memuse <  t2->stats.ks_memuse)
		return sortdir;
	if (t1->stats.ks_memuse >  t2->stats.ks_memuse)
		return -sortdir;

	return sort_tname_callback(s1, s2);
}


void
sort_types(void)
{
	order_type *ordering;

	if (curr_mgr == NULL)
		return;

	ordering = curr_mgr->order_curr;

	if (ordering == NULL)
		return;
	if (ordering->func == NULL)
		return;
	if (num_types <= 0)
		return;

	mergesort(types, num_types, sizeof(struct type_info), ordering->func);
}

int
select_types(void)
{
	num_disp = num_types;
	return (0);
}

int
select_buckets(void)
{
	num_disp = num_buckets;
	return (0);
}

int
read_buckets(void)
{
	int mib[4];
	char buf[BUFSIZ], *bufp, *ap;
	const char *errstr;
	size_t siz;

	mib[0] = CTL_KERN;
	mib[1] = KERN_MALLOCSTATS;
	mib[2] = KERN_MALLOC_BUCKETS;

	siz = sizeof(buf);
	num_buckets = 0;

	if (sysctl(mib, 3, buf, &siz, NULL, 0) < 0) {
		error("sysctl(kern.malloc.buckets): %s", strerror(errno));
		return (-1);
	}

	bufp = buf;
	mib[2] = KERN_MALLOC_BUCKET;
	siz = sizeof(struct kmembuckets);

	while ((ap = strsep(&bufp, ",")) != NULL) {
		if (num_buckets >= MAX_BUCKETS)
			break;
		bucket_sizes[num_buckets] = strtonum(ap, 0, INT_MAX, &errstr);
		if (errstr) {
			error("strtonum(%s): %s", ap, errstr);
			return (-1);
		}
		mib[3] = bucket_sizes[num_buckets];
		if (sysctl(mib, 4, &buckets[num_buckets], &siz,
			   NULL, 0) < 0) {
			error("sysctl(kern.malloc.bucket.%d): %s",
			    mib[3], strerror(errno));
			return (-1);
		}
		num_buckets++;
	}

	return (0);
}

int
read_types(void)
{
	struct type_info *ti;
	int i, j, k, mib[4];
	size_t siz;

	bzero(types, sizeof(types));
	ti = types;
	siz = sizeof(struct kmemstats);

	num_types = 0;

	for (i = 0; i < M_LAST; i++) {
		mib[0] = CTL_KERN;
		mib[1] = KERN_MALLOCSTATS;
		mib[2] = KERN_MALLOC_KMEMSTATS;
		mib[3] = i;

		/*
		 * Skip errors -- these are presumed to be unallocated
		 * entries.
		 */
		if (sysctl(mib, 4, &ti->stats, &siz, NULL, 0) < 0)
			continue;

		if (ti->stats.ks_calls == 0)
			continue;

		ti->name = kmemnames[i];
		j = 1 << MINBUCKET;

		for (k = 0; k < MAX_BUCKETS; k++, j <<= 1)
			ti->buckets[k] = (ti->stats.ks_size & j) ? '|' : '.';

		ti++;
		num_types++;
	}

	return (0);
}


void
print_types(void)
{
	int n, count = 0;

	for (n = dispstart; n < num_disp; n++) {
		showtype(n);
		count++;
		if (maxprint > 0 && count >= maxprint)
			break;	}
}

void
print_buckets(void)
{
	int n, count = 0;

	for (n = dispstart; n < num_disp; n++) {
		showbucket(n);
		count++;
		if (maxprint > 0 && count >= maxprint)
			break;
	}
}

int
initmalloc(void)
{
	field_view *v;

	for (v = views_malloc; v->name != NULL; v++)
		add_view(v);

	read_buckets();
	read_types();

	return(0);
}

void
showbucket(int k)
{
	struct kmembuckets *kp = buckets + k;

	if (k < 0 || k >= num_buckets)
		return;

	print_fld_size(FLD_BUCKET_SIZE, bucket_sizes[k]);
	print_fld_size(FLD_BUCKET_INUSE, kp->kb_total - kp->kb_totalfree);
	print_fld_size(FLD_BUCKET_FREE, kp->kb_totalfree);
	print_fld_size(FLD_BUCKET_REQUESTS, kp->kb_calls);
	print_fld_size(FLD_BUCKET_HIWAT, kp->kb_highwat);
	print_fld_size(FLD_BUCKET_COULDFREE, kp->kb_couldfree);

	end_line();
}


void
showtype(int k)
{
	struct type_info *t = types + k;

	if (k < 0 || k >= num_types)
		return;


	print_fld_str(FLD_TYPE_NAME, t->name ? t->name : "undefined");
	print_fld_size(FLD_TYPE_INUSE, t->stats.ks_inuse);
	print_fld_size(FLD_TYPE_MEMUSE, t->stats.ks_memuse);
	print_fld_size(FLD_TYPE_HIGHUSE, t->stats.ks_maxused);
	print_fld_size(FLD_TYPE_LIMIT, t->stats.ks_limit);
	print_fld_size(FLD_TYPE_REQUESTS, t->stats.ks_calls);
	print_fld_size(FLD_TYPE_TLIMIT, t->stats.ks_limblocks);
	print_fld_size(FLD_TYPE_KLIMIT, t->stats.ks_mapblocks);
	print_fld_str(FLD_TYPE_SIZES, t->buckets);

	end_line();
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: malloc.c,v 1.3 2015/01/16 00:03:37 deraadt Exp $ */
2			/*
3			* Copyright (c) 2008 Can Erkin Acar <canacar@openbsd.org>
4			*
5			* Permission to use, copy, modify, and distribute this software for any
6			* purpose with or without fee is hereby granted, provided that the above
7			* copyright notice and this permission notice appear in all copies.
8			*
9			* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10			* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11			* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12			* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13			* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14			* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15			* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16			*/
17
18			#include <sys/types.h>
19			#include <sys/signal.h>
20			#include <sys/sysctl.h>
21			#include <sys/malloc.h>
22			#include <errno.h>
23			#include <stdlib.h>
24			#include <string.h>
25			#include <limits.h>
26
27			#include "systat.h"
28
29			void print_types(void);
30			void print_buckets(void);
31			int read_types(void);
32			int read_buckets(void);
33			void sort_types(void);
34			int select_types(void);
35			int select_buckets(void);
36			void showtype(int k);
37			void showbucket(int k);
38
39
40			/* qsort callbacks */
41			int sort_tname_callback(const void s1, const void s2);
42			int sort_treq_callback(const void s1, const void s2);
43			int sort_inuse_callback(const void s1, const void s2);
44			int sort_memuse_callback(const void s1, const void s2);
45
46			#define MAX_BUCKETS 16
47
48			struct type_info {
49			const char *name;
50			struct kmemstats stats;
51			char buckets[MAX_BUCKETS];
52			};
53
54
55			struct type_info types[M_LAST];
56
57			struct kmembuckets buckets[MAX_BUCKETS];
58			int bucket_sizes[MAX_BUCKETS];
59
60			int num_types = 0;
61			int num_buckets = 0;
62
63			/*
64			* These names are defined in <sys/malloc.h>.
65			*/
66			const char *kmemnames[] = INITKMEMNAMES;
67
68			field_def fields_malloc[] = {
69			{"TYPE", 14, 32, 1, FLD_ALIGN_LEFT, -1, 0, 0, 0},
70			{"INUSE", 6, 16, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
71			{"MEMUSE", 6, 16, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
72			{"HIGHUSE", 6, 16, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
73			{"LIMIT", 6, 16, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
74			{"REQUESTS", 8, 16, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
75			{"TYPE LIMIT", 5, 12, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
76			{"KERN LIMIT", 5, 12, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
77			{"BUCKETS", MAX_BUCKETS, MAX_BUCKETS, 1, FLD_ALIGN_LEFT, -1, 0, 0, 0},
78
79			{"BUCKET", 8, 8, 1, FLD_ALIGN_LEFT, -1, 0, 0, 0},
80			{"REQUESTS", 8, 24, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
81			{"INUSE", 8, 24, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
82			{"FREE", 8, 24, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
83			{"HIWAT", 8, 24, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
84			{"COULDFREE", 8, 24, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
85			};
86
87
88			#define FLD_TYPE_NAME FIELD_ADDR(fields_malloc,0)
89			#define FLD_TYPE_INUSE FIELD_ADDR(fields_malloc,1)
90			#define FLD_TYPE_MEMUSE FIELD_ADDR(fields_malloc,2)
91			#define FLD_TYPE_HIGHUSE FIELD_ADDR(fields_malloc,3)
92			#define FLD_TYPE_LIMIT FIELD_ADDR(fields_malloc,4)
93			#define FLD_TYPE_REQUESTS FIELD_ADDR(fields_malloc,5)
94			#define FLD_TYPE_TLIMIT FIELD_ADDR(fields_malloc,6)
95			#define FLD_TYPE_KLIMIT FIELD_ADDR(fields_malloc,7)
96			#define FLD_TYPE_SIZES FIELD_ADDR(fields_malloc,8)
97
98			#define FLD_BUCKET_SIZE FIELD_ADDR(fields_malloc,9)
99			#define FLD_BUCKET_REQUESTS FIELD_ADDR(fields_malloc,10)
100			#define FLD_BUCKET_INUSE FIELD_ADDR(fields_malloc,11)
101			#define FLD_BUCKET_FREE FIELD_ADDR(fields_malloc,12)
102			#define FLD_BUCKET_HIWAT FIELD_ADDR(fields_malloc,13)
103			#define FLD_BUCKET_COULDFREE FIELD_ADDR(fields_malloc,14)
104
105
106
107			/* Define views */
108			field_def *view_malloc_0[] = {
109			FLD_TYPE_NAME, FLD_TYPE_INUSE, FLD_TYPE_MEMUSE,
110			FLD_TYPE_HIGHUSE, FLD_TYPE_LIMIT, FLD_TYPE_REQUESTS,
111			FLD_TYPE_TLIMIT, FLD_TYPE_KLIMIT, FLD_TYPE_SIZES, NULL
112			};
113
114			field_def *view_malloc_1[] = {
115			FLD_BUCKET_SIZE, FLD_BUCKET_REQUESTS, FLD_BUCKET_INUSE,
116			FLD_BUCKET_FREE, FLD_BUCKET_HIWAT, FLD_BUCKET_COULDFREE, NULL
117			};
118
119			order_type type_order_list[] = {
120			{"name", "name", 'N', sort_tname_callback},
121			{"inuse", "in use", 'U', sort_inuse_callback},
122			{"memuse", "mem use", 'S', sort_memuse_callback},
123			{"requests", "requests", 'Q', sort_treq_callback},
124			{NULL, NULL, 0, NULL}
125			};
126
127			/* Define view managers */
128			struct view_manager types_mgr = {
129			"Types", select_types, read_types, sort_types, print_header,
130			print_types, keyboard_callback, type_order_list, type_order_list
131			};
132
133			struct view_manager buckets_mgr = {
134			"Buckets", select_buckets, read_buckets, NULL, print_header,
135			print_buckets, keyboard_callback, NULL, NULL
136			};
137
138			field_view views_malloc[] = {
139			{view_malloc_0, "malloc", '6', &types_mgr},
140			{view_malloc_1, "buckets", '7', &buckets_mgr},
141			{NULL, NULL, 0, NULL}
142			};
143
144
145			int
146			sort_tname_callback(const void s1, const void s2)
147			{
148			struct type_info t1, t2;
149			t1 = (struct type_info *)s1;
150			t2 = (struct type_info *)s2;
151
152			return strcmp(t1->name, t2->name) * sortdir;
153			}
154
155			int
156			sort_treq_callback(const void s1, const void s2)
157			{
158			struct type_info t1, t2;
159			t1 = (struct type_info *)s1;
160			t2 = (struct type_info *)s2;
161
162			if (t1->stats.ks_calls < t2->stats.ks_calls)
163			return sortdir;
164			if (t1->stats.ks_calls > t2->stats.ks_calls)
165			return -sortdir;
166
167			return sort_tname_callback(s1, s2);
168			}
169
170			int
171			sort_inuse_callback(const void s1, const void s2)
172			{
173			struct type_info t1, t2;
174			t1 = (struct type_info *)s1;
175			t2 = (struct type_info *)s2;
176
177			if (t1->stats.ks_inuse < t2->stats.ks_inuse)
178			return sortdir;
179			if (t1->stats.ks_inuse > t2->stats.ks_inuse)
180			return -sortdir;
181
182			return sort_tname_callback(s1, s2);
183			}
184
185			int
186			sort_memuse_callback(const void s1, const void s2)
187			{
188			struct type_info t1, t2;
189			t1 = (struct type_info *)s1;
190			t2 = (struct type_info *)s2;
191
192			if (t1->stats.ks_memuse < t2->stats.ks_memuse)
193			return sortdir;
194			if (t1->stats.ks_memuse > t2->stats.ks_memuse)
195			return -sortdir;
196
197			return sort_tname_callback(s1, s2);
198			}
199
200
201			void
202			sort_types(void)
203			{
204			order_type *ordering;
205
206			if (curr_mgr == NULL)
207			return;
208
209			ordering = curr_mgr->order_curr;
210
211			if (ordering == NULL)
212			return;
213			if (ordering->func == NULL)
214			return;
215			if (num_types <= 0)
216			return;
217
218			mergesort(types, num_types, sizeof(struct type_info), ordering->func);
219			}
220
221			int
222			select_types(void)
223			{
224			num_disp = num_types;
225			return (0);
226			}
227
228			int
229			select_buckets(void)
230			{
231			num_disp = num_buckets;
232			return (0);
233			}
234
235			int
236			read_buckets(void)
237			{
238			int mib[4];
239			char buf[BUFSIZ], bufp, ap;
240			const char *errstr;
241			size_t siz;
242
243			mib[0] = CTL_KERN;
244			mib[1] = KERN_MALLOCSTATS;
245			mib[2] = KERN_MALLOC_BUCKETS;
246
247			siz = sizeof(buf);
248			num_buckets = 0;
249
250			if (sysctl(mib, 3, buf, &siz, NULL, 0) < 0) {
251			error("sysctl(kern.malloc.buckets): %s", strerror(errno));
252			return (-1);
253			}
254
255			bufp = buf;
256			mib[2] = KERN_MALLOC_BUCKET;
257			siz = sizeof(struct kmembuckets);
258
259			while ((ap = strsep(&bufp, ",")) != NULL) {
260			if (num_buckets >= MAX_BUCKETS)
261			break;
262			bucket_sizes[num_buckets] = strtonum(ap, 0, INT_MAX, &errstr);
263			if (errstr) {
264			error("strtonum(%s): %s", ap, errstr);
265			return (-1);
266			}
267			mib[3] = bucket_sizes[num_buckets];
268			if (sysctl(mib, 4, &buckets[num_buckets], &siz,
269			NULL, 0) < 0) {
270			error("sysctl(kern.malloc.bucket.%d): %s",
271			mib[3], strerror(errno));
272			return (-1);
273			}
274			num_buckets++;
275			}
276
277			return (0);
278			}
279
280			int
281			read_types(void)
282			{
283			struct type_info *ti;
284			int i, j, k, mib[4];
285			size_t siz;
286
287			bzero(types, sizeof(types));
288			ti = types;
289			siz = sizeof(struct kmemstats);
290
291			num_types = 0;
292
293			for (i = 0; i < M_LAST; i++) {
294			mib[0] = CTL_KERN;
295			mib[1] = KERN_MALLOCSTATS;
296			mib[2] = KERN_MALLOC_KMEMSTATS;
297			mib[3] = i;
298
299			/*
300			* Skip errors -- these are presumed to be unallocated
301			* entries.
302			*/
303			if (sysctl(mib, 4, &ti->stats, &siz, NULL, 0) < 0)
304			continue;
305
306			if (ti->stats.ks_calls == 0)
307			continue;
308
309			ti->name = kmemnames[i];
310			j = 1 << MINBUCKET;
311
312			for (k = 0; k < MAX_BUCKETS; k++, j <<= 1)
313			ti->buckets[k] = (ti->stats.ks_size & j) ? '\|' : '.';
314
315			ti++;
316			num_types++;
317			}
318
319			return (0);
320			}
321
322
323			void
324			print_types(void)
325			{
326			int n, count = 0;
327
328			for (n = dispstart; n < num_disp; n++) {
329			showtype(n);
330			count++;
331			if (maxprint > 0 && count >= maxprint)
332			break; }
333			}
334
335			void
336			print_buckets(void)
337			{
338			int n, count = 0;
339
340			for (n = dispstart; n < num_disp; n++) {
341			showbucket(n);
342			count++;
343			if (maxprint > 0 && count >= maxprint)
344			break;
345			}
346			}
347
348			int
349			initmalloc(void)
350			{
351			field_view *v;
352
353			for (v = views_malloc; v->name != NULL; v++)
354			add_view(v);
355
356			read_buckets();
357			read_types();
358
359			return(0);
360			}
361
362			void
363			showbucket(int k)
364			{
365			struct kmembuckets *kp = buckets + k;
366
367			if (k < 0 \|\| k >= num_buckets)
368			return;
369
370			print_fld_size(FLD_BUCKET_SIZE, bucket_sizes[k]);
371			print_fld_size(FLD_BUCKET_INUSE, kp->kb_total - kp->kb_totalfree);
372			print_fld_size(FLD_BUCKET_FREE, kp->kb_totalfree);
373			print_fld_size(FLD_BUCKET_REQUESTS, kp->kb_calls);
374			print_fld_size(FLD_BUCKET_HIWAT, kp->kb_highwat);
375			print_fld_size(FLD_BUCKET_COULDFREE, kp->kb_couldfree);
376
377			end_line();
378			}
379
380
381			void
382			showtype(int k)
383			{
384			struct type_info *t = types + k;
385
386			if (k < 0 \|\| k >= num_types)
387			return;
388
389
390			print_fld_str(FLD_TYPE_NAME, t->name ? t->name : "undefined");
391			print_fld_size(FLD_TYPE_INUSE, t->stats.ks_inuse);
392			print_fld_size(FLD_TYPE_MEMUSE, t->stats.ks_memuse);
393			print_fld_size(FLD_TYPE_HIGHUSE, t->stats.ks_maxused);
394			print_fld_size(FLD_TYPE_LIMIT, t->stats.ks_limit);
395			print_fld_size(FLD_TYPE_REQUESTS, t->stats.ks_calls);
396			print_fld_size(FLD_TYPE_TLIMIT, t->stats.ks_limblocks);
397			print_fld_size(FLD_TYPE_KLIMIT, t->stats.ks_mapblocks);
398			print_fld_str(FLD_TYPE_SIZES, t->buckets);
399
400			end_line();
401			}