1/*-
2 * SPDX-License-Identifier: BSD-3-Clause
3 *
4 * Copyright (c) 1980, 1991, 1993, 1994
5 *	The Regents of the University of California.  All rights reserved.
6 * Copyright (c) 2002 Networks Associates Technologies, Inc.
7 * All rights reserved.
8 *
9 * Portions of this software were developed for the FreeBSD Project by
10 * ThinkSec AS and NAI Labs, the Security Research Division of Network
11 * Associates, Inc.  under DARPA/SPAWAR contract N66001-01-C-8035
12 * ("CBOSS"), as part of the DARPA CHATS research program.
13 *
14 * Redistribution and use in source and binary forms, with or without
15 * modification, are permitted provided that the following conditions
16 * are met:
17 * 1. Redistributions of source code must retain the above copyright
18 *    notice, this list of conditions and the following disclaimer.
19 * 2. Redistributions in binary form must reproduce the above copyright
20 *    notice, this list of conditions and the following disclaimer in the
21 *    documentation and/or other materials provided with the distribution.
22 * 3. Neither the name of the University nor the names of its contributors
23 *    may be used to endorse or promote products derived from this software
24 *    without specific prior written permission.
25 *
26 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
27 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
30 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
31 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
32 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
35 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36 * SUCH DAMAGE.
37 */
38
39#include <sys/param.h>
40#include <sys/time.h>
41#include <sys/file.h>
42#include <sys/stat.h>
43#include <sys/stdint.h>
44#include <sys/ioctl.h>
45#include <sys/tty.h>
46#include <sys/blist.h>
47
48#include <sys/sysctl.h>
49#include <vm/vm_param.h>
50
51#include <err.h>
52#include <errno.h>
53#include <fcntl.h>
54#include <kvm.h>
55#include <libutil.h>
56#include <limits.h>
57#include <nlist.h>
58#include <stdio.h>
59#include <stdlib.h>
60#include <string.h>
61#include <unistd.h>
62
63enum {
64	NL_CONSTTY,
65	NL_MAXFILES,
66	NL_NFILES,
67	NL_TTY_LIST,
68	NL_MARKER
69};
70
71static struct {
72	int order;
73	const char *name;
74} namelist[] = {
75	{ NL_CONSTTY, "_constty" },
76	{ NL_MAXFILES, "_maxfiles" },
77	{ NL_NFILES, "_openfiles" },
78	{ NL_TTY_LIST, "_tty_list" },
79	{ NL_MARKER, "" },
80};
81#define NNAMES	(sizeof(namelist) / sizeof(*namelist))
82static struct nlist nl[NNAMES];
83
84#define	SIZEHDR	"Size"
85
86static int	humanflag;
87static int	usenumflag;
88static int	totalflag;
89static int	swapflag;
90static char	*nlistf;
91static char	*memf;
92static kvm_t	*kd;
93
94static const char *usagestr;
95
96static void	filemode(void);
97static int	getfiles(struct xfile **, size_t *);
98static void	swapmode(void);
99static void	ttymode(void);
100static void	ttyprt(struct xtty *);
101static void	usage(void);
102
103int
104main(int argc, char *argv[])
105{
106	int ch, quit, ret;
107	int fileflag, ttyflag;
108	unsigned int i;
109	char buf[_POSIX2_LINE_MAX];
110	const char *opts;
111
112	fileflag = swapflag = ttyflag = 0;
113
114	/* We will behave like good old swapinfo if thus invoked */
115	opts = strrchr(argv[0], '/');
116	if (opts)
117		opts++;
118	else
119		opts = argv[0];
120	if (!strcmp(opts, "swapinfo")) {
121		swapflag = 1;
122		opts = "ghkmM:N:";
123		usagestr = "swapinfo [-ghkm] [-M core [-N system]]";
124	} else {
125		opts = "TM:N:fghkmnst";
126		usagestr = "pstat [-Tfghkmnst] [-M core [-N system]]";
127	}
128
129	while ((ch = getopt(argc, argv, opts)) != -1)
130		switch (ch) {
131		case 'f':
132			fileflag = 1;
133			break;
134		case 'g':
135			setenv("BLOCKSIZE", "1G", 1);
136			break;
137		case 'h':
138			humanflag = 1;
139			break;
140		case 'k':
141			setenv("BLOCKSIZE", "1K", 1);
142			break;
143		case 'm':
144			setenv("BLOCKSIZE", "1M", 1);
145			break;
146		case 'M':
147			memf = optarg;
148			break;
149		case 'N':
150			nlistf = optarg;
151			break;
152		case 'n':
153			usenumflag = 1;
154			break;
155		case 's':
156			++swapflag;
157			break;
158		case 'T':
159			totalflag = 1;
160			break;
161		case 't':
162			ttyflag = 1;
163			break;
164		default:
165			usage();
166		}
167
168	/*
169	 * Initialize symbol names list.
170	 */
171	for (i = 0; i < NNAMES; i++)
172		nl[namelist[i].order].n_name = strdup(namelist[i].name);
173
174	if (memf != NULL) {
175		kd = kvm_openfiles(nlistf, memf, NULL, O_RDONLY, buf);
176		if (kd == NULL)
177			errx(1, "kvm_openfiles: %s", buf);
178		if ((ret = kvm_nlist(kd, nl)) != 0) {
179			if (ret == -1)
180				errx(1, "kvm_nlist: %s", kvm_geterr(kd));
181			quit = 0;
182			for (i = 0; nl[i].n_name[0] != '\0'; ++i)
183				if (nl[i].n_value == 0) {
184					quit = 1;
185					warnx("undefined symbol: %s",
186					    nl[i].n_name);
187				}
188			if (quit)
189				exit(1);
190		}
191	}
192	if (!(fileflag | ttyflag | swapflag | totalflag))
193		usage();
194	if (fileflag || totalflag)
195		filemode();
196	if (ttyflag)
197		ttymode();
198	if (swapflag || totalflag)
199		swapmode();
200	exit (0);
201}
202
203static void
204usage(void)
205{
206	fprintf(stderr, "usage: %s\n", usagestr);
207	exit (1);
208}
209
210static const char fhdr32[] =
211  "   LOC   TYPE   FLG  CNT MSG   DATA        OFFSET\n";
212/* c0000000 ------ RWAI 123 123 c0000000 1000000000000000 */
213
214static const char fhdr64[] =
215  "       LOC       TYPE   FLG  CNT MSG       DATA            OFFSET\n";
216/* c000000000000000 ------ RWAI 123 123 c000000000000000 1000000000000000 */
217
218static const char hdr[] =
219"      LINE   INQ  CAN  LIN  LOW  OUTQ  USE  LOW   COL  SESS  PGID STATE\n";
220
221static void
222ttymode_kvm(void)
223{
224	TAILQ_HEAD(, tty) tl;
225	struct tty *tp, tty;
226	struct xtty xt;
227
228	(void)printf("%s", hdr);
229	bzero(&xt, sizeof xt);
230	xt.xt_size = sizeof xt;
231	if (kvm_read(kd, nl[NL_TTY_LIST].n_value, &tl, sizeof tl) != sizeof tl)
232		errx(1, "kvm_read(): %s", kvm_geterr(kd));
233	tp = TAILQ_FIRST(&tl);
234	while (tp != NULL) {
235		if (kvm_read(kd, (u_long)tp, &tty, sizeof tty) != sizeof tty)
236			errx(1, "kvm_read(): %s", kvm_geterr(kd));
237		xt.xt_insize = tty.t_inq.ti_nblocks * TTYINQ_DATASIZE;
238		xt.xt_incc = tty.t_inq.ti_linestart - tty.t_inq.ti_begin;
239		xt.xt_inlc = tty.t_inq.ti_end - tty.t_inq.ti_linestart;
240		xt.xt_inlow = tty.t_inlow;
241		xt.xt_outsize = tty.t_outq.to_nblocks * TTYOUTQ_DATASIZE;
242		xt.xt_outcc = tty.t_outq.to_end - tty.t_outq.to_begin;
243		xt.xt_outlow = tty.t_outlow;
244		xt.xt_column = tty.t_column;
245		/* xt.xt_pgid = ... */
246		/* xt.xt_sid = ... */
247		xt.xt_flags = tty.t_flags;
248		xt.xt_dev = (uint32_t)NODEV;
249		ttyprt(&xt);
250		tp = TAILQ_NEXT(&tty, t_list);
251	}
252}
253
254static void
255ttymode_sysctl(void)
256{
257	struct xtty *xttys;
258	size_t len;
259	unsigned int i, n;
260
261	(void)printf("%s", hdr);
262	if ((xttys = malloc(len = sizeof(*xttys))) == NULL)
263		err(1, "malloc()");
264	while (sysctlbyname("kern.ttys", xttys, &len, 0, 0) == -1) {
265		if (errno != ENOMEM)
266			err(1, "sysctlbyname()");
267		len *= 2;
268		if ((xttys = realloc(xttys, len)) == NULL)
269			err(1, "realloc()");
270	}
271	n = len / sizeof(*xttys);
272	for (i = 0; i < n; i++)
273		ttyprt(&xttys[i]);
274}
275
276static void
277ttymode(void)
278{
279
280	if (kd != NULL)
281		ttymode_kvm();
282	else
283		ttymode_sysctl();
284}
285
286static struct {
287	int flag;
288	char val;
289} ttystates[] = {
290#if 0
291	{ TF_NOPREFIX,		'N' },
292#endif
293	{ TF_INITLOCK,		'I' },
294	{ TF_CALLOUT,		'C' },
295
296	/* Keep these together -> 'Oi' and 'Oo'. */
297	{ TF_OPENED,		'O' },
298	{ TF_OPENED_IN,		'i' },
299	{ TF_OPENED_OUT,	'o' },
300	{ TF_OPENED_CONS,	'c' },
301
302	{ TF_GONE,		'G' },
303	{ TF_OPENCLOSE,		'B' },
304	{ TF_ASYNC,		'Y' },
305	{ TF_LITERAL,		'L' },
306
307	/* Keep these together -> 'Hi' and 'Ho'. */
308	{ TF_HIWAT,		'H' },
309	{ TF_HIWAT_IN,		'i' },
310	{ TF_HIWAT_OUT,		'o' },
311
312	{ TF_STOPPED,		'S' },
313	{ TF_EXCLUDE,		'X' },
314	{ TF_BYPASS,		'l' },
315	{ TF_ZOMBIE,		'Z' },
316	{ TF_HOOK,		's' },
317
318	/* Keep these together -> 'bi' and 'bo'. */
319	{ TF_BUSY,		'b' },
320	{ TF_BUSY_IN,		'i' },
321	{ TF_BUSY_OUT,		'o' },
322
323	{ 0,			'\0'},
324};
325
326static void
327ttyprt(struct xtty *xt)
328{
329	int i, j;
330	const char *name;
331
332	if (xt->xt_size != sizeof *xt)
333		errx(1, "struct xtty size mismatch");
334	if (usenumflag || xt->xt_dev == 0 ||
335	   (name = devname(xt->xt_dev, S_IFCHR)) == NULL)
336		printf("%#10jx ", (uintmax_t)xt->xt_dev);
337	else
338		printf("%10s ", name);
339	printf("%5zu %4zu %4zu %4zu %5zu %4zu %4zu %5u %5d %5d ",
340	    xt->xt_insize, xt->xt_incc, xt->xt_inlc,
341	    (xt->xt_insize - xt->xt_inlow), xt->xt_outsize,
342	    xt->xt_outcc, (xt->xt_outsize - xt->xt_outlow),
343	    MIN(xt->xt_column, 99999), xt->xt_sid, xt->xt_pgid);
344	for (i = j = 0; ttystates[i].flag; i++)
345		if (xt->xt_flags & ttystates[i].flag) {
346			putchar(ttystates[i].val);
347			j++;
348		}
349	if (j == 0)
350		putchar('-');
351	putchar('\n');
352}
353
354static void
355filemode(void)
356{
357	struct xfile *fp, *buf;
358	char flagbuf[16], *fbp;
359	int maxf, openf;
360	size_t len;
361	static char const * const dtypes[] = { "???", "inode", "socket",
362	    "pipe", "fifo", "kqueue", "crypto" };
363	int i;
364	int wid;
365
366	if (kd != NULL) {
367		if (kvm_read(kd, nl[NL_MAXFILES].n_value,
368			&maxf, sizeof maxf) != sizeof maxf ||
369		    kvm_read(kd, nl[NL_NFILES].n_value,
370			&openf, sizeof openf) != sizeof openf)
371			errx(1, "kvm_read(): %s", kvm_geterr(kd));
372	} else {
373		len = sizeof(int);
374		if (sysctlbyname("kern.maxfiles", &maxf, &len, 0, 0) == -1 ||
375		    sysctlbyname("kern.openfiles", &openf, &len, 0, 0) == -1)
376			err(1, "sysctlbyname()");
377	}
378
379	if (totalflag) {
380		(void)printf("%3d/%3d files\n", openf, maxf);
381		return;
382	}
383	if (getfiles(&buf, &len) == -1)
384		return;
385	openf = len / sizeof *fp;
386
387	(void)printf("%d/%d open files\n", openf, maxf);
388	printf(sizeof(uintptr_t) == 4 ? fhdr32 : fhdr64);
389	wid = (int)sizeof(uintptr_t) * 2;
390	for (fp = (struct xfile *)buf, i = 0; i < openf; ++fp, ++i) {
391		if ((size_t)fp->xf_type >= nitems(dtypes))
392			continue;
393		(void)printf("%*jx", wid, (uintmax_t)(uintptr_t)fp->xf_file);
394		(void)printf(" %-6.6s", dtypes[fp->xf_type]);
395		fbp = flagbuf;
396		if (fp->xf_flag & FREAD)
397			*fbp++ = 'R';
398		if (fp->xf_flag & FWRITE)
399			*fbp++ = 'W';
400		if (fp->xf_flag & FAPPEND)
401			*fbp++ = 'A';
402		if (fp->xf_flag & FASYNC)
403			*fbp++ = 'I';
404		*fbp = '\0';
405		(void)printf(" %4s %3d", flagbuf, fp->xf_count);
406		(void)printf(" %3d", fp->xf_msgcount);
407		(void)printf(" %*jx", wid, (uintmax_t)(uintptr_t)fp->xf_data);
408		(void)printf(" %*jx\n", (int)sizeof(fp->xf_offset) * 2,
409		    (uintmax_t)fp->xf_offset);
410	}
411	free(buf);
412}
413
414static int
415getfiles(struct xfile **abuf, size_t *alen)
416{
417	struct xfile *buf;
418	size_t len;
419	int mib[2];
420
421	/*
422	 * XXX
423	 * Add emulation of KINFO_FILE here.
424	 */
425	if (kd != NULL)
426		errx(1, "files on dead kernel, not implemented");
427
428	mib[0] = CTL_KERN;
429	mib[1] = KERN_FILE;
430	if (sysctl(mib, 2, NULL, &len, NULL, 0) == -1) {
431		warn("sysctl: KERN_FILE");
432		return (-1);
433	}
434	if ((buf = malloc(len)) == NULL)
435		errx(1, "malloc");
436	if (sysctl(mib, 2, buf, &len, NULL, 0) == -1) {
437		warn("sysctl: KERN_FILE");
438		return (-1);
439	}
440	*abuf = buf;
441	*alen = len;
442	return (0);
443}
444
445/*
446 * swapmode is based on a program called swapinfo written
447 * by Kevin Lahey <kml@rokkaku.atl.ga.us>.
448 */
449
450#define CONVERT(v)	((int64_t)(v) * pagesize / blocksize)
451#define CONVERT_BLOCKS(v)	((int64_t)(v) * pagesize)
452static struct kvm_swap swtot;
453static int nswdev;
454
455static void
456print_swap_header(void)
457{
458	int hlen;
459	long blocksize;
460	const char *header;
461
462	if (humanflag) {
463		header = SIZEHDR;
464		hlen = 8; /* as the hardcoded field width of values */
465	} else {
466		header = getbsize(&hlen, &blocksize);
467	}
468	if (totalflag == 0)
469		(void)printf("%-15s %*s %8s %8s %8s\n",
470		    "Device", hlen, header,
471		    "Used", "Avail", "Capacity");
472}
473
474static void
475print_swap_line(const char *swdevname, intmax_t nblks, intmax_t bused,
476    intmax_t bavail, float bpercent)
477{
478	char usedbuf[5];
479	char availbuf[5];
480	char sizebuf[5];
481	int hlen, pagesize;
482	long blocksize;
483
484	pagesize = getpagesize();
485	getbsize(&hlen, &blocksize);
486
487	printf("%-15s ", swdevname);
488	if (humanflag) {
489		humanize_number(sizebuf, sizeof(sizebuf),
490		    CONVERT_BLOCKS(nblks), "",
491		    HN_AUTOSCALE, HN_B | HN_NOSPACE | HN_DECIMAL);
492		humanize_number(usedbuf, sizeof(usedbuf),
493		    CONVERT_BLOCKS(bused), "",
494		    HN_AUTOSCALE, HN_B | HN_NOSPACE | HN_DECIMAL);
495		humanize_number(availbuf, sizeof(availbuf),
496		    CONVERT_BLOCKS(bavail), "",
497		    HN_AUTOSCALE, HN_B | HN_NOSPACE | HN_DECIMAL);
498		printf("%8s %8s %8s %5.0f%%\n", sizebuf,
499		    usedbuf, availbuf, bpercent);
500	} else {
501		printf("%*jd %8jd %8jd %5.0f%%\n", hlen,
502		    (intmax_t)CONVERT(nblks),
503		    (intmax_t)CONVERT(bused),
504		    (intmax_t)CONVERT(bavail), bpercent);
505	}
506}
507
508static void
509print_swap(struct kvm_swap *ksw)
510{
511
512	swtot.ksw_total += ksw->ksw_total;
513	swtot.ksw_used += ksw->ksw_used;
514	++nswdev;
515	if (totalflag == 0)
516		print_swap_line(ksw->ksw_devname, ksw->ksw_total,
517		    ksw->ksw_used, ksw->ksw_total - ksw->ksw_used,
518		    (ksw->ksw_used * 100.0) / ksw->ksw_total);
519}
520
521static void
522print_swap_total(void)
523{
524	int hlen, pagesize;
525	long blocksize;
526
527	pagesize = getpagesize();
528	getbsize(&hlen, &blocksize);
529	if (totalflag) {
530		blocksize = 1024 * 1024;
531		(void)printf("%jdM/%jdM swap space\n",
532		    CONVERT(swtot.ksw_used), CONVERT(swtot.ksw_total));
533	} else if (nswdev > 1) {
534		print_swap_line("Total", swtot.ksw_total, swtot.ksw_used,
535		    swtot.ksw_total - swtot.ksw_used,
536		    (swtot.ksw_used * 100.0) / swtot.ksw_total);
537	}
538}
539
540static void
541swapmode_kvm(void)
542{
543	struct kvm_swap kswap[16];
544	int i, n;
545
546	n = kvm_getswapinfo(kd, kswap, sizeof kswap / sizeof kswap[0],
547	    SWIF_DEV_PREFIX);
548
549	print_swap_header();
550	for (i = 0; i < n; ++i)
551		print_swap(&kswap[i]);
552	print_swap_total();
553}
554
555static void
556swapmode_sysctl(void)
557{
558	struct kvm_swap ksw;
559	struct xswdev xsw;
560	size_t mibsize, size;
561	int mib[16], n;
562
563	print_swap_header();
564	mibsize = sizeof mib / sizeof mib[0];
565	if (sysctlnametomib("vm.swap_info", mib, &mibsize) == -1)
566		err(1, "sysctlnametomib()");
567	for (n = 0; ; ++n) {
568		mib[mibsize] = n;
569		size = sizeof xsw;
570		if (sysctl(mib, mibsize + 1, &xsw, &size, NULL, 0) == -1)
571			break;
572		if (xsw.xsw_version != XSWDEV_VERSION)
573			errx(1, "xswdev version mismatch");
574		if (xsw.xsw_dev == NODEV)
575			snprintf(ksw.ksw_devname, sizeof ksw.ksw_devname,
576			    "<NFSfile>");
577		else
578			snprintf(ksw.ksw_devname, sizeof ksw.ksw_devname,
579			    "/dev/%s", devname(xsw.xsw_dev, S_IFCHR));
580		ksw.ksw_used = xsw.xsw_used;
581		ksw.ksw_total = xsw.xsw_nblks;
582		ksw.ksw_flags = xsw.xsw_flags;
583		print_swap(&ksw);
584	}
585	if (errno != ENOENT)
586		err(1, "sysctl()");
587	print_swap_total();
588}
589
590static void
591swapmode(void)
592{
593	if (kd != NULL)
594		swapmode_kvm();
595	else
596		swapmode_sysctl();
597}
598