/usr/src/usr.sbin/pstat/pstat.c

Bug Summary

File:	src/usr.sbin/pstat/pstat.c
Warning:	line 411, column 8 Null pointer passed as 1st argument to string comparison function
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple amd64-unknown-openbsd7.4 -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name pstat.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/usr.sbin/pstat/obj -resource-dir /usr/local/llvm16/lib/clang/16 -internal-isystem /usr/local/llvm16/lib/clang/16/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/usr.sbin/pstat/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fcf-protection=branch -fno-jump-tables -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/scan/2024-01-11-140451-98009-1 -x c /usr/src/usr.sbin/pstat/pstat.c
1/*	$OpenBSD: pstat.c,v 1.129 2022/02/22 17:35:01 deraadt Exp $	*/
2/*	$NetBSD: pstat.c,v 1.27 1996/10/23 22:50:06 cgd Exp $	*/

4/*-
* Copyright (c) 1980, 1991, 1993
*	The Regents of the University of California.  All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University nor the names of its contributors
*    may be used to endorse or promote products derived from this software
*    without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/

33#include <sys/param.h>	/* DEV_BSIZE */
34#include <sys/types.h>
35#include <sys/signal.h>
36#include <sys/proc.h>
37#include <sys/time.h>
38#include <sys/vnode.h>
39#include <sys/ucred.h>
40#include <sys/stat.h>
41#define _KERNEL
42#include <sys/file.h>
43#include <ufs/ufs/quota.h>
44#include <ufs/ufs/inode.h>
45#include <sys/mount.h>
46#undef _KERNEL
47#include <nfs/nfsproto.h>
48#include <nfs/rpcv2.h>
49#include <nfs/nfsnode.h>
50#include <sys/ioctl.h>
51#include <sys/tty.h>
52#include <sys/conf.h>
53#include <sys/device.h>
54#include <sys/swap.h>

56#include <sys/sysctl.h>

58#include <stdint.h>
59#include <endian.h>
60#include <err.h>
61#include <fcntl.h>
62#include <kvm.h>
63#include <limits.h>
64#include <nlist.h>
65#include <paths.h>
66#include <stdio.h>
67#include <stdlib.h>
68#include <string.h>
69#include <unistd.h>

71struct nlist vnodenl[] = {
72#define	FNL_NFILE0	0		/* sysctl */
{"_numfiles"},
74#define FNL_MAXFILE1	1		/* sysctl */
{"_maxfiles"},
76#define TTY_NTTY2	2		/* sysctl */
{"_tty_count"},
78#define V_NUMV3		3		/* sysctl */
{ "_numvnodes" },
80#define TTY_TTYLIST4	4		/* sysctl */
{"_ttylist"},
82#define	V_MOUNTLIST5	5		/* no sysctl */
{ "_mountlist" },
{ NULL((void *)0) }
85};

87struct itty *globalitp;
88struct kinfo_file *kf;
89struct nlist *globalnl;

91struct e_vnode {
struct vnode *vptr;
struct vnode vnode;
94};

96int	kflag;
97int	totalflag;
98int	usenumflag;
99int	hideroot;
100int	maxfile;
101int	need_nlist;
102int	nfile;
103int	ntty;
104int	numvnodes;
105char	*nlistf	= NULL((void *)0);
106char	*memf	= NULL((void *)0);
107kvm_t	*kd = NULL((void *)0);

109#define	SVAR(var)"var" __STRING(var)"var"	/* to force expansion */
110#define	KGET(idx, var)if (kvm_read(kd, (u_long)(globalnl[idx].n_value), &var, sizeof
(var)) != sizeof(var)) warnx("cannot read %s: %s", "var", kvm_geterr
(kd))							\
KGET1(idx, &var, sizeof(var), SVAR(var))if (kvm_read(kd, (u_long)(globalnl[idx].n_value), &var, sizeof
(var)) != sizeof(var)) warnx("cannot read %s: %s", "var", kvm_geterr
(kd))
112#define	KGET1(idx, p, s, msg)if (kvm_read(kd, (u_long)(globalnl[idx].n_value), p, s) != s)
 warnx("cannot read %s: %s", msg, kvm_geterr(kd))						\
KGET2(globalnl[idx].n_value, p, s, msg)if (kvm_read(kd, (u_long)(globalnl[idx].n_value), p, s) != s)
 warnx("cannot read %s: %s", msg, kvm_geterr(kd))
114#define	KGET2(addr, p, s, msg)if (kvm_read(kd, (u_long)(addr), p, s) != s) warnx("cannot read %s: %s"
, msg, kvm_geterr(kd))						\
if (kvm_read(kd, (u_long)(addr), p, s) != s)			\
warnx("cannot read %s: %s", msg, kvm_geterr(kd))
117#define	KGETRET(addr, p, s, msg)if (kvm_read(kd, (u_long)(addr), p, s) != s) { warnx("cannot read %s: %s"
, msg, kvm_geterr(kd)); return (0); }					\
if (kvm_read(kd, (u_long)(addr), p, s) != s) {			\
warnx("cannot read %s: %s", msg, kvm_geterr(kd));	\
return (0);						\
}

123void	filemode(void);
124void	filemodeprep(void);
125struct mount *
getmnt(struct mount *);
127struct e_vnode *
kinfo_vnodes(void);
129void	mount_print(struct mount *);
130void	nfs_header(void);
131int	nfs_print(struct vnode *);
132void	swapmode(void);
133void	ttymode(void);
134void	ttymodeprep(void);
135void	ttyprt(struct itty *);
136void	tty2itty(struct tty *tp, struct itty *itp);
137void	ufs_header(void);
138int	ufs_print(struct vnode *);
139void	ext2fs_header(void);
140int	ext2fs_print(struct vnode *);
141static void __dead__attribute__((__noreturn__))	usage(void);
142void	vnode_header(void);
143void	vnode_print(struct vnode *, struct vnode *);
144void	vnodemode(void);
145void	vnodemodeprep(void);


