Home | History | Annotate | Line # | Download | only in pstat
pstat.c revision 1.126
      1  1.126   hannken /*	$NetBSD: pstat.c,v 1.126 2017/01/11 09:07:58 hannken Exp $	*/
      2   1.16   thorpej 
      3    1.1       cgd /*-
      4   1.33       mrg  * Copyright (c) 1980, 1991, 1993, 1994
      5    1.1       cgd  *	The Regents of the University of California.  All rights reserved.
      6    1.1       cgd  *
      7    1.1       cgd  * Redistribution and use in source and binary forms, with or without
      8    1.1       cgd  * modification, are permitted provided that the following conditions
      9    1.1       cgd  * are met:
     10    1.1       cgd  * 1. Redistributions of source code must retain the above copyright
     11    1.1       cgd  *    notice, this list of conditions and the following disclaimer.
     12    1.1       cgd  * 2. Redistributions in binary form must reproduce the above copyright
     13    1.1       cgd  *    notice, this list of conditions and the following disclaimer in the
     14    1.1       cgd  *    documentation and/or other materials provided with the distribution.
     15   1.83       agc  * 3. Neither the name of the University nor the names of its contributors
     16    1.1       cgd  *    may be used to endorse or promote products derived from this software
     17    1.1       cgd  *    without specific prior written permission.
     18    1.1       cgd  *
     19    1.1       cgd  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     20    1.1       cgd  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     21    1.1       cgd  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     22    1.1       cgd  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     23    1.1       cgd  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     24    1.1       cgd  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     25    1.1       cgd  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     26    1.1       cgd  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     27    1.1       cgd  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     28    1.1       cgd  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     29    1.1       cgd  * SUCH DAMAGE.
     30    1.1       cgd  */
     31    1.1       cgd 
     32   1.34     lukem #include <sys/cdefs.h>
     33    1.1       cgd #ifndef lint
     34  1.110     lukem __COPYRIGHT("@(#) Copyright (c) 1980, 1991, 1993, 1994\
     35  1.110     lukem  The Regents of the University of California.  All rights reserved.");
     36    1.1       cgd #endif /* not lint */
     37    1.1       cgd 
     38    1.1       cgd #ifndef lint
     39   1.16   thorpej #if 0
     40   1.33       mrg static char sccsid[] = "@(#)pstat.c	8.16 (Berkeley) 5/9/95";
     41   1.16   thorpej #else
     42  1.126   hannken __RCSID("$NetBSD: pstat.c,v 1.126 2017/01/11 09:07:58 hannken Exp $");
     43   1.16   thorpej #endif
     44    1.1       cgd #endif /* not lint */
     45    1.1       cgd 
     46  1.109        ad #define _KERNEL
     47  1.109        ad #include <sys/types.h>
     48  1.109        ad #undef _KERNEL
     49    1.1       cgd #include <sys/param.h>
     50    1.1       cgd #include <sys/time.h>
     51    1.1       cgd #include <sys/vnode.h>
     52    1.1       cgd #include <sys/ucred.h>
     53   1.99        he #include <stdbool.h>
     54   1.11       jtc #define _KERNEL
     55    1.1       cgd #define NFS
     56    1.1       cgd #include <sys/mount.h>
     57    1.1       cgd #undef NFS
     58  1.115   mlelstv #include <sys/file.h>
     59  1.115   mlelstv #include <ufs/ufs/inode.h>
     60  1.115   mlelstv #include <ufs/ufs/ufsmount.h>
     61   1.33       mrg #include <sys/uio.h>
     62   1.56     enami #include <miscfs/genfs/layer.h>
     63   1.11       jtc #undef _KERNEL
     64    1.1       cgd #include <sys/stat.h>
     65   1.17       cgd #include <nfs/nfsproto.h>
     66   1.17       cgd #include <nfs/rpcv2.h>
     67   1.33       mrg #include <nfs/nfs.h>
     68    1.1       cgd #include <nfs/nfsnode.h>
     69    1.1       cgd #include <sys/ioctl.h>
     70    1.1       cgd #include <sys/tty.h>
     71    1.1       cgd #include <sys/conf.h>
     72    1.1       cgd 
     73    1.1       cgd #include <sys/sysctl.h>
     74    1.1       cgd 
     75    1.1       cgd #include <err.h>
     76  1.120       apb #include <errno.h>
     77    1.1       cgd #include <kvm.h>
     78    1.1       cgd #include <limits.h>
     79    1.1       cgd #include <nlist.h>
     80    1.1       cgd #include <stdio.h>
     81    1.1       cgd #include <stdlib.h>
     82    1.1       cgd #include <string.h>
     83    1.1       cgd #include <unistd.h>
     84    1.1       cgd 
     85   1.31       mrg #include "swapctl.h"
     86   1.31       mrg 
     87    1.1       cgd struct nlist nl[] = {
     88   1.31       mrg #define	V_MOUNTLIST	0
     89  1.114     lukem 	{ "_mountlist", 0, 0, 0, 0 },	/* address of head of mount list. */
     90   1.49     enami #define	V_NUMV		1
     91  1.114     lukem 	{ "_numvnodes", 0, 0, 0, 0 },
     92  1.126   hannken #define	V_NEXT_OFFSET	2
     93  1.126   hannken 	{ "_vnode_offset_next_by_mount", 0, 0, 0, 0 },
     94  1.126   hannken #define	FNL_NFILE	3
     95  1.114     lukem 	{ "_nfiles", 0, 0, 0, 0 },
     96  1.126   hannken #define FNL_MAXFILE	4
     97  1.114     lukem 	{ "_maxfiles", 0, 0, 0, 0 },
     98  1.126   hannken #define TTY_NTTY	5
     99  1.114     lukem 	{ "_tty_count", 0, 0, 0, 0 },
    100  1.126   hannken #define TTY_TTYLIST	6
    101  1.114     lukem 	{ "_ttylist", 0, 0, 0, 0 },
    102   1.20       mrg #define NLMANDATORY TTY_TTYLIST	/* names up to here are mandatory */
    103  1.114     lukem 	{ "", 0, 0, 0, 0 }
    104    1.1       cgd };
    105    1.1       cgd 
    106    1.1       cgd int	usenumflag;
    107    1.1       cgd int	totalflag;
    108    1.8   mycroft int	kflag;
    109   1.84       mrg int	hflag;
    110    1.1       cgd char	*nlistf	= NULL;
    111    1.1       cgd char	*memf	= NULL;
    112    1.1       cgd kvm_t	*kd;
    113    1.1       cgd 
    114   1.88  christos static const char * const dtypes[] = { DTYPE_NAMES };
    115   1.88  christos 
    116   1.88  christos 
    117   1.74  jdolecek static const struct {
    118   1.71     enami 	u_int m_flag;
    119   1.75  christos 	u_int m_visible;
    120   1.33       mrg 	const char *m_name;
    121   1.33       mrg } mnt_flags[] = {
    122   1.75  christos 	__MNT_FLAGS
    123   1.33       mrg };
    124   1.33       mrg 
    125   1.71     enami struct flagbit_desc {
    126   1.71     enami 	u_int fd_flags;
    127   1.71     enami 	char fd_mark;
    128   1.71     enami };
    129   1.71     enami 
    130    1.1       cgd #define	SVAR(var) __STRING(var)	/* to force expansion */
    131    1.1       cgd #define	KGET(idx, var)							\
    132    1.1       cgd 	KGET1(idx, &var, sizeof(var), SVAR(var))
    133    1.1       cgd #define	KGET1(idx, p, s, msg)						\
    134    1.1       cgd 	KGET2(nl[idx].n_value, p, s, msg)
    135   1.58     enami #define	KGET2(addr, p, s, msg) do {					\
    136    1.1       cgd 	if (kvm_read(kd, (u_long)(addr), p, s) != s)			\
    137   1.58     enami 		warnx("cannot read %s: %s", msg, kvm_geterr(kd));	\
    138   1.58     enami } while (/* CONSTCOND */0)
    139   1.58     enami #define	KGETRET(addr, p, s, msg) do {					\
    140    1.1       cgd 	if (kvm_read(kd, (u_long)(addr), p, s) != s) {			\
    141    1.1       cgd 		warnx("cannot read %s: %s", msg, kvm_geterr(kd));	\
    142    1.1       cgd 		return (0);						\
    143   1.58     enami 	}								\
    144   1.58     enami } while (/* CONSTCOND */0)
    145    1.1       cgd 
    146   1.66     enami #if 1				/* This is copied from vmstat/vmstat.c */
    147   1.66     enami /*
    148   1.66     enami  * Print single word.  `ovflow' is number of characters didn't fit
    149   1.66     enami  * on the last word.  `fmt' is a format string to print this word.
    150   1.66     enami  * It must contain asterisk for field width.  `width' is a width
    151   1.66     enami  * occupied by this word.  `fixed' is a number of constant chars in
    152   1.66     enami  * `fmt'.  `val' is a value to be printed using format string `fmt'.
    153   1.66     enami  */
    154   1.66     enami #define	PRWORD(ovflw, fmt, width, fixed, val) do {	\
    155   1.66     enami 	(ovflw) += printf((fmt),			\
    156   1.66     enami 	    (width) - (fixed) - (ovflw) > 0 ?		\
    157   1.66     enami 	    (width) - (fixed) - (ovflw) : 0,		\
    158   1.66     enami 	    (val)) - (width);				\
    159   1.66     enami 	if ((ovflw) < 0)				\
    160   1.66     enami 		(ovflw) = 0;				\
    161   1.66     enami } while (/* CONSTCOND */0)
    162   1.66     enami #endif
    163   1.66     enami 
    164   1.91    rpaulo void	filemode(void);
    165   1.91    rpaulo int	getfiles(char **, int *, char **);
    166   1.91    rpaulo int	getflags(const struct flagbit_desc *, char *, u_int);
    167    1.1       cgd struct mount *
    168   1.91    rpaulo 	getmnt(struct mount *);
    169   1.91    rpaulo char *	kinfo_vnodes(int *);
    170   1.91    rpaulo void	layer_header(void);
    171   1.91    rpaulo int	layer_print(struct vnode *, int);
    172   1.91    rpaulo char *	loadvnodes(int *);
    173   1.91    rpaulo int	main(int, char **);
    174   1.91    rpaulo void	mount_print(struct mount *);
    175   1.91    rpaulo void	nfs_header(void);
    176   1.91    rpaulo int	nfs_print(struct vnode *, int);
    177   1.91    rpaulo void	ttymode(void);
    178   1.91    rpaulo void	ttyprt(struct tty *);
    179   1.91    rpaulo void	ufs_header(void);
    180   1.91    rpaulo int	ufs_print(struct vnode *, int);
    181   1.91    rpaulo int	ext2fs_print(struct vnode *, int);
    182  1.118     joerg __dead void	usage(void);
    183   1.91    rpaulo void	vnode_header(void);
    184   1.91    rpaulo int	vnode_print(struct vnode *, struct vnode *);
    185   1.91    rpaulo void	vnodemode(void);
    186    1.1       cgd 
    187    1.1       cgd int
    188   1.91    rpaulo main(int argc, char *argv[])
    189    1.1       cgd {
    190   1.92    rpaulo 	int ch, i, quit, ret, use_sysctl;
    191    1.1       cgd 	int fileflag, swapflag, ttyflag, vnodeflag;
    192   1.44       mrg 	gid_t egid = getegid();
    193    1.1       cgd 	char buf[_POSIX2_LINE_MAX];
    194    1.1       cgd 
    195   1.44       mrg 	setegid(getgid());
    196    1.1       cgd 	fileflag = swapflag = ttyflag = vnodeflag = 0;
    197   1.85       mrg 	while ((ch = getopt(argc, argv, "TM:N:fghikmnstv")) != -1)
    198    1.1       cgd 		switch (ch) {
    199    1.1       cgd 		case 'f':
    200    1.1       cgd 			fileflag = 1;
    201    1.1       cgd 			break;
    202    1.1       cgd 		case 'M':
    203    1.1       cgd 			memf = optarg;
    204    1.1       cgd 			break;
    205    1.1       cgd 		case 'N':
    206    1.1       cgd 			nlistf = optarg;
    207    1.1       cgd 			break;
    208    1.1       cgd 		case 'n':
    209    1.1       cgd 			usenumflag = 1;
    210    1.1       cgd 			break;
    211    1.1       cgd 		case 's':
    212    1.1       cgd 			swapflag = 1;
    213    1.1       cgd 			break;
    214    1.1       cgd 		case 'T':
    215    1.1       cgd 			totalflag = 1;
    216    1.1       cgd 			break;
    217    1.1       cgd 		case 't':
    218    1.1       cgd 			ttyflag = 1;
    219    1.1       cgd 			break;
    220    1.8   mycroft 		case 'k':
    221    1.8   mycroft 			kflag = 1;
    222    1.8   mycroft 			break;
    223   1.85       mrg 		case 'g':
    224   1.85       mrg 			kflag = 3; /* 1k ^ 3 */
    225   1.85       mrg 			break;
    226   1.84       mrg 		case 'h':
    227   1.84       mrg 			hflag = 1;
    228   1.84       mrg 			break;
    229   1.85       mrg 		case 'm':
    230   1.85       mrg 			kflag = 2; /* 1k ^ 2 */
    231   1.85       mrg 			break;
    232    1.1       cgd 		case 'v':
    233    1.1       cgd 		case 'i':		/* Backward compatibility. */
    234    1.1       cgd 			vnodeflag = 1;
    235    1.1       cgd 			break;
    236    1.1       cgd 		default:
    237    1.1       cgd 			usage();
    238    1.1       cgd 		}
    239    1.1       cgd 	argc -= optind;
    240    1.1       cgd 	argv += optind;
    241    1.1       cgd 
    242    1.1       cgd 	/*
    243   1.44       mrg 	 * Discard setgid privileges.  If not the running kernel, we toss
    244   1.44       mrg 	 * them away totally so that bad guys can't print interesting stuff
    245   1.44       mrg 	 * from kernel memory, otherwise switch back to kmem for the
    246   1.44       mrg 	 * duration of the kvm_openfiles() call.
    247    1.1       cgd 	 */
    248    1.1       cgd 	if (nlistf != NULL || memf != NULL)
    249    1.1       cgd 		(void)setgid(getgid());
    250   1.44       mrg 	else
    251   1.44       mrg 		(void)setegid(egid);
    252    1.1       cgd 
    253   1.92    rpaulo 	use_sysctl = (nlistf == NULL && memf == NULL);
    254   1.92    rpaulo 
    255    1.1       cgd 	if ((kd = kvm_openfiles(nlistf, memf, NULL, O_RDONLY, buf)) == 0)
    256    1.1       cgd 		errx(1, "kvm_openfiles: %s", buf);
    257   1.44       mrg 
    258   1.44       mrg 	/* get rid of it now anyway */
    259   1.44       mrg 	if (nlistf == NULL && memf == NULL)
    260   1.44       mrg 		(void)setgid(getgid());
    261    1.1       cgd 	if ((ret = kvm_nlist(kd, nl)) != 0) {
    262    1.1       cgd 		if (ret == -1)
    263    1.1       cgd 			errx(1, "kvm_nlist: %s", kvm_geterr(kd));
    264    1.1       cgd 		for (i = quit = 0; i <= NLMANDATORY; i++)
    265    1.1       cgd 			if (!nl[i].n_value) {
    266    1.1       cgd 				quit = 1;
    267   1.24       cgd 				warnx("undefined symbol: %s", nl[i].n_name);
    268    1.1       cgd 			}
    269    1.1       cgd 		if (quit)
    270    1.1       cgd 			exit(1);
    271    1.1       cgd 	}
    272    1.1       cgd 	if (!(fileflag | vnodeflag | ttyflag | swapflag | totalflag))
    273    1.1       cgd 		usage();
    274    1.1       cgd 	if (fileflag || totalflag)
    275    1.1       cgd 		filemode();
    276    1.1       cgd 	if (vnodeflag || totalflag)
    277    1.1       cgd 		vnodemode();
    278    1.1       cgd 	if (ttyflag)
    279    1.1       cgd 		ttymode();
    280    1.1       cgd 	if (swapflag || totalflag)
    281   1.92    rpaulo 		if (use_sysctl)
    282   1.92    rpaulo 			list_swap(0, kflag, 0, totalflag, 1, hflag);
    283   1.71     enami 	exit(0);
    284    1.1       cgd }
    285    1.1       cgd 
    286   1.59     enami #define	VPTRSZ  sizeof(struct vnode *)
    287   1.59     enami #define	VNODESZ sizeof(struct vnode)
    288   1.71     enami #define	PTRSTRWIDTH ((int)sizeof(void *) * 2) /* Width of resulting string
    289   1.71     enami 						 when pointer is printed
    290   1.71     enami 						 in hexadecimal. */
    291    1.1       cgd 
    292  1.111  christos static void
    293  1.111  christos devprintf(char *buf, size_t buflen, dev_t dev)
    294  1.111  christos {
    295  1.111  christos 	(void)snprintf(buf, buflen, "%llu,%llu",
    296  1.111  christos 	    (unsigned long long)major(dev),
    297  1.111  christos 	    (unsigned long long)minor(dev));
    298  1.111  christos }
    299  1.111  christos 
    300    1.1       cgd void
    301   1.91    rpaulo vnodemode(void)
    302    1.1       cgd {
    303   1.59     enami 	char *e_vnodebase, *endvnode, *evp;
    304   1.33       mrg 	struct vnode *vp;
    305   1.33       mrg 	struct mount *maddr, *mp;
    306   1.66     enami 	int numvnodes, ovflw;
    307   1.91    rpaulo 	int (*vnode_fsprint) (struct vnode *, int); /* per-fs data printer */
    308    1.1       cgd 
    309   1.34     lukem 	mp = NULL;
    310   1.81       mrg 	e_vnodebase = loadvnodes(&numvnodes);
    311    1.1       cgd 	if (totalflag) {
    312    1.1       cgd 		(void)printf("%7d vnodes\n", numvnodes);
    313   1.81       mrg 		goto out;
    314    1.1       cgd 	}
    315   1.59     enami 	endvnode = e_vnodebase + numvnodes * (VPTRSZ + VNODESZ);
    316    1.1       cgd 	(void)printf("%d active vnodes\n", numvnodes);
    317    1.1       cgd 
    318   1.49     enami #define	ST	mp->mnt_stat
    319   1.50     enami #define	FSTYPE_IS(mp, name)						\
    320  1.100  christos 	(strncmp((mp)->mnt_stat.f_fstypename, (name), 			\
    321  1.100  christos 	sizeof((mp)->mnt_stat.f_fstypename)) == 0)
    322    1.1       cgd 	maddr = NULL;
    323   1.50     enami 	vnode_fsprint = NULL;
    324   1.59     enami 	for (evp = e_vnodebase; evp < endvnode; evp += VPTRSZ + VNODESZ) {
    325   1.59     enami 		vp = (struct vnode *)(evp + VPTRSZ);
    326    1.1       cgd 		if (vp->v_mount != maddr) {
    327    1.1       cgd 			/*
    328    1.1       cgd 			 * New filesystem
    329    1.1       cgd 			 */
    330    1.1       cgd 			if ((mp = getmnt(vp->v_mount)) == NULL)
    331    1.1       cgd 				continue;
    332    1.1       cgd 			maddr = vp->v_mount;
    333    1.1       cgd 			mount_print(mp);
    334    1.1       cgd 			vnode_header();
    335  1.124  dholland 			/*
    336  1.124  dholland 			 * XXX do this in a more fs-independent way
    337  1.124  dholland 			 */
    338   1.50     enami 			if (FSTYPE_IS(mp, MOUNT_FFS) ||
    339   1.50     enami 			    FSTYPE_IS(mp, MOUNT_MFS)) {
    340    1.1       cgd 				ufs_header();
    341   1.50     enami 				vnode_fsprint = ufs_print;
    342   1.50     enami 			} else if (FSTYPE_IS(mp, MOUNT_NFS)) {
    343    1.1       cgd 				nfs_header();
    344   1.50     enami 				vnode_fsprint = nfs_print;
    345   1.50     enami 			} else if (FSTYPE_IS(mp, MOUNT_EXT2FS)) {
    346   1.30    bouyer 				ufs_header();
    347   1.50     enami 				vnode_fsprint = ext2fs_print;
    348   1.56     enami 			} else if (FSTYPE_IS(mp, MOUNT_NULL) ||
    349   1.56     enami 			    FSTYPE_IS(mp, MOUNT_OVERLAY) ||
    350   1.56     enami 			    FSTYPE_IS(mp, MOUNT_UMAP)) {
    351   1.56     enami 				layer_header();
    352   1.56     enami 				vnode_fsprint = layer_print;
    353   1.50     enami 			} else
    354   1.50     enami 				vnode_fsprint = NULL;
    355    1.1       cgd 			(void)printf("\n");
    356    1.1       cgd 		}
    357   1.66     enami 		ovflw = vnode_print(*(struct vnode **)evp, vp);
    358   1.50     enami 		if (VTOI(vp) != NULL && vnode_fsprint != NULL)
    359   1.66     enami 			(*vnode_fsprint)(vp, ovflw);
    360    1.1       cgd 		(void)printf("\n");
    361    1.1       cgd 	}
    362   1.81       mrg 
    363   1.81       mrg  out:
    364  1.102    briggs 	if (e_vnodebase)
    365  1.102    briggs 		free(e_vnodebase);
    366    1.1       cgd }
    367    1.1       cgd 
    368   1.71     enami int
    369   1.91    rpaulo getflags(const struct flagbit_desc *fd, char *p, u_int flags)
    370   1.71     enami {
    371   1.71     enami 	char *q = p;
    372   1.71     enami 
    373   1.71     enami 	if (flags == 0) {
    374   1.71     enami 		*p++ = '-';
    375   1.71     enami 		*p = '\0';
    376   1.71     enami 		return (0);
    377   1.71     enami 	}
    378   1.71     enami 
    379   1.71     enami 	for (; fd->fd_flags != 0; fd++)
    380   1.71     enami 		if ((flags & fd->fd_flags) != 0)
    381   1.71     enami 			*p++ = fd->fd_mark;
    382   1.71     enami 	*p = '\0';
    383   1.71     enami 	return (p - q);
    384   1.71     enami }
    385   1.71     enami 
    386   1.71     enami const struct flagbit_desc vnode_flags[] = {
    387  1.101        ad 	{ VV_ROOT,	'R' },
    388  1.101        ad 	{ VI_TEXT,	'T' },
    389  1.101        ad 	{ VV_SYSTEM,	'S' },
    390  1.101        ad 	{ VV_ISTTY,	'I' },
    391  1.101        ad 	{ VI_EXECMAP,	'E' },
    392  1.101        ad 	{ VU_DIROP,	'D' },
    393  1.101        ad 	{ VI_ONWORKLST,	'O' },
    394   1.71     enami 	{ 0,		'\0' },
    395   1.71     enami };
    396   1.71     enami 
    397    1.1       cgd void
    398   1.91    rpaulo vnode_header(void)
    399    1.1       cgd {
    400   1.49     enami 
    401   1.66     enami 	(void)printf("%-*s TYP VFLAG  USE HOLD TAG NPAGE",
    402   1.67     enami 	    PTRSTRWIDTH, "ADDR");
    403    1.1       cgd }
    404    1.1       cgd 
    405   1.66     enami int
    406   1.91    rpaulo vnode_print(struct vnode *avnode, struct vnode *vp)
    407    1.1       cgd {
    408  1.114     lukem 	const char *type;
    409  1.114     lukem 	char flags[sizeof(vnode_flags) / sizeof(vnode_flags[0])];
    410   1.71     enami 	int ovflw;
    411    1.1       cgd 
    412    1.1       cgd 	/*
    413    1.1       cgd 	 * set type
    414    1.1       cgd 	 */
    415   1.33       mrg 	switch (vp->v_type) {
    416    1.1       cgd 	case VNON:
    417    1.1       cgd 		type = "non"; break;
    418    1.1       cgd 	case VREG:
    419    1.1       cgd 		type = "reg"; break;
    420    1.1       cgd 	case VDIR:
    421    1.1       cgd 		type = "dir"; break;
    422    1.1       cgd 	case VBLK:
    423    1.1       cgd 		type = "blk"; break;
    424    1.1       cgd 	case VCHR:
    425    1.1       cgd 		type = "chr"; break;
    426    1.1       cgd 	case VLNK:
    427    1.1       cgd 		type = "lnk"; break;
    428    1.1       cgd 	case VSOCK:
    429    1.1       cgd 		type = "soc"; break;
    430    1.1       cgd 	case VFIFO:
    431    1.1       cgd 		type = "fif"; break;
    432    1.1       cgd 	case VBAD:
    433    1.1       cgd 		type = "bad"; break;
    434   1.49     enami 	default:
    435    1.1       cgd 		type = "unk"; break;
    436    1.1       cgd 	}
    437    1.1       cgd 	/*
    438    1.1       cgd 	 * gather flags
    439    1.1       cgd 	 */
    440  1.101        ad 	(void)getflags(vnode_flags, flags,
    441  1.101        ad 	    vp->v_uflag | vp->v_iflag | vp->v_vflag);
    442   1.66     enami 
    443   1.66     enami 	ovflw = 0;
    444   1.67     enami 	PRWORD(ovflw, "%*lx", PTRSTRWIDTH, 0, (long)avnode);
    445   1.66     enami 	PRWORD(ovflw, " %*s", 4, 1, type);
    446   1.66     enami 	PRWORD(ovflw, " %*s", 6, 1, flags);
    447   1.66     enami 	PRWORD(ovflw, " %*ld", 5, 1, (long)vp->v_usecount);
    448   1.66     enami 	PRWORD(ovflw, " %*ld", 5, 1, (long)vp->v_holdcnt);
    449   1.66     enami 	PRWORD(ovflw, " %*d", 4, 1, vp->v_tag);
    450   1.66     enami 	PRWORD(ovflw, " %*d", 6, 1, vp->v_uobj.uo_npages);
    451   1.66     enami 	return (ovflw);
    452    1.1       cgd }
    453    1.1       cgd 
    454   1.71     enami const struct flagbit_desc ufs_flags[] = {
    455   1.71     enami 	{ IN_ACCESS,	'A' },
    456   1.71     enami 	{ IN_CHANGE,	'C' },
    457   1.71     enami 	{ IN_UPDATE,	'U' },
    458   1.71     enami 	{ IN_MODIFIED,	'M' },
    459   1.71     enami 	{ IN_ACCESSED,	'a' },
    460   1.71     enami 	{ IN_SHLOCK,	'S' },
    461   1.71     enami 	{ IN_EXLOCK,	'E' },
    462   1.71     enami 	{ IN_SPACECOUNTED, 's' },
    463   1.71     enami 	{ 0,		'\0' },
    464   1.71     enami };
    465   1.30    bouyer 
    466   1.30    bouyer void
    467   1.91    rpaulo ufs_header(void)
    468   1.30    bouyer {
    469   1.49     enami 
    470   1.30    bouyer 	(void)printf(" FILEID IFLAG RDEV|SZ");
    471   1.30    bouyer }
    472   1.30    bouyer 
    473   1.30    bouyer int
    474   1.91    rpaulo ufs_print(struct vnode *vp, int ovflw)
    475   1.30    bouyer {
    476   1.30    bouyer 	struct inode inode, *ip = &inode;
    477   1.82      fvdl 	union dinode {
    478   1.82      fvdl 		struct ufs1_dinode dp1;
    479   1.82      fvdl 		struct ufs2_dinode dp2;
    480   1.82      fvdl 	} dip;
    481  1.115   mlelstv 	struct ufsmount ump;
    482   1.71     enami 	char flags[sizeof(ufs_flags) / sizeof(ufs_flags[0])];
    483   1.71     enami 	char dev[4 + 1 + 7 + 1]; /* 12bit marjor + 20bit minor */
    484   1.71     enami 	char *name;
    485   1.30    bouyer 	mode_t type;
    486   1.82      fvdl 	dev_t rdev;
    487   1.30    bouyer 
    488   1.30    bouyer 	KGETRET(VTOI(vp), &inode, sizeof(struct inode), "vnode's inode");
    489  1.115   mlelstv 	KGETRET(ip->i_ump, &ump, sizeof(struct ufsmount),
    490  1.115   mlelstv 	    "vnode's mount point");
    491   1.82      fvdl 
    492  1.115   mlelstv 	if (ump.um_fstype == UFS1) {
    493  1.115   mlelstv 		KGETRET(ip->i_din.ffs1_din, &dip, sizeof (struct ufs1_dinode),
    494  1.115   mlelstv 		    "inode's dinode");
    495  1.116     enami 		rdev = (uint32_t)dip.dp1.di_rdev;
    496  1.115   mlelstv 	} else {
    497  1.115   mlelstv 		KGETRET(ip->i_din.ffs2_din, &dip, sizeof (struct ufs2_dinode),
    498   1.82      fvdl 		    "inode's UFS2 dinode");
    499   1.82      fvdl 		rdev = dip.dp2.di_rdev;
    500   1.82      fvdl 	}
    501   1.71     enami 
    502   1.71     enami 	/*
    503   1.71     enami 	 * XXX need to to locking state.
    504   1.71     enami 	 */
    505   1.71     enami 
    506   1.71     enami 	(void)getflags(ufs_flags, flags, ip->i_flag);
    507   1.90  christos 	PRWORD(ovflw, " %*llu", 7, 1, (unsigned long long)ip->i_number);
    508   1.71     enami 	PRWORD(ovflw, " %*s", 6, 1, flags);
    509   1.82      fvdl 	type = ip->i_mode & S_IFMT;
    510   1.82      fvdl 	if (S_ISCHR(ip->i_mode) || S_ISBLK(ip->i_mode)) {
    511   1.49     enami 		if (usenumflag ||
    512   1.82      fvdl 		    (name = devname(rdev, type)) == NULL) {
    513  1.111  christos 			devprintf(dev, sizeof(dev), rdev);
    514   1.71     enami 			name = dev;
    515   1.66     enami 		}
    516   1.66     enami 		PRWORD(ovflw, " %*s", 8, 1, name);
    517   1.66     enami 	} else
    518   1.82      fvdl 		PRWORD(ovflw, " %*lld", 8, 1, (long long)ip->i_size);
    519   1.82      fvdl 	return 0;
    520   1.30    bouyer }
    521   1.30    bouyer 
    522   1.30    bouyer int
    523   1.91    rpaulo ext2fs_print(struct vnode *vp, int ovflw)
    524   1.30    bouyer {
    525   1.30    bouyer 	struct inode inode, *ip = &inode;
    526   1.98    daniel 	struct ext2fs_dinode dip;
    527   1.71     enami 	char flags[sizeof(ufs_flags) / sizeof(ufs_flags[0])];
    528   1.71     enami 	char dev[4 + 1 + 7 + 1]; /* 12bit marjor + 20bit minor */
    529   1.71     enami 	char *name;
    530   1.30    bouyer 	mode_t type;
    531   1.30    bouyer 
    532   1.30    bouyer 	KGETRET(VTOI(vp), &inode, sizeof(struct inode), "vnode's inode");
    533   1.98    daniel 	KGETRET(ip->i_din.e2fs_din, &dip, sizeof (struct ext2fs_dinode),
    534   1.98    daniel 	    "inode's dinode");
    535   1.71     enami 
    536   1.71     enami 	/*
    537   1.71     enami 	 * XXX need to to locking state.
    538   1.71     enami 	 */
    539   1.71     enami 
    540   1.71     enami 	(void)getflags(ufs_flags, flags, ip->i_flag);
    541   1.90  christos 	PRWORD(ovflw, " %*llu", 7, 1, (unsigned long long)ip->i_number);
    542   1.71     enami 	PRWORD(ovflw, " %*s", 6, 1, flags);
    543   1.98    daniel 	type = dip.e2di_mode & S_IFMT;
    544   1.98    daniel 	if (S_ISCHR(dip.e2di_mode) || S_ISBLK(dip.e2di_mode)) {
    545   1.49     enami 		if (usenumflag ||
    546   1.98    daniel 		    (name = devname(dip.e2di_rdev, type)) == NULL) {
    547  1.111  christos 			devprintf(dev, sizeof(dev), dip.e2di_rdev);
    548   1.71     enami 			name = dev;
    549   1.66     enami 		}
    550   1.66     enami 		PRWORD(ovflw, " %*s", 8, 1, name);
    551   1.66     enami 	} else
    552   1.98    daniel 		PRWORD(ovflw, " %*u", 8, 1, (u_int)dip.e2di_size);
    553    1.1       cgd 	return (0);
    554    1.1       cgd }
    555    1.1       cgd 
    556   1.71     enami const struct flagbit_desc nfs_flags[] = {
    557   1.71     enami 	{ NFLUSHWANT,	'W' },
    558   1.71     enami 	{ NFLUSHINPROG,	'P' },
    559   1.71     enami 	{ NMODIFIED,	'M' },
    560   1.71     enami 	{ NWRITEERR,	'E' },
    561   1.71     enami 	{ NACC,		'A' },
    562   1.71     enami 	{ NUPD,		'U' },
    563   1.71     enami 	{ NCHG,		'C' },
    564   1.71     enami 	{ 0,		'\0' },
    565   1.71     enami };
    566   1.71     enami 
    567    1.1       cgd void
    568   1.91    rpaulo nfs_header(void)
    569    1.1       cgd {
    570   1.49     enami 
    571    1.1       cgd 	(void)printf(" FILEID NFLAG RDEV|SZ");
    572    1.1       cgd }
    573    1.1       cgd 
    574    1.1       cgd int
    575   1.91    rpaulo nfs_print(struct vnode *vp, int ovflw)
    576    1.1       cgd {
    577    1.1       cgd 	struct nfsnode nfsnode, *np = &nfsnode;
    578   1.71     enami 	char flags[sizeof(nfs_flags) / sizeof(nfs_flags[0])];
    579   1.71     enami 	char dev[4 + 1 + 7 + 1]; /* 12bit marjor + 20bit minor */
    580   1.38  drochner 	struct vattr va;
    581    1.1       cgd 	char *name;
    582    1.1       cgd 	mode_t type;
    583    1.1       cgd 
    584    1.1       cgd 	KGETRET(VTONFS(vp), &nfsnode, sizeof(nfsnode), "vnode's nfsnode");
    585   1.71     enami 	(void)getflags(nfs_flags, flags, np->n_flag);
    586    1.1       cgd 
    587   1.38  drochner 	KGETRET(np->n_vattr, &va, sizeof(va), "vnode attr");
    588   1.66     enami 	PRWORD(ovflw, " %*ld", 7, 1, (long)va.va_fileid);
    589   1.71     enami 	PRWORD(ovflw, " %*s", 6, 1, flags);
    590   1.55     enami 	switch (va.va_type) {
    591   1.55     enami 	case VCHR:
    592   1.55     enami 		type = S_IFCHR;
    593   1.55     enami 		goto device;
    594   1.55     enami 
    595   1.55     enami 	case VBLK:
    596   1.55     enami 		type = S_IFBLK;
    597   1.55     enami 	device:
    598   1.66     enami 		if (usenumflag || (name = devname(va.va_rdev, type)) == NULL) {
    599  1.111  christos 			devprintf(dev, sizeof(dev), va.va_rdev);
    600   1.71     enami 			name = dev;
    601   1.66     enami 		}
    602   1.66     enami 		PRWORD(ovflw, " %*s", 8, 1, name);
    603   1.55     enami 		break;
    604   1.55     enami 	default:
    605   1.66     enami 		PRWORD(ovflw, " %*lld", 8, 1, (long long)np->n_size);
    606   1.55     enami 		break;
    607   1.55     enami 	}
    608   1.56     enami 	return (0);
    609   1.56     enami }
    610   1.56     enami 
    611   1.56     enami void
    612   1.91    rpaulo layer_header(void)
    613   1.56     enami {
    614   1.56     enami 
    615   1.67     enami 	(void)printf(" %*s", PTRSTRWIDTH, "LOWER");
    616   1.56     enami }
    617   1.56     enami 
    618   1.56     enami int
    619   1.91    rpaulo layer_print(struct vnode *vp, int ovflw)
    620   1.56     enami {
    621   1.56     enami 	struct layer_node lnode, *lp = &lnode;
    622   1.56     enami 
    623   1.56     enami 	KGETRET(VTOLAYER(vp), &lnode, sizeof(lnode), "layer vnode");
    624   1.56     enami 
    625   1.67     enami 	PRWORD(ovflw, " %*lx", PTRSTRWIDTH + 1, 1, (long)lp->layer_lowervp);
    626    1.1       cgd 	return (0);
    627    1.1       cgd }
    628   1.33       mrg 
    629    1.1       cgd /*
    630    1.1       cgd  * Given a pointer to a mount structure in kernel space,
    631    1.1       cgd  * read it in and return a usable pointer to it.
    632    1.1       cgd  */
    633    1.1       cgd struct mount *
    634   1.91    rpaulo getmnt(struct mount *maddr)
    635    1.1       cgd {
    636    1.1       cgd 	static struct mtab {
    637    1.1       cgd 		struct mtab *next;
    638    1.1       cgd 		struct mount *maddr;
    639    1.1       cgd 		struct mount mount;
    640    1.1       cgd 	} *mhead = NULL;
    641   1.33       mrg 	struct mtab *mt;
    642   1.95  christos 	struct mount mb;
    643    1.1       cgd 
    644    1.1       cgd 	for (mt = mhead; mt != NULL; mt = mt->next)
    645    1.1       cgd 		if (maddr == mt->maddr)
    646    1.1       cgd 			return (&mt->mount);
    647   1.95  christos 	KGETRET(maddr, &mb, sizeof(struct mount), "mount table");
    648    1.1       cgd 	if ((mt = malloc(sizeof(struct mtab))) == NULL)
    649   1.34     lukem 		err(1, "malloc");
    650   1.95  christos 	mt->mount = mb;
    651    1.1       cgd 	mt->maddr = maddr;
    652    1.1       cgd 	mt->next = mhead;
    653    1.1       cgd 	mhead = mt;
    654    1.1       cgd 	return (&mt->mount);
    655    1.1       cgd }
    656    1.1       cgd 
    657    1.1       cgd void
    658   1.91    rpaulo mount_print(struct mount *mp)
    659    1.1       cgd {
    660   1.33       mrg 	int flags;
    661    1.1       cgd 
    662   1.33       mrg 	(void)printf("*** MOUNT %s %s on %s", ST.f_fstypename,
    663    1.2       cgd 	    ST.f_mntfromname, ST.f_mntonname);
    664   1.34     lukem 	if ((flags = mp->mnt_flag) != 0) {
    665  1.114     lukem 		size_t i;
    666   1.33       mrg 		const char *sep = " (";
    667    1.1       cgd 
    668   1.93      elad 		for (i = 0; i < sizeof mnt_flags / sizeof mnt_flags[0]; i++) {
    669   1.33       mrg 			if (flags & mnt_flags[i].m_flag) {
    670   1.33       mrg 				(void)printf("%s%s", sep, mnt_flags[i].m_name);
    671   1.33       mrg 				flags &= ~mnt_flags[i].m_flag;
    672   1.33       mrg 				sep = ",";
    673   1.33       mrg 			}
    674   1.49     enami 		}
    675   1.49     enami 		if (flags)
    676   1.49     enami 			(void)printf("%sunknown_flags:%x", sep, flags);
    677    1.1       cgd 		(void)printf(")");
    678    1.1       cgd 	}
    679    1.1       cgd 	(void)printf("\n");
    680    1.1       cgd }
    681    1.1       cgd 
    682   1.81       mrg char *
    683   1.91    rpaulo loadvnodes(int *avnodes)
    684    1.1       cgd {
    685    1.1       cgd 	int mib[2];
    686  1.120       apb 	int status;
    687  1.121  christos 	size_t copysize;
    688  1.121  christos #if 0
    689  1.121  christos 	size_t oldsize;
    690  1.121  christos #endif
    691   1.81       mrg 	char *vnodebase;
    692    1.1       cgd 
    693  1.102    briggs 	if (totalflag) {
    694  1.102    briggs 		KGET(V_NUMV, *avnodes);
    695  1.102    briggs 		return NULL;
    696  1.102    briggs 	}
    697    1.1       cgd 	if (memf != NULL) {
    698    1.1       cgd 		/*
    699    1.1       cgd 		 * do it by hand
    700    1.1       cgd 		 */
    701   1.81       mrg 		return (kinfo_vnodes(avnodes));
    702    1.1       cgd 	}
    703    1.1       cgd 	mib[0] = CTL_KERN;
    704    1.1       cgd 	mib[1] = KERN_VNODE;
    705  1.120       apb 	/*
    706  1.120       apb 	 * First sysctl call gets the necessary buffer size; second
    707  1.120       apb 	 * sysctl call gets the data.  We allow for some growth in the
    708  1.120       apb 	 * data size between the two sysctl calls (increases of a few
    709  1.120       apb 	 * thousand vnodes in between the two calls have been observed).
    710  1.120       apb 	 * We ignore ENOMEM from the second sysctl call, which can
    711  1.120       apb 	 * happen if the kernel's data grew by even more than we allowed
    712  1.120       apb 	 * for.
    713  1.120       apb 	 */
    714    1.1       cgd 	if (sysctl(mib, 2, NULL, &copysize, NULL, 0) == -1)
    715    1.1       cgd 		err(1, "sysctl: KERN_VNODE");
    716  1.121  christos #if 0
    717  1.120       apb 	oldsize = copysize;
    718  1.121  christos #endif
    719  1.120       apb 	copysize += 100 * sizeof(struct vnode) + copysize / 20;
    720   1.81       mrg 	if ((vnodebase = malloc(copysize)) == NULL)
    721   1.34     lukem 		err(1, "malloc");
    722  1.120       apb 	status = sysctl(mib, 2, vnodebase, &copysize, NULL, 0);
    723  1.120       apb 	if (status == -1 && errno != ENOMEM)
    724    1.1       cgd 		err(1, "sysctl: KERN_VNODE");
    725  1.120       apb #if 0 /* for debugging the amount of growth allowed for */
    726  1.120       apb 	if (copysize != oldsize) {
    727  1.120       apb 		warnx("count changed from %ld to %ld (%+ld)%s",
    728  1.120       apb 		    (long)(oldsize / sizeof(struct vnode)),
    729  1.120       apb 		    (long)(copysize / sizeof(struct vnode)),
    730  1.120       apb 		    (long)(copysize / sizeof(struct vnode)) -
    731  1.120       apb 			(long)(oldsize / sizeof(struct vnode)),
    732  1.120       apb 		    (status == 0 ? "" : ", and errno = ENOMEM"));
    733  1.120       apb 	}
    734  1.120       apb #endif
    735   1.59     enami 	if (copysize % (VPTRSZ + VNODESZ))
    736    1.1       cgd 		errx(1, "vnode size mismatch");
    737   1.81       mrg 	*avnodes = copysize / (VPTRSZ + VNODESZ);
    738   1.81       mrg 
    739   1.81       mrg 	return (vnodebase);
    740    1.1       cgd }
    741    1.1       cgd 
    742    1.1       cgd /*
    743    1.1       cgd  * simulate what a running kernel does in in kinfo_vnode
    744    1.1       cgd  */
    745   1.81       mrg char *
    746   1.91    rpaulo kinfo_vnodes(int *avnodes)
    747    1.1       cgd {
    748  1.114     lukem 	struct mntlist mlist;
    749    1.1       cgd 	struct mount *mp, mount;
    750    1.1       cgd 	struct vnode *vp, vnode;
    751   1.59     enami 	char *beg, *bp, *ep;
    752  1.126   hannken 	int numvnodes, next_offset;
    753    1.1       cgd 
    754    1.1       cgd 	KGET(V_NUMV, numvnodes);
    755   1.59     enami 	if ((bp = malloc((numvnodes + 20) * (VPTRSZ + VNODESZ))) == NULL)
    756   1.34     lukem 		err(1, "malloc");
    757   1.59     enami 	beg = bp;
    758   1.59     enami 	ep = bp + (numvnodes + 20) * (VPTRSZ + VNODESZ);
    759  1.126   hannken 	KGET(V_NEXT_OFFSET, next_offset);
    760  1.114     lukem 	KGET(V_MOUNTLIST, mlist);
    761  1.126   hannken 	mp = TAILQ_FIRST(&mlist);
    762  1.126   hannken 	while (mp != NULL) {
    763    1.1       cgd 		KGET2(mp, &mount, sizeof(mount), "mount entry");
    764  1.126   hannken 		vp = (struct vnode *)TAILQ_FIRST(&mount.mnt_vnodelist);
    765  1.126   hannken 		while (vp != NULL) {
    766    1.1       cgd 			KGET2(vp, &vnode, sizeof(vnode), "vnode");
    767   1.59     enami 			if (bp + VPTRSZ + VNODESZ > ep)
    768    1.1       cgd 				/* XXX - should realloc */
    769    1.1       cgd 				errx(1, "no more room for vnodes");
    770    1.1       cgd 			memmove(bp, &vp, VPTRSZ);
    771    1.1       cgd 			bp += VPTRSZ;
    772    1.1       cgd 			memmove(bp, &vnode, VNODESZ);
    773    1.1       cgd 			bp += VNODESZ;
    774  1.126   hannken 			KGET2((char *)vp + next_offset, &vp, sizeof(vp), "nvp");
    775    1.1       cgd 		}
    776  1.126   hannken 		mp = TAILQ_NEXT(&mount, mnt_list);
    777    1.1       cgd 	}
    778   1.59     enami 	*avnodes = (bp - beg) / (VPTRSZ + VNODESZ);
    779   1.81       mrg 	return (beg);
    780    1.1       cgd }
    781   1.49     enami 
    782    1.1       cgd void
    783   1.91    rpaulo ttymode(void)
    784    1.1       cgd {
    785   1.34     lukem 	int ntty;
    786   1.20       mrg 	struct ttylist_head tty_head;
    787   1.20       mrg 	struct tty *tp, tty;
    788   1.20       mrg 
    789   1.20       mrg 	KGET(TTY_NTTY, ntty);
    790   1.20       mrg 	(void)printf("%d terminal device%s\n", ntty, ntty == 1 ? "" : "s");
    791   1.20       mrg 	KGET(TTY_TTYLIST, tty_head);
    792   1.72     enami 	(void)printf(
    793   1.72     enami 	    "  LINE RAW CAN OUT  HWT LWT     COL STATE  %-*s  PGID DISC\n",
    794   1.72     enami 	    PTRSTRWIDTH, "SESS");
    795   1.20       mrg 	for (tp = tty_head.tqh_first; tp; tp = tty.tty_link.tqe_next) {
    796   1.20       mrg 		KGET2(tp, &tty, sizeof tty, "tty struct");
    797   1.20       mrg 		ttyprt(&tty);
    798    1.3   deraadt 	}
    799    1.1       cgd }
    800    1.1       cgd 
    801   1.74  jdolecek static const struct flagbit_desc ttystates[] = {
    802    1.1       cgd 	{ TS_ISOPEN,	'O'},
    803   1.41   mycroft 	{ TS_DIALOUT,	'>'},
    804    1.1       cgd 	{ TS_CARR_ON,	'C'},
    805    1.1       cgd 	{ TS_TIMEOUT,	'T'},
    806    1.1       cgd 	{ TS_FLUSH,	'F'},
    807    1.1       cgd 	{ TS_BUSY,	'B'},
    808    1.1       cgd 	{ TS_XCLUDE,	'X'},
    809    1.1       cgd 	{ TS_TTSTOP,	'S'},
    810    1.1       cgd 	{ TS_TBLOCK,	'K'},
    811    1.1       cgd 	{ TS_ASYNC,	'Y'},
    812    1.1       cgd 	{ TS_BKSL,	'D'},
    813    1.1       cgd 	{ TS_ERASE,	'E'},
    814    1.1       cgd 	{ TS_LNCH,	'L'},
    815    1.1       cgd 	{ TS_TYPEN,	'P'},
    816    1.1       cgd 	{ TS_CNTTB,	'N'},
    817   1.72     enami 	{ 0,		'\0'},
    818    1.1       cgd };
    819    1.1       cgd 
    820    1.1       cgd void
    821   1.91    rpaulo ttyprt(struct tty *tp)
    822    1.1       cgd {
    823   1.71     enami 	char state[sizeof(ttystates) / sizeof(ttystates[0]) + 1];
    824   1.72     enami 	char dev[2 + 3 + 1 + 5 + 1]; /* 12bit major + 20bit minor */
    825   1.71     enami 	struct linesw t_linesw;
    826   1.89  christos 	const char *name;
    827   1.89  christos 	char buffer;
    828    1.1       cgd 	pid_t pgid;
    829   1.72     enami 	int n, ovflw;
    830    1.1       cgd 
    831   1.72     enami 	if (usenumflag || (name = devname(tp->t_dev, S_IFCHR)) == NULL) {
    832  1.111  christos 		devprintf(dev, sizeof(dev), tp->t_dev);
    833   1.72     enami 		name = dev;
    834   1.72     enami 	}
    835   1.72     enami 	ovflw = 0;
    836   1.72     enami 	PRWORD(ovflw, "%-*s", 7, 0, name);
    837   1.72     enami 	PRWORD(ovflw, " %*d", 3, 1, tp->t_rawq.c_cc);
    838   1.72     enami 	PRWORD(ovflw, " %*d", 4, 1, tp->t_canq.c_cc);
    839   1.72     enami 	PRWORD(ovflw, " %*d", 4, 1, tp->t_outq.c_cc);
    840   1.72     enami 	PRWORD(ovflw, " %*d", 5, 1, tp->t_hiwat);
    841   1.72     enami 	PRWORD(ovflw, " %*d", 4, 1, tp->t_lowat);
    842   1.72     enami 	PRWORD(ovflw, " %*d", 8, 1, tp->t_column);
    843   1.71     enami 	n = getflags(ttystates, state, tp->t_state);
    844   1.71     enami 	if (tp->t_wopen) {
    845   1.71     enami 		state[n++] = 'W';
    846   1.71     enami 		state[n] = '\0';
    847   1.71     enami 	}
    848   1.72     enami 	PRWORD(ovflw, " %-*s", 7, 1, state);
    849   1.72     enami 	PRWORD(ovflw, " %*lX", PTRSTRWIDTH + 1, 1, (u_long)tp->t_session);
    850    1.1       cgd 	pgid = 0;
    851    1.1       cgd 	if (tp->t_pgrp != NULL)
    852    1.1       cgd 		KGET2(&tp->t_pgrp->pg_id, &pgid, sizeof(pid_t), "pgid");
    853   1.72     enami 	PRWORD(ovflw, " %*d", 6, 1, pgid);
    854   1.54      tron 	KGET2(tp->t_linesw, &t_linesw, sizeof(t_linesw),
    855   1.64     enami 	    "line discipline switch table");
    856   1.54      tron 	name = t_linesw.l_name;
    857   1.72     enami 	(void)putchar(' ');
    858   1.54      tron 	for (;;) {
    859   1.54      tron 		KGET2(name, &buffer, sizeof(buffer), "line discipline name");
    860   1.54      tron 		if (buffer == '\0')
    861   1.54      tron 			break;
    862   1.54      tron 		(void)putchar(buffer);
    863   1.54      tron 		name++;
    864    1.1       cgd 	}
    865   1.54      tron 	(void)putchar('\n');
    866    1.1       cgd }
    867    1.1       cgd 
    868   1.74  jdolecek static const struct flagbit_desc filemode_flags[] = {
    869   1.71     enami 	{ FREAD,	'R' },
    870   1.71     enami 	{ FWRITE,	'W' },
    871   1.71     enami 	{ FAPPEND,	'A' },
    872   1.71     enami #ifdef FSHLOCK	/* currently gone */
    873   1.71     enami 	{ FSHLOCK,	'S' },
    874   1.71     enami 	{ FEXLOCK,	'X' },
    875   1.71     enami #endif
    876   1.71     enami 	{ FASYNC,	'I' },
    877   1.71     enami 	{ 0,		'\0' },
    878   1.71     enami };
    879   1.71     enami 
    880    1.1       cgd void
    881   1.91    rpaulo filemode(void)
    882    1.1       cgd {
    883  1.113       mrg 	struct kinfo_file *ki;
    884   1.71     enami 	char flags[sizeof(filemode_flags) / sizeof(filemode_flags[0])];
    885   1.86       jdc 	char *buf, *offset;
    886   1.72     enami 	int len, maxfile, nfile, ovflw;
    887    1.1       cgd 
    888    1.1       cgd 	KGET(FNL_MAXFILE, maxfile);
    889    1.1       cgd 	if (totalflag) {
    890    1.1       cgd 		KGET(FNL_NFILE, nfile);
    891    1.1       cgd 		(void)printf("%3d/%3d files\n", nfile, maxfile);
    892    1.1       cgd 		return;
    893    1.1       cgd 	}
    894   1.86       jdc 	if (getfiles(&buf, &len, &offset) == -1)
    895    1.1       cgd 		return;
    896    1.1       cgd 	/*
    897  1.113       mrg 	 * Getfiles returns in malloc'd memory to an array of kinfo_file2
    898  1.113       mrg 	 * structures.
    899    1.1       cgd 	 */
    900  1.113       mrg 	nfile = len / sizeof(struct kinfo_file);
    901   1.49     enami 
    902    1.1       cgd 	(void)printf("%d/%d open files\n", nfile, maxfile);
    903  1.107        ad 	(void)printf("%*s%s%*s TYPE    FLG     CNT  MSG  %*s%s%*s IFLG OFFSET\n",
    904   1.72     enami 	    (PTRSTRWIDTH - 4) / 2, "", " LOC", (PTRSTRWIDTH - 4) / 2, "",
    905   1.72     enami 	    (PTRSTRWIDTH - 4) / 2, "", "DATA", (PTRSTRWIDTH - 4) / 2, "");
    906  1.113       mrg 	for (ki = (struct kinfo_file *)offset; nfile--; ki++) {
    907  1.113       mrg 		if ((unsigned)ki->ki_ftype >= sizeof(dtypes) / sizeof(dtypes[0]))
    908    1.1       cgd 			continue;
    909   1.72     enami 		ovflw = 0;
    910  1.113       mrg 		(void)getflags(filemode_flags, flags, ki->ki_flag);
    911  1.113       mrg 		PRWORD(ovflw, "%*lx", PTRSTRWIDTH, 0, (long)ki->ki_fileaddr);
    912  1.113       mrg 		PRWORD(ovflw, " %-*s", 9, 1, dtypes[ki->ki_ftype]);
    913   1.72     enami 		PRWORD(ovflw, " %*s", 6, 1, flags);
    914  1.113       mrg 		PRWORD(ovflw, " %*d", 5, 1, ki->ki_count);
    915  1.113       mrg 		PRWORD(ovflw, " %*d", 5, 1, ki->ki_msgcount);
    916  1.113       mrg 		PRWORD(ovflw, "  %*lx", PTRSTRWIDTH + 1, 2, (long)ki->ki_fdata);
    917  1.112        ad 		PRWORD(ovflw, " %*x", 5, 1, 0);
    918  1.114     lukem 		if ((off_t)ki->ki_foffset < 0)
    919   1.86       jdc 			PRWORD(ovflw, "  %-*lld\n", PTRSTRWIDTH + 1, 2,
    920  1.113       mrg 			    (long long)ki->ki_foffset);
    921    1.1       cgd 		else
    922   1.72     enami 			PRWORD(ovflw, "  %-*lld\n", PTRSTRWIDTH + 1, 2,
    923  1.113       mrg 			    (long long)ki->ki_foffset);
    924    1.1       cgd 	}
    925    1.1       cgd 	free(buf);
    926    1.1       cgd }
    927    1.1       cgd 
    928    1.1       cgd int
    929   1.91    rpaulo getfiles(char **abuf, int *alen, char **aoffset)
    930    1.1       cgd {
    931    1.1       cgd 	size_t len;
    932  1.113       mrg 	int mib[6];
    933    1.1       cgd 	char *buf;
    934   1.86       jdc 	size_t offset;
    935    1.1       cgd 
    936    1.1       cgd 	/*
    937    1.1       cgd 	 * XXX
    938    1.1       cgd 	 * Add emulation of KINFO_FILE here.
    939    1.1       cgd 	 */
    940    1.1       cgd 	if (memf != NULL)
    941   1.61        ad 		errx(1, "files on dead kernel, not implemented");
    942    1.1       cgd 
    943    1.1       cgd 	mib[0] = CTL_KERN;
    944  1.113       mrg 	mib[1] = KERN_FILE2;
    945  1.113       mrg 	mib[2] = KERN_FILE_BYFILE;
    946  1.113       mrg 	mib[3] = 0;
    947  1.113       mrg 	mib[4] = sizeof(struct kinfo_file);
    948  1.113       mrg 	mib[5] = 0;
    949  1.113       mrg 	if (sysctl(mib, 6, NULL, &len, NULL, 0) == -1) {
    950  1.113       mrg 		warn("sysctl: KERN_FILE2");
    951    1.1       cgd 		return (-1);
    952    1.1       cgd 	}
    953  1.113       mrg 	/* We need to align (struct kinfo_file *) in the buffer. */
    954   1.86       jdc 	offset = len % sizeof(off_t);
    955  1.113       mrg 	mib[5] = len / sizeof(struct kinfo_file);
    956   1.86       jdc 	if ((buf = malloc(len + offset)) == NULL)
    957   1.34     lukem 		err(1, "malloc");
    958  1.113       mrg 	if (sysctl(mib, 6, buf + offset, &len, NULL, 0) == -1) {
    959  1.113       mrg 		warn("sysctl: 2nd KERN_FILE2");
    960  1.117       wiz 		free(buf);
    961    1.1       cgd 		return (-1);
    962    1.1       cgd 	}
    963    1.1       cgd 	*abuf = buf;
    964    1.1       cgd 	*alen = len;
    965   1.86       jdc 	*aoffset = (buf + offset);
    966    1.1       cgd 	return (0);
    967    1.1       cgd }
    968    1.1       cgd 
    969    1.1       cgd void
    970   1.91    rpaulo usage(void)
    971    1.1       cgd {
    972   1.49     enami 
    973    1.1       cgd 	(void)fprintf(stderr,
    974   1.85       mrg 	    "usage: %s [-T|-f|-s|-t|-v] [-ghkmn] [-M core] [-N system]\n",
    975   1.69     enami 	    getprogname());
    976    1.1       cgd 	exit(1);
    977    1.1       cgd }
    978