Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.bin/systat/mbufs.c	Lines:	0	177	0.0 %
Date:	2017-11-07	Branches:	0	114	0.0 %


/*	$OpenBSD: mbufs.c,v 1.41 2016/04/04 16:26:00 sthen 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/signal.h>
#include <sys/socket.h>
#include <sys/sysctl.h>
#include <sys/queue.h>
#include <sys/mbuf.h>
#include <sys/pool.h>
#include <net/if.h>
#include <sys/sockio.h>
#include <sys/ioctl.h>

#include <err.h>
#include <errno.h>
#include <ifaddrs.h>
#include <stdlib.h>
#include <string.h>

#include "systat.h"

/* pool info */
int mbpool_index = -1;
int mclpools_index[MCLPOOLS];
int mclpool_count = 0;
struct kinfo_pool mbpool;
u_int mcllivelocks, mcllivelocks_cur, mcllivelocks_diff;

/* interfaces */
static int num_ifs = 0;
struct if_info {
	char name[16];
	struct if_rxrinfo data;
} *interfaces = NULL;

static int sock;

void print_mb(void);
int read_mb(void);
int select_mb(void);
static void showmbuf(struct if_info *, int, int);

/* Define fields */
field_def fields_mbuf[] = {
	{"IFACE", 8, 16, 1, FLD_ALIGN_LEFT, -1, 0, 0, 0},
	{"RXDELAY", 5, 8, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
	{"TXDELAY", 5, 8, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
	{"LIVELOCKS", 5, 10, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
	{"SIZE", 3, 5, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
	{"ALIVE", 3, 5, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
	{"LWM", 3, 5, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
	{"HWM", 3, 5, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
	{"CWM", 3, 5, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
};


#define FLD_MB_IFACE	FIELD_ADDR(fields_mbuf,0)
#define FLD_MB_RXDELAY	FIELD_ADDR(fields_mbuf,1)
#define FLD_MB_TXDELAY	FIELD_ADDR(fields_mbuf,2)
#define FLD_MB_LLOCKS	FIELD_ADDR(fields_mbuf,3)
#define FLD_MB_MSIZE	FIELD_ADDR(fields_mbuf,4)
#define FLD_MB_MALIVE	FIELD_ADDR(fields_mbuf,5)
#define FLD_MB_MLWM	FIELD_ADDR(fields_mbuf,6)
#define FLD_MB_MHWM	FIELD_ADDR(fields_mbuf,7)
#define FLD_MB_MCWM	FIELD_ADDR(fields_mbuf,8)


/* Define views */
field_def *view_mbuf[] = {
	FLD_MB_IFACE,
	FLD_MB_LLOCKS, FLD_MB_MSIZE, FLD_MB_MALIVE, FLD_MB_MLWM, FLD_MB_MHWM,
	FLD_MB_MCWM, NULL
};

/* Define view managers */

struct view_manager mbuf_mgr = {
	"Mbufs", select_mb, read_mb, NULL, print_header,
	print_mb, keyboard_callback, NULL, NULL
};

field_view views_mb[] = {
	{view_mbuf, "mbufs", '4', &mbuf_mgr},
	{NULL, NULL, 0, NULL}
};


int
initmembufs(void)
{
	struct if_rxring_info *ifr;
	field_view *v;
	int i, mib[4], npools;
	struct kinfo_pool pool;
	char pname[32];
	size_t size;

	sock = socket(AF_INET, SOCK_DGRAM, 0);
	if (sock == -1) {
		err(1, "socket()");
		/* NOTREACHED */
	}

	/* set up the "System" interface */

	interfaces = calloc(1, sizeof(*interfaces));
	if (interfaces == NULL)
		err(1, "calloc: interfaces");

	ifr = calloc(MCLPOOLS, sizeof(*ifr));
	if (ifr == NULL)
		err(1, "calloc: system pools");

	strlcpy(interfaces[0].name, "System", sizeof(interfaces[0].name));
	interfaces[0].data.ifri_total = MCLPOOLS;
	interfaces[0].data.ifri_entries = ifr;
	num_ifs = 1;

	/* go through all pools to identify mbuf and cluster pools */

	mib[0] = CTL_KERN;
	mib[1] = KERN_POOL;
	mib[2] = KERN_POOL_NPOOLS;
	size = sizeof(npools);

	if (sysctl(mib, 3, &npools, &size, NULL, 0) < 0) {
		err(1, "sysctl(KERN_POOL_NPOOLS)");
		/* NOTREACHED */
	}

	for (i = 1; i <= npools; i++) {
		mib[0] = CTL_KERN;
		mib[1] = KERN_POOL;
		mib[2] = KERN_POOL_NAME;
		mib[3] = i;
		size = sizeof(pname);
		if (sysctl(mib, 4, &pname, &size, NULL, 0) < 0) {
			continue;
		}

		if (strcmp(pname, "mbufpl") == 0) {
			mbpool_index = i;
			continue;
		}

		if (strncmp(pname, "mcl", 3) != 0)
			continue;

		if (mclpool_count == MCLPOOLS) {
			warnx("mbufs: Too many mcl* pools");
			break;
		}

		mib[2] = KERN_POOL_POOL;
		size = sizeof(pool);

		if (sysctl(mib, 4, &pool, &size, NULL, 0) < 0) {
			err(1, "sysctl(KERN_POOL_POOL, %d)", i);
			/* NOTREACHED */
		}

		snprintf(ifr[mclpool_count].ifr_name,
		    sizeof(ifr[mclpool_count].ifr_name), "%dk",
		    pool.pr_size / 1024);
		ifr[mclpool_count].ifr_size = pool.pr_size;

		mclpools_index[mclpool_count++] = i;
	}

	if (mclpool_count != MCLPOOLS)
		warnx("mbufs: Unable to read all %d mcl* pools", MCLPOOLS);

	/* add view to the engine */
	for (v = views_mb; v->name != NULL; v++)
		add_view(v);

	/* finally read it once */
	read_mb();

	return(1);
}

int
select_mb(void)
{
	num_disp = 0;
	return (0);
}

int
read_mb(void)
{
	struct kinfo_pool pool;
	struct ifaddrs *ifap = NULL, *ifa;
	struct if_info *ifi;
	struct if_rxring_info *ifr;
	int mib[4];
	int i, p, nif, ret = 1, rv;
	u_int rings;
	size_t size;

	mib[0] = CTL_KERN;
	mib[1] = KERN_NETLIVELOCKS;
	size = sizeof(mcllivelocks_cur);
	if (sysctl(mib, 2, &mcllivelocks_cur, &size, NULL, 0) < 0 &&
	    errno != EOPNOTSUPP) {
		error("sysctl(KERN_NETLIVELOCKS)");
		goto exit;
	}
	mcllivelocks_diff = mcllivelocks_cur - mcllivelocks;
	mcllivelocks = mcllivelocks_cur;

	num_disp = 0;
	if (getifaddrs(&ifap)) {
		error("getifaddrs: %s", strerror(errno));
		return (1);
	}

	nif = 1;
	for (ifa = ifap; ifa != NULL; ifa = ifa->ifa_next) {
		if (ifa->ifa_addr == NULL ||
		    ifa->ifa_addr->sa_family != AF_LINK)
			continue;

		nif++;
	}

	if (num_ifs < nif) {
		ifi = reallocarray(interfaces, nif, sizeof(*interfaces));
		if (ifi == NULL) {
			error("reallocarray: %d interfaces", nif);
			goto exit;
		}

		interfaces = ifi;
		while (num_ifs < nif)
			memset(&interfaces[num_ifs++], 0, sizeof(*interfaces));
	}

	/* Fill in the "real" interfaces */
	ifi = interfaces + 1;

	for (ifa = ifap; ifa != NULL; ifa = ifa->ifa_next) {
		if (ifa->ifa_addr == NULL ||
		    ifa->ifa_addr->sa_family != AF_LINK)
			continue;

		strlcpy(ifi->name, ifa->ifa_name, sizeof(ifi->name));
		for (;;) {
			struct ifreq ifreq;
			rings = ifi->data.ifri_total;

			memset(&ifreq, 0, sizeof(ifreq));
			strlcpy(ifreq.ifr_name, ifa->ifa_name,
			    sizeof(ifreq.ifr_name));
			ifreq.ifr_data = (caddr_t)&ifi->data;

			rv = ioctl(sock, SIOCGIFRXR, &ifreq);
			if (rv == -1) {
				if (errno == ENOTTY) {
					free(ifi->data.ifri_entries);
					ifi->data.ifri_total = 0;
					ifi->data.ifri_entries = NULL;
					break;
				}

				error("ioctl(SIOCGIFRXR) %s", strerror(errno));
				break;
			}

			if (rings >= ifi->data.ifri_total)
				break;

			ifr = reallocarray(ifi->data.ifri_entries,
			    ifi->data.ifri_total, sizeof(*ifr));
			if (ifr == NULL) {
				ifi->data.ifri_total = rings;
				error("reallocarray: %u rings",
				    ifi->data.ifri_total);
				goto exit;
			}

			ifi->data.ifri_entries = ifr;
		}

		ifi++;
	}

	/* Fill in the "System" entry from pools */

	mib[0] = CTL_KERN;
	mib[1] = KERN_POOL;
	mib[2] = KERN_POOL_POOL;
	mib[3] = mbpool_index;
	size = sizeof(mbpool);

	if (sysctl(mib, 4, &mbpool, &size, NULL, 0) < 0) {
		error("sysctl(KERN_POOL_POOL, %d)", mib[3]);
		goto exit;
	}

	for (i = 0; i < mclpool_count; i++) {
		ifr = &interfaces[0].data.ifri_entries[i];

		mib[3] = mclpools_index[i];
		size = sizeof(pool);

		if (sysctl(mib, 4, &pool, &size, NULL, 0) < 0) {
			error("sysctl(KERN_POOL_POOL, %d)", mib[3]);
			continue;
		}

		ifr->ifr_info.rxr_alive = pool.pr_nget - pool.pr_nput;
		ifr->ifr_info.rxr_hwm = pool.pr_hiwat;
	}

	num_disp = 1;
	ret = 0;

	for (i = 0; i < num_ifs; i++) {
		struct if_info *ifi = &interfaces[i];
		int pnd = num_disp;
		for (p = 0; p < ifi->data.ifri_total; p++) {
			ifr = &ifi->data.ifri_entries[p];
			if (ifr->ifr_info.rxr_alive == 0)
				continue;
			num_disp++;
		}
		if (i && pnd == num_disp)
			num_disp++;
	}

 exit:
	if (ifap)
		freeifaddrs(ifap);
	return (ret);
}

void
print_mb(void)
{
	int i, p, n, count = 0;

	showmbuf(interfaces, -1, 1);

	for (n = i = 0; i < num_ifs; i++) {
		struct if_info *ifi = &interfaces[i];
		int pcnt = count;
		int showif = i;

		if (maxprint > 0 && count >= maxprint)
			return;

		for (p = 0; p < ifi->data.ifri_total; p++) {
			struct if_rxring_info *ifr = &ifi->data.ifri_entries[p];
			if (ifr->ifr_info.rxr_alive == 0)
				continue;
			if (n++ >= dispstart) {
				showmbuf(ifi, p, showif);
				showif = 0;
				count++;
			}
		}

		if (i && pcnt == count) {
			/* only print the first line */
			if (n++ >= dispstart) {
				showmbuf(ifi, -1, 1);
				count++;
			}
		}
	}
}


static void
showmbuf(struct if_info *ifi, int p, int showif)
{
	if (showif)
		print_fld_str(FLD_MB_IFACE, ifi->name);

	if (p == -1 && ifi == interfaces) {
		print_fld_uint(FLD_MB_LLOCKS, mcllivelocks_diff);
		print_fld_size(FLD_MB_MSIZE, mbpool.pr_size);
		print_fld_size(FLD_MB_MALIVE, mbpool.pr_nget - mbpool.pr_nput);
		print_fld_size(FLD_MB_MHWM, mbpool.pr_hiwat);
	}

	if (p >= 0 && p < mclpool_count) {
		struct if_rxring_info *ifr = &ifi->data.ifri_entries[p];
		struct if_rxring *rxr= &ifr->ifr_info;
		print_fld_uint(FLD_MB_MSIZE, ifr->ifr_size);
		print_fld_uint(FLD_MB_MALIVE, rxr->rxr_alive);
		if (rxr->rxr_lwm)
			print_fld_size(FLD_MB_MLWM, rxr->rxr_lwm);
		if (rxr->rxr_hwm)
			print_fld_size(FLD_MB_MHWM, rxr->rxr_hwm);
		if (rxr->rxr_cwm)
			print_fld_size(FLD_MB_MCWM, rxr->rxr_cwm);
	}

	end_line();
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: mbufs.c,v 1.41 2016/04/04 16:26:00 sthen 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/signal.h>
19			#include <sys/socket.h>
20			#include <sys/sysctl.h>
21			#include <sys/queue.h>
22			#include <sys/mbuf.h>
23			#include <sys/pool.h>
24			#include <net/if.h>
25			#include <sys/sockio.h>
26			#include <sys/ioctl.h>
27
28			#include <err.h>
29			#include <errno.h>
30			#include <ifaddrs.h>
31			#include <stdlib.h>
32			#include <string.h>
33
34			#include "systat.h"
35
36			/* pool info */
37			int mbpool_index = -1;
38			int mclpools_index[MCLPOOLS];
39			int mclpool_count = 0;
40			struct kinfo_pool mbpool;
41			u_int mcllivelocks, mcllivelocks_cur, mcllivelocks_diff;
42
43			/* interfaces */
44			static int num_ifs = 0;
45			struct if_info {
46			char name[16];
47			struct if_rxrinfo data;
48			} *interfaces = NULL;
49
50			static int sock;
51
52			void print_mb(void);
53			int read_mb(void);
54			int select_mb(void);
55			static void showmbuf(struct if_info *, int, int);
56
57			/* Define fields */
58			field_def fields_mbuf[] = {
59			{"IFACE", 8, 16, 1, FLD_ALIGN_LEFT, -1, 0, 0, 0},
60			{"RXDELAY", 5, 8, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
61			{"TXDELAY", 5, 8, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
62			{"LIVELOCKS", 5, 10, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
63			{"SIZE", 3, 5, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
64			{"ALIVE", 3, 5, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
65			{"LWM", 3, 5, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
66			{"HWM", 3, 5, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
67			{"CWM", 3, 5, 1, FLD_ALIGN_RIGHT, -1, 0, 0, 0},
68			};
69
70
71			#define FLD_MB_IFACE FIELD_ADDR(fields_mbuf,0)
72			#define FLD_MB_RXDELAY FIELD_ADDR(fields_mbuf,1)
73			#define FLD_MB_TXDELAY FIELD_ADDR(fields_mbuf,2)
74			#define FLD_MB_LLOCKS FIELD_ADDR(fields_mbuf,3)
75			#define FLD_MB_MSIZE FIELD_ADDR(fields_mbuf,4)
76			#define FLD_MB_MALIVE FIELD_ADDR(fields_mbuf,5)
77			#define FLD_MB_MLWM FIELD_ADDR(fields_mbuf,6)
78			#define FLD_MB_MHWM FIELD_ADDR(fields_mbuf,7)
79			#define FLD_MB_MCWM FIELD_ADDR(fields_mbuf,8)
80
81
82			/* Define views */
83			field_def *view_mbuf[] = {
84			FLD_MB_IFACE,
85			FLD_MB_LLOCKS, FLD_MB_MSIZE, FLD_MB_MALIVE, FLD_MB_MLWM, FLD_MB_MHWM,
86			FLD_MB_MCWM, NULL
87			};
88
89			/* Define view managers */
90
91			struct view_manager mbuf_mgr = {
92			"Mbufs", select_mb, read_mb, NULL, print_header,
93			print_mb, keyboard_callback, NULL, NULL
94			};
95
96			field_view views_mb[] = {
97			{view_mbuf, "mbufs", '4', &mbuf_mgr},
98			{NULL, NULL, 0, NULL}
99			};
100
101
102			int
103			initmembufs(void)
104			{
105			struct if_rxring_info *ifr;
106			field_view *v;
107			int i, mib[4], npools;
108			struct kinfo_pool pool;
109			char pname[32];
110			size_t size;
111
112			sock = socket(AF_INET, SOCK_DGRAM, 0);
113			if (sock == -1) {
114			err(1, "socket()");
115			/* NOTREACHED */
116			}
117
118			/* set up the "System" interface */
119
120			interfaces = calloc(1, sizeof(*interfaces));
121			if (interfaces == NULL)
122			err(1, "calloc: interfaces");
123
124			ifr = calloc(MCLPOOLS, sizeof(*ifr));
125			if (ifr == NULL)
126			err(1, "calloc: system pools");
127
128			strlcpy(interfaces[0].name, "System", sizeof(interfaces[0].name));
129			interfaces[0].data.ifri_total = MCLPOOLS;
130			interfaces[0].data.ifri_entries = ifr;
131			num_ifs = 1;
132
133			/* go through all pools to identify mbuf and cluster pools */
134
135			mib[0] = CTL_KERN;
136			mib[1] = KERN_POOL;
137			mib[2] = KERN_POOL_NPOOLS;
138			size = sizeof(npools);
139
140			if (sysctl(mib, 3, &npools, &size, NULL, 0) < 0) {
141			err(1, "sysctl(KERN_POOL_NPOOLS)");
142			/* NOTREACHED */
143			}
144
145			for (i = 1; i <= npools; i++) {
146			mib[0] = CTL_KERN;
147			mib[1] = KERN_POOL;
148			mib[2] = KERN_POOL_NAME;
149			mib[3] = i;
150			size = sizeof(pname);
151			if (sysctl(mib, 4, &pname, &size, NULL, 0) < 0) {
152			continue;
153			}
154
155			if (strcmp(pname, "mbufpl") == 0) {
156			mbpool_index = i;
157			continue;
158			}
159
160			if (strncmp(pname, "mcl", 3) != 0)
161			continue;
162
163			if (mclpool_count == MCLPOOLS) {
164			warnx("mbufs: Too many mcl* pools");
165			break;
166			}
167
168			mib[2] = KERN_POOL_POOL;
169			size = sizeof(pool);
170
171			if (sysctl(mib, 4, &pool, &size, NULL, 0) < 0) {
172			err(1, "sysctl(KERN_POOL_POOL, %d)", i);
173			/* NOTREACHED */
174			}
175
176			snprintf(ifr[mclpool_count].ifr_name,
177			sizeof(ifr[mclpool_count].ifr_name), "%dk",
178			pool.pr_size / 1024);
179			ifr[mclpool_count].ifr_size = pool.pr_size;
180
181			mclpools_index[mclpool_count++] = i;
182			}
183
184			if (mclpool_count != MCLPOOLS)
185			warnx("mbufs: Unable to read all %d mcl* pools", MCLPOOLS);
186
187			/* add view to the engine */
188			for (v = views_mb; v->name != NULL; v++)
189			add_view(v);
190
191			/* finally read it once */
192			read_mb();
193
194			return(1);
195			}
196
197			int
198			select_mb(void)
199			{
200			num_disp = 0;
201			return (0);
202			}
203
204			int
205			read_mb(void)
206			{
207			struct kinfo_pool pool;
208			struct ifaddrs ifap = NULL, ifa;
209			struct if_info *ifi;
210			struct if_rxring_info *ifr;
211			int mib[4];
212			int i, p, nif, ret = 1, rv;
213			u_int rings;
214			size_t size;
215
216			mib[0] = CTL_KERN;
217			mib[1] = KERN_NETLIVELOCKS;
218			size = sizeof(mcllivelocks_cur);
219			if (sysctl(mib, 2, &mcllivelocks_cur, &size, NULL, 0) < 0 &&
220			errno != EOPNOTSUPP) {
221			error("sysctl(KERN_NETLIVELOCKS)");
222			goto exit;
223			}
224			mcllivelocks_diff = mcllivelocks_cur - mcllivelocks;
225			mcllivelocks = mcllivelocks_cur;
226
227			num_disp = 0;
228			if (getifaddrs(&ifap)) {
229			error("getifaddrs: %s", strerror(errno));
230			return (1);
231			}
232
233			nif = 1;
234			for (ifa = ifap; ifa != NULL; ifa = ifa->ifa_next) {
235			if (ifa->ifa_addr == NULL \|\|
236			ifa->ifa_addr->sa_family != AF_LINK)
237			continue;
238
239			nif++;
240			}
241
242			if (num_ifs < nif) {
243			ifi = reallocarray(interfaces, nif, sizeof(*interfaces));
244			if (ifi == NULL) {
245			error("reallocarray: %d interfaces", nif);
246			goto exit;
247			}
248
249			interfaces = ifi;
250			while (num_ifs < nif)
251			memset(&interfaces[num_ifs++], 0, sizeof(*interfaces));
252			}
253
254			/* Fill in the "real" interfaces */
255			ifi = interfaces + 1;
256
257			for (ifa = ifap; ifa != NULL; ifa = ifa->ifa_next) {
258			if (ifa->ifa_addr == NULL \|\|
259			ifa->ifa_addr->sa_family != AF_LINK)
260			continue;
261
262			strlcpy(ifi->name, ifa->ifa_name, sizeof(ifi->name));
263			for (;;) {
264			struct ifreq ifreq;
265			rings = ifi->data.ifri_total;
266
267			memset(&ifreq, 0, sizeof(ifreq));
268			strlcpy(ifreq.ifr_name, ifa->ifa_name,
269			sizeof(ifreq.ifr_name));
270			ifreq.ifr_data = (caddr_t)&ifi->data;
271
272			rv = ioctl(sock, SIOCGIFRXR, &ifreq);
273			if (rv == -1) {
274			if (errno == ENOTTY) {
275			free(ifi->data.ifri_entries);
276			ifi->data.ifri_total = 0;
277			ifi->data.ifri_entries = NULL;
278			break;
279			}
280
281			error("ioctl(SIOCGIFRXR) %s", strerror(errno));
282			break;
283			}
284
285			if (rings >= ifi->data.ifri_total)
286			break;
287
288			ifr = reallocarray(ifi->data.ifri_entries,
289			ifi->data.ifri_total, sizeof(*ifr));
290			if (ifr == NULL) {
291			ifi->data.ifri_total = rings;
292			error("reallocarray: %u rings",
293			ifi->data.ifri_total);
294			goto exit;
295			}
296
297			ifi->data.ifri_entries = ifr;
298			}
299
300			ifi++;
301			}
302
303			/* Fill in the "System" entry from pools */
304
305			mib[0] = CTL_KERN;
306			mib[1] = KERN_POOL;
307			mib[2] = KERN_POOL_POOL;
308			mib[3] = mbpool_index;
309			size = sizeof(mbpool);
310
311			if (sysctl(mib, 4, &mbpool, &size, NULL, 0) < 0) {
312			error("sysctl(KERN_POOL_POOL, %d)", mib[3]);
313			goto exit;
314			}
315
316			for (i = 0; i < mclpool_count; i++) {
317			ifr = &interfaces[0].data.ifri_entries[i];
318
319			mib[3] = mclpools_index[i];
320			size = sizeof(pool);
321
322			if (sysctl(mib, 4, &pool, &size, NULL, 0) < 0) {
323			error("sysctl(KERN_POOL_POOL, %d)", mib[3]);
324			continue;
325			}
326
327			ifr->ifr_info.rxr_alive = pool.pr_nget - pool.pr_nput;
328			ifr->ifr_info.rxr_hwm = pool.pr_hiwat;
329			}
330
331			num_disp = 1;
332			ret = 0;
333
334			for (i = 0; i < num_ifs; i++) {
335			struct if_info *ifi = &interfaces[i];
336			int pnd = num_disp;
337			for (p = 0; p < ifi->data.ifri_total; p++) {
338			ifr = &ifi->data.ifri_entries[p];
339			if (ifr->ifr_info.rxr_alive == 0)
340			continue;
341			num_disp++;
342			}
343			if (i && pnd == num_disp)
344			num_disp++;
345			}
346
347			exit:
348			if (ifap)
349			freeifaddrs(ifap);
350			return (ret);
351			}
352
353			void
354			print_mb(void)
355			{
356			int i, p, n, count = 0;
357
358			showmbuf(interfaces, -1, 1);
359
360			for (n = i = 0; i < num_ifs; i++) {
361			struct if_info *ifi = &interfaces[i];
362			int pcnt = count;
363			int showif = i;
364
365			if (maxprint > 0 && count >= maxprint)
366			return;
367
368			for (p = 0; p < ifi->data.ifri_total; p++) {
369			struct if_rxring_info *ifr = &ifi->data.ifri_entries[p];
370			if (ifr->ifr_info.rxr_alive == 0)
371			continue;
372			if (n++ >= dispstart) {
373			showmbuf(ifi, p, showif);
374			showif = 0;
375			count++;
376			}
377			}
378
379			if (i && pcnt == count) {
380			/* only print the first line */
381			if (n++ >= dispstart) {
382			showmbuf(ifi, -1, 1);
383			count++;
384			}
385			}
386			}
387			}
388
389
390			static void
391			showmbuf(struct if_info *ifi, int p, int showif)
392			{
393			if (showif)
394			print_fld_str(FLD_MB_IFACE, ifi->name);
395
396			if (p == -1 && ifi == interfaces) {
397			print_fld_uint(FLD_MB_LLOCKS, mcllivelocks_diff);
398			print_fld_size(FLD_MB_MSIZE, mbpool.pr_size);
399			print_fld_size(FLD_MB_MALIVE, mbpool.pr_nget - mbpool.pr_nput);
400			print_fld_size(FLD_MB_MHWM, mbpool.pr_hiwat);
401			}
402
403			if (p >= 0 && p < mclpool_count) {
404			struct if_rxring_info *ifr = &ifi->data.ifri_entries[p];
405			struct if_rxring *rxr= &ifr->ifr_info;
406			print_fld_uint(FLD_MB_MSIZE, ifr->ifr_size);
407			print_fld_uint(FLD_MB_MALIVE, rxr->rxr_alive);
408			if (rxr->rxr_lwm)
409			print_fld_size(FLD_MB_MLWM, rxr->rxr_lwm);
410			if (rxr->rxr_hwm)
411			print_fld_size(FLD_MB_MHWM, rxr->rxr_hwm);
412			if (rxr->rxr_cwm)
413			print_fld_size(FLD_MB_MCWM, rxr->rxr_cwm);
414			}
415
416			end_line();
417			}