148int
149main(int argc, char *argv[])
150{
int fileflag = 0, swapflag = 0, ttyflag = 0, vnodeflag = 0, ch;
char buf[_POSIX2_LINE_MAX2048];
const char *dformat = NULL((void *)0);
int i;

hideroot = getuid();

while ((ch = getopt(argc, argv, "d:TM:N:fiknstv")) != -1)
1
Assuming the condition is true→
2
←
Loop condition is true.  Entering loop body→
4
←
 Execution continues on line 158→
5
←
Assuming the condition is false→
6
←
Loop condition is false. Execution continues on line 194→
switch (ch) {
3
←
Control jumps to 'case 102:'  at line 163→
case 'd':
	dformat = optarg;
	break;
case 'f':
	fileflag = 1;
	break;
case 'M':
	memf = optarg;
	break;
case 'N':
	nlistf = optarg;
	break;
case 'n':
	usenumflag = 1;
	break;
case 's':
	swapflag = 1;
	break;
case 'T':
	totalflag = 1;
	break;
case 't':
	ttyflag = 1;
	break;
case 'k':
	kflag = 1;
	break;
case 'v':
case 'i':		/* Backward compatibility. */
	vnodeflag = 1;
	break;
default:
	usage();
}
argc -= optind;
argv += optind;

if (dformat6.1
'dformat' is null
 && getuid())
errx(1, "Only root can use -d");

if ((dformat6.2
'dformat' is equal to NULL
 == NULL((void *)0) && argc > 0) || (dformat7.1
'dformat' is null
 && argc == 0))
7
←
Assuming 'argc' is <= 0→
usage();

need_nlist = dformat7.2
'dformat' is null
 || vnodeflag;

if (nlistf7.3
'nlistf' is equal to NULL
 != NULL((void *)0) || memf7.4
'memf' is equal to NULL
 != NULL((void *)0)) {
if (fileflag || totalflag)
	need_nlist = 1;
}

if (vnodeflag7.5
'vnodeflag' is 0
 || fileflag7.6
'fileflag' is 1
 || dformat || need_nlist)
if ((kd = kvm_openfiles(nlistf, memf, NULL((void *)0),
9
←
Assuming the condition is false→
10
←
Taking false branch→
    O_RDONLY0x0000 | (need_nlist7.7
'need_nlist' is 0
 ? 0 : KVM_NO_FILES0x80000000), buf)) == 0)
8
←
'?' condition is false→
	errx(1, "kvm_openfiles: %s", buf);

if (need_nlist10.1
'need_nlist' is 0
)
if (kvm_nlist(kd, vnodenl) == -1)
	errx(1, "kvm_nlist: %s", kvm_geterr(kd));

if (!(fileflag | vnodeflag | ttyflag | swapflag | totalflag || dformat))
11
←
Assuming the condition is true→
12
←
Taking false branch→
usage();

if(!dformat12.1
'dformat' is null
) {
if (fileflag12.2
'fileflag' is 1
 || totalflag)
	filemodeprep();
if (vnodeflag12.3
'vnodeflag' is 0
 || totalflag12.4
'totalflag' is not equal to 0
)
13
←
Taking true branch→
	vnodemodeprep();
if (ttyflag13.1
'ttyflag' is 0
)
14
←
Taking false branch→
	ttymodeprep();
}

if (unveil(_PATH_DEVDB"/var/run/dev.db", "r") == -1)
15
←
Assuming the condition is false→
16
←
Taking false branch→
err(1, "unveil %s", _PATH_DEVDB"/var/run/dev.db");
if (pledge("stdio rpath vminfo", NULL((void *)0)) == -1)
17
←
Assuming the condition is false→
18
←
Taking false branch→
err(1, "pledge");

if (dformat18.1
'dformat' is null
) {
struct nlist *nl;
int longformat = 0, stringformat = 0, error = 0, n;
uint32_t mask = ~0;
char format[10], buf[1024];

n = strlen(dformat);
if (n == 0)
	errx(1, "illegal format");

/*
 * Support p, c, s, and {l, ll, h, hh, j, t, z, }[diouxX]
 */
if (strcmp(dformat, "p") == 0)
	longformat = sizeof(long) == 8;
else if (strcmp(dformat, "c") == 0)
	mask = 0xff;
else if (strcmp(dformat, "s") == 0)
	stringformat = 1;
else if (strchr("diouxX", dformat[n - 1])) {
	char *ptbl[]= {"l", "ll", "h", "hh", "j", "t", "z", ""};
	int i;

	char *mod;
	for (i = 0; i < sizeof(ptbl)/sizeof(ptbl[0]); i++) {
		mod = ptbl[i];
		if (strlen(mod) == n - 1 &&
		    strncmp(mod, dformat, strlen(mod)) == 0)
			break;
	}
	if (i == sizeof(ptbl)/sizeof(ptbl[0])
	    && dformat[1] != '\0')
		errx(1, "illegal format");
	if (strcmp(mod, "l") == 0)
		longformat = sizeof(long) == sizeof(long long);
	else if (strcmp(mod, "h") == 0)
		mask = 0xffff;
	else if (strcmp(mod, "hh") == 0)
		mask = 0xff;
	else if (strcmp(mod, "") != 0)
		longformat = 1;

} else
	errx(1, "illegal format");

if (*dformat == 's') {
	stringformat = 1;
	snprintf(format, sizeof(format), "%%.%zus",
	    sizeof buf);
} else
	snprintf(format, sizeof(format), "%%%s", dformat);

nl = calloc(argc + 1, sizeof *nl);
if (!nl)
	err(1, "calloc nl: ");
for (i = 0; i < argc; i++) {
	if (asprintf(&nl[i].n_name, "_%s",
	    argv[i]) == -1)
		warn("asprintf");
}
kvm_nlist(kd, nl);
globalnl = nl;
for (i = 0; i < argc; i++) {
	uint64_t v;

	printf("%s ", argv[i]);
	if (!nl[i].n_value && argv[i][0] == '0') {
		nl[i].n_value = strtoul(argv[i], NULL((void *)0), 16);
		nl[i].n_type = N_DATA0x06;
	}
	if (!nl[i].n_value) {
		printf("not found\n");
		error++;
		continue;
	}

	printf("at %p: ", (void *)nl[i].n_value);
	if ((nl[i].n_type & N_TYPE0x1e) == N_DATA0x06 ||
	    (nl[i].n_type & N_TYPE0x1e) == N_COMM0x12) {
		if (stringformat) {
			KGET1(i, &buf, sizeof(buf), argv[i])if (kvm_read(kd, (u_long)(globalnl[i].n_value), &buf, sizeof
(buf)) != sizeof(buf)) warnx("cannot read %s: %s", argv[i], kvm_geterr
(kd));
			buf[sizeof(buf) - 1] = '\0';
		} else
			KGET1(i, &v, sizeof(v), argv[i])if (kvm_read(kd, (u_long)(globalnl[i].n_value), &v, sizeof
(v)) != sizeof(v)) warnx("cannot read %s: %s", argv[i], kvm_geterr
(kd));
		if (stringformat)
			printf(format, &buf);
		else if (longformat)
			printf(format, v);
		else {
325#if BYTE_ORDER1234 == BIG_ENDIAN4321
			switch (mask) {
			case 0xff:
				v >>= 8;
				/* FALLTHROUGH */
			case 0xffff:
				v >>= 16;
				/* FALLTHROUGH */
			case 0xffffffff:
				v >>= 32;
				break;
			}
337#endif
			printf(format, ((uint32_t)v) & mask);
		}
	}
	printf("\n");
}
for (i = 0; i < argc; i++)
	free(nl[i].n_name);
free(nl);
return error;
}

if (fileflag18.2
'fileflag' is 1
 || totalflag)
filemode();
if (vnodeflag18.3
'vnodeflag' is 0
 || totalflag18.4
'totalflag' is not equal to 0
)
19
←
Taking true branch→
vnodemode();
20
←
Calling 'vnodemode'→
if (ttyflag)
ttymode();
if (swapflag || totalflag)
swapmode();
return 0;
358}

360void
361vnodemode(void)
362{
struct e_vnode *e_vnodebase, *endvnode, *evp;
struct vnode *vp;
struct mount *maddr, *mp = NULL((void *)0);

globalnl = vnodenl;

e_vnodebase = kinfo_vnodes();
if (totalflag) {
21
←
Assuming 'totalflag' is 0→
22
←
Taking false branch→
(void)printf("%7d vnodes\n", numvnodes);
return;
}
if (!e_vnodebase)
23
←
Assuming 'e_vnodebase' is non-null→
24
←
Taking false branch→
return;
endvnode = e_vnodebase + numvnodes;
(void)printf("%d active vnodes\n", numvnodes);

maddr = NULL((void *)0);
for (evp = e_vnodebase; evp < endvnode; evp++) {
25
←
Loop condition is true.  Entering loop body→
vp = &evp->vnode;
if (vp->v_mount != maddr) {
26
←
Assuming 'maddr' is equal to field 'v_mount'→
27
←
Taking false branch→
	/*
	 * New filesystem
	 */
	if ((mp = getmnt(vp->v_mount)) == NULL((void *)0))
		continue;
	maddr = vp->v_mount;
	mount_print(mp);
	vnode_header();
	if (!strncmp(mp->mnt_stat.f_fstypename, MOUNT_FFS"ffs", MFSNAMELEN16) ||
	    !strncmp(mp->mnt_stat.f_fstypename, MOUNT_MFS"mfs", MFSNAMELEN16)) {
		ufs_header();
	} else if (!strncmp(mp->mnt_stat.f_fstypename, MOUNT_NFS"nfs",
	    MFSNAMELEN16)) {
		nfs_header();
	} else if (!strncmp(mp->mnt_stat.f_fstypename, MOUNT_EXT2FS"ext2fs",
	    MFSNAMELEN16)) {
		ext2fs_header();
	}
	(void)printf("\n");
}
vnode_print(evp->vptr, vp);

/* Syncer vnodes have no associated fs-specific data */
if (vp->v_data == NULL((void *)0)) {
28
←
Assuming field 'v_data' is not equal to NULL→
	printf(" %6c %5c %7c\n", '-', '-', '-');
	continue;
}

if (!strncmp(mp->mnt_stat.f_fstypename, MOUNT_FFS"ffs", MFSNAMELEN16) ||
29
←
Null pointer passed as 1st argument to string comparison function
    !strncmp(mp->mnt_stat.f_fstypename, MOUNT_MFS"mfs", MFSNAMELEN16)) {
	ufs_print(vp);
} else if (!strncmp(mp->mnt_stat.f_fstypename, MOUNT_NFS"nfs", MFSNAMELEN16)) {
	nfs_print(vp);
} else if (!strncmp(mp->mnt_stat.f_fstypename, MOUNT_EXT2FS"ext2fs",
    MFSNAMELEN16)) {
	ext2fs_print(vp);
}
(void)printf("\n");
}
free(e_vnodebase);
423}

425void
426vnodemodeprep(void)
427{
int mib[2];
size_t num;

if (kd == NULL((void *)0)) {
mib[0] = CTL_KERN1;
mib[1] = KERN_NUMVNODES58;
num = sizeof(numvnodes);
if (sysctl(mib, 2, &numvnodes, &num, NULL((void *)0), 0) < 0)
	err(1, "sysctl(KERN_NUMVNODES) failed");
}
438}

440void
441vnode_header(void)
442{
(void)printf("%*s TYP VFLAG  USE HOLD", 2 * (int)sizeof(long), "ADDR");
444}

446void
447vnode_print(struct vnode *avnode, struct vnode *vp)
448{
char *type, flags[16];
char *fp;
int flag;

/*
* set type
*/
switch (vp->v_type) {
case VNON:
type = "non"; break;
case VREG:
type = "reg"; break;
case VDIR:
type = "dir"; break;
case VBLK:
type = "blk"; break;
case VCHR:
type = "chr"; break;
case VLNK:
type = "lnk"; break;
case VSOCK:
type = "soc"; break;
case VFIFO:
type = "fif"; break;
case VBAD:
type = "bad"; break;
default:
type = "unk"; break;
}
/*
* gather flags
*/
fp = flags;
flag = vp->v_flag;
if (flag & VROOT0x0001)
*fp++ = 'R';
if (flag & VTEXT0x0002)
*fp++ = 'T';
if (flag & VSYSTEM0x0004)
*fp++ = 'S';
if (flag & VISTTY0x0008)
*fp++ = 'I';
if (flag & VXLOCK0x0100)
*fp++ = 'L';
if (flag & VXWANT0x0200)
*fp++ = 'W';
if (vp->v_bioflag & VBIOWAIT0x0001)
*fp++ = 'B';
if (flag & VALIASED0x0800)
*fp++ = 'A';
if (vp->v_bioflag & VBIOONFREELIST0x0004)
*fp++ = 'F';
if (flag & VLOCKSWORK0x4000)
*fp++ = 'l';
if (vp->v_bioflag & VBIOONSYNCLIST0x0002)
*fp++ = 's';
if (fp == flags)
*fp++ = '-';
*fp = '\0';
(void)printf("%0*lx %s %5s %4d %4u",
   2 * (int)sizeof(long), hideroot ? 0L : (long)avnode,
   type, flags, vp->v_usecount, vp->v_holdcnt);
511}

513void
514ufs_header(void)
515{
(void)printf(" FILEID IFLAG RDEV|SZ");
517}

519int
520ufs_print(struct vnode *vp)
521{
int flag;
struct inode inode, *ip = &inode;
struct ufs1_dinode di1;
char flagbuf[16], *flags = flagbuf;
char *name;
mode_t type;

KGETRET(VTOI(vp), &inode, sizeof(struct inode), "vnode's inode")if (kvm_read(kd, (u_long)(((struct inode *)(vp)->v_data)),
 &inode, sizeof(struct inode)) != sizeof(struct inode)) {
 warnx("cannot read %s: %s", "vnode's inode", kvm_geterr(kd))
; return (0); };
KGETRET(inode.i_din1, &di1, sizeof(struct ufs1_dinode),if (kvm_read(kd, (u_long)(inode.dinode_u.ffs1_din), &di1,
 sizeof(struct ufs1_dinode)) != sizeof(struct ufs1_dinode)) {
 warnx("cannot read %s: %s", "vnode's dinode", kvm_geterr(kd)
); return (0); }
   "vnode's dinode")if (kvm_read(kd, (u_long)(inode.dinode_u.ffs1_din), &di1,
 sizeof(struct ufs1_dinode)) != sizeof(struct ufs1_dinode)) {
 warnx("cannot read %s: %s", "vnode's dinode", kvm_geterr(kd)
); return (0); };

inode.i_din1dinode_u.ffs1_din = &di1;
flag = ip->i_flag;
535#if 0
if (flag & IN_LOCKED)
*flags++ = 'L';
if (flag & IN_WANTED)
*flags++ = 'W';
if (flag & IN_LWAIT)
*flags++ = 'Z';
542#endif
if (flag & IN_ACCESS0x0001)
*flags++ = 'A';
if (flag & IN_CHANGE0x0002)
*flags++ = 'C';
if (flag & IN_UPDATE0x0004)
*flags++ = 'U';
if (flag & IN_MODIFIED0x0008)
*flags++ = 'M';
if (flag & IN_LAZYMOD0x0080)
*flags++ = 'm';
if (flag & IN_RENAME0x0010)
*flags++ = 'R';
if (flag & IN_SHLOCK0x0020)
*flags++ = 'S';
if (flag & IN_EXLOCK0x0040)
*flags++ = 'E';
if (flag == 0)
*flags++ = '-';
*flags = '\0';

(void)printf(" %6d %5s", ip->i_number, flagbuf);
type = ip->i_ffs1_modedinode_u.ffs1_din->di_mode & S_IFMT0170000;
if (S_ISCHR(ip->i_ffs1_mode)((ip->dinode_u.ffs1_din->di_mode & 0170000) == 0020000
) || S_ISBLK(ip->i_ffs1_mode)((ip->dinode_u.ffs1_din->di_mode & 0170000) == 0060000
))
if (usenumflag ||
    ((name = devname(ip->i_ffs1_rdevdinode_u.ffs1_din->di_db[0], type)) == NULL((void *)0)))
	(void)printf("   %2u,%-2u",
	    major(ip->i_ffs1_rdev)(((unsigned)(ip->dinode_u.ffs1_din->di_db[0]) >> 8
) & 0xff), minor(ip->i_ffs1_rdev)((unsigned)((ip->dinode_u.ffs1_din->di_db[0]) & 0xff
) | (((ip->dinode_u.ffs1_din->di_db[0]) & 0xffff0000
) >> 8)));
else
	(void)printf(" %7s", name);
else
(void)printf(" %7lld", (long long)ip->i_ffs1_sizedinode_u.ffs1_din->di_size);
return (0);
575}

577void
578ext2fs_header(void)
579{
(void)printf(" FILEID IFLAG SZ");
581}

583int
584ext2fs_print(struct vnode *vp)
585{
int flag;
struct inode inode, *ip = &inode;
struct ext2fs_dinode di;
char flagbuf[16], *flags = flagbuf;

KGETRET(VTOI(vp), &inode, sizeof(struct inode), "vnode's inode")if (kvm_read(kd, (u_long)(((struct inode *)(vp)->v_data)),
 &inode, sizeof(struct inode)) != sizeof(struct inode)) {
 warnx("cannot read %s: %s", "vnode's inode", kvm_geterr(kd))
; return (0); };
KGETRET(inode.i_e2din, &di, sizeof(struct ext2fs_dinode),if (kvm_read(kd, (u_long)(inode.dinode_u.e2fs_din), &di, sizeof
(struct ext2fs_dinode)) != sizeof(struct ext2fs_dinode)) { warnx
("cannot read %s: %s", "vnode's dinode", kvm_geterr(kd)); return
 (0); }
   "vnode's dinode")if (kvm_read(kd, (u_long)(inode.dinode_u.e2fs_din), &di, sizeof
(struct ext2fs_dinode)) != sizeof(struct ext2fs_dinode)) { warnx
("cannot read %s: %s", "vnode's dinode", kvm_geterr(kd)); return
 (0); };

inode.i_e2dindinode_u.e2fs_din = &di;
flag = ip->i_flag;

598#if 0
if (flag & IN_LOCKED)
*flags++ = 'L';
if (flag & IN_WANTED)
*flags++ = 'W';
if (flag & IN_LWAIT)
*flags++ = 'Z';
605#endif
if (flag & IN_ACCESS0x0001)
*flags++ = 'A';
if (flag & IN_CHANGE0x0002)
*flags++ = 'C';
if (flag & IN_UPDATE0x0004)
*flags++ = 'U';
if (flag & IN_MODIFIED0x0008)
*flags++ = 'M';
if (flag & IN_RENAME0x0010)
*flags++ = 'R';
if (flag & IN_SHLOCK0x0020)
*flags++ = 'S';
if (flag & IN_EXLOCK0x0040)
*flags++ = 'E';
if (flag == 0)
*flags++ = '-';
*flags = '\0';

(void)printf(" %6d %5s %2d", ip->i_number, flagbuf, ip->i_e2fs_sizedinode_u.e2fs_din->e2di_size);
return (0);
626}

628void
629nfs_header(void)
630{
(void)printf(" FILEID NFLAG RDEV|SZ");
632}

634int
635nfs_print(struct vnode *vp)
636{
struct nfsnode nfsnode, *np = &nfsnode;
char flagbuf[16], *flags = flagbuf;
int flag;
char *name;
mode_t type;

KGETRET(VTONFS(vp), &nfsnode, sizeof(nfsnode), "vnode's nfsnode")if (kvm_read(kd, (u_long)(((struct nfsnode *)(vp)->v_data)
), &nfsnode, sizeof(nfsnode)) != sizeof(nfsnode)) { warnx
("cannot read %s: %s", "vnode's nfsnode", kvm_geterr(kd)); return
 (0); };
flag = np->n_flag;
if (flag & NFLUSHWANT0x0001)
*flags++ = 'W';
if (flag & NFLUSHINPROG0x0002)
*flags++ = 'P';
if (flag & NMODIFIED0x0004)
*flags++ = 'M';
if (flag & NWRITEERR0x0008)
*flags++ = 'E';
if (flag & NACC0x0100)
*flags++ = 'A';
if (flag & NUPD0x0200)
*flags++ = 'U';
if (flag & NCHG0x0400)
*flags++ = 'C';
if (flag == 0)
*flags++ = '-';
*flags = '\0';

(void)printf(" %6lld %5s", (long long)np->n_vattr.va_fileid, flagbuf);
type = np->n_vattr.va_mode & S_IFMT0170000;
if (S_ISCHR(np->n_vattr.va_mode)((np->n_vattr.va_mode & 0170000) == 0020000) || S_ISBLK(np->n_vattr.va_mode)((np->n_vattr.va_mode & 0170000) == 0060000))
if (usenumflag ||
    ((name = devname(np->n_vattr.va_rdev, type)) == NULL((void *)0)))
	(void)printf("   %2u,%-2u", major(np->n_vattr.va_rdev)(((unsigned)(np->n_vattr.va_rdev) >> 8) & 0xff),
	    minor(np->n_vattr.va_rdev)((unsigned)((np->n_vattr.va_rdev) & 0xff) | (((np->
n_vattr.va_rdev) & 0xffff0000) >> 8)));
else
	(void)printf(" %7s", name);
else
(void)printf(" %7lld", (long long)np->n_size);
return (0);
675}

677/*
* Given a pointer to a mount structure in kernel space,
* read it in and return a usable pointer to it.
*/
681struct mount *
682getmnt(struct mount *maddr)
683{
static struct mtab {
struct mtab *next;
struct mount *maddr;
struct mount mount;
} *mhead = NULL((void *)0);
struct mtab *mt;

for (mt = mhead; mt != NULL((void *)0); mt = mt->next)
if (maddr == mt->maddr)
	return (&mt->mount);
if ((mt = malloc(sizeof(struct mtab))) == NULL((void *)0))
err(1, "malloc: mount table");
KGETRET(maddr, &mt->mount, sizeof(struct mount), "mount table")if (kvm_read(kd, (u_long)(maddr), &mt->mount, sizeof(struct
 mount)) != sizeof(struct mount)) { warnx("cannot read %s: %s"
, "mount table", kvm_geterr(kd)); return (0); };
mt->maddr = maddr;
mt->next = mhead;
mhead = mt;
return (&mt->mount);
701}

703void
704mount_print(struct mount *mp)
705{
int flags;

(void)printf("*** MOUNT ");
(void)printf("%.*s %s on %s", MFSNAMELEN16,
   mp->mnt_stat.f_fstypename, mp->mnt_stat.f_mntfromname,
   mp->mnt_stat.f_mntonname);
if ((flags = mp->mnt_flag)) {
char *comma = "(";

putchar(' ')(!__isthreaded ? __sputc(' ', (&__sF[1])) : (putc)(' ', (
&__sF[1])));
/* user visible flags */
if (flags & MNT_RDONLY0x00000001) {
	(void)printf("%srdonly", comma);
	flags &= ~MNT_RDONLY0x00000001;
	comma = ",";
}
if (flags & MNT_SYNCHRONOUS0x00000002) {
	(void)printf("%ssynchronous", comma);
	flags &= ~MNT_SYNCHRONOUS0x00000002;
	comma = ",";
}
if (flags & MNT_NOEXEC0x00000004) {
	(void)printf("%snoexec", comma);
	flags &= ~MNT_NOEXEC0x00000004;
	comma = ",";
}
if (flags & MNT_NOSUID0x00000008) {
	(void)printf("%snosuid", comma);
	flags &= ~MNT_NOSUID0x00000008;
	comma = ",";
}
if (flags & MNT_NODEV0x00000010) {
	(void)printf("%snodev", comma);
	flags &= ~MNT_NODEV0x00000010;
	comma = ",";
}
if (flags & MNT_ASYNC0x00000040) {
	(void)printf("%sasync", comma);
	flags &= ~MNT_ASYNC0x00000040;
	comma = ",";
}
if (flags & MNT_EXRDONLY0x00000080) {
	(void)printf("%sexrdonly", comma);
	flags &= ~MNT_EXRDONLY0x00000080;
	comma = ",";
}
if (flags & MNT_EXPORTED0x00000100) {
	(void)printf("%sexport", comma);
	flags &= ~MNT_EXPORTED0x00000100;
	comma = ",";
}
if (flags & MNT_DEFEXPORTED0x00000200) {
	(void)printf("%sdefdexported", comma);
	flags &= ~MNT_DEFEXPORTED0x00000200;
	comma = ",";
}
if (flags & MNT_EXPORTANON0x00000400) {
	(void)printf("%sexportanon", comma);
	flags &= ~MNT_EXPORTANON0x00000400;
	comma = ",";
}
if (flags & MNT_WXALLOWED0x00000800) {
	(void)printf("%swxallowed", comma);
	flags &= ~MNT_WXALLOWED0x00000800;
	comma = ",";
}
if (flags & MNT_LOCAL0x00001000) {
	(void)printf("%slocal", comma);
	flags &= ~MNT_LOCAL0x00001000;
	comma = ",";
}
if (flags & MNT_QUOTA0x00002000) {
	(void)printf("%squota", comma);
	flags &= ~MNT_QUOTA0x00002000;
	comma = ",";
}
if (flags & MNT_ROOTFS0x00004000) {
	(void)printf("%srootfs", comma);
	flags &= ~MNT_ROOTFS0x00004000;
	comma = ",";
}
if (flags & MNT_NOATIME0x00008000) {
	(void)printf("%snoatime", comma);
	flags &= ~MNT_NOATIME0x00008000;
	comma = ",";
}
/* filesystem control flags */
if (flags & MNT_UPDATE0x00010000) {
	(void)printf("%supdate", comma);
	flags &= ~MNT_UPDATE0x00010000;
	comma = ",";
}
if (flags & MNT_DELEXPORT0x00020000) {
	(void)printf("%sdelexport", comma);
	flags &= ~MNT_DELEXPORT0x00020000;
	comma = ",";
}
if (flags & MNT_RELOAD0x00040000) {
	(void)printf("%sreload", comma);
	flags &= ~MNT_RELOAD0x00040000;
	comma = ",";
}
if (flags & MNT_FORCE0x00080000) {
	(void)printf("%sforce", comma);
	flags &= ~MNT_FORCE0x00080000;
	comma = ",";
}
if (flags & MNT_WANTRDWR0x02000000) {
	(void)printf("%swantrdwr", comma);
	flags &= ~MNT_WANTRDWR0x02000000;
	comma = ",";
}
if (flags & MNT_SOFTDEP0x04000000) {
	(void)printf("%ssoftdep", comma);
	flags &= ~MNT_SOFTDEP0x04000000;
	comma = ",";
}
if (flags)
	(void)printf("%sunknown_flags:%x", comma, flags);
(void)printf(")");
}
(void)printf("\n");
828}

830/*
* simulate what a running kernel does in kinfo_vnode
*/
833struct e_vnode *
834kinfo_vnodes(void)
835{
struct mntlist kvm_mountlist;
struct mount *mp, mount;
struct vnode *vp, vnode;
char *vbuf, *evbuf, *bp;
size_t num;

if (kd != NULL((void *)0))
KGET(V_NUMV, numvnodes)if (kvm_read(kd, (u_long)(globalnl[3].n_value), &numvnodes
, sizeof(numvnodes)) != sizeof(numvnodes)) warnx("cannot read %s: %s"
, "numvnodes", kvm_geterr(kd));
if (totalflag)
return NULL((void *)0);
if ((vbuf = calloc(numvnodes + 20,
   sizeof(struct vnode *) + sizeof(struct vnode))) == NULL((void *)0))
err(1, "malloc: vnode buffer");
bp = vbuf;
evbuf = vbuf + (numvnodes + 20) *
   (sizeof(struct vnode *) + sizeof(struct vnode));
KGET(V_MOUNTLIST, kvm_mountlist)if (kvm_read(kd, (u_long)(globalnl[5].n_value), &kvm_mountlist
, sizeof(kvm_mountlist)) != sizeof(kvm_mountlist)) warnx("cannot read %s: %s"
, "kvm_mountlist", kvm_geterr(kd));
num = 0;
for (mp = TAILQ_FIRST(&kvm_mountlist)((&kvm_mountlist)->tqh_first); mp != NULL((void *)0);
   mp = TAILQ_NEXT(&mount, mnt_list)((&mount)->mnt_list.tqe_next)) {
KGETRET(mp, &mount, sizeof(mount), "mount entry")if (kvm_read(kd, (u_long)(mp), &mount, sizeof(mount)) != sizeof
(mount)) { warnx("cannot read %s: %s", "mount entry", kvm_geterr
(kd)); return (0); };
for (vp = TAILQ_FIRST(&mount.mnt_vnodelist)((&mount.mnt_vnodelist)->tqh_first);
    vp != NULL((void *)0); vp = TAILQ_NEXT(&vnode, v_mntvnodes)((&vnode)->v_mntvnodes.tqe_next)) {
	KGETRET(vp, &vnode, sizeof(vnode), "vnode")if (kvm_read(kd, (u_long)(vp), &vnode, sizeof(vnode)) != sizeof
(vnode)) { warnx("cannot read %s: %s", "vnode", kvm_geterr(kd
)); return (0); };
	if ((bp + sizeof(struct vnode *) +
	    sizeof(struct vnode)) > evbuf)
		/* XXX - should realloc */
		errx(1, "no more room for vnodes");
	memmove(bp, &vp, sizeof(struct vnode *));
	bp += sizeof(struct vnode *);
	memmove(bp, &vnode, sizeof(struct vnode));
	bp += sizeof(struct vnode);
	num++;
}
}
numvnodes = num;
return ((struct e_vnode *)vbuf);
873}

875const char hdr[] =
876"   LINE RAW  CAN  OUT  HWT LWT    COL STATE      SESS  PGID DISC\n";

878void
879tty2itty(struct tty *tp, struct itty *itp)
880{
itp->t_dev = tp->t_dev;
itp->t_rawq_c_cc = tp->t_rawq.c_cc;
itp->t_canq_c_cc = tp->t_canq.c_cc;
itp->t_outq_c_cc = tp->t_outq.c_cc;
itp->t_hiwat = tp->t_hiwat;
itp->t_lowat = tp->t_lowat;
itp->t_column = tp->t_column;
itp->t_state = tp->t_state;
itp->t_session = tp->t_session;
if (tp->t_pgrp != NULL((void *)0))
KGET2(&tp->t_pgrp->pg_id, &itp->t_pgrp_pg_id, sizeof(pid_t), "pgid")if (kvm_read(kd, (u_long)(&tp->t_pgrp->pg_id), &
itp->t_pgrp_pg_id, sizeof(pid_t)) != sizeof(pid_t)) warnx(
"cannot read %s: %s", "pgid", kvm_geterr(kd));
itp->t_line = tp->t_line;
893}

895void
896ttymode(void)
897{
struct ttylist_head tty_head;
struct tty *tp, tty;
int i;
struct itty itty;

if (need_nlist)
KGET(TTY_NTTY, ntty)if (kvm_read(kd, (u_long)(globalnl[2].n_value), &ntty, sizeof
(ntty)) != sizeof(ntty)) warnx("cannot read %s: %s", "ntty", kvm_geterr
(kd));
(void)printf("%d terminal device%s\n", ntty, ntty == 1 ? "" : "s");
(void)printf("%s", hdr);
if (!need_nlist) {
for (i = 0; i < ntty; i++)
	ttyprt(&globalitp[i]);
free(globalitp);
} else {
KGET(TTY_TTYLIST, tty_head)if (kvm_read(kd, (u_long)(globalnl[4].n_value), &tty_head
, sizeof(tty_head)) != sizeof(tty_head)) warnx("cannot read %s: %s"
, "tty_head", kvm_geterr(kd));
for (tp = TAILQ_FIRST(&tty_head)((&tty_head)->tqh_first); tp;
    tp = TAILQ_NEXT(&tty, tty_link)((&tty)->tty_link.tqe_next)) {
	KGET2(tp, &tty, sizeof tty, "tty struct")if (kvm_read(kd, (u_long)(tp), &tty, sizeof tty) != sizeof
 tty) warnx("cannot read %s: %s", "tty struct", kvm_geterr(kd
));
	tty2itty(&tty, &itty);
	ttyprt(&itty);
}
}
920}

922void
923ttymodeprep(void)
924{
int mib[3];
size_t nlen;

if (!need_nlist) {
mib[0] = CTL_KERN1;
mib[1] = KERN_TTYCOUNT57;
nlen = sizeof(ntty);
if (sysctl(mib, 2, &ntty, &nlen, NULL((void *)0), 0) < 0)
	err(1, "sysctl(KERN_TTYCOUNT) failed");

mib[0] = CTL_KERN1;
mib[1] = KERN_TTY44;
mib[2] = KERN_TTY_INFO5;
if ((globalitp = reallocarray(NULL((void *)0), ntty, sizeof(struct itty))) == NULL((void *)0))
	err(1, "malloc");
nlen = ntty * sizeof(struct itty);
if (sysctl(mib, 3, globalitp, &nlen, NULL((void *)0), 0) < 0)
	err(1, "sysctl(KERN_TTY_INFO) failed");
}
944}

946struct {
int flag;
char val;
949} ttystates[] = {
{ TS_WOPEN0x00200,	'W'},
{ TS_ISOPEN0x00020,	'O'},
{ TS_CARR_ON0x00008,	'C'},
{ TS_TIMEOUT0x00080,	'T'},
{ TS_FLUSH0x00010,	'F'},
{ TS_BUSY0x00004,	'B'},
{ TS_ASLEEP0x00001,	'A'},
{ TS_XCLUDE0x00400,	'X'},
{ TS_TTSTOP0x00100,	'S'},
{ TS_TBLOCK0x00040,	'K'},
{ TS_ASYNC0x00002,	'Y'},
{ TS_BKSL0x00800,	'D'},
{ TS_ERASE0x02000,	'E'},
{ TS_LNCH0x04000,	'L'},
{ TS_TYPEN0x08000,	'P'},
{ TS_CNTTB0x01000,	'N'},
{ 0,		'\0'},
967};

969void
970ttyprt(struct itty *tp)
971{
char *name, state[20];
int i, j;

if (usenumflag || (name = devname(tp->t_dev, S_IFCHR0020000)) == NULL((void *)0))
(void)printf("%2u,%-3u   ", major(tp->t_dev)(((unsigned)(tp->t_dev) >> 8) & 0xff), minor(tp->t_dev)((unsigned)((tp->t_dev) & 0xff) | (((tp->t_dev) &
 0xffff0000) >> 8)));
else
(void)printf("%7s ", name);
(void)printf("%3d %4d ", tp->t_rawq_c_cc, tp->t_canq_c_cc);
(void)printf("%4d %4d %3d %6d ", tp->t_outq_c_cc,
tp->t_hiwat, tp->t_lowat, tp->t_column);
for (i = j = 0; ttystates[i].flag; i++)
if (tp->t_state&ttystates[i].flag)
	state[j++] = ttystates[i].val;
if (j == 0)
state[j++] = '-';
state[j] = '\0';
(void)printf("%-6s %8lx", state,
hideroot ? 0 : (u_long)tp->t_session & 0xffffffff);
(void)printf("%6d ", tp->t_pgrp_pg_id);
switch (tp->t_line) {
case TTYDISC0:
(void)printf("term\n");
break;
case PPPDISC5:
(void)printf("ppp\n");
break;
case NMEADISC7:
(void)printf("nmea\n");
break;
default:
(void)printf("%d\n", tp->t_line);
break;
}
1005}

1007void
1008filemode(void)
1009{
char flagbuf[16], *fbp;
static char *dtypes[] = { "???", "inode", "socket", "pipe", "kqueue", "???", "???" };

globalnl = vnodenl;

if (nlistf != NULL((void *)0) || memf != NULL((void *)0)) {
KGET(FNL_MAXFILE, maxfile)if (kvm_read(kd, (u_long)(globalnl[1].n_value), &maxfile,
 sizeof(maxfile)) != sizeof(maxfile)) warnx("cannot read %s: %s"
, "maxfile", kvm_geterr(kd));
if (totalflag) {
	KGET(FNL_NFILE, nfile)if (kvm_read(kd, (u_long)(globalnl[0].n_value), &nfile, sizeof
(nfile)) != sizeof(nfile)) warnx("cannot read %s: %s", "nfile"
, kvm_geterr(kd));
	(void)printf("%3d/%3d files\n", nfile, maxfile);
	return;
}
}

(void)printf("%d/%d open files\n", nfile, maxfile);
if (totalflag)
return;

(void)printf("%*s TYPE       FLG  CNT  MSG  %*s  OFFSET\n",
   2 * (int)sizeof(long), "LOC", 2 * (int)sizeof(long), "DATA");
for (; nfile-- > 0; kf++) {
(void)printf("%0*llx ", 2 * (int)sizeof(long),
    hideroot ? 0LL : kf->f_fileaddr);
(void)printf("%-8.8s", dtypes[
    (kf->f_type >= (sizeof(dtypes)/sizeof(dtypes[0])))
    ? 0 : kf->f_type]);
fbp = flagbuf;
if (kf->f_flag & FREAD0x0001)
	*fbp++ = 'R';
if (kf->f_flag & FWRITE0x0002)
	*fbp++ = 'W';
if (kf->f_flag & FAPPEND0x0008)
	*fbp++ = 'A';
if (kf->f_flag & FASYNC0x0040)
	*fbp++ = 'I';

if (kf->f_iflags & FIF_HASLOCK0x01)
	*fbp++ = 'L';

*fbp = '\0';
(void)printf("%6s  %3ld", flagbuf, (long)kf->f_count);
(void)printf("  %3ld", (long)kf->f_msgcount);
(void)printf("  %0*lx", 2 * (int)sizeof(long),
    hideroot ? 0L : (long)kf->f_data);

if (kf->f_offset == (uint64_t)-1)
	(void)printf("  *\n");
else if (kf->f_offset > INT64_MAX0x7fffffffffffffffLL) {
	/* would have been negative */
	(void)printf("  %llx\n",
	    hideroot ? 0LL : (long long)kf->f_offset);
} else
	(void)printf("  %lld\n",
	    hideroot ? 0LL : (long long)kf->f_offset);
}
1065}

1067void
1068filemodeprep(void)
1069{
int mib[2];
size_t len;

if (nlistf == NULL((void *)0) && memf == NULL((void *)0)) {
mib[0] = CTL_KERN1;
mib[1] = KERN_MAXFILES7;
len = sizeof(maxfile);
if (sysctl(mib, 2, &maxfile, &len, NULL((void *)0), 0) < 0)
	err(1, "sysctl(KERN_MAXFILES) failed");
if (totalflag) {
	mib[0] = CTL_KERN1;
	mib[1] = KERN_NFILES56;
	len = sizeof(nfile);
	if (sysctl(mib, 2, &nfile, &len, NULL((void *)0), 0) < 0)
		err(1, "sysctl(KERN_NFILES) failed");
}
}

if (!totalflag) {
kf = kvm_getfiles(kd, KERN_FILE_BYFILE1, 0, sizeof *kf, &nfile);
if (kf == NULL((void *)0)) {
	warnx("kvm_getfiles: %s", kvm_geterr(kd));
	return;
}
}
1095}

1097/*
* swapmode is based on a program called swapinfo written
* by Kevin Lahey <kml@rokkaku.atl.ga.us>.
*/
1101void
1102swapmode(void)
1103{
char *header;
int hlen = 10, nswap;
int bdiv, i, avail, nfree, npfree, used;
long blocksize;
struct swapent *swdev;

if (kflag) {
header = "1K-blocks";
blocksize = 1024;
hlen = strlen(header);
} else
header = getbsize(&hlen, &blocksize);

nswap = swapctl(SWAP_NSWAP3, 0, 0);
if (nswap == 0) {
if (!totalflag)
	(void)printf("%-11s %*s %8s %8s %8s  %s\n",
	    "Device", hlen, header,
	    "Used", "Avail", "Capacity", "Priority");
(void)printf("%-11s %*d %8d %8d %5.0f%%\n",
    "Total", hlen, 0, 0, 0, 0.0);
return;
}
if ((swdev = calloc(nswap, sizeof(*swdev))) == NULL((void *)0))
err(1, "malloc");
if (swapctl(SWAP_STATS4, swdev, nswap) == -1)
err(1, "swapctl");

if (!totalflag)
(void)printf("%-11s %*s %8s %8s %8s  %s\n",
    "Device", hlen, header,
    "Used", "Avail", "Capacity", "Priority");

/* Run through swap list, doing the funky monkey. */
bdiv = blocksize / DEV_BSIZE(1 << 9);
avail = nfree = npfree = 0;
for (i = 0; i < nswap; i++) {
int xsize, xfree;

if (!(swdev[i].se_flags & SWF_ENABLE0x00000002))
	continue;

if (!totalflag) {
	if (usenumflag)
		(void)printf("%2u,%-2u       %*d ",
		    major(swdev[i].se_dev)(((unsigned)(swdev[i].se_dev) >> 8) & 0xff),
		    minor(swdev[i].se_dev)((unsigned)((swdev[i].se_dev) & 0xff) | (((swdev[i].se_dev
) & 0xffff0000) >> 8)),
		    hlen, swdev[i].se_nblks / bdiv);
	else
		(void)printf("%-11s %*d ", swdev[i].se_path,
		    hlen, swdev[i].se_nblks / bdiv);
}

xsize = swdev[i].se_nblks;
used = swdev[i].se_inuse;
xfree = xsize - used;
nfree += (xsize - used);
npfree++;
avail += xsize;
if (totalflag)
	continue;
(void)printf("%8d %8d %5.0f%%    %d\n",
    used / bdiv, xfree / bdiv,
    (double)used / (double)xsize * 100.0,
    swdev[i].se_priority);
}
free(swdev);

/*
* If only one partition has been set up via swapon(8), we don't
* need to bother with totals.
*/
used = avail - nfree;
if (totalflag) {
(void)printf("%dM/%dM swap space\n",
    used / (1048576 / DEV_BSIZE(1 << 9)),
    avail / (1048576 / DEV_BSIZE(1 << 9)));
return;
}
if (npfree > 1) {
(void)printf("%-11s %*d %8d %8d %5.0f%%\n",
    "Total", hlen, avail / bdiv, used / bdiv, nfree / bdiv,
    (double)used / (double)avail * 100.0);
}
1188}

1190static void __dead__attribute__((__noreturn__))
1191usage(void)
1192{
(void)fprintf(stderr(&__sF[2]), "usage: "
   "pstat [-fknsTtv] [-M core] [-N system] [-d format symbol ...]\n");
exit(1);
1196}