- Commit work from libprocstat project. These patches add support for runtime

  file and processes information retrieval from the running kernel via sysctl
  in the form of new library, libprocstat.  The library also supports KVM backend
  for analyzing memory crash dumps.  Both procstat(1) and fstat(1) utilities have
  been modified to take advantage of the library (as the bonus point the fstat(1)
  utility no longer need superuser privileges to operate), and the procstat(1)
  utility is now able to display information from memory dumps as well.

  The newly introduced fuser(1) utility also uses this library and able to operate
  via sysctl and kvm backends.

  The library is by no means complete (e.g. KVM backend is missing vnode name
  resolution routines, and there're no manpages for the library itself) so I
  plan to improve it further.  I'm commiting it so it will get wider exposure
  and review.

  We won't be able to MFC this work as it relies on changes in HEAD, which
  was introduced some time ago, that break kernel ABI.  OTOH we may be able
  to merge the library with KVM backend if we really need it there.

Discussed with:	rwatson

42 files changed, 3931 insertions, 1250 deletions

diff --git a/lib/Makefile b/lib/Makefile
index 4fef1bb..7be186f 100644
--- a/lib/Makefile
+++ b/lib/Makefile
@@ -92,6 +92,7 @@ SUBDIR=	${SUBDIR_ORDERED} \
 	${_libpkg} \
 	${_libpmc} \
 	${_libproc} \
+	libprocstat \
 	librt \
 	${_librtld_db} \
 	${_libsdp} \
diff --git a/lib/libprocstat/Makefile b/lib/libprocstat/Makefile
new file mode 100644
index 0000000..dc3dd58
--- /dev/null
+++ b/lib/libprocstat/Makefile
@@ -0,0 +1,36 @@
+# $FreeBSD$
+
+.include <bsd.own.mk>
+
+LIB=	procstat
+
+SRCS=	cd9660.c	\
+	common_kvm.c	\
+	libprocstat.c	\
+        msdosfs.c	\
+	ntfs.c		\
+	nwfs.c		\
+	smbfs.c		\
+	udf.c
+
+INCS=	libprocstat.h
+CFLAGS+=	-I. -I${.CURDIR} -D_KVM_VNODE
+SHLIB_MAJOR=	1
+WITHOUT_MAN=	yes
+
+# XXX This is a hack.
+.if ${MK_CDDL} != "no"
+CFLAGS+=	-DZFS
+OBJS+=	zfs/zfs.o
+SOBJS+=	zfs/zfs.So
+POBJS+=	zfs/zfs.po
+SUBDIR=	zfs
+zfs/zfs.o: .PHONY
+	@cd ${.CURDIR}/zfs && ${MAKE} zfs.o
+zfs/zfs.So: .PHONY
+	@cd ${.CURDIR}/zfs && ${MAKE} zfs.So
+zfs/zfs.po: .PHONY
+	@cd ${.CURDIR}/zfs && ${MAKE} zfs.po
+.endif
+
+.include <bsd.lib.mk>
diff --git a/usr.bin/fstat/cd9660.c b/lib/libprocstat/cd9660.c
index 1c26e8d..95882be 100644
--- a/usr.bin/fstat/cd9660.c
+++ b/lib/libprocstat/cd9660.c
@@ -49,31 +49,42 @@ __FBSDID("$FreeBSD$");
 #include <sys/vnode.h>
 #include <sys/mount.h>
 
+#include <netinet/in.h>
+
+#include <err.h>
+
 #include <isofs/cd9660/cd9660_node.h>
+#define _KERNEL
+#include <isofs/cd9660/iso.h>
+#undef _KERNEL
 
 #include <kvm.h>
 #include <stdio.h>
 
-#include "fstat.h"
+#include "libprocstat.h"
+#include "common_kvm.h"
 
 int
-isofs_filestat(struct vnode *vp, struct filestat *fsp)
+isofs_filestat(kvm_t *kd, struct vnode *vp, struct vnstat *vn)
 {
 	struct iso_node isonode;
+	struct iso_mnt mnt;
 
-	if (!KVM_READ(VTOI(vp), &isonode, sizeof (isonode))) {
-		dprintf(stderr, "can't read iso_node at %p for pid %d\n",
-		    (void *)VTOI(vp), Pid);
-		return 0;
+	if (!kvm_read_all(kd, (unsigned long)VTOI(vp), &isonode,
+	    sizeof(isonode))) {
+		warnx("can't read iso_node at %p",
+		    (void *)VTOI(vp));
+		return (1);
 	}
-#if 0
-	fsp->fsid = dev2udev(isonode.i_dev);
-#endif
-	fsp->mode = (mode_t)isonode.inode.iso_mode;
-	fsp->rdev = isonode.inode.iso_rdev;
-
-	fsp->fileid = (long)isonode.i_number;
-	fsp->size = (u_long)isonode.i_size;
-	return 1;
+	if (!kvm_read_all(kd, (unsigned long)isonode.i_mnt, &mnt,
+	    sizeof(mnt))) {
+		warnx("can't read iso_mnt at %p",
+		    (void *)VTOI(vp));
+		return (1);
+	}
+	vn->vn_fsid = dev2udev(kd, mnt.im_dev);
+	vn->vn_mode = (mode_t)isonode.inode.iso_mode;
+	vn->vn_fileid = (long)isonode.i_number;
+	vn->vn_size = (u_long)isonode.i_size;
+	return (0);
 }
-
diff --git a/lib/libprocstat/common_kvm.c b/lib/libprocstat/common_kvm.c
new file mode 100644
index 0000000..1ff181c
--- /dev/null
+++ b/lib/libprocstat/common_kvm.c
@@ -0,0 +1,207 @@
+/*-
+ * Copyright (c) 2009 Stanislav Sedov <stas@FreeBSD.org>
+ * Copyright (c) 1988, 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. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Berkeley and its contributors.
+ * 4. 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.
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <sys/param.h>
+#include <sys/user.h>
+#include <sys/stat.h>
+#include <sys/vnode.h>
+#include <sys/conf.h>
+#define	_KERNEL
+#include <sys/pipe.h>
+#include <sys/mount.h>
+#include <ufs/ufs/quota.h>
+#include <ufs/ufs/inode.h>
+#include <fs/devfs/devfs.h>
+#include <fs/devfs/devfs_int.h>
+#undef _KERNEL
+#include <nfs/nfsproto.h>
+#include <nfsclient/nfs.h>
+#include <nfsclient/nfsnode.h>
+
+#include <assert.h>
+#include <err.h>
+#include <kvm.h>
+#include <stddef.h>
+#include <string.h>
+
+#include <libprocstat.h>
+#include "common_kvm.h"
+
+int
+kvm_read_all(kvm_t *kd, unsigned long addr, void *buf, size_t nbytes)
+{
+	ssize_t error;
+
+	if (nbytes >= SSIZE_MAX)
+		return (0);
+	error = kvm_read(kd, addr, buf, nbytes);
+	return (error == (ssize_t)(nbytes));
+}
+
+int
+kdevtoname(kvm_t *kd, struct cdev *dev, char *buf)
+{
+	struct cdev si;
+
+	assert(buf);
+	if (!kvm_read_all(kd, (unsigned long)dev, &si, sizeof(si)))
+		return (1);
+	strlcpy(buf, si.__si_namebuf, SPECNAMELEN + 1);
+	return (0);
+}
+
+int
+ufs_filestat(kvm_t *kd, struct vnode *vp, struct vnstat *vn)
+{
+	struct inode inode;
+
+	if (!kvm_read_all(kd, (unsigned long)VTOI(vp), &inode, sizeof(inode))) {
+		warnx("can't read inode at %p", (void *)VTOI(vp));
+		return (1);
+	}
+	/*
+	 * The st_dev from stat(2) is a dev_t. These kernel structures
+	 * contain cdev pointers. We need to convert to dev_t to make
+	 * comparisons
+	 */
+	vn->vn_fsid = dev2udev(kd, inode.i_dev);
+	vn->vn_fileid = (long)inode.i_number;
+	vn->vn_mode = (mode_t)inode.i_mode;
+	vn->vn_size = (u_long)inode.i_size;
+	return (0);
+}
+
+int
+devfs_filestat(kvm_t *kd, struct vnode *vp, struct vnstat *vn)
+{
+	struct devfs_dirent devfs_dirent;
+	struct mount mount;
+
+	if (!kvm_read_all(kd, (unsigned long)getvnodedata(vp), &devfs_dirent,
+	    sizeof(devfs_dirent))) {
+		warnx("can't read devfs_dirent at %p",
+		    (void *)vp->v_data);
+		return (1);
+	}
+	if (!kvm_read_all(kd, (unsigned long)getvnodemount(vp), &mount,
+	    sizeof(mount))) {
+		warnx("can't read mount at %p",
+		    (void *)getvnodemount(vp));
+		return (1);
+	}
+	vn->vn_fsid = mount.mnt_stat.f_fsid.val[0];
+	vn->vn_fileid = devfs_dirent.de_inode;
+	vn->vn_mode = (devfs_dirent.de_mode & ~S_IFMT) | S_IFCHR;
+	vn->vn_size = 0;
+	return (0);
+}
+
+int
+nfs_filestat(kvm_t *kd, struct vnode *vp, struct vnstat *vn)
+{
+	struct nfsnode nfsnode;
+	mode_t mode;
+
+	if (!kvm_read_all(kd, (unsigned long)VTONFS(vp), &nfsnode,
+	    sizeof(nfsnode))) {
+		warnx("can't read nfsnode at %p",
+		    (void *)VTONFS(vp));
+		return (1);
+	}
+	vn->vn_fsid = nfsnode.n_vattr.va_fsid;
+	vn->vn_fileid = nfsnode.n_vattr.va_fileid;
+	vn->vn_size = nfsnode.n_size;
+	mode = (mode_t)nfsnode.n_vattr.va_mode;
+	switch (vp->v_type) {
+	case VREG:
+		mode |= S_IFREG;
+		break;
+	case VDIR:
+		mode |= S_IFDIR;
+		break;
+	case VBLK:
+		mode |= S_IFBLK;
+		break;
+	case VCHR:
+		mode |= S_IFCHR;
+		break;
+	case VLNK:
+		mode |= S_IFLNK;
+		break;
+	case VSOCK:
+		mode |= S_IFSOCK;
+		break;
+	case VFIFO:
+		mode |= S_IFIFO;
+		break;
+	default:
+		break;
+	};
+	vn->vn_mode = mode;
+	return (0);
+}
+
+/*
+ * Read the cdev structure in the kernel in order to work out the
+ * associated dev_t
+ */
+dev_t
+dev2udev(kvm_t *kd, struct cdev *dev)
+{
+	struct cdev_priv priv;
+
+	assert(kd);
+	if (kvm_read_all(kd, (unsigned long)cdev2priv(dev), &priv,
+	    sizeof(priv))) {
+		return ((dev_t)priv.cdp_inode);
+	} else {
+		warnx("can't convert cdev *%p to a dev_t\n", dev);
+		return (-1);
+	}
+}
+
+void *
+getvnodedata(struct vnode *vp)
+{
+	return (vp->v_data);
+}
+
+struct mount *
+getvnodemount(struct vnode *vp)
+{
+	return (vp->v_mount);
+}
diff --git a/usr.bin/fstat/fstat.h b/lib/libprocstat/common_kvm.h
index 3533a60..d0b5307 100644
--- a/usr.bin/fstat/fstat.h
+++ b/lib/libprocstat/common_kvm.h
@@ -1,6 +1,6 @@
 /*-
- * Copyright (c) 1988, 1993
- *	The Regents of the University of California.  All rights reserved.
+ * Copyright (c) 2009 Stanislav Sedov <stas@FreeBSD.org>
+ * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -10,9 +10,6 @@
  * 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.
- * 4. 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
@@ -29,48 +26,28 @@
  * $FreeBSD$
  */
 
-#ifndef	__FSTAT_H__
-#define	__FSTAT_H__
+#ifndef	_COMMON_KVM_H_
+#define	_COMMON_KVM_H_
+
+dev_t	dev2udev(kvm_t *kd, struct cdev *dev);
+int	kdevtoname(kvm_t *kd, struct cdev *dev, char *);
+int	kvm_read_all(kvm_t *kd, unsigned long addr, void *buf,
+    size_t nbytes);
 
 /*
- * a kvm_read that returns true if everything is read
+ * Filesystems specific access routines.
  */
-#define KVM_READ(kaddr, paddr, len) \
-	((len) < SSIZE_MAX && \
-	kvm_read(kd, (u_long)(kaddr), (char *)(paddr), (len)) == (ssize_t)(len))
-
-#define dprintf	if (vflg) fprintf
-
-typedef struct devs {
-	struct	devs *next;
-	long	fsid;
-	long	ino;
-	const char	*name;
-} DEVS;
-
-struct  filestat {
-	long	fsid;
-	long	fileid;
-	mode_t	mode;
-	u_long	size;
-	dev_t	rdev;
-};
-
-/* Ugh */
-extern kvm_t *kd;
-extern int vflg;
-extern int Pid;
-
-dev_t dev2udev(struct cdev *dev);
-
-/* Additional filesystem types */
-int isofs_filestat(struct vnode *vp, struct filestat *fsp);
-int msdosfs_filestat(struct vnode *vp, struct filestat *fsp);
-
-#ifdef ZFS
-int zfs_filestat(struct vnode *vp, struct filestat *fsp);
-void *getvnodedata(struct vnode *vp);
-struct mount *getvnodemount(struct vnode *vp);
-#endif
-
-#endif /* __FSTAT_H__ */
+int	devfs_filestat(kvm_t *kd, struct vnode *vp, struct vnstat *vn);
+int	isofs_filestat(kvm_t *kd, struct vnode *vp, struct vnstat *vn);
+int	msdosfs_filestat(kvm_t *kd, struct vnode *vp, struct vnstat *vn);
+int	nfs_filestat(kvm_t *kd, struct vnode *vp, struct vnstat *vn);
+int	ntfs_filestat(kvm_t *kd, struct vnode *vp, struct vnstat *vn);
+int	nwfs_filestat(kvm_t *kd, struct vnode *vp, struct vnstat *vn);
+int	smbfs_filestat(kvm_t *kd, struct vnode *vp, struct vnstat *vn);
+int	udf_filestat(kvm_t *kd, struct vnode *vp, struct vnstat *vn);
+int	ufs_filestat(kvm_t *kd, struct vnode *vp, struct vnstat *vn);
+int	zfs_filestat(kvm_t *kd, struct vnode *vp, struct vnstat *vn);
+void	*getvnodedata(struct vnode *vp);
+struct mount	*getvnodemount(struct vnode *vp);
+
+#endif	/* _COMMON_KVM_H_ */
diff --git a/lib/libprocstat/libprocstat.c b/lib/libprocstat/libprocstat.c
new file mode 100644
index 0000000..cfe81a2
--- /dev/null
+++ b/lib/libprocstat/libprocstat.c
@@ -0,0 +1,1306 @@
+/*-
+ * Copyright (c) 2009 Stanislav Sedov <stas@FreeBSD.org>
+ * Copyright (c) 1988, 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. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by the University of
+ *      California, Berkeley and its contributors.
+ * 4. 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.
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <sys/param.h>
+#include <sys/time.h>
+#include <sys/proc.h>
+#include <sys/user.h>
+#include <sys/stat.h>
+#include <sys/vnode.h>
+#include <sys/socket.h>
+#include <sys/socketvar.h>
+#include <sys/domain.h>
+#include <sys/protosw.h>
+#include <sys/un.h>
+#include <sys/unpcb.h>
+#include <sys/sysctl.h>
+#include <sys/tty.h>
+#include <sys/filedesc.h>
+#include <sys/queue.h>
+#define	_WANT_FILE
+#include <sys/file.h>
+#include <sys/conf.h>
+#define	_KERNEL
+#include <sys/mount.h>
+#include <sys/pipe.h>
+#include <ufs/ufs/quota.h>
+#include <ufs/ufs/inode.h>
+#include <fs/devfs/devfs.h>
+#include <fs/devfs/devfs_int.h>
+#undef _KERNEL
+#include <nfs/nfsproto.h>
+#include <nfsclient/nfs.h>
+#include <nfsclient/nfsnode.h>
+
+#include <vm/vm.h>
+#include <vm/vm_map.h>
+#include <vm/vm_object.h>
+
+#include <net/route.h>
+#include <netinet/in.h>
+#include <netinet/in_systm.h>
+#include <netinet/ip.h>
+#include <netinet/in_pcb.h>
+
+#include <assert.h>
+#include <ctype.h>
+#include <err.h>
+#include <fcntl.h>
+#include <kvm.h>
+#include <libutil.h>
+#include <limits.h>
+#include <paths.h>
+#include <pwd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <string.h>
+#include <unistd.h>
+#include <netdb.h>
+
+#include <libprocstat.h>
+#include "libprocstat_internal.h"
+#include "common_kvm.h"
+
+int     statfs(const char *, struct statfs *);	/* XXX */
+
+#define	PROCSTAT_KVM	1
+#define	PROCSTAT_SYSCTL	2
+
+static char	*getmnton(kvm_t *kd, struct mount *m);
+static struct filestat_list	*procstat_getfiles_kvm(
+    struct procstat *procstat, struct kinfo_proc *kp, int mmapped);
+static struct filestat_list	*procstat_getfiles_sysctl(
+    struct procstat *procstat, struct kinfo_proc *kp, int mmapped);
+static int	procstat_get_pipe_info_sysctl(struct filestat *fst,
+    struct pipestat *pipe, char *errbuf);
+static int	procstat_get_pipe_info_kvm(kvm_t *kd, struct filestat *fst,
+    struct pipestat *pipe, char *errbuf);
+static int	procstat_get_pts_info_sysctl(struct filestat *fst,
+    struct ptsstat *pts, char *errbuf);
+static int	procstat_get_pts_info_kvm(kvm_t *kd, struct filestat *fst,
+    struct ptsstat *pts, char *errbuf);
+static int	procstat_get_socket_info_sysctl(struct filestat *fst,
+    struct sockstat *sock, char *errbuf);
+static int	procstat_get_socket_info_kvm(kvm_t *kd, struct filestat *fst,
+    struct sockstat *sock, char *errbuf);
+static int	to_filestat_flags(int flags);
+static int	procstat_get_vnode_info_kvm(kvm_t *kd, struct filestat *fst,
+    struct vnstat *vn, char *errbuf);
+static int	procstat_get_vnode_info_sysctl(struct filestat *fst,
+    struct vnstat *vn, char *errbuf);
+static int	vntype2psfsttype(int type);
+
+void
+procstat_close(struct procstat *procstat)
+{
+
+	assert(procstat);
+	if (procstat->type == PROCSTAT_KVM)
+		kvm_close(procstat->kd);
+}
+
+struct procstat *
+procstat_open_sysctl(void)
+{
+	struct procstat *procstat;
+
+	procstat = calloc(1, sizeof(*procstat));
+	if (procstat == NULL) {
+		warn("malloc()");
+		return (NULL);
+	}
+	procstat->type = PROCSTAT_SYSCTL;
+	return (procstat);
+}
+
+struct procstat *
+procstat_open_kvm(const char *nlistf, const char *memf)
+{
+	struct procstat *procstat;
+	kvm_t *kd;
+	char buf[_POSIX2_LINE_MAX];
+
+	procstat = calloc(1, sizeof(*procstat));
+	if (procstat == NULL) {
+		warn("malloc()");
+		return (NULL);
+	}
+	kd = kvm_openfiles(nlistf, memf, NULL, O_RDONLY, buf);
+	if (kd == NULL) {
+		warnx("kvm_openfiles(): %s", buf);
+		free(procstat);
+		return (NULL);
+	}
+	procstat->type = PROCSTAT_KVM;
+	procstat->kd = kd;
+	return (procstat);
+}
+
+struct kinfo_proc *
+procstat_getprocs(struct procstat *procstat, int what, int arg,
+    unsigned int *count)
+{
+	struct kinfo_proc *p0, *p;
+	size_t len;
+	int name[4];
+	int error;
+
+	assert(procstat);
+	assert(count);
+	p = NULL;
+	if (procstat->type == PROCSTAT_KVM) {
+		p0 = kvm_getprocs(procstat->kd, what, arg, count);
+		if (p0 == NULL || count == 0)
+			return (NULL);
+		len = *count * sizeof(*p);
+		p = malloc(len);
+		if (p == NULL) {
+			warnx("malloc(%zd)", len);
+			goto fail;
+		}
+		bcopy(p0, p, len);
+		return (p);
+	} else if (procstat->type == PROCSTAT_SYSCTL) {
+		len = 0;
+		name[0] = CTL_KERN;
+		name[1] = KERN_PROC;
+		name[2] = what;
+		name[3] = arg;
+		error = sysctl(name, 4, NULL, &len, NULL, 0);
+		if (error < 0 && errno != EPERM) {
+			warn("sysctl(kern.proc)");
+			goto fail;
+		}
+		if (len == 0) {
+			warnx("no processes?");
+			goto fail;
+		}
+		p = malloc(len);
+		if (p == NULL) {
+			warnx("malloc(%zd)", len);
+			goto fail;
+		}
+		error = sysctl(name, 4, p, &len, NULL, 0);
+		if (error < 0 && errno != EPERM) {
+			warn("sysctl(kern.proc)");
+			goto fail;
+		}
+		/* Perform simple consistency checks. */
+		if ((len % sizeof(*p)) != 0 || p->ki_structsize != sizeof(*p)) {
+			warnx("kinfo_proc structure size mismatch");
+			goto fail;
+		}
+		*count = len / sizeof(*p);
+		return (p);
+	} else {
+		warnx("unknown access method");
+		return (NULL);
+	}
+fail:
+	if (p)
+		free(p);
+	return (NULL);
+}
+
+void
+procstat_freeprocs(struct procstat *procstat __unused, struct kinfo_proc *p)
+{
+
+	if (p != NULL)
+		free(p);
+	p = NULL;
+}
+
+struct filestat_list *
+procstat_getfiles(struct procstat *procstat, struct kinfo_proc *kp, int mmapped)
+{
+	
+	if (procstat->type == PROCSTAT_SYSCTL)
+		return (procstat_getfiles_sysctl(procstat, kp, mmapped));
+	else if (procstat->type == PROCSTAT_KVM)
+		 return (procstat_getfiles_kvm(procstat, kp, mmapped));
+	else
+		return (NULL);
+}
+
+void
+procstat_freefiles(struct procstat *procstat, struct filestat_list *head)
+{
+	struct filestat *fst, *tmp;
+
+	STAILQ_FOREACH_SAFE(fst, head, next, tmp) {
+		if (fst->fs_path != NULL)
+			free(fst->fs_path);
+		free(fst);
+	}
+	free(head);
+	if (procstat->vmentries != NULL) {
+		free (procstat->vmentries);
+		procstat->vmentries = NULL;
+	}
+	if (procstat->files != NULL) {
+		free (procstat->files);
+		procstat->files = NULL;
+	}
+}
+
+static struct filestat *
+filestat_new_entry(void *typedep, int type, int fd, int fflags, int uflags,
+    int refcount, off_t offset, char *path)
+{
+	struct filestat *entry;
+
+	entry = calloc(1, sizeof(*entry));
+	if (entry == NULL) {
+		warn("malloc()");
+		return (NULL);
+	}
+	entry->fs_typedep = typedep;
+	entry->fs_fflags = fflags;
+	entry->fs_uflags = uflags;
+	entry->fs_fd = fd;
+	entry->fs_type = type;
+	entry->fs_ref_count = refcount;
+	entry->fs_offset = offset;
+	entry->fs_path = path;
+	return (entry);
+}
+
+static struct vnode *
+getctty(kvm_t *kd, struct kinfo_proc *kp)
+{
+	struct pgrp pgrp;
+	struct proc proc;
+	struct session sess;
+	int error;
+                        
+	assert(kp);
+	error = kvm_read_all(kd, (unsigned long)kp->ki_paddr, &proc,
+	    sizeof(proc));
+	if (error == 0) {
+		warnx("can't read proc struct at %p for pid %d",
+		    kp->ki_paddr, kp->ki_pid);
+		return (NULL);
+	}
+	if (proc.p_pgrp == NULL)
+		return (NULL);
+	error = kvm_read_all(kd, (unsigned long)proc.p_pgrp, &pgrp,
+	    sizeof(pgrp));
+	if (error == 0) {
+		warnx("can't read pgrp struct at %p for pid %d",
+		    proc.p_pgrp, kp->ki_pid);
+		return (NULL);
+	}
+	error = kvm_read_all(kd, (unsigned long)pgrp.pg_session, &sess,
+	    sizeof(sess));
+	if (error == 0) {
+		warnx("can't read session struct at %p for pid %d",
+		    pgrp.pg_session, kp->ki_pid);
+		return (NULL);
+	}
+	return (sess.s_ttyvp);
+}
+
+static struct filestat_list *
+procstat_getfiles_kvm(struct procstat *procstat, struct kinfo_proc *kp, int mmapped)
+{
+	struct file file;
+	struct filedesc filed;
+	struct vm_map_entry vmentry;
+	struct vm_object object;
+	struct vmspace vmspace;
+	vm_map_entry_t entryp;
+	vm_map_t map;
+	vm_object_t objp;
+	struct vnode *vp;
+	struct file **ofiles;
+	struct filestat *entry;
+	struct filestat_list *head;
+	kvm_t *kd;
+	void *data;
+	int i, fflags;
+	int prot, type;
+	unsigned int nfiles;
+
+	assert(procstat);
+	kd = procstat->kd;
+	if (kd == NULL)
+		return (NULL);
+	if (kp->ki_fd == NULL)
+		return (NULL);
+	if (!kvm_read_all(kd, (unsigned long)kp->ki_fd, &filed,
+	    sizeof(filed))) {
+		warnx("can't read filedesc at %p", (void *)kp->ki_fd);
+		return (NULL);
+	}
+
+	/*
+	 * Allocate list head.
+	 */
+	head = malloc(sizeof(*head));
+	if (head == NULL)
+		return (NULL);
+	STAILQ_INIT(head);
+
+	/* root directory vnode, if one. */
+	if (filed.fd_rdir) {
+		entry = filestat_new_entry(filed.fd_rdir, PS_FST_TYPE_VNODE, -1,
+		    PS_FST_FFLAG_READ, PS_FST_UFLAG_RDIR, 0, 0, NULL);
+		if (entry != NULL)
+			STAILQ_INSERT_TAIL(head, entry, next);
+	}
+	/* current working directory vnode. */
+	if (filed.fd_cdir) {
+		entry = filestat_new_entry(filed.fd_cdir, PS_FST_TYPE_VNODE, -1,
+		    PS_FST_FFLAG_READ, PS_FST_UFLAG_CDIR, 0, 0, NULL);
+		if (entry != NULL)
+			STAILQ_INSERT_TAIL(head, entry, next);
+	}
+	/* jail root, if any. */
+	if (filed.fd_jdir) {
+		entry = filestat_new_entry(filed.fd_jdir, PS_FST_TYPE_VNODE, -1,
+		    PS_FST_FFLAG_READ, PS_FST_UFLAG_JAIL, 0, 0, NULL);
+		if (entry != NULL)
+			STAILQ_INSERT_TAIL(head, entry, next);
+	}
+	/* ktrace vnode, if one */
+	if (kp->ki_tracep) {
+		entry = filestat_new_entry(kp->ki_tracep, PS_FST_TYPE_VNODE, -1,
+		    PS_FST_FFLAG_READ | PS_FST_FFLAG_WRITE,
+		    PS_FST_UFLAG_TRACE, 0, 0, NULL);
+		if (entry != NULL)
+			STAILQ_INSERT_TAIL(head, entry, next);
+	}
+	/* text vnode, if one */
+	if (kp->ki_textvp) {
+		entry = filestat_new_entry(kp->ki_textvp, PS_FST_TYPE_VNODE, -1,
+		    PS_FST_FFLAG_READ, PS_FST_UFLAG_TEXT, 0, 0, NULL);
+		if (entry != NULL)
+			STAILQ_INSERT_TAIL(head, entry, next);
+	}
+	/* Controlling terminal. */
+	if ((vp = getctty(kd, kp)) != NULL) {
+		entry = filestat_new_entry(vp, PS_FST_TYPE_VNODE, -1,
+		    PS_FST_FFLAG_READ | PS_FST_FFLAG_WRITE,
+		    PS_FST_UFLAG_CTTY, 0, 0, NULL);
+		if (entry != NULL)
+			STAILQ_INSERT_TAIL(head, entry, next);
+	}
+
+	nfiles = filed.fd_lastfile + 1;
+	ofiles = malloc(nfiles * sizeof(struct file *));
+	if (ofiles == NULL) {
+		warn("malloc(%zd)", nfiles * sizeof(struct file *));
+		goto do_mmapped;
+	}
+	if (!kvm_read_all(kd, (unsigned long)filed.fd_ofiles, ofiles,
+	    nfiles * sizeof(struct file *))) {
+		warnx("cannot read file structures at %p",
+		    (void *)filed.fd_ofiles);
+		free(ofiles);
+		goto do_mmapped;
+	}
+	for (i = 0; i <= filed.fd_lastfile; i++) {
+		if (ofiles[i] == NULL)
+			continue;
+		if (!kvm_read_all(kd, (unsigned long)ofiles[i], &file,
+		    sizeof(struct file))) {
+			warnx("can't read file %d at %p", i,
+			    (void *)ofiles[i]);
+			continue;
+		}
+		switch (file.f_type) {
+		case DTYPE_VNODE:
+			type = PS_FST_TYPE_VNODE;
+			data = file.f_vnode;
+			break;
+		case DTYPE_SOCKET:
+			type = PS_FST_TYPE_SOCKET;
+			data = file.f_data;
+			break;
+		case DTYPE_PIPE:
+			type = PS_FST_TYPE_PIPE;
+			data = file.f_data;
+			break;
+		case DTYPE_FIFO:
+			type = PS_FST_TYPE_FIFO;
+			data = file.f_vnode;
+			break;
+#ifdef DTYPE_PTS
+		case DTYPE_PTS:
+			type = PS_FST_TYPE_PTS;
+			data = file.f_data;
+			break;
+#endif
+		default:
+			continue;
+		}
+		entry = filestat_new_entry(data, type, i,
+		    to_filestat_flags(file.f_flag), 0, 0, 0, NULL);
+		if (entry != NULL)
+			STAILQ_INSERT_TAIL(head, entry, next);
+	}
+	free(ofiles);
+
+do_mmapped:
+
+	/*
+	 * Process mmapped files if requested.
+	 */
+	if (mmapped) {
+		if (!kvm_read_all(kd, (unsigned long)kp->ki_vmspace, &vmspace,
+		    sizeof(vmspace))) {
+			warnx("can't read vmspace at %p",
+			    (void *)kp->ki_vmspace);
+			goto exit;
+		}
+		map = &vmspace.vm_map;
+
+		for (entryp = map->header.next;
+		    entryp != &kp->ki_vmspace->vm_map.header;
+		    entryp = vmentry.next) {
+			if (!kvm_read_all(kd, (unsigned long)entryp, &vmentry,
+			    sizeof(vmentry))) {
+				warnx("can't read vm_map_entry at %p",
+				    (void *)entryp);
+				continue;
+			}
+			if (vmentry.eflags & MAP_ENTRY_IS_SUB_MAP)
+				continue;
+			if ((objp = vmentry.object.vm_object) == NULL)
+				continue;
+			for (; objp; objp = object.backing_object) {
+				if (!kvm_read_all(kd, (unsigned long)objp,
+				    &object, sizeof(object))) {
+					warnx("can't read vm_object at %p",
+					    (void *)objp);
+					break;
+				}
+			}
+
+			/* We want only vnode objects. */
+			if (object.type != OBJT_VNODE)
+				continue;
+
+			prot = vmentry.protection;
+			fflags = 0;
+			if (prot & VM_PROT_READ)
+				fflags = PS_FST_FFLAG_READ;
+			if (prot & VM_PROT_WRITE)
+				fflags |= PS_FST_FFLAG_WRITE;
+
+			/*
+			 * Create filestat entry.
+			 */
+			entry = filestat_new_entry(object.handle,
+			    PS_FST_TYPE_VNODE, -1, fflags,
+			    PS_FST_UFLAG_MMAP, 0, 0, NULL);
+			if (entry != NULL)
+				STAILQ_INSERT_TAIL(head, entry, next);
+		}
+	}
+exit:
+	return (head);
+}
+
+/*
+ * kinfo types to filestat translation.
+ */
+static int
+kinfo_type2fst(int kftype)
+{
+	static struct {
+		int	kf_type;
+		int	fst_type;
+	} kftypes2fst[] = {
+		{ KF_TYPE_CRYPTO, PS_FST_TYPE_CRYPTO },
+		{ KF_TYPE_FIFO, PS_FST_TYPE_FIFO },
+		{ KF_TYPE_KQUEUE, PS_FST_TYPE_KQUEUE },
+		{ KF_TYPE_MQUEUE, PS_FST_TYPE_MQUEUE },
+		{ KF_TYPE_NONE, PS_FST_TYPE_NONE },
+		{ KF_TYPE_PIPE, PS_FST_TYPE_PIPE },
+		{ KF_TYPE_PTS, PS_FST_TYPE_PTS },
+		{ KF_TYPE_SEM, PS_FST_TYPE_SEM },
+		{ KF_TYPE_SHM, PS_FST_TYPE_SHM },
+		{ KF_TYPE_SOCKET, PS_FST_TYPE_SOCKET },
+		{ KF_TYPE_VNODE, PS_FST_TYPE_VNODE },
+		{ KF_TYPE_UNKNOWN, PS_FST_TYPE_UNKNOWN }
+	};
+#define NKFTYPES	(sizeof(kftypes2fst) / sizeof(*kftypes2fst))
+	unsigned int i;
+
+	for (i = 0; i < NKFTYPES; i++)
+		if (kftypes2fst[i].kf_type == kftype)
+			break;
+	if (i == NKFTYPES)
+		return (PS_FST_TYPE_UNKNOWN);
+	return (kftypes2fst[i].fst_type);
+}
+
+/*
+ * kinfo flags to filestat translation.
+ */
+static int
+kinfo_fflags2fst(int kfflags)
+{
+	static struct {
+		int	kf_flag;
+		int	fst_flag;
+	} kfflags2fst[] = {
+		{ KF_FLAG_APPEND, PS_FST_FFLAG_APPEND },
+		{ KF_FLAG_ASYNC, PS_FST_FFLAG_ASYNC },
+		{ KF_FLAG_CREAT, PS_FST_FFLAG_CREAT },
+		{ KF_FLAG_DIRECT, PS_FST_FFLAG_DIRECT },
+		{ KF_FLAG_EXCL, PS_FST_FFLAG_EXCL },
+		{ KF_FLAG_EXEC, PS_FST_FFLAG_EXEC },
+		{ KF_FLAG_EXLOCK, PS_FST_FFLAG_EXLOCK },
+		{ KF_FLAG_FSYNC, PS_FST_FFLAG_SYNC },
+		{ KF_FLAG_HASLOCK, PS_FST_FFLAG_HASLOCK },
+		{ KF_FLAG_NOFOLLOW, PS_FST_FFLAG_NOFOLLOW },
+		{ KF_FLAG_NONBLOCK, PS_FST_FFLAG_NONBLOCK },
+		{ KF_FLAG_READ, PS_FST_FFLAG_READ },
+		{ KF_FLAG_SHLOCK, PS_FST_FFLAG_SHLOCK },
+		{ KF_FLAG_TRUNC, PS_FST_FFLAG_TRUNC },
+		{ KF_FLAG_WRITE, PS_FST_FFLAG_WRITE }
+	};
+#define NKFFLAGS	(sizeof(kfflags2fst) / sizeof(*kfflags2fst))
+	unsigned int i;
+	int flags;
+
+	flags = 0;
+	for (i = 0; i < NKFFLAGS; i++)
+		if ((kfflags & kfflags2fst[i].kf_flag) != 0)
+			flags |= kfflags2fst[i].fst_flag;
+	return (flags);
+}
+
+static int
+kinfo_uflags2fst(int fd)
+{
+
+	switch (fd) {
+	case KF_FD_TYPE_CTTY:
+		return (PS_FST_UFLAG_CTTY);
+	case KF_FD_TYPE_CWD:
+		return (PS_FST_UFLAG_CDIR);
+	case KF_FD_TYPE_JAIL:
+		return (PS_FST_UFLAG_JAIL);
+	case KF_FD_TYPE_TEXT:
+		return (PS_FST_UFLAG_TEXT);
+	case KF_FD_TYPE_TRACE:
+		return (PS_FST_UFLAG_TRACE);
+	case KF_FD_TYPE_ROOT:
+		return (PS_FST_UFLAG_RDIR);
+	}
+	return (0);
+}
+
+static struct filestat_list *
+procstat_getfiles_sysctl(struct procstat *procstat, struct kinfo_proc *kp, int mmapped)
+{
+	struct kinfo_file *kif, *files;
+	struct kinfo_vmentry *kve, *vmentries;
+	struct filestat_list *head;
+	struct filestat *entry;
+	char *path;
+	off_t offset;
+	int cnt, fd, fflags;
+	int i, type, uflags;
+	int refcount;
+
+	assert(kp);
+	if (kp->ki_fd == NULL)
+		return (NULL);
+
+	files = kinfo_getfile(kp->ki_pid, &cnt);
+	if (files == NULL && errno != EPERM) {
+		warn("kinfo_getfile()");
+		return (NULL);
+	}
+	procstat->files = files;
+
+	/*
+	 * Allocate list head.
+	 */
+	head = malloc(sizeof(*head));
+	if (head == NULL)
+		return (NULL);
+	STAILQ_INIT(head);
+	for (i = 0; i < cnt; i++) {
+		kif = &files[i];
+
+		type = kinfo_type2fst(kif->kf_type);
+		fd = kif->kf_fd >= 0 ? kif->kf_fd : -1;
+		fflags = kinfo_fflags2fst(kif->kf_flags);
+		uflags = kinfo_uflags2fst(kif->kf_fd);
+		refcount = kif->kf_ref_count;
+		offset = kif->kf_offset;
+		if (*kif->kf_path != '\0')
+			path = strdup(kif->kf_path);
+		else
+			path = NULL;
+
+		/*
+		 * Create filestat entry.
+		 */
+		entry = filestat_new_entry(kif, type, fd, fflags, uflags,
+		    refcount, offset, path);
+		if (entry != NULL)
+			STAILQ_INSERT_TAIL(head, entry, next);
+	}
+	if (mmapped != 0) {
+		vmentries = kinfo_getvmmap(kp->ki_pid, &cnt);
+		procstat->vmentries = vmentries;
+		if (vmentries == NULL || cnt == 0)
+			goto fail;
+		for (i = 0; i < cnt; i++) {
+			kve = &vmentries[i];
+			if (kve->kve_type != KVME_TYPE_VNODE)
+				continue;
+			fflags = 0;
+			if (kve->kve_protection & KVME_PROT_READ)
+				fflags = PS_FST_FFLAG_READ;
+			if (kve->kve_protection & KVME_PROT_WRITE)
+				fflags |= PS_FST_FFLAG_WRITE;
+			offset = kve->kve_offset;
+			refcount = kve->kve_ref_count;
+			if (*kve->kve_path != '\0')
+				path = strdup(kve->kve_path);
+			else
+				path = NULL;
+			entry = filestat_new_entry(kve, PS_FST_TYPE_VNODE, -1,
+			    fflags, PS_FST_UFLAG_MMAP, refcount, offset, path);
+			if (entry != NULL)
+				STAILQ_INSERT_TAIL(head, entry, next);
+		}
+	}
+fail:
+	return (head);
+}
+
+int
+procstat_get_pipe_info(struct procstat *procstat, struct filestat *fst,
+    struct pipestat *ps, char *errbuf)
+{
+
+	assert(ps);
+	if (procstat->type == PROCSTAT_KVM) {
+		return (procstat_get_pipe_info_kvm(procstat->kd, fst, ps,
+		    errbuf));
+	} else if (procstat->type == PROCSTAT_SYSCTL) {
+		return (procstat_get_pipe_info_sysctl(fst, ps, errbuf));
+	} else {
+		warnx("unknow access method: %d", procstat->type);
+		snprintf(errbuf, _POSIX2_LINE_MAX, "error");
+		return (1);
+	}
+}
+
+static int
+procstat_get_pipe_info_kvm(kvm_t *kd, struct filestat *fst,
+    struct pipestat *ps, char *errbuf)
+{
+	struct pipe pi;
+	void *pipep;
+
+	assert(kd);
+	assert(ps);
+	assert(fst);
+	bzero(ps, sizeof(*ps));
+	pipep = fst->fs_typedep;
+	if (pipep == NULL)
+		goto fail;
+	if (!kvm_read_all(kd, (unsigned long)pipep, &pi, sizeof(struct pipe))) {
+		warnx("can't read pipe at %p", (void *)pipep);
+		goto fail;
+	}
+	ps->addr = (uintptr_t)pipep;
+	ps->peer = (uintptr_t)pi.pipe_peer;
+	ps->buffer_cnt = pi.pipe_buffer.cnt;
+	return (0);
+
+fail:
+	snprintf(errbuf, _POSIX2_LINE_MAX, "error");
+	return (1);
+}
+
+static int
+procstat_get_pipe_info_sysctl(struct filestat *fst, struct pipestat *ps,
+    char *errbuf __unused)
+{
+	struct kinfo_file *kif;
+
+	assert(ps);
+	assert(fst);
+	bzero(ps, sizeof(*ps));
+	kif = fst->fs_typedep;
+	if (kif == NULL)
+		return (1);
+	ps->addr = kif->kf_un.kf_pipe.kf_pipe_addr;
+	ps->peer = kif->kf_un.kf_pipe.kf_pipe_peer;
+	ps->buffer_cnt = kif->kf_un.kf_pipe.kf_pipe_buffer_cnt;
+	return (0);
+}
+
+int
+procstat_get_pts_info(struct procstat *procstat, struct filestat *fst,
+    struct ptsstat *pts, char *errbuf)
+{
+
+	assert(pts);
+	if (procstat->type == PROCSTAT_KVM) {
+		return (procstat_get_pts_info_kvm(procstat->kd, fst, pts,
+		    errbuf));
+	} else if (procstat->type == PROCSTAT_SYSCTL) {
+		return (procstat_get_pts_info_sysctl(fst, pts, errbuf));
+	} else {
+		warnx("unknow access method: %d", procstat->type);
+		snprintf(errbuf, _POSIX2_LINE_MAX, "error");
+		return (1);
+	}
+}
+
+static int
+procstat_get_pts_info_kvm(kvm_t *kd, struct filestat *fst,
+    struct ptsstat *pts, char *errbuf)
+{
+	struct tty tty;
+	void *ttyp;
+
+	assert(kd);
+	assert(pts);
+	assert(fst);
+	bzero(pts, sizeof(*pts));
+	ttyp = fst->fs_typedep;
+	if (ttyp == NULL)
+		goto fail;
+	if (!kvm_read_all(kd, (unsigned long)ttyp, &tty, sizeof(struct tty))) {
+		warnx("can't read tty at %p", (void *)ttyp);
+		goto fail;
+	}
+	pts->dev = dev2udev(kd, tty.t_dev);
+	(void)kdevtoname(kd, tty.t_dev, pts->devname);
+	return (0);
+
+fail:
+	snprintf(errbuf, _POSIX2_LINE_MAX, "error");
+	return (1);
+}
+
+static int
+procstat_get_pts_info_sysctl(struct filestat *fst, struct ptsstat *pts,
+    char *errbuf __unused)
+{
+	struct kinfo_file *kif;
+
+	assert(pts);
+	assert(fst);
+	bzero(pts, sizeof(*pts));
+	kif = fst->fs_typedep;
+	if (kif == NULL)
+		return (0);
+	pts->dev = kif->kf_un.kf_pts.kf_pts_dev;
+	strlcpy(pts->devname, kif->kf_path, sizeof(pts->devname));
+	return (0);
+}
+
+int
+procstat_get_vnode_info(struct procstat *procstat, struct filestat *fst,
+    struct vnstat *vn, char *errbuf)
+{
+
+	assert(vn);
+	if (procstat->type == PROCSTAT_KVM) {
+		return (procstat_get_vnode_info_kvm(procstat->kd, fst, vn,
+		    errbuf));
+	} else if (procstat->type == PROCSTAT_SYSCTL) {
+		return (procstat_get_vnode_info_sysctl(fst, vn, errbuf));
+	} else {
+		warnx("unknow access method: %d", procstat->type);
+		snprintf(errbuf, _POSIX2_LINE_MAX, "error");
+		return (1);
+	}
+}
+
+static int
+procstat_get_vnode_info_kvm(kvm_t *kd, struct filestat *fst,
+    struct vnstat *vn, char *errbuf)
+{
+	/* Filesystem specific handlers. */
+	#define FSTYPE(fst)     {#fst, fst##_filestat}
+	struct {
+		const char	*tag;
+		int		(*handler)(kvm_t *kd, struct vnode *vp,
+		    struct vnstat *vn);
+	} fstypes[] = {
+		FSTYPE(devfs),
+		FSTYPE(isofs),
+		FSTYPE(msdosfs),
+		FSTYPE(nfs),
+		FSTYPE(ntfs),
+		FSTYPE(nwfs), 
+		FSTYPE(smbfs),
+		FSTYPE(udf), 
+		FSTYPE(ufs),
+#ifdef ZFS
+		FSTYPE(zfs),
+#endif
+	};
+#define	NTYPES	(sizeof(fstypes) / sizeof(*fstypes))
+	struct vnode vnode;
+	char tagstr[12];
+	void *vp;
+	int error, found;
+	unsigned int i;
+
+	assert(kd);
+	assert(vn);
+	assert(fst);
+	vp = fst->fs_typedep;
+	if (vp == NULL)
+		goto fail;
+	error = kvm_read_all(kd, (unsigned long)vp, &vnode, sizeof(vnode));
+	if (error == 0) {
+		warnx("can't read vnode at %p", (void *)vp);
+		goto fail;
+	}
+	bzero(vn, sizeof(*vn));
+	vn->vn_type = vntype2psfsttype(vnode.v_type);
+	if (vnode.v_type == VNON || vnode.v_type == VBAD)
+		return (0);
+	error = kvm_read_all(kd, (unsigned long)vnode.v_tag, tagstr,
+	    sizeof(tagstr));
+	if (error == 0) {
+		warnx("can't read v_tag at %p", (void *)vp);
+		goto fail;
+	}
+	tagstr[sizeof(tagstr) - 1] = '\0';
+
+	/*
+	 * Find appropriate handler.
+	 */
+	for (i = 0, found = 0; i < NTYPES; i++)
+		if (!strcmp(fstypes[i].tag, tagstr)) {
+			if (fstypes[i].handler(kd, &vnode, vn) != 0) {
+				goto fail;
+			}
+			break;
+		}
+	if (i == NTYPES) {
+		snprintf(errbuf, _POSIX2_LINE_MAX, "?(%s)", tagstr);
+		return (1);
+	}
+	vn->vn_mntdir = getmnton(kd, vnode.v_mount);
+	if ((vnode.v_type == VBLK || vnode.v_type == VCHR) &&
+	    vnode.v_rdev != NULL){
+		vn->vn_dev = dev2udev(kd, vnode.v_rdev);
+		(void)kdevtoname(kd, vnode.v_rdev, vn->vn_devname);
+	} else {
+		vn->vn_dev = -1;
+	}
+	return (0);
+
+fail:
+	snprintf(errbuf, _POSIX2_LINE_MAX, "error");
+	return (1);
+}
+
+/*
+ * kinfo vnode type to filestat translation.
+ */
+static int
+kinfo_vtype2fst(int kfvtype)
+{
+	static struct {
+		int	kf_vtype; 
+		int	fst_vtype;
+	} kfvtypes2fst[] = {
+		{ KF_VTYPE_VBAD, PS_FST_VTYPE_VBAD },
+		{ KF_VTYPE_VBLK, PS_FST_VTYPE_VBLK },
+		{ KF_VTYPE_VCHR, PS_FST_VTYPE_VCHR },
+		{ KF_VTYPE_VDIR, PS_FST_VTYPE_VDIR },
+		{ KF_VTYPE_VFIFO, PS_FST_VTYPE_VFIFO },
+		{ KF_VTYPE_VLNK, PS_FST_VTYPE_VLNK },
+		{ KF_VTYPE_VNON, PS_FST_VTYPE_VNON },
+		{ KF_VTYPE_VREG, PS_FST_VTYPE_VREG },
+		{ KF_VTYPE_VSOCK, PS_FST_VTYPE_VSOCK }
+	};
+#define	NKFVTYPES	(sizeof(kfvtypes2fst) / sizeof(*kfvtypes2fst))
+	unsigned int i;
+
+	for (i = 0; i < NKFVTYPES; i++)
+		if (kfvtypes2fst[i].kf_vtype == kfvtype)
+			break;
+	if (i == NKFVTYPES)
+		return (PS_FST_VTYPE_UNKNOWN);
+	return (kfvtypes2fst[i].fst_vtype);
+}
+
+static int
+procstat_get_vnode_info_sysctl(struct filestat *fst, struct vnstat *vn,
+    char *errbuf)
+{
+	struct statfs stbuf;
+	struct kinfo_file *kif;
+	struct kinfo_vmentry *kve;
+	uint64_t fileid;
+	uint64_t size;
+	char *name, *path;
+	uint32_t fsid;
+	uint16_t mode;
+	uint32_t rdev;
+	int vntype;
+	int status;
+
+	assert(fst);
+	assert(vn);
+	bzero(vn, sizeof(*vn));
+	if (fst->fs_typedep == NULL)
+		return (1);
+	if (fst->fs_uflags & PS_FST_UFLAG_MMAP) {
+		kve = fst->fs_typedep;
+		fileid = kve->kve_vn_fileid;
+		fsid = kve->kve_vn_fsid;
+		mode = kve->kve_vn_mode;
+		path = kve->kve_path;
+		rdev = kve->kve_vn_rdev;
+		size = kve->kve_vn_size;
+		vntype = kinfo_vtype2fst(kve->kve_vn_type);
+		status = kve->kve_status;
+	} else {
+		kif = fst->fs_typedep;
+		fileid = kif->kf_un.kf_file.kf_file_fileid;
+		fsid = kif->kf_un.kf_file.kf_file_fsid;
+		mode = kif->kf_un.kf_file.kf_file_mode;
+		path = kif->kf_path;
+		rdev = kif->kf_un.kf_file.kf_file_rdev;
+		size = kif->kf_un.kf_file.kf_file_size;
+		vntype = kinfo_vtype2fst(kif->kf_vnode_type);
+		status = kif->kf_status;
+	}
+	vn->vn_type = vntype;
+	if (vntype == PS_FST_VTYPE_VNON || vntype == PS_FST_VTYPE_VBAD)
+		return (0);
+	if ((status & KF_ATTR_VALID) == 0) {
+		snprintf(errbuf, _POSIX2_LINE_MAX, "? (no info available)");
+		return (1);
+	}
+	if (path && *path) {
+		statfs(path, &stbuf);
+		vn->vn_mntdir = strdup(stbuf.f_mntonname);
+	} else
+		vn->vn_mntdir = strdup("-");
+	vn->vn_dev = rdev;
+	if (vntype == PS_FST_VTYPE_VBLK) {
+		name = devname(rdev, S_IFBLK);
+		if (name != NULL)
+			strlcpy(vn->vn_devname, name,
+			    sizeof(vn->vn_devname));
+	} else if (vntype == PS_FST_VTYPE_VCHR) {
+		name = devname(vn->vn_dev, S_IFCHR);
+		if (name != NULL)
+			strlcpy(vn->vn_devname, name,
+			    sizeof(vn->vn_devname));
+	}
+	vn->vn_fsid = fsid;
+	vn->vn_fileid = fileid;
+	vn->vn_size = size;
+	vn->vn_mode = mode;
+	return (0);
+}
+
+int
+procstat_get_socket_info(struct procstat *procstat, struct filestat *fst,
+    struct sockstat *sock, char *errbuf)
+{
+
+	assert(sock);
+	if (procstat->type == PROCSTAT_KVM) {
+		return (procstat_get_socket_info_kvm(procstat->kd, fst, sock,
+		    errbuf));
+	} else if (procstat->type == PROCSTAT_SYSCTL) {
+		return (procstat_get_socket_info_sysctl(fst, sock, errbuf));
+	} else {
+		warnx("unknow access method: %d", procstat->type);
+		snprintf(errbuf, _POSIX2_LINE_MAX, "error");
+		return (1);
+	}
+}
+
+static int
+procstat_get_socket_info_kvm(kvm_t *kd, struct filestat *fst,
+    struct sockstat *sock, char *errbuf)
+{
+	struct domain dom;
+	struct inpcb inpcb;
+	struct protosw proto;
+	struct socket s;
+	struct unpcb unpcb;
+	ssize_t len;
+	void *so;
+
+	assert(kd);
+	assert(sock);
+	assert(fst);
+	bzero(sock, sizeof(*sock));
+	so = fst->fs_typedep;
+	if (so == NULL)
+		goto fail;
+	sock->so_addr = (uintptr_t)so;
+	/* fill in socket */
+	if (!kvm_read_all(kd, (unsigned long)so, &s,
+	    sizeof(struct socket))) {
+		warnx("can't read sock at %p", (void *)so);
+		goto fail;
+	}
+	/* fill in protosw entry */
+	if (!kvm_read_all(kd, (unsigned long)s.so_proto, &proto,
+	    sizeof(struct protosw))) {
+		warnx("can't read protosw at %p", (void *)s.so_proto);
+		goto fail;
+	}
+	/* fill in domain */
+	if (!kvm_read_all(kd, (unsigned long)proto.pr_domain, &dom,
+	    sizeof(struct domain))) {
+		warnx("can't read domain at %p",
+		    (void *)proto.pr_domain);
+		goto fail;
+	}
+	if ((len = kvm_read(kd, (unsigned long)dom.dom_name, sock->dname,
+	    sizeof(sock->dname) - 1)) < 0) {
+		warnx("can't read domain name at %p", (void *)dom.dom_name);
+		sock->dname[0] = '\0';
+	}
+	else
+		sock->dname[len] = '\0';
+	
+	/*
+	 * Fill in known data.
+	 */
+	sock->type = s.so_type;
+	sock->proto = proto.pr_protocol;
+	sock->dom_family = dom.dom_family;
+	sock->so_pcb = (uintptr_t)s.so_pcb;
+
+	/*
+	 * Protocol specific data.
+	 */
+	switch(dom.dom_family) {
+	case AF_INET:
+	case AF_INET6:
+		if (proto.pr_protocol == IPPROTO_TCP) {
+			if (s.so_pcb) {
+				if (kvm_read(kd, (u_long)s.so_pcb,
+				    (char *)&inpcb, sizeof(struct inpcb))
+				    != sizeof(struct inpcb)) {
+					warnx("can't read inpcb at %p",
+					    (void *)s.so_pcb);
+				} else
+					sock->inp_ppcb =
+					    (uintptr_t)inpcb.inp_ppcb;
+			}
+		}
+		break;
+	case AF_UNIX:
+		if (s.so_pcb) {
+			if (kvm_read(kd, (u_long)s.so_pcb, (char *)&unpcb,
+			    sizeof(struct unpcb)) != sizeof(struct unpcb)){
+				warnx("can't read unpcb at %p",
+				    (void *)s.so_pcb);
+			} else if (unpcb.unp_conn) {
+				sock->so_rcv_sb_state = s.so_rcv.sb_state;
+				sock->so_snd_sb_state = s.so_snd.sb_state;
+				sock->unp_conn = (uintptr_t)unpcb.unp_conn;
+			}
+		}
+		break;
+	default:
+		break;
+	}
+	return (0);
+
+fail:
+	snprintf(errbuf, _POSIX2_LINE_MAX, "error");
+	return (1);
+}
+
+static int
+procstat_get_socket_info_sysctl(struct filestat *fst, struct sockstat *sock,
+    char *errbuf __unused)
+{
+	struct kinfo_file *kif;
+
+	assert(sock);
+	assert(fst);
+	bzero(sock, sizeof(*sock));
+	kif = fst->fs_typedep;
+	if (kif == NULL)
+		return (0);
+
+	/*
+	 * Fill in known data.
+	 */
+	sock->type = kif->kf_sock_type;
+	sock->proto = kif->kf_sock_protocol;
+	sock->dom_family = kif->kf_sock_domain;
+	sock->so_pcb = kif->kf_un.kf_sock.kf_sock_pcb;
+	strlcpy(sock->dname, kif->kf_path, sizeof(sock->dname));
+	bcopy(&kif->kf_sa_local, &sock->sa_local, kif->kf_sa_local.ss_len);
+	bcopy(&kif->kf_sa_peer, &sock->sa_peer, kif->kf_sa_peer.ss_len);
+
+	/*
+	 * Protocol specific data.
+	 */
+	switch(sock->dom_family) {
+	case AF_INET:
+	case AF_INET6:
+		if (sock->proto == IPPROTO_TCP)
+			sock->inp_ppcb = kif->kf_un.kf_sock.kf_sock_inpcb;
+		break;
+	case AF_UNIX:
+		if (kif->kf_un.kf_sock.kf_sock_unpconn != 0) {
+				sock->so_rcv_sb_state =
+				    kif->kf_un.kf_sock.kf_sock_rcv_sb_state;
+				sock->so_snd_sb_state =
+				    kif->kf_un.kf_sock.kf_sock_snd_sb_state;
+				sock->unp_conn =
+				    kif->kf_un.kf_sock.kf_sock_unpconn;
+		}
+		break;
+	default:
+		break;
+	}
+	return (0);
+}
+
+/*
+ * Descriptor flags to filestat translation.
+ */
+static int
+to_filestat_flags(int flags)
+{
+	static struct {
+		int flag;
+		int fst_flag;
+	} fstflags[] = {
+		{ FREAD, PS_FST_FFLAG_READ },
+		{ FWRITE, PS_FST_FFLAG_WRITE },
+		{ O_APPEND, PS_FST_FFLAG_APPEND },
+		{ O_ASYNC, PS_FST_FFLAG_ASYNC },
+		{ O_CREAT, PS_FST_FFLAG_CREAT },
+		{ O_DIRECT, PS_FST_FFLAG_DIRECT },
+		{ O_EXCL, PS_FST_FFLAG_EXCL },
+		{ O_EXEC, PS_FST_FFLAG_EXEC },
+		{ O_EXLOCK, PS_FST_FFLAG_EXLOCK },
+		{ O_NOFOLLOW, PS_FST_FFLAG_NOFOLLOW },
+		{ O_NONBLOCK, PS_FST_FFLAG_NONBLOCK },
+		{ O_SHLOCK, PS_FST_FFLAG_SHLOCK },
+		{ O_SYNC, PS_FST_FFLAG_SYNC },
+		{ O_TRUNC, PS_FST_FFLAG_TRUNC }
+	};
+#define NFSTFLAGS	(sizeof(fstflags) / sizeof(*fstflags))
+	int fst_flags;
+	unsigned int i;
+
+	fst_flags = 0;
+	for (i = 0; i < NFSTFLAGS; i++)
+		if (flags & fstflags[i].flag)
+			fst_flags |= fstflags[i].fst_flag;
+	return (fst_flags);
+}
+
+/*
+ * Vnode type to filestate translation.
+ */
+static int
+vntype2psfsttype(int type)
+{
+	static struct {
+		int	vtype; 
+		int	fst_vtype;
+	} vt2fst[] = {
+		{ VBAD, PS_FST_VTYPE_VBAD },
+		{ VBLK, PS_FST_VTYPE_VBLK },
+		{ VCHR, PS_FST_VTYPE_VCHR },
+		{ VDIR, PS_FST_VTYPE_VDIR },
+		{ VFIFO, PS_FST_VTYPE_VFIFO },
+		{ VLNK, PS_FST_VTYPE_VLNK },
+		{ VNON, PS_FST_VTYPE_VNON },
+		{ VREG, PS_FST_VTYPE_VREG },
+		{ VSOCK, PS_FST_VTYPE_VSOCK }
+	};
+#define	NVFTYPES	(sizeof(vt2fst) / sizeof(*vt2fst))
+	unsigned int i, fst_type;
+
+	fst_type = PS_FST_VTYPE_UNKNOWN;
+	for (i = 0; i < NVFTYPES; i++) {
+		if (type == vt2fst[i].vtype) {
+			fst_type = vt2fst[i].fst_vtype;
+			break;
+		}
+	}
+	return (fst_type);
+}
+
+static char *
+getmnton(kvm_t *kd, struct mount *m)
+{
+	static struct mount mnt;
+	static struct mtab {
+		struct mtab *next;
+		struct mount *m;
+		char mntonname[MNAMELEN + 1];
+	} *mhead = NULL;
+	struct mtab *mt;
+
+	for (mt = mhead; mt != NULL; mt = mt->next)
+		if (m == mt->m)
+			return (mt->mntonname);
+	if (!kvm_read_all(kd, (unsigned long)m, &mnt, sizeof(struct mount))) {
+		warnx("can't read mount table at %p", (void *)m);
+		return (NULL);
+	}
+	if ((mt = malloc(sizeof (struct mtab))) == NULL)
+		err(1, NULL);
+	mt->m = m;
+	bcopy(&mnt.mnt_stat.f_mntonname[0], &mt->mntonname[0], MNAMELEN);
+	mnt.mnt_stat.f_mntonname[MNAMELEN] = '\0';
+	mt->next = mhead;
+	mhead = mt;
+	return (mt->mntonname);
+}
diff --git a/lib/libprocstat/libprocstat.h b/lib/libprocstat/libprocstat.h
new file mode 100644
index 0000000..62b1bd5
--- /dev/null
+++ b/lib/libprocstat/libprocstat.h
@@ -0,0 +1,160 @@
+/*-
+ * Copyright (c) 2009 Stanislav Sedov <stas@FreeBSD.org>
+ * 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.
+ *
+ * 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.
+ *
+ * $FreeBSD$
+ */
+
+#ifndef _LIBPROCSTAT_H_
+#define	_LIBPROCSTAT_H_
+
+/*
+ * Vnode types.
+ */
+#define	PS_FST_VTYPE_VNON	1
+#define	PS_FST_VTYPE_VREG	2
+#define	PS_FST_VTYPE_VDIR	3
+#define	PS_FST_VTYPE_VBLK	4
+#define	PS_FST_VTYPE_VCHR	5
+#define	PS_FST_VTYPE_VLNK	6
+#define	PS_FST_VTYPE_VSOCK	7
+#define	PS_FST_VTYPE_VFIFO	8
+#define	PS_FST_VTYPE_VBAD	9
+#define	PS_FST_VTYPE_UNKNOWN	255
+
+/*
+ * Descriptor types.
+ */
+#define	PS_FST_TYPE_VNODE	1
+#define	PS_FST_TYPE_FIFO	2
+#define	PS_FST_TYPE_SOCKET	3
+#define	PS_FST_TYPE_PIPE	4
+#define	PS_FST_TYPE_PTS		5
+#define	PS_FST_TYPE_KQUEUE	6
+#define	PS_FST_TYPE_CRYPTO	7
+#define	PS_FST_TYPE_MQUEUE	8
+#define	PS_FST_TYPE_SHM		9
+#define	PS_FST_TYPE_SEM		10
+#define	PS_FST_TYPE_UNKNOWN	11
+#define	PS_FST_TYPE_NONE	12
+
+/*
+ * Special descriptor numbers.
+ */
+#define	PS_FST_UFLAG_RDIR	0x0001
+#define	PS_FST_UFLAG_CDIR	0x0002
+#define	PS_FST_UFLAG_JAIL	0x0004
+#define	PS_FST_UFLAG_TRACE	0x0008
+#define	PS_FST_UFLAG_TEXT	0x0010
+#define	PS_FST_UFLAG_MMAP	0x0020
+#define	PS_FST_UFLAG_CTTY	0x0040
+
+/*
+ * Descriptor flags.
+ */
+#define PS_FST_FFLAG_READ	0x0001
+#define PS_FST_FFLAG_WRITE	0x0002
+#define	PS_FST_FFLAG_NONBLOCK	0x0004
+#define	PS_FST_FFLAG_APPEND	0x0008
+#define	PS_FST_FFLAG_SHLOCK	0x0010
+#define	PS_FST_FFLAG_EXLOCK	0x0020
+#define	PS_FST_FFLAG_ASYNC	0x0040
+#define	PS_FST_FFLAG_SYNC	0x0080
+#define	PS_FST_FFLAG_NOFOLLOW	0x0100
+#define	PS_FST_FFLAG_CREAT	0x0200
+#define	PS_FST_FFLAG_TRUNC	0x0400
+#define	PS_FST_FFLAG_EXCL	0x0800
+#define	PS_FST_FFLAG_DIRECT	0x1000
+#define	PS_FST_FFLAG_EXEC	0x2000
+#define	PS_FST_FFLAG_HASLOCK	0x4000
+
+struct procstat;
+struct filestat {
+	int	fs_type;	/* Descriptor type. */
+	int	fs_flags;	/* filestat specific flags. */
+	int	fs_fflags;	/* Descriptor access flags. */
+	int	fs_uflags;	/* How this file is used. */
+	int	fs_fd;		/* File descriptor number. */
+	int	fs_ref_count;	/* Reference count. */
+	off_t	fs_offset;	/* Seek location. */
+	void	*fs_typedep;	/* Type dependent data. */
+	char	*fs_path;
+	STAILQ_ENTRY(filestat)	next;
+};
+struct vnstat {
+	uint64_t	vn_fileid;
+	uint64_t	vn_size;
+	char		*vn_mntdir;
+	uint32_t	vn_dev;
+	uint32_t	vn_fsid;
+	int		vn_type;
+	uint16_t	vn_mode;
+	char		vn_devname[SPECNAMELEN + 1];
+};
+struct ptsstat {
+	uint32_t	dev;
+	char		devname[SPECNAMELEN + 1];
+};
+struct pipestat {
+	size_t		buffer_cnt;
+	uint64_t	addr;
+	uint64_t	peer;
+};
+struct sockstat {
+	uint64_t	inp_ppcb;
+	uint64_t	so_addr;
+	uint64_t	so_pcb;
+	uint64_t	unp_conn;
+	int		dom_family;
+	int		proto;
+	int		so_rcv_sb_state;
+	int		so_snd_sb_state;
+	struct sockaddr_storage	sa_local;	/* Socket address. */
+	struct sockaddr_storage	sa_peer;	/* Peer address. */
+	int		type;
+	char		dname[32];
+};
+
+STAILQ_HEAD(filestat_list, filestat);
+
+void	procstat_close(struct procstat *procstat);
+void	procstat_freeprocs(struct procstat *procstat, struct kinfo_proc *p);
+void	procstat_freefiles(struct procstat *procstat,
+    struct filestat_list *head);
+struct filestat_list	*procstat_getfiles(struct procstat *procstat,
+    struct kinfo_proc *kp, int mmapped);
+struct kinfo_proc	*procstat_getprocs(struct procstat *procstat,
+    int what, int arg, unsigned int *count);
+int	procstat_get_pipe_info(struct procstat *procstat, struct filestat *fst,
+    struct pipestat *pipe, char *errbuf);
+int	procstat_get_pts_info(struct procstat *procstat, struct filestat *fst,
+    struct ptsstat *pts, char *errbuf);
+int	procstat_get_socket_info(struct procstat *procstat, struct filestat *fst,
+    struct sockstat *sock, char *errbuf);
+int	procstat_get_vnode_info(struct procstat *procstat, struct filestat *fst,
+    struct vnstat *vn, char *errbuf);
+struct procstat	*procstat_open_sysctl(void);
+struct procstat	*procstat_open_kvm(const char *nlistf, const char *memf);
+
+#endif	/* !_LIBPROCSTAT_H_ */
diff --git a/lib/libprocstat/libprocstat_internal.h b/lib/libprocstat/libprocstat_internal.h
new file mode 100644
index 0000000..1c1d842
--- /dev/null
+++ b/lib/libprocstat/libprocstat_internal.h
@@ -0,0 +1,39 @@
+/*-
+ * Copyright (c) 2009 Stanislav Sedov <stas@FreeBSD.org>
+ * 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.
+ *
+ * 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.
+ *
+ * $FreeBSD$
+ */
+
+#ifndef _LIBPROCSTAT_INTERNAL_H_
+#define	_LIBPROCSTAT_INTERNAL_H_
+
+struct procstat {
+	int	type;
+	kvm_t	*kd;
+	void	*vmentries;
+	void	*files;
+};
+
+#endif	/* !_LIBPROCSTAT_INTERNAL_H_ */
diff --git a/usr.bin/fstat/msdosfs.c b/lib/libprocstat/msdosfs.c
index 7f80499..84b437e 100644
--- a/usr.bin/fstat/msdosfs.c
+++ b/lib/libprocstat/msdosfs.c
@@ -42,6 +42,8 @@ __FBSDID("$FreeBSD$");
 #include <sys/stat.h>
 #include <sys/vnode.h>
 
+#include <netinet/in.h>
+
 #define	_KERNEL
 #include <sys/mount.h>
 #include <fs/msdosfs/bpb.h>
@@ -62,9 +64,10 @@ __FBSDID("$FreeBSD$");
  * VTODE is defined in denode.h only if _KERNEL is defined, but that leads to
  * header explosion
  */
-#define VTODE(vp) ((struct denode *)(vp)->v_data)
+#define VTODE(vp) ((struct denode *)getvnodedata(vp))
 
-#include "fstat.h"
+#include "libprocstat.h"
+#include "common_kvm.h"
 
 struct dosmount {
 	struct dosmount *next;
@@ -73,7 +76,7 @@ struct dosmount {
 };
 
 int
-msdosfs_filestat(struct vnode *vp, struct filestat *fsp)
+msdosfs_filestat(kvm_t *kd, struct vnode *vp, struct vnstat *vn)
 {
 	struct denode denode;
 	static struct dosmount *mounts;
@@ -81,10 +84,10 @@ msdosfs_filestat(struct vnode *vp, struct filestat *fsp)
 	u_long dirsperblk;
 	int fileid;
 
-	if (!KVM_READ(VTODE(vp), &denode, sizeof (denode))) {
-		dprintf(stderr, "can't read denode at %p for pid %d\n",
-		    (void *)VTODE(vp), Pid);
-		return 0;
+	if (!kvm_read_all(kd, (unsigned long)VTODE(vp), &denode,
+	    sizeof(denode))) {
+		warnx("can't read denode at %p", (void *)VTODE(vp));
+		return (1);
 	}
 
 	/*
@@ -96,30 +99,30 @@ msdosfs_filestat(struct vnode *vp, struct filestat *fsp)
 			break;
 
 	if (!mnt) {
-		if ((mnt = malloc(sizeof(struct dosmount))) == NULL)
-			err(1, NULL);
-		if (!KVM_READ(denode.de_pmp, &mnt->data, sizeof mnt->data)) {
+		if ((mnt = malloc(sizeof(struct dosmount))) == NULL) {
+			warn("malloc()");
+			return (1);
+		}
+		if (!kvm_read_all(kd, (unsigned long)denode.de_pmp,
+		    &mnt->data, sizeof(mnt->data))) {
 			free(mnt);
-			dprintf(stderr,
-			    "can't read mount info at %p for pid %d\n",
-			    (void *)denode.de_pmp, Pid);
-			return 0;
+			    warnx("can't read mount info at %p",
+			    (void *)denode.de_pmp);
+			return (1);
 		}
 		mnt->next = mounts;
 		mounts = mnt;
 		mnt->kptr = denode.de_pmp;
 	}
 
-	fsp->fsid = dev2udev(mnt->data.pm_dev);
-	fsp->mode = 0555;
-	fsp->mode |= denode.de_Attributes & ATTR_READONLY ? 0 : 0222;
-	fsp->mode &= mnt->data.pm_mask;
+	vn->vn_fsid = dev2udev(kd, mnt->data.pm_dev);
+	vn->vn_mode = 0555;
+	vn->vn_mode |= denode.de_Attributes & ATTR_READONLY ? 0 : 0222;
+	vn->vn_mode &= mnt->data.pm_mask;
 
 	/* Distinguish directories and files. No "special" files in FAT. */
-	fsp->mode |= denode.de_Attributes & ATTR_DIRECTORY ? S_IFDIR : S_IFREG;
-
-	fsp->size = denode.de_FileSize;
-	fsp->rdev = 0;
+	vn->vn_mode |= denode.de_Attributes & ATTR_DIRECTORY ? S_IFDIR : S_IFREG;
+	vn->vn_size = denode.de_FileSize;
 
 	/*
 	 * XXX -
@@ -145,6 +148,6 @@ msdosfs_filestat(struct vnode *vp, struct filestat *fsp)
 		fileid += denode.de_diroffset / sizeof(struct direntry);
 	}
 
-	fsp->fileid = fileid;
-	return 1;
+	vn->vn_fileid = fileid;
+	return (0);
 }
diff --git a/lib/libprocstat/ntfs.c b/lib/libprocstat/ntfs.c
new file mode 100644
index 0000000..888e6cd
--- /dev/null
+++ b/lib/libprocstat/ntfs.c
@@ -0,0 +1,71 @@
+/*-
+ * Copyright (c) 2005-2009 Stanislav Sedov <stas@FreeBSD.org>
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
+ */
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <sys/param.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/vnode.h>
+#include <sys/mount.h>
+
+#include <netinet/in.h>
+
+#include <assert.h>
+#include <err.h>
+#include <kvm.h>
+#include <stdlib.h>
+
+#include <fs/ntfs/ntfs.h>
+#include <fs/ntfs/ntfs_inode.h>
+
+#include "libprocstat.h"
+#include "common_kvm.h"
+
+int
+ntfs_filestat(kvm_t *kd, struct vnode *vp, struct vnstat *vn)
+{
+	struct fnode fnod;
+	struct ntnode node;
+	int error;
+
+	assert(kd);
+	assert(vn);
+	error = kvm_read_all(kd, (unsigned long)VTOF(vp), &fnod, sizeof(fnod));
+	if (error != 0) {
+		warnx("can't read ntfs fnode at %p", (void *)VTOF(vp));
+		return (1);
+	}
+	error = kvm_read_all(kd, (unsigned long)FTONT(&fnod), &node,
+	    sizeof(node));
+	if (error != 0) {
+		warnx("can't read ntfs node at %p", (void *)FTONT(&fnod));
+		return (1);
+	}
+	vn->vn_fileid = node.i_number;
+	vn->vn_fsid = dev2udev(kd, node.i_dev);
+	return (0);
+}
diff --git a/lib/libprocstat/nwfs.c b/lib/libprocstat/nwfs.c
new file mode 100644
index 0000000..006f9aa
--- /dev/null
+++ b/lib/libprocstat/nwfs.c
@@ -0,0 +1,76 @@
+/*-
+ * Copyright (c) 2005-2009 Stanislav Sedov <stas@FreeBSD.org>
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
+ */
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <sys/param.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/vnode.h>
+#define _KERNEL
+#include <sys/mount.h>
+#undef _KERNEL
+
+#include <netinet/in.h>
+
+#include <assert.h>
+#include <err.h>
+#include <kvm.h>
+#include <stdlib.h>
+
+#include <fs/nwfs/nwfs.h>
+#include <fs/nwfs/nwfs_node.h>
+
+#include "libprocstat.h"
+#include "common_kvm.h"
+
+int
+nwfs_filestat(kvm_t *kd, struct vnode *vp, struct vnstat *vn)
+{
+	struct mount mnt;
+	struct nwnode node;
+	int error;
+
+	assert(kd);
+	assert(vn);
+	error = kvm_read_all(kd, (unsigned long)VTONW(vp), &node, sizeof(node));
+	if (error != 0) {
+		warnx("can't read nwfs fnode at %p", (void *)VTONW(vp));
+		return (1);
+	}
+        error = kvm_read_all(kd, (unsigned long)getvnodemount(vp), &mnt,
+	    sizeof(mnt));
+        if (error != 0) {
+                warnx("can't read mount at %p for vnode %p",
+                    (void *)getvnodemount(vp), vp);
+                return (1);
+        }
+	vn->vn_fileid = node.n_fid.f_id;
+	if (vn->vn_fileid == 0)
+		vn->vn_fileid = NWFS_ROOT_INO;
+	vn->vn_fsid = mnt.mnt_stat.f_fsid.val[0];
+	return (0);
+}
diff --git a/lib/libprocstat/smbfs.c b/lib/libprocstat/smbfs.c
new file mode 100644
index 0000000..24d8acd
--- /dev/null
+++ b/lib/libprocstat/smbfs.c
@@ -0,0 +1,77 @@
+/*-
+ * Copyright (c) 2005-2009 Stanislav Sedov <stas@FreeBSD.org>
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
+ */
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <sys/param.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/vnode.h>
+#define _KERNEL
+#include <sys/mount.h>
+#undef _KERNEL
+
+#include <netinet/in.h>
+
+#include <assert.h>
+#include <err.h>
+#include <kvm.h>
+#include <stdlib.h>
+
+#include <fs/smbfs/smbfs.h>
+#include <fs/smbfs/smbfs_node.h>
+
+#include "libprocstat.h"
+#include "common_kvm.h"
+
+int
+smbfs_filestat(kvm_t *kd, struct vnode *vp, struct vnstat *vn)
+{
+	struct smbnode node;
+	struct mount mnt;
+	int error;
+
+	assert(kd);
+	assert(vn);
+	error = kvm_read_all(kd, (unsigned long)VTOSMB(vp), &node,
+	    sizeof(node));
+	if (error != 0) {
+		warnx("can't read smbfs fnode at %p", (void *)VTOSMB(vp));
+		return (1);
+	}
+        error = kvm_read_all(kd, (unsigned long)getvnodemount(vp), &mnt,
+	    sizeof(mnt));
+        if (error != 0) {
+                warnx("can't read mount at %p for vnode %p",
+                    (void *)getvnodemount(vp), vp);
+                return (1);
+        }
+	vn->vn_fileid = node.n_ino;
+	if (vn->vn_fileid == 0)
+		vn->vn_fileid = 2;
+	vn->vn_fsid = mnt.mnt_stat.f_fsid.val[0];
+	return (0);
+}
diff --git a/lib/libprocstat/udf.c b/lib/libprocstat/udf.c
new file mode 100644
index 0000000..5d9310e
--- /dev/null
+++ b/lib/libprocstat/udf.c
@@ -0,0 +1,102 @@
+/*-
+ * Copyright (c) 2005-2009 Stanislav Sedov <stas@FreeBSD.org>
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
+ */
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <sys/param.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/vnode.h>
+#include <sys/buf.h>
+#define _KERNEL
+#include <sys/mount.h>
+#undef _KERNEL
+
+#include <netinet/in.h>
+
+#include <assert.h>
+#include <err.h>
+#include <kvm.h>
+#include <stdlib.h>
+
+#include <fs/udf/ecma167-udf.h>
+
+#include "libprocstat.h"
+#include "common_kvm.h"
+
+/* XXX */
+struct udf_mnt {
+	int			im_flags;
+	struct mount		*im_mountp;
+	struct g_consumer	*im_cp;
+	struct bufobj		*im_bo;
+	struct cdev		*im_dev;
+	struct vnode		*im_devvp;
+	int			bsize;
+	int			bshift;
+	int			bmask;
+	uint32_t		part_start;
+	uint32_t		part_len;
+	uint64_t		root_id;
+	struct long_ad		root_icb;
+	int			p_sectors;
+	int			s_table_entries;
+	void			*s_table;
+	void			*im_d2l;
+};
+struct udf_node {
+	struct vnode	*i_vnode;
+	struct udf_mnt	*udfmp;
+	ino_t		hash_id;
+	long		diroff;
+	struct file_entry *fentry;
+};
+#define VTON(vp)	((struct udf_node *)((vp)->v_data))
+
+int
+udf_filestat(kvm_t *kd, struct vnode *vp, struct vnstat *vn)
+{
+	struct udf_node node;
+	struct udf_mnt mnt;
+	int error;
+
+	assert(kd);
+	assert(vn);
+	error = kvm_read_all(kd, (unsigned long)VTON(vp), &node, sizeof(node));
+	if (error != 0) {
+		warnx("can't read udf fnode at %p", (void *)VTON(vp));
+		return (1);
+	}
+        error = kvm_read_all(kd, (unsigned long)node.udfmp, &mnt, sizeof(mnt));
+        if (error != 0) {
+                warnx("can't read udf_mnt at %p for vnode %p",
+                    (void *)node.udfmp, vp);
+                return (1);
+        }
+	vn->vn_fileid = node.hash_id;
+	vn->vn_fsid = dev2udev(kd, mnt.im_dev);
+	return (0);
+}
diff --git a/usr.bin/fstat/zfs.c b/lib/libprocstat/zfs.c
index cdca41f..aa6d78e 100644
--- a/usr.bin/fstat/zfs.c
+++ b/lib/libprocstat/zfs.c
@@ -45,14 +45,16 @@
 #include <sys/zfs_znode.h>
 #include <sys/zfs_sa.h>
 
+#include <netinet/in.h>
+
 #include <err.h>
 #include <kvm.h>
 #include <stdio.h>
 #include <stdlib.h>
 
 #define ZFS
-#undef dprintf
-#include <fstat.h>
+#include "libprocstat.h"
+#include "common_kvm.h"
 
 /* 
  * Offset calculations that are used to get data from znode without having the
@@ -62,7 +64,7 @@
 #define LOCATION_ZPHYS(zsize) ((zsize) - (2 * sizeof(void *) + sizeof(struct task)))
 
 int
-zfs_filestat(struct vnode *vp, struct filestat *fsp)
+zfs_filestat(kvm_t *kd, struct vnode *vp, struct vnstat *vn)
 {
 
 	znode_phys_t zphys;
@@ -76,20 +78,19 @@ zfs_filestat(struct vnode *vp, struct filestat *fsp)
 
 	len = sizeof(size);
 	if (sysctlbyname("debug.sizeof.znode", &size, &len, NULL, 0) == -1) {
-		dprintf(stderr, "error getting sysctl\n");
-		return (0);
+		warnx("error getting sysctl");
+		return (1);
 	}
 	znodeptr = malloc(size);
 	if (znodeptr == NULL) {
-		dprintf(stderr, "error allocating memory for znode storage\n");
-		return (0);
+		warnx("error allocating memory for znode storage");
+		return (1);
 	}
-
 	/* Since we have problems including vnode.h, we'll use the wrappers. */
 	vnodeptr = getvnodedata(vp);
-	if (!KVM_READ(vnodeptr, znodeptr, (size_t)size)) {
-		dprintf(stderr, "can't read znode at %p for pid %d\n",
-		    (void *)vnodeptr, Pid);
+	if (!kvm_read_all(kd, (unsigned long)vnodeptr, znodeptr,
+	    (size_t)size)) {
+		warnx("can't read znode at %p", (void *)vnodeptr);
 		goto bad;
 	}
 
@@ -104,33 +105,30 @@ zfs_filestat(struct vnode *vp, struct filestat *fsp)
 	zid = (uint64_t *)(dataptr + LOCATION_ZID);
 	zphys_addr = *(void **)(dataptr + LOCATION_ZPHYS(size));
 
-	if (!KVM_READ(zphys_addr, &zphys, sizeof(zphys))) {
-		dprintf(stderr, "can't read znode_phys at %p for pid %d\n",
-		    zphys_addr, Pid);
+	if (!kvm_read_all(kd, (unsigned long)zphys_addr, &zphys,
+	    sizeof(zphys))) {
+		warnx("can't read znode_phys at %p", zphys_addr);
 		goto bad;
 	}
 
 	/* Get the mount pointer, and read from the address. */
 	mountptr = getvnodemount(vp);
-	if (!KVM_READ(mountptr, &mount, sizeof(mount))) {
-		dprintf(stderr, "can't read mount at %p for pid %d\n",
-		    (void *)mountptr, Pid);
+	if (!kvm_read_all(kd, (unsigned long)mountptr, &mount, sizeof(mount))) {
+		warnx("can't read mount at %p", (void *)mountptr);
 		goto bad;
 	}
-
-	fsp->fsid = (long)(uint32_t)mount.mnt_stat.f_fsid.val[0];
-	fsp->fileid = *zid;
+	vn->vn_fsid = mount.mnt_stat.f_fsid.val[0];
+	vn->vn_fileid = *zid;
 	/*
 	 * XXX: Shows up wrong in output, but UFS has this error too. Could
 	 * be that we're casting mode-variables from 64-bit to 8-bit or simply
 	 * error in the mode-to-string function.
 	 */
-	fsp->mode = (mode_t)zphys.zp_mode;
-	fsp->size = (u_long)zphys.zp_size;
-	fsp->rdev = (dev_t)zphys.zp_rdev;
+	vn->vn_mode = (mode_t)zphys.zp_mode;
+	vn->vn_size = (u_long)zphys.zp_size;
 	free(znodeptr);
-	return (1);
+	return (0);
 bad:
 	free(znodeptr);
-	return (0);
+	return (1);
 }
diff --git a/usr.bin/fstat/zfs/Makefile b/lib/libprocstat/zfs/Makefile
index 7ecfc85..7ecfc85 100644
--- a/usr.bin/fstat/zfs/Makefile
+++ b/lib/libprocstat/zfs/Makefile
diff --git a/lib/libutil/Makefile b/lib/libutil/Makefile
index 9dc35c0..b2378ad 100644
--- a/lib/libutil/Makefile
+++ b/lib/libutil/Makefile
@@ -9,7 +9,8 @@ LIB=	util
 SHLIB_MAJOR= 9
 
 SRCS=	_secure_path.c auth.c expand_number.c flopen.c fparseln.c gr_util.c \
-	hexdump.c humanize_number.c kinfo_getfile.c kinfo_getvmmap.c kld.c \
+	hexdump.c humanize_number.c kinfo_getfile.c kinfo_getfile.c \
+	kinfo_getallproc.c kinfo_getproc.c kinfo_getvmmap.c kld.c \
 	login_auth.c login_cap.c \
 	login_class.c login_crypt.c login_ok.c login_times.c login_tty.c \
 	pidfile.c property.c pty.c pw_util.c quotafile.c realhostname.c \
@@ -29,7 +30,8 @@ MAN+=	kld.3 login_auth.3 login_tty.3 pty.3 \
 	_secure_path.3 uucplock.3 property.3 auth.3 realhostname.3 \
 	realhostname_sa.3 trimdomain.3 fparseln.3 humanize_number.3 \
 	pidfile.3 flopen.3 expand_number.3 hexdump.3 \
-	kinfo_getfile.3 kinfo_getvmmap.3 quotafile.3
+	kinfo_getfile.3 kinfo_getallproc.3 kinfo_getproc.3 \
+	kinfo_getvmmap.3 quotafile.3
 MAN+=	login.conf.5 auth.conf.5
 MLINKS+= kld.3 kld_isloaded.3 kld.3 kld_load.3
 MLINKS+= property.3 properties_read.3  property.3 properties_free.3
diff --git a/lib/libutil/kinfo_getallproc.3 b/lib/libutil/kinfo_getallproc.3
new file mode 100644
index 0000000..73981ae
--- /dev/null
+++ b/lib/libutil/kinfo_getallproc.3
@@ -0,0 +1,74 @@
+.\"
+.\" Copyright (c) 2009 Ulf Lilleengen
+.\" 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.
+.\"
+.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
+.\"
+.\" $FreeBSD$
+.\"
+.Dd July 9, 2009
+.Os
+.Dt KINFO_GETALLPROC 3
+.Sh NAME
+.Nm kinfo_getallproc
+.Nd function for getting process information of all processes from kernel
+.Sh LIBRARY
+.Lb libutil
+.Sh SYNOPSIS
+.In sys/types.h
+.In libutil.h
+.Ft struct kinfo_proc *
+.Fn kinfo_getallproc "int *cntp"
+.Sh DESCRIPTION
+This function is used for obtaining process information of all processes from
+the kernel.
+.Pp
+The
+.Ar cntp
+field is a pointer containing the number of process structures returned.
+This function is a wrapper around
+.Xr sysctl 3
+with the
+.Dv KERN_PROC_PROC
+mib.
+While the kernel returns a packed structure, this function expands the
+data into a fixed record format.
+.Sh RETURN VALUES
+On success the
+.Fn kinfo_getallproc
+function returns a pointer to
+.Ar cntp
+.Vt struct kinfo_proc
+structures as defined by
+.In sys/user.h .
+The pointer was obtained by an internal call to
+.Xr malloc 3
+and must be freed by the caller with a call to
+.Xr free 3 .
+On failure the
+.Fn kinfo_getallproc
+function returns
+.Dv NULL .
+.Sh SEE ALSO
+.Xr free 3 ,
+.Xr malloc 3 ,
+.Xr sysctl 3
diff --git a/lib/libutil/kinfo_getallproc.c b/lib/libutil/kinfo_getallproc.c
new file mode 100644
index 0000000..0f43ce2
--- /dev/null
+++ b/lib/libutil/kinfo_getallproc.c
@@ -0,0 +1,98 @@
+/*-
+ * Copyright (c) 2007 Robert N. M. Watson
+ * Copyright (c) 2009 Ulf Lilleengen
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
+ *
+ * $FreeBSD$
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <sys/param.h>
+#include <sys/user.h>
+#include <sys/sysctl.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "libutil.h"
+
+
+/*
+ * Sort processes first by pid and then tid.
+ */
+static int
+kinfo_proc_compare(const void *a, const void *b)
+{
+	int i;
+
+	i = ((const struct kinfo_proc *)a)->ki_pid -
+	    ((const struct kinfo_proc *)b)->ki_pid;
+	if (i != 0)
+		return (i);
+	i = ((const struct kinfo_proc *)a)->ki_tid -
+	    ((const struct kinfo_proc *)b)->ki_tid;
+	return (i);
+}
+
+static void
+kinfo_proc_sort(struct kinfo_proc *kipp, int count)
+{
+
+	qsort(kipp, count, sizeof(*kipp), kinfo_proc_compare);
+}
+
+struct kinfo_proc *
+kinfo_getallproc(int *cntp)
+{
+	struct kinfo_proc *kipp;
+	size_t len;
+	int mib[3];
+
+	mib[0] = CTL_KERN;
+	mib[1] = KERN_PROC;
+	mib[2] = KERN_PROC_PROC;
+
+	len = 0;
+	if (sysctl(mib, 3, NULL, &len, NULL, 0) < 0)
+		return (NULL);
+
+	kipp = malloc(len);
+	if (kipp == NULL)
+		return (NULL);
+
+	if (sysctl(mib, 3, kipp, &len, NULL, 0) < 0)
+		goto bad;
+	if (len % sizeof(*kipp) != 0)
+		goto bad;
+	if (kipp->ki_structsize != sizeof(*kipp))
+		goto bad;
+	*cntp = len / sizeof(*kipp);
+	kinfo_proc_sort(kipp, len / sizeof(*kipp));
+	return (kipp);
+bad:
+	*cntp = 0;
+	free(kipp);
+	return (NULL);
+}
diff --git a/lib/libutil/kinfo_getproc.3 b/lib/libutil/kinfo_getproc.3
new file mode 100644
index 0000000..2778ad1
--- /dev/null
+++ b/lib/libutil/kinfo_getproc.3
@@ -0,0 +1,73 @@
+.\"
+.\" Copyright (c) 2009 Ulf Lilleengen
+.\" 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.
+.\"
+.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
+.\"
+.\" $FreeBSD$
+.\"
+.Dd July 9, 2009
+.Os
+.Dt KINFO_GETPROC 3
+.Sh NAME
+.Nm kinfo_getproc
+.Nd function for getting process information from kernel
+.Sh LIBRARY
+.Lb libutil
+.Sh SYNOPSIS
+.In sys/types.h
+.In libutil.h
+.Ft struct kinfo_proc *
+.Fn kinfo_getproc "pid_t pid" "int *cntp"
+.Sh DESCRIPTION
+This function is used for obtaining process information from the kernel.
+.Pp
+The
+.Ar pid
+field contains the process identifier.
+This should be the a process that you have privilige to access.
+This function is a wrapper around
+.Xr sysctl 3
+with the
+.Dv KERN_PROC_PID
+mib.
+While the kernel returns a packed structure, this function expands the
+data into a fixed record format.
+.Sh RETURN VALUES
+On success the
+.Fn kinfo_getproc
+function returns a pointer to a
+.Vt struct kinfo_proc
+structure as defined by
+.In sys/user.h .
+The pointer was obtained by an internal call to
+.Xr malloc 3
+and must be freed by the caller with a call to
+.Xr free 3 .
+On failure the
+.Fn kinfo_getproc
+function returns
+.Dv NULL .
+.Sh SEE ALSO
+.Xr free 3 ,
+.Xr malloc 3 ,
+.Xr sysctl 3
diff --git a/lib/libutil/kinfo_getproc.c b/lib/libutil/kinfo_getproc.c
new file mode 100644
index 0000000..2ae6b57
--- /dev/null
+++ b/lib/libutil/kinfo_getproc.c
@@ -0,0 +1,71 @@
+/*-
+ * Copyright (c) 2009 Ulf Lilleengen
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
+ *
+ * $FreeBSD$
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <sys/param.h>
+#include <sys/user.h>
+#include <sys/sysctl.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "libutil.h"
+
+struct kinfo_proc *
+kinfo_getproc(pid_t pid)
+{
+	struct kinfo_proc *kipp;
+	int mib[4];
+	size_t len;
+
+	len = 0;
+	mib[0] = CTL_KERN;
+	mib[1] = KERN_PROC;
+	mib[2] = KERN_PROC_PID;
+	mib[3] = pid;
+	if (sysctl(mib, 4, NULL, &len, NULL, 0) < 0)
+		return (NULL);
+
+	kipp = malloc(len);
+	if (kipp == NULL)
+		return (NULL);
+
+	if (sysctl(mib, 4, kipp, &len, NULL, 0) < 0)
+		goto bad;
+	if (len != sizeof(*kipp))
+		goto bad;
+	if (kipp->ki_structsize != sizeof(*kipp))
+		goto bad;
+	if (kipp->ki_pid != pid)
+		goto bad;
+	return (kipp);
+bad:
+	free(kipp);
+	return (NULL);
+}
diff --git a/lib/libutil/libutil.h b/lib/libutil/libutil.h
index f39e4f5..fc6d3bb 100644
--- a/lib/libutil/libutil.h
+++ b/lib/libutil/libutil.h
@@ -88,6 +88,7 @@ struct termios;
 struct winsize;
 struct in_addr;
 struct kinfo_file;
+struct kinfo_proc;
 struct kinfo_vmentry;
 
 __BEGIN_DECLS
@@ -126,6 +127,10 @@ struct kinfo_file *
 	kinfo_getfile(pid_t _pid, int *_cntp);
 struct kinfo_vmentry *
 	kinfo_getvmmap(pid_t _pid, int *_cntp);
+struct kinfo_proc *
+	kinfo_getallproc(int *_cntp);
+struct kinfo_proc *
+	kinfo_getproc(pid_t _pid);
 
 #ifdef _STDIO_H_	/* avoid adding new includes */
 char   *fparseln(FILE *, size_t *, size_t *, const char[3], int);
diff --git a/sys/kern/kern_descrip.c b/sys/kern/kern_descrip.c
index 3f40f2b..bf75db0 100644
--- a/sys/kern/kern_descrip.c
+++ b/sys/kern/kern_descrip.c
@@ -59,6 +59,8 @@ __FBSDID("$FreeBSD$");
 #include <sys/mqueue.h>
 #include <sys/mutex.h>
 #include <sys/namei.h>
+#include <sys/selinfo.h>
+#include <sys/pipe.h>
 #include <sys/priv.h>
 #include <sys/proc.h>
 #include <sys/protosw.h>
@@ -73,6 +75,8 @@ __FBSDID("$FreeBSD$");
 #include <sys/sysproto.h>
 #include <sys/tty.h>
 #include <sys/unistd.h>
+#include <sys/un.h>
+#include <sys/unpcb.h>
 #include <sys/user.h>
 #include <sys/vnode.h>
 #ifdef KTRACE
@@ -81,6 +85,9 @@ __FBSDID("$FreeBSD$");
 
 #include <net/vnet.h>
 
+#include <netinet/in.h>
+#include <netinet/in_pcb.h>
+
 #include <security/audit/audit.h>
 
 #include <vm/uma.h>
@@ -106,6 +113,10 @@ static int	fd_last_used(struct filedesc *, int, int);
 static void	fdgrowtable(struct filedesc *, int);
 static void	fdunused(struct filedesc *fdp, int fd);
 static void	fdused(struct filedesc *fdp, int fd);
+static int	fill_vnode_info(struct vnode *vp, struct kinfo_file *kif);
+static int	fill_socket_info(struct socket *so, struct kinfo_file *kif);
+static int	fill_pts_info(struct tty *tp, struct kinfo_file *kif);
+static int	fill_pipe_info(struct pipe *pi, struct kinfo_file *kif);
 
 /*
  * A process is initially started out with NDFILE descriptors stored within
@@ -2972,48 +2983,74 @@ CTASSERT(sizeof(struct kinfo_file) == KINFO_FILE_SIZE);
 #endif
 
 static int
-export_vnode_for_sysctl(struct vnode *vp, int type,
-    struct kinfo_file *kif, struct filedesc *fdp, struct sysctl_req *req)
-{
-	int error;
-	char *fullpath, *freepath;
-	int vfslocked;
+export_fd_for_sysctl(void *data, int type, int fd, int fflags, int refcnt,
+    int64_t offset, struct kinfo_file *kif, struct sysctl_req *req)
+{
+	struct {
+		int	fflag;
+		int	kf_fflag;
+	} fflags_table[] = {
+		{ FAPPEND, KF_FLAG_APPEND },
+		{ FASYNC, KF_FLAG_ASYNC },
+		{ FFSYNC, KF_FLAG_FSYNC },
+		{ FHASLOCK, KF_FLAG_HASLOCK },
+		{ FNONBLOCK, KF_FLAG_NONBLOCK },
+		{ FREAD, KF_FLAG_READ },
+		{ FWRITE, KF_FLAG_WRITE },
+		{ O_CREAT, KF_FLAG_CREAT },
+		{ O_DIRECT, KF_FLAG_DIRECT },
+		{ O_EXCL, KF_FLAG_EXCL },
+		{ O_EXEC, KF_FLAG_EXEC },
+		{ O_EXLOCK, KF_FLAG_EXLOCK },
+		{ O_NOFOLLOW, KF_FLAG_NOFOLLOW },
+		{ O_SHLOCK, KF_FLAG_SHLOCK },
+		{ O_TRUNC, KF_FLAG_TRUNC }
+	};
+#define	NFFLAGS	(sizeof(fflags_table) / sizeof(*fflags_table))
+	struct vnode *vp;
+	int error, vfslocked;
+	unsigned int i;
 
 	bzero(kif, sizeof(*kif));
-
-	vref(vp);
-	kif->kf_fd = type;
-	kif->kf_type = KF_TYPE_VNODE;
-	/* This function only handles directories. */
-	if (vp->v_type != VDIR) {
+	switch (type) {
+	case KF_TYPE_FIFO:
+	case KF_TYPE_VNODE:
+		vp = (struct vnode *)data;
+		error = fill_vnode_info(vp, kif);
+		vfslocked = VFS_LOCK_GIANT(vp->v_mount);
 		vrele(vp);
-		return (ENOTDIR);
+		VFS_UNLOCK_GIANT(vfslocked);
+		break;
+	case KF_TYPE_SOCKET:
+		error = fill_socket_info((struct socket *)data, kif);
+		break;
+	case KF_TYPE_PIPE:
+		error = fill_pipe_info((struct pipe *)data, kif);
+		break;
+	case KF_TYPE_PTS:
+		error = fill_pts_info((struct tty *)data, kif);
+		break;
+	default:
+		error = 0;
 	}
-	kif->kf_vnode_type = KF_VTYPE_VDIR;
+	if (error == 0)
+		kif->kf_status |= KF_ATTR_VALID;
 
 	/*
-	 * This is not a true file descriptor, so we set a bogus refcount
-	 * and offset to indicate these fields should be ignored.
+	 * Translate file access flags.
 	 */
-	kif->kf_ref_count = -1;
-	kif->kf_offset = -1;
-
-	freepath = NULL;
-	fullpath = "-";
-	FILEDESC_SUNLOCK(fdp);
-	vn_fullpath(curthread, vp, &fullpath, &freepath);
-	vfslocked = VFS_LOCK_GIANT(vp->v_mount);
-	vrele(vp);
-	VFS_UNLOCK_GIANT(vfslocked);
-	strlcpy(kif->kf_path, fullpath, sizeof(kif->kf_path));
-	if (freepath != NULL)
-		free(freepath, M_TEMP);
+	for (i = 0; i < NFFLAGS; i++)
+		if (fflags & fflags_table[i].fflag)
+			kif->kf_flags |=  fflags_table[i].kf_fflag;
+	kif->kf_fd = fd;
+	kif->kf_type = type;
+	kif->kf_ref_count = refcnt;
+	kif->kf_offset = offset;
 	/* Pack record size down */
 	kif->kf_structsize = offsetof(struct kinfo_file, kf_path) +
 	    strlen(kif->kf_path) + 1;
 	kif->kf_structsize = roundup(kif->kf_structsize, sizeof(uint64_t));
 	error = SYSCTL_OUT(req, kif, kif->kf_structsize);
-	FILEDESC_SLOCK(fdp);
 	return (error);
 }
 
@@ -3023,17 +3060,16 @@ export_vnode_for_sysctl(struct vnode *vp, int type,
 static int
 sysctl_kern_proc_filedesc(SYSCTL_HANDLER_ARGS)
 {
-	char *fullpath, *freepath;
-	struct kinfo_file *kif;
-	struct filedesc *fdp;
-	int error, i, *name;
-	struct socket *so;
-	struct vnode *vp;
 	struct file *fp;
+	struct filedesc *fdp;
+	struct kinfo_file *kif;
 	struct proc *p;
-	struct tty *tp;
-	int vfslocked;
+	struct vnode *cttyvp, *textvp, *tracevp;
 	size_t oldidx;
+	int64_t offset;
+	void *data;
+	int error, i, *name;
+	int type, refcnt, fflags;
 
 	name = (int *)arg1;
 	if ((p = pfind((pid_t)name[0])) == NULL)
@@ -3042,177 +3078,136 @@ sysctl_kern_proc_filedesc(SYSCTL_HANDLER_ARGS)
 		PROC_UNLOCK(p);
 		return (error);
 	}
+	/* ktrace vnode */
+	tracevp = p->p_tracevp;
+	if (tracevp != NULL)
+		vref(tracevp);
+	/* text vnode */
+	textvp = p->p_textvp;
+	if (textvp != NULL)
+		vref(textvp);
+	/* Controlling tty. */
+	cttyvp = NULL;
+	if (p->p_pgrp != NULL && p->p_pgrp->pg_session != NULL) {
+		cttyvp = p->p_pgrp->pg_session->s_ttyvp;
+		if (cttyvp != NULL)
+			vref(cttyvp);
+	}
 	fdp = fdhold(p);
 	PROC_UNLOCK(p);
-	if (fdp == NULL)
-		return (ENOENT);
 	kif = malloc(sizeof(*kif), M_TEMP, M_WAITOK);
+	if (tracevp != NULL)
+		export_fd_for_sysctl(tracevp, KF_TYPE_VNODE, KF_FD_TYPE_TRACE,
+		    FREAD | FWRITE, -1, -1, kif, req);
+	if (textvp != NULL)
+		export_fd_for_sysctl(textvp, KF_TYPE_VNODE, KF_FD_TYPE_TEXT,
+		    FREAD, -1, -1, kif, req);
+	if (cttyvp != NULL)
+		export_fd_for_sysctl(cttyvp, KF_TYPE_VNODE, KF_FD_TYPE_CTTY,
+		    FREAD | FWRITE, -1, -1, kif, req);
+	if (fdp == NULL)
+		goto fail;
 	FILEDESC_SLOCK(fdp);
-	if (fdp->fd_cdir != NULL)
-		export_vnode_for_sysctl(fdp->fd_cdir, KF_FD_TYPE_CWD, kif,
-				fdp, req);
-	if (fdp->fd_rdir != NULL)
-		export_vnode_for_sysctl(fdp->fd_rdir, KF_FD_TYPE_ROOT, kif,
-				fdp, req);
-	if (fdp->fd_jdir != NULL)
-		export_vnode_for_sysctl(fdp->fd_jdir, KF_FD_TYPE_JAIL, kif,
-				fdp, req);
+	/* working directory */
+	if (fdp->fd_cdir != NULL) {
+		vref(fdp->fd_cdir);
+		data = fdp->fd_cdir;
+		FILEDESC_SUNLOCK(fdp);
+		export_fd_for_sysctl(data, KF_TYPE_VNODE, KF_FD_TYPE_CWD,
+		    FREAD, -1, -1, kif, req);
+		FILEDESC_SLOCK(fdp);
+	}
+	/* root directory */
+	if (fdp->fd_rdir != NULL) {
+		vref(fdp->fd_rdir);
+		data = fdp->fd_rdir;
+		FILEDESC_SUNLOCK(fdp);
+		export_fd_for_sysctl(data, KF_TYPE_VNODE, KF_FD_TYPE_ROOT,
+		    FREAD, -1, -1, kif, req);
+		FILEDESC_SLOCK(fdp);
+	}
+	/* jail directory */
+	if (fdp->fd_jdir != NULL) {
+		vref(fdp->fd_jdir);
+		data = fdp->fd_jdir;
+		FILEDESC_SUNLOCK(fdp);
+		export_fd_for_sysctl(data, KF_TYPE_VNODE, KF_FD_TYPE_JAIL,
+		    FREAD, -1, -1, kif, req);
+		FILEDESC_SLOCK(fdp);
+	}
 	for (i = 0; i < fdp->fd_nfiles; i++) {
 		if ((fp = fdp->fd_ofiles[i]) == NULL)
 			continue;
-		bzero(kif, sizeof(*kif));
-		vp = NULL;
-		so = NULL;
-		tp = NULL;
-		kif->kf_fd = i;
+		data = NULL;
 		switch (fp->f_type) {
 		case DTYPE_VNODE:
-			kif->kf_type = KF_TYPE_VNODE;
-			vp = fp->f_vnode;
+			type = KF_TYPE_VNODE;
+			vref(fp->f_vnode);
+			data = fp->f_vnode;
 			break;
 
 		case DTYPE_SOCKET:
-			kif->kf_type = KF_TYPE_SOCKET;
-			so = fp->f_data;
+			type = KF_TYPE_SOCKET;
+			data = fp->f_data;
 			break;
 
 		case DTYPE_PIPE:
-			kif->kf_type = KF_TYPE_PIPE;
+			type = KF_TYPE_PIPE;
+			data = fp->f_data;
 			break;
 
 		case DTYPE_FIFO:
-			kif->kf_type = KF_TYPE_FIFO;
-			vp = fp->f_vnode;
+			type = KF_TYPE_FIFO;
+			vref(fp->f_vnode);
+			data = fp->f_vnode;
 			break;
 
 		case DTYPE_KQUEUE:
-			kif->kf_type = KF_TYPE_KQUEUE;
+			type = KF_TYPE_KQUEUE;
 			break;
 
 		case DTYPE_CRYPTO:
-			kif->kf_type = KF_TYPE_CRYPTO;
+			type = KF_TYPE_CRYPTO;
 			break;
 
 		case DTYPE_MQUEUE:
-			kif->kf_type = KF_TYPE_MQUEUE;
+			type = KF_TYPE_MQUEUE;
 			break;
 
 		case DTYPE_SHM:
-			kif->kf_type = KF_TYPE_SHM;
+			type = KF_TYPE_SHM;
 			break;
 
 		case DTYPE_SEM:
-			kif->kf_type = KF_TYPE_SEM;
+			type = KF_TYPE_SEM;
 			break;
 
 		case DTYPE_PTS:
-			kif->kf_type = KF_TYPE_PTS;
-			tp = fp->f_data;
+			type = KF_TYPE_PTS;
+			data = fp->f_data;
 			break;
 
 		default:
-			kif->kf_type = KF_TYPE_UNKNOWN;
+			type = KF_TYPE_UNKNOWN;
 			break;
 		}
-		kif->kf_ref_count = fp->f_count;
-		if (fp->f_flag & FREAD)
-			kif->kf_flags |= KF_FLAG_READ;
-		if (fp->f_flag & FWRITE)
-			kif->kf_flags |= KF_FLAG_WRITE;
-		if (fp->f_flag & FAPPEND)
-			kif->kf_flags |= KF_FLAG_APPEND;
-		if (fp->f_flag & FASYNC)
-			kif->kf_flags |= KF_FLAG_ASYNC;
-		if (fp->f_flag & FFSYNC)
-			kif->kf_flags |= KF_FLAG_FSYNC;
-		if (fp->f_flag & FNONBLOCK)
-			kif->kf_flags |= KF_FLAG_NONBLOCK;
-		if (fp->f_flag & O_DIRECT)
-			kif->kf_flags |= KF_FLAG_DIRECT;
-		if (fp->f_flag & FHASLOCK)
-			kif->kf_flags |= KF_FLAG_HASLOCK;
-		kif->kf_offset = fp->f_offset;
-		if (vp != NULL) {
-			vref(vp);
-			switch (vp->v_type) {
-			case VNON:
-				kif->kf_vnode_type = KF_VTYPE_VNON;
-				break;
-			case VREG:
-				kif->kf_vnode_type = KF_VTYPE_VREG;
-				break;
-			case VDIR:
-				kif->kf_vnode_type = KF_VTYPE_VDIR;
-				break;
-			case VBLK:
-				kif->kf_vnode_type = KF_VTYPE_VBLK;
-				break;
-			case VCHR:
-				kif->kf_vnode_type = KF_VTYPE_VCHR;
-				break;
-			case VLNK:
-				kif->kf_vnode_type = KF_VTYPE_VLNK;
-				break;
-			case VSOCK:
-				kif->kf_vnode_type = KF_VTYPE_VSOCK;
-				break;
-			case VFIFO:
-				kif->kf_vnode_type = KF_VTYPE_VFIFO;
-				break;
-			case VBAD:
-				kif->kf_vnode_type = KF_VTYPE_VBAD;
-				break;
-			default:
-				kif->kf_vnode_type = KF_VTYPE_UNKNOWN;
-				break;
-			}
-			/*
-			 * It is OK to drop the filedesc lock here as we will
-			 * re-validate and re-evaluate its properties when
-			 * the loop continues.
-			 */
-			freepath = NULL;
-			fullpath = "-";
-			FILEDESC_SUNLOCK(fdp);
-			vn_fullpath(curthread, vp, &fullpath, &freepath);
-			vfslocked = VFS_LOCK_GIANT(vp->v_mount);
-			vrele(vp);
-			VFS_UNLOCK_GIANT(vfslocked);
-			strlcpy(kif->kf_path, fullpath,
-			    sizeof(kif->kf_path));
-			if (freepath != NULL)
-				free(freepath, M_TEMP);
-			FILEDESC_SLOCK(fdp);
-		}
-		if (so != NULL) {
-			struct sockaddr *sa;
+		refcnt = fp->f_count;
+		fflags = fp->f_flag;
+		offset = fp->f_offset;
 
-			if (so->so_proto->pr_usrreqs->pru_sockaddr(so, &sa)
-			    == 0 && sa->sa_len <= sizeof(kif->kf_sa_local)) {
-				bcopy(sa, &kif->kf_sa_local, sa->sa_len);
-				free(sa, M_SONAME);
-			}
-			if (so->so_proto->pr_usrreqs->pru_peeraddr(so, &sa)
-			    == 0 && sa->sa_len <= sizeof(kif->kf_sa_peer)) {
-				bcopy(sa, &kif->kf_sa_peer, sa->sa_len);
-				free(sa, M_SONAME);
-			}
-			kif->kf_sock_domain =
-			    so->so_proto->pr_domain->dom_family;
-			kif->kf_sock_type = so->so_type;
-			kif->kf_sock_protocol = so->so_proto->pr_protocol;
-		}
-		if (tp != NULL) {
-			strlcpy(kif->kf_path, tty_devname(tp),
-			    sizeof(kif->kf_path));
-		}
-		/* Pack record size down */
-		kif->kf_structsize = offsetof(struct kinfo_file, kf_path) +
-		    strlen(kif->kf_path) + 1;
-		kif->kf_structsize = roundup(kif->kf_structsize,
-		    sizeof(uint64_t));
+		/*
+		 * Create sysctl entry.
+		 * It is OK to drop the filedesc lock here as we will
+		 * re-validate and re-evaluate its properties when
+		 * the loop continues.
+		 */
 		oldidx = req->oldidx;
-		error = SYSCTL_OUT(req, kif, kif->kf_structsize);
+		if (type == KF_TYPE_VNODE || type == KF_TYPE_FIFO)
+			FILEDESC_SUNLOCK(fdp);
+		error = export_fd_for_sysctl(data, type, i,
+		    fflags, refcnt, offset, kif, req);
+		if (type == KF_TYPE_VNODE || type == KF_TYPE_FIFO)
+			FILEDESC_SLOCK(fdp);
 		if (error) {
 			if (error == ENOMEM) {
 				/*
@@ -3228,11 +3223,164 @@ sysctl_kern_proc_filedesc(SYSCTL_HANDLER_ARGS)
 		}
 	}
 	FILEDESC_SUNLOCK(fdp);
+fail:
 	fddrop(fdp);
 	free(kif, M_TEMP);
 	return (error);
 }
 
+int
+vntype_to_kinfo(int vtype)
+{
+	struct {
+		int	vtype;
+		int	kf_vtype;
+	} vtypes_table[] = {
+		{ VBAD, KF_VTYPE_VBAD },
+		{ VBLK, KF_VTYPE_VBLK },
+		{ VCHR, KF_VTYPE_VCHR },
+		{ VDIR, KF_VTYPE_VDIR },
+		{ VFIFO, KF_VTYPE_VFIFO },
+		{ VLNK, KF_VTYPE_VLNK },
+		{ VNON, KF_VTYPE_VNON },
+		{ VREG, KF_VTYPE_VREG },
+		{ VSOCK, KF_VTYPE_VSOCK }
+	};
+#define	NVTYPES	(sizeof(vtypes_table) / sizeof(*vtypes_table))
+	unsigned int i;
+
+	/*
+	 * Perform vtype translation.
+	 */
+	for (i = 0; i < NVTYPES; i++)
+		if (vtypes_table[i].vtype == vtype)
+			break;
+	if (i < NVTYPES)
+		return (vtypes_table[i].kf_vtype);
+
+	return (KF_VTYPE_UNKNOWN);
+}
+
+static int
+fill_vnode_info(struct vnode *vp, struct kinfo_file *kif)
+{
+	struct vattr va;
+	char *fullpath, *freepath;
+	int error, vfslocked;
+
+	if (vp == NULL)
+		return (1);
+	kif->kf_vnode_type = vntype_to_kinfo(vp->v_type);
+	freepath = NULL;
+	fullpath = "-";
+	error = vn_fullpath(curthread, vp, &fullpath, &freepath);
+	if (error == 0) {
+		strlcpy(kif->kf_path, fullpath, sizeof(kif->kf_path));
+	}
+	if (freepath != NULL)
+		free(freepath, M_TEMP);
+
+	/*
+	 * Retrieve vnode attributes.
+	 */
+	va.va_fsid = VNOVAL;
+	va.va_rdev = NODEV;
+	vfslocked = VFS_LOCK_GIANT(vp->v_mount);
+	vn_lock(vp, LK_SHARED | LK_RETRY);
+	error = VOP_GETATTR(vp, &va, curthread->td_ucred);
+	VOP_UNLOCK(vp, 0);
+	VFS_UNLOCK_GIANT(vfslocked);
+	if (error != 0)
+		return (error);
+	if (va.va_fsid != VNOVAL)
+		kif->kf_un.kf_file.kf_file_fsid = va.va_fsid;
+	else
+		kif->kf_un.kf_file.kf_file_fsid =
+		    vp->v_mount->mnt_stat.f_fsid.val[0];
+	kif->kf_un.kf_file.kf_file_fileid = va.va_fileid;
+	kif->kf_un.kf_file.kf_file_mode = MAKEIMODE(va.va_type, va.va_mode);
+	kif->kf_un.kf_file.kf_file_size = va.va_size;
+	kif->kf_un.kf_file.kf_file_rdev = va.va_rdev;
+	return (0);
+}
+
+static int
+fill_socket_info(struct socket *so, struct kinfo_file *kif)
+{
+	struct sockaddr *sa;
+	struct inpcb *inpcb;
+	struct unpcb *unpcb;
+	int error;
+
+	if (so == NULL)
+		return (1);
+	kif->kf_sock_domain = so->so_proto->pr_domain->dom_family;
+	kif->kf_sock_type = so->so_type;
+	kif->kf_sock_protocol = so->so_proto->pr_protocol;
+	kif->kf_un.kf_sock.kf_sock_pcb = (uintptr_t)so->so_pcb;
+	switch(kif->kf_sock_domain) {
+	case AF_INET:
+	case AF_INET6:
+		if (kif->kf_sock_protocol == IPPROTO_TCP) {
+			if (so->so_pcb != NULL) {
+				inpcb = (struct inpcb *)(so->so_pcb);
+				kif->kf_un.kf_sock.kf_sock_inpcb =
+				    (uintptr_t)inpcb->inp_ppcb;
+			}
+		}
+		break;
+	case AF_UNIX:
+		if (so->so_pcb != NULL) {
+			unpcb = (struct unpcb *)(so->so_pcb);
+			if (unpcb->unp_conn) {
+				kif->kf_un.kf_sock.kf_sock_unpconn =
+				    (uintptr_t)unpcb->unp_conn;
+				kif->kf_un.kf_sock.kf_sock_rcv_sb_state =
+				    so->so_rcv.sb_state;
+				kif->kf_un.kf_sock.kf_sock_snd_sb_state =
+				    so->so_snd.sb_state;
+			}
+		}
+		break;
+	}
+	error = so->so_proto->pr_usrreqs->pru_sockaddr(so, &sa);
+	if (error == 0 && sa->sa_len <= sizeof(kif->kf_sa_local)) {
+		bcopy(sa, &kif->kf_sa_local, sa->sa_len);
+		free(sa, M_SONAME);
+	}
+	error = so->so_proto->pr_usrreqs->pru_peeraddr(so, &sa);
+	if (error == 0 && sa->sa_len <= sizeof(kif->kf_sa_peer)) {
+		bcopy(sa, &kif->kf_sa_peer, sa->sa_len);
+		free(sa, M_SONAME);
+	}
+	strncpy(kif->kf_path, so->so_proto->pr_domain->dom_name,
+	    sizeof(kif->kf_path));
+	return (0);
+}
+
+static int
+fill_pts_info(struct tty *tp, struct kinfo_file *kif)
+{
+
+	if (tp == NULL)
+		return (1);
+	kif->kf_un.kf_pts.kf_pts_dev = tty_udev(tp);
+	strlcpy(kif->kf_path, tty_devname(tp), sizeof(kif->kf_path));
+	return (0);
+}
+
+static int
+fill_pipe_info(struct pipe *pi, struct kinfo_file *kif)
+{
+
+	if (pi == NULL)
+		return (1);
+	kif->kf_un.kf_pipe.kf_pipe_addr = (uintptr_t)pi;
+	kif->kf_un.kf_pipe.kf_pipe_peer = (uintptr_t)pi->pipe_peer;
+	kif->kf_un.kf_pipe.kf_pipe_buffer_cnt = pi->pipe_buffer.cnt;
+	return (0);
+}
+
 static SYSCTL_NODE(_kern_proc, KERN_PROC_FILEDESC, filedesc, CTLFLAG_RD,
     sysctl_kern_proc_filedesc, "Process filedesc entries");
 
diff --git a/sys/kern/kern_proc.c b/sys/kern/kern_proc.c
index 34cc570..4f1dc45 100644
--- a/sys/kern/kern_proc.c
+++ b/sys/kern/kern_proc.c
@@ -1757,8 +1757,6 @@ sysctl_kern_proc_vmmap(SYSCTL_HANDLER_ARGS)
 		last_timestamp = map->timestamp;
 		vm_map_unlock_read(map);
 
-		kve->kve_fileid = 0;
-		kve->kve_fsid = 0;
 		freepath = NULL;
 		fullpath = "";
 		if (lobj) {
@@ -1800,12 +1798,18 @@ sysctl_kern_proc_vmmap(SYSCTL_HANDLER_ARGS)
 			if (vp != NULL) {
 				vn_fullpath(curthread, vp, &fullpath,
 				    &freepath);
+				kve->kve_vn_type = vntype_to_kinfo(vp->v_type);
 				cred = curthread->td_ucred;
 				vfslocked = VFS_LOCK_GIANT(vp->v_mount);
 				vn_lock(vp, LK_SHARED | LK_RETRY);
 				if (VOP_GETATTR(vp, &va, cred) == 0) {
-					kve->kve_fileid = va.va_fileid;
-					kve->kve_fsid = va.va_fsid;
+					kve->kve_vn_fileid = va.va_fileid;
+					kve->kve_vn_fsid = va.va_fsid;
+					kve->kve_vn_mode =
+					    MAKEIMODE(va.va_type, va.va_mode);
+					kve->kve_vn_size = va.va_size;
+					kve->kve_vn_rdev = va.va_rdev;
+					kve->kve_status = KF_ATTR_VALID;
 				}
 				vput(vp);
 				VFS_UNLOCK_GIANT(vfslocked);
diff --git a/sys/sys/user.h b/sys/sys/user.h
index 5c5cbd4..644f911 100644
--- a/sys/sys/user.h
+++ b/sys/sys/user.h
@@ -233,6 +233,8 @@ struct user {
  * The KERN_PROC_FILE sysctl allows a process to dump the file descriptor
  * array of another process.
  */
+#define	KF_ATTR_VALID	0x0001
+
 #define	KF_TYPE_NONE	0
 #define	KF_TYPE_VNODE	1
 #define	KF_TYPE_SOCKET	2
@@ -260,6 +262,9 @@ struct user {
 #define	KF_FD_TYPE_CWD	-1	/* Current working directory */
 #define	KF_FD_TYPE_ROOT	-2	/* Root directory */
 #define	KF_FD_TYPE_JAIL	-3	/* Jail directory */
+#define	KF_FD_TYPE_TRACE	-4	/* ptrace vnode */
+#define	KF_FD_TYPE_TEXT	-5	/* Text vnode */
+#define	KF_FD_TYPE_CTTY	-6	/* Controlling terminal */
 
 #define	KF_FLAG_READ		0x00000001
 #define	KF_FLAG_WRITE		0x00000002
@@ -269,6 +274,13 @@ struct user {
 #define	KF_FLAG_NONBLOCK	0x00000020
 #define	KF_FLAG_DIRECT		0x00000040
 #define	KF_FLAG_HASLOCK		0x00000080
+#define	KF_FLAG_SHLOCK		0x00000100
+#define	KF_FLAG_EXLOCK		0x00000200
+#define	KF_FLAG_NOFOLLOW	0x00000400
+#define	KF_FLAG_CREAT		0x00000800
+#define	KF_FLAG_TRUNC		0x00001000
+#define	KF_FLAG_EXCL		0x00002000
+#define	KF_FLAG_EXEC		0x00004000
 
 /*
  * Old format.  Has variable hidden padding due to alignment.
@@ -303,22 +315,67 @@ struct kinfo_ofile {
 #endif
 
 struct kinfo_file {
-	int	kf_structsize;			/* Variable size of record. */
-	int	kf_type;			/* Descriptor type. */
-	int	kf_fd;				/* Array index. */
-	int	kf_ref_count;			/* Reference count. */
-	int	kf_flags;			/* Flags. */
-	int	_kf_pad0;			/* Round to 64 bit alignment */
-	int64_t	kf_offset;			/* Seek location. */
-	int	kf_vnode_type;			/* Vnode type. */
-	int	kf_sock_domain;			/* Socket domain. */
-	int	kf_sock_type;			/* Socket type. */
-	int	kf_sock_protocol;		/* Socket protocol. */
+	int		kf_structsize;		/* Variable size of record. */
+	int		kf_type;		/* Descriptor type. */
+	int		kf_fd;			/* Array index. */
+	int		kf_ref_count;		/* Reference count. */
+	int		kf_flags;		/* Flags. */
+	int		kf_pad0;		/* Round to 64 bit alignment. */
+	int64_t		kf_offset;		/* Seek location. */
+	int		kf_vnode_type;		/* Vnode type. */
+	int		kf_sock_domain;		/* Socket domain. */
+	int		kf_sock_type;		/* Socket type. */
+	int		kf_sock_protocol;	/* Socket protocol. */
 	struct sockaddr_storage kf_sa_local;	/* Socket address. */
 	struct sockaddr_storage	kf_sa_peer;	/* Peer address. */
-	int	_kf_ispare[16];			/* Space for more stuff. */
+	union {
+		struct {
+			/* Address of so_pcb. */
+			uint64_t	kf_sock_pcb;
+			/* Address of inp_ppcb. */
+			uint64_t	kf_sock_inpcb;
+			/* Address of unp_conn. */
+			uint64_t	kf_sock_unpconn;
+			/* Send buffer state. */
+			uint16_t	kf_sock_snd_sb_state;
+			/* Receive buffer state. */
+			uint16_t	kf_sock_rcv_sb_state;
+			/* Round to 64 bit alignment. */
+			uint32_t	kf_sock_pad0;
+		} kf_sock;
+		struct {
+			/* Global file id. */
+			uint64_t	kf_file_fileid;
+			/* File size. */
+			uint64_t	kf_file_size;
+			/* Vnode filesystem id. */
+			uint32_t	kf_file_fsid;
+			/* File device. */
+			uint32_t	kf_file_rdev;
+			/* File mode. */
+			uint16_t	kf_file_mode;
+			/* Round to 64 bit alignment. */
+			uint16_t	kf_file_pad0;
+			uint32_t	kf_file_pad1;
+		} kf_file;
+		struct {
+			uint64_t	kf_pipe_addr;
+			uint64_t	kf_pipe_peer;
+			uint32_t	kf_pipe_buffer_cnt;
+			/* Round to 64 bit alignment. */
+			uint32_t	kf_pipe_pad0[3];
+		} kf_pipe;
+		struct {
+			uint32_t	kf_pts_dev;
+			/* Round to 64 bit alignment. */
+			uint32_t	kf_pts_pad0[7];
+		} kf_pts;
+	} kf_un;
+	uint16_t	kf_status;		/* Status flags. */
+	uint16_t	kf_pad1;		/* Round to 32 bit alignment. */
+	int		_kf_ispare[7];		/* Space for more stuff. */
 	/* Truncated before copyout in sysctl */
-	char	kf_path[PATH_MAX];		/* Path to file, if any. */
+	char		kf_path[PATH_MAX];	/* Path to file, if any. */
 };
 
 /*
@@ -379,16 +436,20 @@ struct kinfo_vmentry {
 	uint64_t kve_start;			/* Starting address. */
 	uint64_t kve_end;			/* Finishing address. */
 	uint64_t kve_offset;			/* Mapping offset in object */
-	uint64_t kve_fileid;			/* inode number if vnode */
-	uint32_t kve_fsid;			/* dev_t of vnode location */
+	uint64_t kve_vn_fileid;			/* inode number if vnode */
+	uint32_t kve_vn_fsid;			/* dev_t of vnode location */
 	int	 kve_flags;			/* Flags on map entry. */
 	int	 kve_resident;			/* Number of resident pages. */
 	int	 kve_private_resident;		/* Number of private pages. */
 	int	 kve_protection;		/* Protection bitmask. */
 	int	 kve_ref_count;			/* VM obj ref count. */
 	int	 kve_shadow_count;		/* VM obj shadow count. */
-	int	 _kve_pad0;			/* 64bit align next field */
-	int	 _kve_ispare[16];		/* Space for more stuff. */
+	int	 kve_vn_type;			/* Vnode type. */
+	uint64_t kve_vn_size;			/* File size. */
+	uint32_t kve_vn_rdev;			/* Device id if device. */
+	uint16_t kve_vn_mode;			/* File mode. */
+	uint16_t kve_status;			/* Status flags. */
+	int	 _kve_ispare[12];		/* Space for more stuff. */
 	/* Truncated before copyout in sysctl */
 	char	 kve_path[PATH_MAX];		/* Path to VM obj, if any. */
 };
@@ -415,4 +476,8 @@ struct kinfo_kstack {
 	int	 _kkst_ispare[16];		/* Space for more stuff. */
 };
 
+#ifdef _KERNEL
+int	vntype_to_kinfo(int vtype);
+#endif /* !_KERNEL */
+
 #endif
diff --git a/usr.bin/fstat/Makefile b/usr.bin/fstat/Makefile
index 23e907b..c59e123 100644
--- a/usr.bin/fstat/Makefile
+++ b/usr.bin/fstat/Makefile
@@ -1,24 +1,12 @@
 #	@(#)Makefile	8.1 (Berkeley) 6/6/93
 # $FreeBSD$
 
-.include <bsd.own.mk>
-
 PROG=	fstat
-SRCS=	cd9660.c fstat.c msdosfs.c
+SRCS=	fstat.c fuser.c main.c
+LINKS=	${BINDIR}/fstat ${BINDIR}/fuser
 DPADD=	${LIBKVM}
-LDADD=	-lkvm
-BINGRP=	kmem
-BINMODE=2555
-
-CFLAGS+=-D_KVM_VNODE
+LDADD=	-lkvm -lutil -lprocstat
 
-# XXX This is a hack.
-.if ${MK_CDDL} != "no"
-CFLAGS+= -DZFS
-OBJS+=	zfs/zfs.o
-SUBDIR=	zfs
-zfs/zfs.o: .PHONY
-	@cd ${.CURDIR}/zfs && ${MAKE} zfs.o
-.endif
+MAN1=	fuser.1 fstat.1
 
 .include <bsd.prog.mk>
diff --git a/usr.bin/fstat/fstat.c b/usr.bin/fstat/fstat.c
index 7725c88..9d057e5 100644
--- a/usr.bin/fstat/fstat.c
+++ b/usr.bin/fstat/fstat.c
@@ -1,4 +1,5 @@
 /*-
+ * Copyright (c) 2009 Stanislav Sedov <stas@FreeBSD.org>
  * Copyright (c) 1988, 1993
  *	The Regents of the University of California.  All rights reserved.
  *
@@ -27,69 +28,24 @@
  * SUCH DAMAGE.
  */
 
-#ifndef lint
-static const char copyright[] =
-"@(#) Copyright (c) 1988, 1993\n\
-	The Regents of the University of California.  All rights reserved.\n";
-#endif /* not lint */
-
-#ifndef lint
-#if 0
-static char sccsid[] = "@(#)fstat.c	8.3 (Berkeley) 5/2/95";
-#endif
-#endif /* not lint */
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 #include <sys/param.h>
-#include <sys/time.h>
-#include <sys/proc.h>
 #include <sys/user.h>
 #include <sys/stat.h>
-#include <sys/vnode.h>
 #include <sys/socket.h>
 #include <sys/socketvar.h>
-#include <sys/domain.h>
-#include <sys/protosw.h>
-#include <sys/un.h>
-#include <sys/unpcb.h>
 #include <sys/sysctl.h>
-#include <sys/tty.h>
-#include <sys/filedesc.h>
 #include <sys/queue.h>
-#define	_WANT_FILE
-#include <sys/file.h>
-#include <sys/conf.h>
-#define	_KERNEL
-#include <sys/pipe.h>
-#include <sys/mount.h>
-#include <ufs/ufs/quota.h>
-#include <ufs/ufs/inode.h>
-#include <fs/devfs/devfs.h>
-#include <fs/devfs/devfs_int.h>
-#undef _KERNEL
-#include <nfs/nfsproto.h>
-#include <nfsclient/nfs.h>
-#include <nfsclient/nfsnode.h>
-
-
-#include <vm/vm.h>
-#include <vm/vm_map.h>
-#include <vm/vm_object.h>
-
-#include <net/route.h>
+
 #include <netinet/in.h>
-#include <netinet/in_systm.h>
-#include <netinet/ip.h>
-#include <netinet/in_pcb.h>
 
+#include <assert.h>
 #include <ctype.h>
 #include <err.h>
-#include <fcntl.h>
-#include <kvm.h>
+#include <libprocstat.h>
 #include <limits.h>
-#include <nlist.h>
-#include <paths.h>
 #include <pwd.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -98,69 +54,49 @@ __FBSDID("$FreeBSD$");
 #include <unistd.h>
 #include <netdb.h>
 
-#include "fstat.h"
-
-#define	TEXT	-1
-#define	CDIR	-2
-#define	RDIR	-3
-#define	TRACE	-4
-#define	MMAP	-5
-#define	JDIR	-6
-
-DEVS *devs;
-
-#ifdef notdef
-struct nlist nl[] = {
-	{ "" },
-};
-#endif
+#include "functions.h"
 
 int 	fsflg,	/* show files on same filesystem as file(s) argument */
 	pflg,	/* show files open by a particular pid */
 	uflg;	/* show files open by a particular (effective) user */
 int 	checkfile; /* true if restricting to particular files or filesystems */
 int	nflg;	/* (numerical) display f.s. and rdev as dev_t */
-int	vflg;	/* display errors in locating kernel data objects etc... */
 int	mflg;	/* include memory-mapped files */
+int	vflg;	/* be verbose */
 
+typedef struct devs {
+	struct devs	*next;
+	uint32_t	fsid;
+	uint64_t	ino;
+	const char	*name;
+} DEVS;
 
-struct file **ofiles;	/* buffer of pointers to file structures */
-int maxfiles;
-#define ALLOC_OFILES(d)	\
-	if ((d) > maxfiles) { \
-		free(ofiles); \
-		ofiles = malloc((d) * sizeof(struct file *)); \
-		if (ofiles == NULL) { \
-			err(1, NULL); \
-		} \
-		maxfiles = (d); \
-	}
-
+DEVS *devs;
 char *memf, *nlistf;
-kvm_t *kd;
-
-static void fstat_kvm(int, int);
-static void fstat_sysctl(int, int);
-void dofiles(struct kinfo_proc *kp);
-void dommap(struct kinfo_proc *kp);
-void vtrans(struct vnode *vp, int i, int flag);
-int  ufs_filestat(struct vnode *vp, struct filestat *fsp);
-int  nfs_filestat(struct vnode *vp, struct filestat *fsp);
-int  devfs_filestat(struct vnode *vp, struct filestat *fsp);
-char *getmnton(struct mount *m);
-void pipetrans(struct pipe *pi, int i, int flag);
-void socktrans(struct socket *sock, int i);
-void ptstrans(struct tty *tp, int i, int flag);
-void getinetproto(int number);
-int  getfname(const char *filename);
-void usage(void);
-char *kdevtoname(struct cdev *dev);
+
+static int	getfname(const char *filename);
+static void	dofiles(struct procstat *procstat, struct kinfo_proc *p);
+static void	print_access_flags(int flags);
+static void	print_file_info(struct procstat *procstat,
+    struct filestat *fst, const char *uname, const char *cmd, int pid);
+static void	print_pipe_info(struct procstat *procstat,
+    struct filestat *fst);
+static void	print_pts_info(struct procstat *procstat,
+    struct filestat *fst);
+static void	print_socket_info(struct procstat *procstat,
+    struct filestat *fst);
+static void	print_vnode_info(struct procstat *procstat,
+    struct filestat *fst);
+static void	usage(void) __dead2;
 
 int
-main(int argc, char **argv)
+do_fstat(int argc, char **argv)
 {
+	struct kinfo_proc *p;
 	struct passwd *passwd;
+	struct procstat *procstat;
 	int arg, ch, what;
+	int cnt, i;
 
 	arg = 0;
 	what = KERN_PROC_PROC;
@@ -225,16 +161,18 @@ main(int argc, char **argv)
 	}
 
 	if (memf != NULL)
-		fstat_kvm(what, arg);
+		procstat = procstat_open_kvm(nlistf, memf);
 	else
-		fstat_sysctl(what, arg);
-	exit(0);
-}
-
-static void
-print_header(void)
-{
+		procstat = procstat_open_sysctl();
+	if (procstat == NULL)
+		errx(1, "procstat_open()");
+	p = procstat_getprocs(procstat, what, arg, &cnt);
+	if (p == NULL)
+		errx(1, "procstat_getprocs()");
 
+	/*
+	 * Print header.
+	 */
 	if (nflg)
 		printf("%s",
 "USER     CMD          PID   FD  DEV    INUM       MODE SZ|DV R/W");
@@ -245,312 +183,65 @@ print_header(void)
 		printf(" NAME\n");
 	else
 		putchar('\n');
-}
-
-static void
-fstat_kvm(int what, int arg)
-{
-	struct kinfo_proc *p, *plast;
-	char buf[_POSIX2_LINE_MAX];
-	int cnt;
-
-	ALLOC_OFILES(256);	/* reserve space for file pointers */
 
 	/*
-	 * Discard setgid privileges if not the running kernel so that bad
-	 * guys can't print interesting stuff from kernel memory.
+	 * Go through the process list.
 	 */
-	if (nlistf != NULL || memf != NULL)
-		setgid(getgid());
-
-	if ((kd = kvm_openfiles(nlistf, memf, NULL, O_RDONLY, buf)) == NULL)
-		errx(1, "%s", buf);
-	setgid(getgid());
-#ifdef notdef
-	if (kvm_nlist(kd, nl) != 0)
-		errx(1, "no namelist: %s", kvm_geterr(kd));
-#endif
-	if ((p = kvm_getprocs(kd, what, arg, &cnt)) == NULL)
-		errx(1, "%s", kvm_geterr(kd));
-	print_header();
-	for (plast = &p[cnt]; p < plast; ++p) {
-		if (p->ki_stat == SZOMB)
+	for (i = 0; i < cnt; i++) {
+		if (p[i].ki_stat == SZOMB)
 			continue;
-		dofiles(p);
-		if (mflg)
-			dommap(p);
+		dofiles(procstat, &p[i]);
 	}
+	procstat_freeprocs(procstat, p);
+	procstat_close(procstat);
+	return (0);
 }
 
 static void
-fstat_sysctl(int what, int arg)
-{
-
-	/* not yet implemented */
-	fstat_kvm(what, arg);
-}
-
-const char	*Uname, *Comm;
-int	Pid;
-
-#define PREFIX(i) printf("%-8.8s %-10s %5d", Uname, Comm, Pid); \
-	switch(i) { \
-	case TEXT: \
-		printf(" text"); \
-		break; \
-	case CDIR: \
-		printf("   wd"); \
-		break; \
-	case RDIR: \
-		printf(" root"); \
-		break; \
-	case TRACE: \
-		printf("   tr"); \
-		break; \
-	case MMAP: \
-		printf(" mmap"); \
-		break; \
-	case JDIR: \
-		printf(" jail"); \
-		break; \
-	default: \
-		printf(" %4d", i); \
-		break; \
-	}
-
-/*
- * print open files attributed to this process
- */
-void
-dofiles(struct kinfo_proc *kp)
+dofiles(struct procstat *procstat, struct kinfo_proc *kp)
 {
-	int i;
-	struct file file;
-	struct filedesc filed;
-
-	Uname = user_from_uid(kp->ki_uid, 0);
-	Pid = kp->ki_pid;
-	Comm = kp->ki_comm;
-
-	if (kp->ki_fd == NULL)
+	const char *cmd;
+	const char *uname;
+	struct filestat *fst;
+	struct filestat_list *head;
+	int pid;
+
+	uname = user_from_uid(kp->ki_uid, 0);
+	pid = kp->ki_pid;
+	cmd = kp->ki_comm;
+
+	head = procstat_getfiles(procstat, kp, mflg);
+	if (head == NULL)
 		return;
-	if (!KVM_READ(kp->ki_fd, &filed, sizeof (filed))) {
-		dprintf(stderr, "can't read filedesc at %p for pid %d\n",
-		    (void *)kp->ki_fd, Pid);
-		return;
-	}
-	/*
-	 * root directory vnode, if one
-	 */
-	if (filed.fd_rdir)
-		vtrans(filed.fd_rdir, RDIR, FREAD);
-	/*
-	 * current working directory vnode
-	 */
-	if (filed.fd_cdir)
-		vtrans(filed.fd_cdir, CDIR, FREAD);
-	/*
-	 * jail root, if any.
-	 */
-	if (filed.fd_jdir)
-		vtrans(filed.fd_jdir, JDIR, FREAD);
-	/*
-	 * ktrace vnode, if one
-	 */
-	if (kp->ki_tracep)
-		vtrans(kp->ki_tracep, TRACE, FREAD|FWRITE);
-	/*
-	 * text vnode, if one
-	 */
-	if (kp->ki_textvp)
-		vtrans(kp->ki_textvp, TEXT, FREAD);
-	/*
-	 * open files
-	 */
-#define FPSIZE	(sizeof (struct file *))
-#define MAX_LASTFILE	(0x1000000)
-
-	/* Sanity check on filed.fd_lastfile */
-	if (filed.fd_lastfile <= -1 || filed.fd_lastfile > MAX_LASTFILE)
-		return;
-
-	ALLOC_OFILES(filed.fd_lastfile+1);
-	if (!KVM_READ(filed.fd_ofiles, ofiles,
-	    (filed.fd_lastfile+1) * FPSIZE)) {
-		dprintf(stderr,
-		    "can't read file structures at %p for pid %d\n",
-		    (void *)filed.fd_ofiles, Pid);
-		return;
-	}
-	for (i = 0; i <= filed.fd_lastfile; i++) {
-		if (ofiles[i] == NULL)
-			continue;
-		if (!KVM_READ(ofiles[i], &file, sizeof (struct file))) {
-			dprintf(stderr, "can't read file %d at %p for pid %d\n",
-			    i, (void *)ofiles[i], Pid);
-			continue;
-		}
-		if (file.f_type == DTYPE_VNODE)
-			vtrans(file.f_vnode, i, file.f_flag);
-		else if (file.f_type == DTYPE_SOCKET) {
-			if (checkfile == 0)
-				socktrans(file.f_data, i);
-		}
-#ifdef DTYPE_PIPE
-		else if (file.f_type == DTYPE_PIPE) {
-			if (checkfile == 0)
-				pipetrans(file.f_data, i, file.f_flag);
-		}
-#endif
-#ifdef DTYPE_FIFO
-		else if (file.f_type == DTYPE_FIFO) {
-			if (checkfile == 0)
-				vtrans(file.f_vnode, i, file.f_flag);
-		}
-#endif
-#ifdef DTYPE_PTS
-		else if (file.f_type == DTYPE_PTS) {
-			if (checkfile == 0)
-				ptstrans(file.f_data, i, file.f_flag);
-		}
-#endif
-		else {
-			dprintf(stderr,
-			    "unknown file type %d for file %d of pid %d\n",
-			    file.f_type, i, Pid);
-		}
-	}
-}
-
-void
-dommap(struct kinfo_proc *kp)
-{
-	vm_map_t map;
-	struct vmspace vmspace;
-	struct vm_map_entry entry;
-	vm_map_entry_t entryp;
-	struct vm_object object;
-	vm_object_t objp;
-	int prot, fflags;
-
-	if (!KVM_READ(kp->ki_vmspace, &vmspace, sizeof(vmspace))) {
-		dprintf(stderr,
-		    "can't read vmspace at %p for pid %d\n",
-		    (void *)kp->ki_vmspace, Pid);
-		return;
-	}
-	map = &vmspace.vm_map;
-
-	for (entryp = map->header.next;
-	    entryp != &kp->ki_vmspace->vm_map.header; entryp = entry.next) {
-		if (!KVM_READ(entryp, &entry, sizeof(entry))) {
-			dprintf(stderr,
-			    "can't read vm_map_entry at %p for pid %d\n",
-			    (void *)entryp, Pid);
-			return;
-		}
-
-		if (entry.eflags & MAP_ENTRY_IS_SUB_MAP)
-			continue;
-
-		if ((objp = entry.object.vm_object) == NULL)
-			continue;
-
-		for (; objp; objp = object.backing_object) {
-			if (!KVM_READ(objp, &object, sizeof(object))) {
-				dprintf(stderr,
-				    "can't read vm_object at %p for pid %d\n",
-				    (void *)objp, Pid);
-				return;
-			}
-		}
-
-		prot = entry.protection;
-		fflags = (prot & VM_PROT_READ ? FREAD : 0) |
-		    (prot & VM_PROT_WRITE ? FWRITE : 0);
-
-		switch (object.type) {
-		case OBJT_VNODE:
-			vtrans((struct vnode *)object.handle, MMAP, fflags);
-			break;
-		default:
-			break;
-		}
-	}
+	STAILQ_FOREACH(fst, head, next)
+		print_file_info(procstat, fst, uname, cmd, pid);
+	procstat_freefiles(procstat, head);
 }
 
-char *
-kdevtoname(struct cdev *dev)
-{
-	struct cdev si;
 
-	if (!KVM_READ(dev, &si, sizeof si))
-		return (NULL);
-	return (strdup(si.__si_namebuf));
-}
-
-void
-vtrans(struct vnode *vp, int i, int flag)
+static void
+print_file_info(struct procstat *procstat, struct filestat *fst,
+    const char *uname, const char *cmd, int pid)
 {
-	struct vnode vn;
-	struct filestat fst;
-	char rw[3], mode[15], tagstr[12], *tagptr;
-	const char *badtype, *filename;
-
-	filename = badtype = NULL;
-	if (!KVM_READ(vp, &vn, sizeof (struct vnode))) {
-		dprintf(stderr, "can't read vnode at %p for pid %d\n",
-		    (void *)vp, Pid);
-		return;
-	}
-	if (!KVM_READ(&vp->v_tag, &tagptr, sizeof tagptr) ||
-	    !KVM_READ(tagptr, tagstr, sizeof tagstr)) {
-		dprintf(stderr, "can't read v_tag at %p for pid %d\n",
-		    (void *)vp, Pid);
-		return;
-	}
-	tagstr[sizeof(tagstr) - 1] = '\0';
-	if (vn.v_type == VNON)
-		badtype = "none";
-	else if (vn.v_type == VBAD)
-		badtype = "bad";
-	else {
-		if (!strcmp("ufs", tagstr)) {
-			if (!ufs_filestat(&vn, &fst))
-				badtype = "error";
-		} else if (!strcmp("devfs", tagstr)) {
-			if (!devfs_filestat(&vn, &fst))
-				badtype = "error";
-		} else if (!strcmp("nfs", tagstr)) {
-			if (!nfs_filestat(&vn, &fst))
-				badtype = "error";
-		} else if (!strcmp("msdosfs", tagstr)) {
-			if (!msdosfs_filestat(&vn, &fst))
-				badtype = "error";
-		} else if (!strcmp("isofs", tagstr)) {
-			if (!isofs_filestat(&vn, &fst))
-				badtype = "error";
-#ifdef ZFS
-		} else if (!strcmp("zfs", tagstr)) {
-			if (!zfs_filestat(&vn, &fst))
-				badtype = "error";
-#endif
-		} else {
-			static char unknown[32];
-			snprintf(unknown, sizeof unknown, "?(%s)", tagstr);
-			badtype = unknown;
-		}
-	}
-	if (checkfile) {
-		int fsmatch = 0;
-		DEVS *d;
-
-		if (badtype)
+	struct vnstat vn;
+	DEVS *d;
+	const char *filename;
+	int error, fsmatch = 0;
+	char errbuf[_POSIX2_LINE_MAX];
+
+	filename = NULL;
+	if (checkfile != 0) {
+		if (fst->fs_type != PS_FST_TYPE_VNODE &&
+		    fst->fs_type != PS_FST_TYPE_FIFO)
 			return;
+		error = procstat_get_vnode_info(procstat, fst, &vn, errbuf);
+		if (error != 0)
+			return;
+
 		for (d = devs; d != NULL; d = d->next)
-			if (d->fsid == fst.fsid) {
+			if (d->fsid == vn.vn_fsid) {
 				fsmatch = 1;
-				if (d->ino == fst.fileid) {
+				if ((unsigned)d->ino == vn.vn_fileid) {
 					filename = d->name;
 					break;
 				}
@@ -558,271 +249,83 @@ vtrans(struct vnode *vp, int i, int flag)
 		if (fsmatch == 0 || (filename == NULL && fsflg == 0))
 			return;
 	}
-	PREFIX(i);
-	if (badtype) {
-		(void)printf(" -         -  %10s    -\n", badtype);
-		return;
-	}
-	if (nflg)
-		(void)printf(" %2d,%-2d", major(fst.fsid), minor(fst.fsid));
-	else
-		(void)printf(" %-8s", getmnton(vn.v_mount));
-	if (nflg)
-		(void)sprintf(mode, "%o", fst.mode);
-	else
-		strmode(fst.mode, mode);
-	(void)printf(" %6ld %10s", fst.fileid, mode);
-	switch (vn.v_type) {
-	case VBLK:
-	case VCHR: {
-		char *name;
-
-		name = kdevtoname(vn.v_rdev);
-		if (nflg || !name)
-			printf("  %2d,%-2d", major(fst.rdev), minor(fst.rdev));
-		else {
-			printf(" %6s", name);
-			free(name);
-		}
-		break;
-	}
-	default:
-		printf(" %6lu", fst.size);
-	}
-	rw[0] = '\0';
-	if (flag & FREAD)
-		strcat(rw, "r");
-	if (flag & FWRITE)
-		strcat(rw, "w");
-	printf(" %2s", rw);
-	if (filename && !fsflg)
-		printf("  %s", filename);
-	putchar('\n');
-}
-
-int
-ufs_filestat(struct vnode *vp, struct filestat *fsp)
-{
-	struct inode inode;
 
-	if (!KVM_READ(VTOI(vp), &inode, sizeof (inode))) {
-		dprintf(stderr, "can't read inode at %p for pid %d\n",
-		    (void *)VTOI(vp), Pid);
-		return 0;
-	}
 	/*
-	 * The st_dev from stat(2) is a dev_t. These kernel structures
-	 * contain cdev pointers. We need to convert to dev_t to make
-	 * comparisons
+	 * Print entry prefix.
 	 */
-	fsp->fsid = dev2udev(inode.i_dev);
-	fsp->fileid = (long)inode.i_number;
-	fsp->mode = (mode_t)inode.i_mode;
-	fsp->size = (u_long)inode.i_size;
-#if should_be_but_is_hard
-	/* XXX - need to load i_ump and i_din[12] from kernel memory */
-	if (inode.i_ump->um_fstype == UFS1)
-		fsp->rdev = inode.i_din1->di_rdev;
+	printf("%-8.8s %-10s %5d", uname, cmd, pid);
+	if (fst->fs_uflags & PS_FST_UFLAG_TEXT)
+		printf(" text");
+	else if (fst->fs_uflags & PS_FST_UFLAG_CDIR)
+		printf("   wd");
+	else if (fst->fs_uflags & PS_FST_UFLAG_RDIR)
+		printf(" root");
+	else if (fst->fs_uflags & PS_FST_UFLAG_TRACE)
+		printf("   tr");
+	else if (fst->fs_uflags & PS_FST_UFLAG_MMAP)
+		printf(" mmap");
+	else if (fst->fs_uflags & PS_FST_UFLAG_JAIL)
+		printf(" jail");
+	else if (fst->fs_uflags & PS_FST_UFLAG_CTTY)
+		printf(" ctty");
 	else
-		fsp->rdev = inode.i_din2->di_rdev;
-#else
-	fsp->rdev = 0;
-#endif
-
-	return 1;
-}
-
-int
-devfs_filestat(struct vnode *vp, struct filestat *fsp)
-{
-	struct devfs_dirent devfs_dirent;
-	struct mount mount;
-	struct vnode vnode;
-
-	if (!KVM_READ(vp->v_data, &devfs_dirent, sizeof (devfs_dirent))) {
-		dprintf(stderr, "can't read devfs_dirent at %p for pid %d\n",
-		    (void *)vp->v_data, Pid);
-		return 0;
-	}
-	if (!KVM_READ(vp->v_mount, &mount, sizeof (mount))) {
-		dprintf(stderr, "can't read mount at %p for pid %d\n",
-		    (void *)vp->v_mount, Pid);
-		return 0;
-	}
-	if (!KVM_READ(devfs_dirent.de_vnode, &vnode, sizeof (vnode))) {
-		dprintf(stderr, "can't read vnode at %p for pid %d\n",
-		    (void *)devfs_dirent.de_vnode, Pid);
-		return 0;
-	}
-	fsp->fsid = (long)(uint32_t)mount.mnt_stat.f_fsid.val[0];
-	fsp->fileid = devfs_dirent.de_inode;
-	fsp->mode = (devfs_dirent.de_mode & ~S_IFMT) | S_IFCHR;
-	fsp->size = 0;
-	fsp->rdev = dev2udev(vnode.v_rdev);
+		printf(" %4d", fst->fs_fd);
 
-	return 1;
-}
-
-int
-nfs_filestat(struct vnode *vp, struct filestat *fsp)
-{
-	struct nfsnode nfsnode;
-	mode_t mode;
-
-	if (!KVM_READ(VTONFS(vp), &nfsnode, sizeof (nfsnode))) {
-		dprintf(stderr, "can't read nfsnode at %p for pid %d\n",
-		    (void *)VTONFS(vp), Pid);
-		return 0;
-	}
-	fsp->fsid = nfsnode.n_vattr.va_fsid;
-	fsp->fileid = nfsnode.n_vattr.va_fileid;
-	fsp->size = nfsnode.n_size;
-	fsp->rdev = nfsnode.n_vattr.va_rdev;
-	mode = (mode_t)nfsnode.n_vattr.va_mode;
-	switch (vp->v_type) {
-	case VREG:
-		mode |= S_IFREG;
-		break;
-	case VDIR:
-		mode |= S_IFDIR;
-		break;
-	case VBLK:
-		mode |= S_IFBLK;
-		break;
-	case VCHR:
-		mode |= S_IFCHR;
+	/*
+	 * Print type-specific data.
+	 */
+	switch (fst->fs_type) {
+	case PS_FST_TYPE_FIFO:
+	case PS_FST_TYPE_VNODE:
+		print_vnode_info(procstat, fst);
 		break;
-	case VLNK:
-		mode |= S_IFLNK;
+	case PS_FST_TYPE_SOCKET:
+		print_socket_info(procstat, fst);
 		break;
-	case VSOCK:
-		mode |= S_IFSOCK;
+	case PS_FST_TYPE_PIPE:
+		print_pipe_info(procstat, fst);
 		break;
-	case VFIFO:
-		mode |= S_IFIFO;
+	case PS_FST_TYPE_PTS:
+		print_pts_info(procstat, fst);
 		break;
-	case VNON:
-	case VBAD:
-	case VMARKER:
-		return 0;
-	};
-	fsp->mode = mode;
-
-	return 1;
-}
-
-
-char *
-getmnton(struct mount *m)
-{
-	static struct mount mount;
-	static struct mtab {
-		struct mtab *next;
-		struct mount *m;
-		char mntonname[MNAMELEN];
-	} *mhead = NULL;
-	struct mtab *mt;
-
-	for (mt = mhead; mt != NULL; mt = mt->next)
-		if (m == mt->m)
-			return (mt->mntonname);
-	if (!KVM_READ(m, &mount, sizeof(struct mount))) {
-		warnx("can't read mount table at %p", (void *)m);
-		return (NULL);
-	}
-	if ((mt = malloc(sizeof (struct mtab))) == NULL)
-		err(1, NULL);
-	mt->m = m;
-	bcopy(&mount.mnt_stat.f_mntonname[0], &mt->mntonname[0], MNAMELEN);
-	mt->next = mhead;
-	mhead = mt;
-	return (mt->mntonname);
-}
-
-void
-pipetrans(struct pipe *pi, int i, int flag)
-{
-	struct pipe pip;
-	char rw[3];
-
-	PREFIX(i);
-
-	/* fill in socket */
-	if (!KVM_READ(pi, &pip, sizeof(struct pipe))) {
-		dprintf(stderr, "can't read pipe at %p\n", (void *)pi);
-		goto bad;
+	default:	
+		if (vflg)
+			fprintf(stderr,
+			    "unknown file type %d for file %d of pid %d\n",
+			    fst->fs_type, fst->fs_fd, pid);
 	}
-
-	printf("* pipe %8lx <-> %8lx", (u_long)pi, (u_long)pip.pipe_peer);
-	printf(" %6d", (int)pip.pipe_buffer.cnt);
-	rw[0] = '\0';
-	if (flag & FREAD)
-		strcat(rw, "r");
-	if (flag & FWRITE)
-		strcat(rw, "w");
-	printf(" %2s", rw);
+	if (filename && !fsflg)
+		printf("  %s", filename);
 	putchar('\n');
-	return;
-
-bad:
-	printf("* error\n");
 }
 
-void
-socktrans(struct socket *sock, int i)
+static void
+print_socket_info(struct procstat *procstat, struct filestat *fst)
 {
 	static const char *stypename[] = {
 		"unused",	/* 0 */
-		"stream", 	/* 1 */
+		"stream",	/* 1 */
 		"dgram",	/* 2 */
 		"raw",		/* 3 */
 		"rdm",		/* 4 */
 		"seqpak"	/* 5 */
 	};
-#define	STYPEMAX 5
-	struct socket	so;
-	struct protosw	proto;
-	struct domain	dom;
-	struct inpcb	inpcb;
-	struct unpcb	unpcb;
-	int len;
-	char dname[32];
-
-	PREFIX(i);
-
-	/* fill in socket */
-	if (!KVM_READ(sock, &so, sizeof(struct socket))) {
-		dprintf(stderr, "can't read sock at %p\n", (void *)sock);
-		goto bad;
-	}
-
-	/* fill in protosw entry */
-	if (!KVM_READ(so.so_proto, &proto, sizeof(struct protosw))) {
-		dprintf(stderr, "can't read protosw at %p",
-		    (void *)so.so_proto);
-		goto bad;
-	}
-
-	/* fill in domain */
-	if (!KVM_READ(proto.pr_domain, &dom, sizeof(struct domain))) {
-		dprintf(stderr, "can't read domain at %p\n",
-		    (void *)proto.pr_domain);
-		goto bad;
-	}
+#define STYPEMAX 5
+	struct sockstat sock;
+	struct protoent *pe;
+	char errbuf[_POSIX2_LINE_MAX];
+	int error;
+	static int isopen;
 
-	if ((len = kvm_read(kd, (u_long)dom.dom_name, dname,
-	    sizeof(dname) - 1)) < 0) {
-		dprintf(stderr, "can't read domain name at %p\n",
-		    (void *)dom.dom_name);
-		dname[0] = '\0';
+	error = procstat_get_socket_info(procstat, fst, &sock, errbuf);
+	if (error != 0) {
+		printf("* error");
+		return;
 	}
+	if (sock.type > STYPEMAX)
+		printf("* %s ?%d", sock.dname, sock.type);
 	else
-		dname[len] = '\0';
-
-	if ((u_short)so.so_type > STYPEMAX)
-		printf("* %s ?%d", dname, so.so_type);
-	else
-		printf("* %s %s", dname, stypename[so.so_type]);
+		printf("* %s %s", sock.dname, stypename[sock.type]);
 
 	/*
 	 * protocol specific formatting
@@ -835,139 +338,144 @@ socktrans(struct socket *sock, int i)
 	 * The idea is not to duplicate netstat, but to make available enough
 	 * information for further analysis.
 	 */
-	switch(dom.dom_family) {
+	switch (sock.dom_family) {
 	case AF_INET:
 	case AF_INET6:
-		getinetproto(proto.pr_protocol);
-		if (proto.pr_protocol == IPPROTO_TCP ) {
-			if (so.so_pcb) {
-				if (kvm_read(kd, (u_long)so.so_pcb,
-				    (char *)&inpcb, sizeof(struct inpcb))
-				    != sizeof(struct inpcb)) {
-					dprintf(stderr,
-					    "can't read inpcb at %p\n",
-					    (void *)so.so_pcb);
-					goto bad;
-				}
-				printf(" %lx", (u_long)inpcb.inp_ppcb);
-			}
+		if (!isopen)
+			setprotoent(++isopen);
+		if ((pe = getprotobynumber(sock.proto)) != NULL)
+			printf(" %s", pe->p_name);
+		else
+			printf(" %d", sock.proto);
+		if (sock.proto == IPPROTO_TCP ) {
+			if (sock.inp_ppcb != 0)
+				printf(" %lx", (u_long)sock.inp_ppcb);
 		}
-		else if (so.so_pcb)
-			printf(" %lx", (u_long)so.so_pcb);
+		else if (sock.so_pcb != 0)
+			printf(" %lx", (u_long)sock.so_pcb);
 		break;
 	case AF_UNIX:
 		/* print address of pcb and connected pcb */
-		if (so.so_pcb) {
-			printf(" %lx", (u_long)so.so_pcb);
-			if (kvm_read(kd, (u_long)so.so_pcb, (char *)&unpcb,
-			    sizeof(struct unpcb)) != sizeof(struct unpcb)){
-				dprintf(stderr, "can't read unpcb at %p\n",
-				    (void *)so.so_pcb);
-				goto bad;
-			}
-			if (unpcb.unp_conn) {
+		if (sock.so_pcb != 0) {
+			printf(" %lx", (u_long)sock.so_pcb);
+			if (sock.unp_conn) {
 				char shoconn[4], *cp;
 
 				cp = shoconn;
-				if (!(so.so_rcv.sb_state & SBS_CANTRCVMORE))
+				if (!(sock.so_rcv_sb_state & SBS_CANTRCVMORE))
 					*cp++ = '<';
 				*cp++ = '-';
-				if (!(so.so_snd.sb_state & SBS_CANTSENDMORE))
+				if (!(sock.so_snd_sb_state & SBS_CANTSENDMORE))
 					*cp++ = '>';
 				*cp = '\0';
 				printf(" %s %lx", shoconn,
-				    (u_long)unpcb.unp_conn);
-			}
+				    (u_long)sock.unp_conn);
+                        }
 		}
 		break;
 	default:
 		/* print protocol number and socket address */
-		printf(" %d %lx", proto.pr_protocol, (u_long)sock);
+		printf(" %d %lx", sock.proto, (u_long)sock.so_addr);
 	}
-	printf("\n");
-	return;
-bad:
-	printf("* error\n");
 }
 
-void
-ptstrans(struct tty *tp, int i, int flag)
+static void
+print_pipe_info(struct procstat *procstat, struct filestat *fst)
 {
-	struct tty tty;
-	char *name;
-	char rw[3];
-	dev_t rdev;
+	struct pipestat ps;
+	char errbuf[_POSIX2_LINE_MAX];
+	int error;
 
-	PREFIX(i);
-
-	/* Obtain struct tty. */
-	if (!KVM_READ(tp, &tty, sizeof(struct tty))) {
-		dprintf(stderr, "can't read tty at %p\n", (void *)tp);
-		goto bad;
-	}
-
-	/* Figure out the device name. */
-	name = kdevtoname(tty.t_dev);
-	if (name == NULL) {
-		dprintf(stderr, "can't determine tty name at %p\n", (void *)tp);
-		goto bad;
+	error = procstat_get_pipe_info(procstat, fst, &ps, errbuf);
+	if (error != 0) {
+		printf("* error");
+		return;
 	}
+	printf("* pipe %8lx <-> %8lx", (u_long)ps.addr, (u_long)ps.peer);
+	printf(" %6zd", ps.buffer_cnt);
+	print_access_flags(fst->fs_fflags);
+}
 
-	rw[0] = '\0';
-	if (flag & FREAD)
-		strcat(rw, "r");
-	if (flag & FWRITE)
-		strcat(rw, "w");
+static void
+print_pts_info(struct procstat *procstat, struct filestat *fst)
+{
+	struct ptsstat pts;
+	char errbuf[_POSIX2_LINE_MAX];
+	int error;
 
+	error = procstat_get_pts_info(procstat, fst, &pts, errbuf);
+	if (error != 0) {
+		printf("* error");
+		return;
+	}
 	printf("* pseudo-terminal master ");
-	if (nflg || !name) {
-		rdev = dev2udev(tty.t_dev);
-		printf("%10d,%-2d", major(rdev), minor(rdev));
+	if (nflg || !*pts.devname) {
+		printf("%10d,%-2d", major(pts.dev), minor(pts.dev));
 	} else {
-		printf("%10s", name);
+		printf("%10s", pts.devname);
 	}
-	printf(" %2s\n", rw);
-
-	free(name);
-
-	return;
-bad:
-	printf("* error\n");
+	print_access_flags(fst->fs_fflags);
 }
 
-/*
- * Read the cdev structure in the kernel in order to work out the
- * associated dev_t
- */
-dev_t
-dev2udev(struct cdev *dev)
+static void
+print_vnode_info(struct procstat *procstat, struct filestat *fst)
 {
-	struct cdev_priv priv;
+	struct vnstat vn;
+	char errbuf[_POSIX2_LINE_MAX];
+	char mode[15];
+	const char *badtype;
+	int error;
+
+	badtype = NULL;
+	error = procstat_get_vnode_info(procstat, fst, &vn, errbuf);
+	if (error != 0)
+		badtype = errbuf;
+	else if (vn.vn_type == PS_FST_VTYPE_VBAD)
+		badtype = "bad";
+	else if (vn.vn_type == PS_FST_VTYPE_VNON)
+		badtype = "none";
+	if (badtype != NULL) {
+		printf(" -         -  %10s    -", badtype);
+		return;
+	}
 
-	if (KVM_READ(cdev2priv(dev), &priv, sizeof priv)) {
-		return ((dev_t)priv.cdp_inode);
-	} else {
-		dprintf(stderr, "can't convert cdev *%p to a dev_t\n", dev);
-		return -1;
+	if (nflg)
+		printf(" %2d,%-2d", major(vn.vn_fsid), minor(vn.vn_fsid));
+	else if (vn.vn_mntdir != NULL)
+		(void)printf(" %-8s", vn.vn_mntdir);
+
+	/*
+	 * Print access mode.
+	 */
+	if (nflg)
+		(void)snprintf(mode, sizeof(mode), "%o", vn.vn_mode);
+	else {
+		strmode(vn.vn_mode, mode);
 	}
+	(void)printf(" %6ld %10s", vn.vn_fileid, mode);
+
+	if (vn.vn_type == PS_FST_VTYPE_VBLK || vn.vn_type == PS_FST_VTYPE_VCHR) {
+		if (nflg || !*vn.vn_devname)
+			printf("  %2d,%-2d", major(vn.vn_dev), minor(vn.vn_dev));
+		else {
+			printf(" %6s", vn.vn_devname);
+		}
+	} else
+		printf(" %6lu", vn.vn_size);
+	print_access_flags(fst->fs_fflags);
 }
 
-/*
- * getinetproto --
- *	print name of protocol number
- */
-void
-getinetproto(int number)
+static void
+print_access_flags(int flags)
 {
-	static int isopen;
-	struct protoent *pe;
+	char rw[3];
 
-	if (!isopen)
-		setprotoent(++isopen);
-	if ((pe = getprotobynumber(number)) != NULL)
-		printf(" %s", pe->p_name);
-	else
-		printf(" %d", number);
+	rw[0] = '\0';
+	if (flags & PS_FST_FFLAG_READ)
+		strcat(rw, "r");
+	if (flags & PS_FST_FFLAG_WRITE)
+		strcat(rw, "w");
+	printf(" %2s", rw);
 }
 
 int
@@ -978,7 +486,7 @@ getfname(const char *filename)
 
 	if (stat(filename, &statbuf)) {
 		warn("%s", filename);
-		return(0);
+		return (0);
 	}
 	if ((cur = malloc(sizeof(DEVS))) == NULL)
 		err(1, NULL);
@@ -988,24 +496,10 @@ getfname(const char *filename)
 	cur->ino = statbuf.st_ino;
 	cur->fsid = statbuf.st_dev;
 	cur->name = filename;
-	return(1);
+	return (1);
 }
 
-#ifdef ZFS
-void *
-getvnodedata(struct vnode *vp)
-{
-	return (vp->v_data);
-}
-
-struct mount *
-getvnodemount(struct vnode *vp)
-{
-	return (vp->v_mount);
-}
-#endif
-
-void
+static void
 usage(void)
 {
 	(void)fprintf(stderr,
diff --git a/usr.bin/fstat/functions.h b/usr.bin/fstat/functions.h
new file mode 100644
index 0000000..a23d27e
--- /dev/null
+++ b/usr.bin/fstat/functions.h
@@ -0,0 +1,34 @@
+/*-
+ * Copyright (c) 2009 Stanislav Sedov <stas@FreeBSD.org>
+ * 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.
+ *
+ * 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.
+ *
+ * $FreeBSD$
+ */
+#ifndef __FUNCTIONS_H__
+#define	__FUNCTIONS_H__
+
+int	do_fstat(int argc, char *argv[]);
+int	do_fuser(int argc, char *argv[]);
+
+#endif /* !__FUNCTIONS_H__ */
diff --git a/usr.bin/fstat/fuser.1 b/usr.bin/fstat/fuser.1
new file mode 100644
index 0000000..999a72d
--- /dev/null
+++ b/usr.bin/fstat/fuser.1
@@ -0,0 +1,148 @@
+.\" Copyright (c) 2005-2009 Stanislav Sedov <stas@FreeBSD.org>
+.\" 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.
+.\"
+.\" 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.
+.\"
+.\" $FreeBSD$
+.\"
+.Dd July 31, 2009
+.Dt FUSER 1
+.Os
+.Sh NAME
+.Nm fuser
+.Nd list IDs of all processes that have one or more files open 
+.Sh SYNOPSIS
+.Nm
+.Op Fl cfkmu
+.Op Fl M Ar core
+.Op Fl N Ar system
+.Op Fl s Ar signal
+.Op Ar
+.Sh DESCRIPTION
+The
+.Nm
+utility writes to stdout the PIDs of processes that have one or
+more named files open.
+For block and character special devices, all processes using files
+on that device are listed.
+A file is considered open by a process if it was explicitly opened,
+is the working directory, root directory, jail root directory,
+active executable text, kernel trace file or the controlling terminal
+of the process.
+If
+.Fl m
+option is specified, the
+.Nm
+utility will also look through mmapped files.
+.Pp
+The following options are available:
+.Bl -tag -width indent
+.It Fl c
+Treat files as mount point and report on any files open in the file system.
+.It Fl f
+The report must be only for named files.
+.It Fl k
+Send signal to reported processes
+.Pq SIGKILL by default .
+.It Fl m
+Search through mmapped files too.
+.It Fl u
+Write the user name associated with each process to stdout.
+.It Fl M
+Extract values associated with the name list from the specified core
+instead of the default
+.Pa /dev/kmem .
+.It Fl N
+Extract the name list from the specified system instead of the default,
+which is the kernel image the system has booted from.
+.It Fl s
+Use given signal name instead of default SIGKILL.
+.El
+.Pp
+The following symbols, written to stderr will indicate how files is used:
+.Bl -tag -width MOUNT
+.It Cm r
+The file is the root directory of the process.
+.It Cm c
+The file is the current workdir directory of the process.
+.It Cm j
+The file is the jail-root of the process.
+.It Cm t
+The file is the kernel tracing file for the process.
+.It Cm x
+The file is executable text of the process.
+.It Cm y
+The process use this file as its controlling tty.
+.It Cm m
+The file is mmapped.
+.It Cm w
+The file is open for writing.
+.It Cm a
+The file is open as append only
+.Pq O_APPEND was specified .
+.It Cm d
+The process bypasses fs cache while writing to this file
+.Pq O_DIRECT was specified .
+.It Cm s
+Shared lock is hold.
+.It Cm e
+Exclusive lock is hold.
+.El
+.Sh EXIT STATUS
+The
+.Nm
+utility returns 0 on successful completion and >0 otherwise.
+.Sh EXAMPLES
+The command:
+.Dq Li "fuser -fu ."
+writes to standart output the process IDs of processes that are using the
+current directory and writes to stderr an indication of how those processes are
+using the direcory and user names associated with the processes that are using
+this directory.
+.Sh SEE ALSO
+.Xr fstat 1 ,
+.Xr ps 1 ,
+.Xr systat 1 ,
+.Xr iostat 8 ,
+.Xr pstat 8 ,
+.Xr vmstat 8
+.Sh STANDARTS
+The
+.Nm
+utility is expected to conform to
+.St -p1003.1-2004 .
+.Sh BUGS
+Since
+.Nm
+takes a snapshot of the system, it is only correct for a very short period
+of time.
+When working via
+.Xr kvm 3
+interface the report will be limited to filesystems the
+.Nm
+utility knows about (currently only cd9660, devfs, nfs, ntfs, nwfs, udf,
+ufs and zfs).
+.Sh AUTHORS
+The
+.Nm
+utility and this manual page was written by
+.An Stanislav Sedov Aq stas@FreeBSD.org .
diff --git a/usr.bin/fstat/fuser.c b/usr.bin/fstat/fuser.c
new file mode 100644
index 0000000..02975b3
--- /dev/null
+++ b/usr.bin/fstat/fuser.c
@@ -0,0 +1,369 @@
+/*-
+ * Copyright (c) 2005-2009 Stanislav Sedov <stas@FreeBSD.org>
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
+ *
+ */
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <sys/queue.h>
+#include <sys/stat.h>
+#include <sys/sysctl.h>
+#include <sys/user.h>
+
+#include <assert.h>
+#include <ctype.h>
+#include <err.h>
+#include <fcntl.h>
+#include <libprocstat.h>
+#include <limits.h>
+#include <paths.h>
+#include <pwd.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sysexits.h>
+#include <unistd.h>
+
+#include "functions.h"
+
+/*
+ * File access mode flags table.
+ */
+struct {
+	int	flag;
+	char	ch;
+} fflags[] = {
+	{PS_FST_FFLAG_WRITE,	'w'},
+	{PS_FST_FFLAG_APPEND,	'a'},
+	{PS_FST_FFLAG_DIRECT,	'd'},
+	{PS_FST_FFLAG_SHLOCK,	's'},
+	{PS_FST_FFLAG_EXLOCK,	'e'}
+};
+#define	NFFLAGS	(sizeof(fflags) / sizeof(*fflags))
+
+/*
+ * Usage flags translation table.
+ */
+struct {
+	int	flag;
+	char	ch;
+} uflags[] = {
+	{PS_FST_UFLAG_RDIR,	'r'},
+	{PS_FST_UFLAG_CDIR,	'c'},
+	{PS_FST_UFLAG_JAIL,	'j'},
+	{PS_FST_UFLAG_TRACE,	't'},
+	{PS_FST_UFLAG_TEXT,	'x'},
+	{PS_FST_UFLAG_MMAP,	'm'},
+	{PS_FST_UFLAG_CTTY,	'y'}
+};
+#define	NUFLAGS	(sizeof(uflags) / sizeof(*uflags))
+
+struct consumer {
+	pid_t	pid;
+	uid_t	uid;
+	int	fd;
+	int	flags;
+	int	uflags;
+	STAILQ_ENTRY(consumer)	next;
+};
+struct reqfile {
+	uint32_t	fsid;
+	uint64_t	fileid;
+	const char	*name;
+	STAILQ_HEAD(, consumer) consumers;
+};
+
+/*
+ * Option flags.
+ */
+#define	UFLAG	0x01	/* -u flag: show users				*/
+#define	FFLAG	0x02	/* -f flag: specified files only		*/
+#define	CFLAG	0x04	/* -c flag: treat as mpoints			*/
+#define	MFLAG	0x10	/* -m flag: mmapped files too			*/
+#define	KFLAG	0x20	/* -k flag: send signal (SIGKILL by default)	*/
+
+static int flags = 0;	/* Option flags. */
+
+static void	printflags(struct consumer *consumer);
+static int	str2sig(const char *str);
+static void	usage(void) __dead2;
+static int	addfile(const char *path, struct reqfile *reqfile);
+static void	dofiles(struct procstat *procstat, struct kinfo_proc *kp,
+    struct reqfile *reqfiles, size_t nfiles);
+
+static void
+usage(void)
+{
+
+	fprintf(stderr,
+"usage: fuser [-cfhkmu] [-M core] [-N system] [-s signal] file ...\n");
+	exit(EX_USAGE);
+}
+
+static void
+printflags(struct consumer *cons)
+{
+	unsigned int i;
+
+	assert(cons);
+	for (i = 0; i < NUFLAGS; i++)
+		if ((cons->uflags & uflags[i].flag) != 0)
+			fputc(uflags[i].ch, stderr);
+	for (i = 0; i < NFFLAGS; i++)
+		if ((cons->flags & fflags[i].flag) != 0)
+			fputc(fflags[i].ch, stderr);
+}
+
+/*
+ * Add file to the list.
+ */
+static int
+addfile(const char *path, struct reqfile *reqfile)
+{
+	struct stat sb;
+
+	assert(path);
+	if (stat(path, &sb) != 0) {
+		warn("%s", path);
+		return (1);
+	}
+	reqfile->fileid = sb.st_ino;
+	reqfile->fsid = sb.st_dev;
+	reqfile->name = path;
+	STAILQ_INIT(&reqfile->consumers);
+	return (0);
+}
+
+int
+do_fuser(int argc, char *argv[])
+{
+	struct consumer *consumer;
+	struct kinfo_proc *p, *procs;
+	struct procstat *procstat;
+	struct reqfile *reqfiles;
+	char *ep, *nlistf, *memf;
+	int ch, cnt, sig;
+	unsigned int i, nfiles;
+
+	sig = SIGKILL;	/* Default to kill. */
+	nlistf = NULL;
+	memf = NULL;
+	while ((ch = getopt(argc, argv, "M:N:cfhkms:u")) != -1)
+		switch(ch) {
+		case 'f':
+			if ((flags & CFLAG) != 0)
+				usage();
+			flags |= FFLAG;
+			break;
+		case 'c':
+			if ((flags & FFLAG) != 0)
+				usage();
+			flags |= CFLAG;
+			break;
+		case 'N':
+			nlistf = optarg;
+			break;
+		case 'M':
+			memf = optarg;
+			break;
+		case 'u':
+			flags |= UFLAG;
+			break;
+		case 'm':
+			flags |= MFLAG;
+			break;
+		case 'k':
+			flags |= KFLAG;
+			break;
+		case 's':
+			if (isdigit(*optarg)) {
+				sig = strtol(optarg, &ep, 10);
+				if (*ep != '\0' || sig < 0 || sig >= sys_nsig)
+					errx(EX_USAGE, "illegal signal number" ": %s",
+					    optarg);
+			} else {
+				sig = str2sig(optarg);
+				if (sig < 0)
+					errx(EX_USAGE, "illegal signal name: "
+					    "%s", optarg);
+			}
+			break;
+		case 'h':
+			/* PASSTHROUGH */
+		default:
+			usage();
+			/* NORETURN */
+		}
+	argv += optind;
+	argc -= optind;
+
+	assert(argc >= 0);
+	if (argc == 0)
+		usage();
+		/* NORETURN */
+
+	/*
+	 * Process named files.
+	 */
+	reqfiles = malloc(argc * sizeof(struct reqfile));
+	if (reqfiles == NULL)
+		err(EX_OSERR, "malloc()");
+	nfiles = 0;
+	while (argc--)
+		if (!addfile(*(argv++), &reqfiles[nfiles]))
+			nfiles++;
+	if (nfiles == 0)
+		errx(EX_IOERR, "files not accessible");
+
+	if (memf != NULL)
+		procstat = procstat_open_kvm(nlistf, memf);
+	else
+		procstat = procstat_open_sysctl();
+	if (procstat == NULL)
+		errx(1, "procstat_open()");
+	procs = procstat_getprocs(procstat, KERN_PROC_PROC, 0, &cnt);
+	if (procs == NULL)
+		 errx(1, "procstat_getprocs()");
+
+	/*
+	 * Walk through process table and look for matching files.
+	 */
+	p = procs;
+	while(cnt--)
+		if (p->ki_stat != SZOMB)
+			dofiles(procstat, p++, reqfiles, nfiles);
+
+	for (i = 0; i < nfiles; i++) {
+		fprintf(stderr, "%s:", reqfiles[i].name);
+		fflush(stderr);
+		STAILQ_FOREACH(consumer, &reqfiles[i].consumers, next) {
+			if (consumer->flags != 0) {
+				fprintf(stdout, "%6d", consumer->pid);
+				fflush(stdout);
+				printflags(consumer);
+				if ((flags & UFLAG) != 0)
+					fprintf(stderr, "(%s)",
+					    user_from_uid(consumer->uid, 0));
+				if ((flags & KFLAG) != 0)
+					kill(consumer->pid, sig);
+				fflush(stderr);
+			}
+		}
+		(void)fprintf(stderr, "\n");
+	}
+	procstat_freeprocs(procstat, procs);
+	procstat_close(procstat);
+	free(reqfiles);
+	return (0);
+}
+
+static void
+dofiles(struct procstat *procstat, struct kinfo_proc *kp,
+    struct reqfile *reqfiles, size_t nfiles)
+{
+	struct vnstat vn;
+	struct consumer *cons;
+	struct filestat *fst;
+	struct filestat_list *head;
+	int error, match;
+	unsigned int i;
+	char errbuf[_POSIX2_LINE_MAX];
+	
+	head = procstat_getfiles(procstat, kp, flags & MFLAG);
+	if (head == NULL)
+		return;
+	STAILQ_FOREACH(fst, head, next) {
+		if (fst->fs_type != PS_FST_TYPE_VNODE)
+			continue;
+		error = procstat_get_vnode_info(procstat, fst, &vn, errbuf);
+		if (error != 0)
+			continue;
+		for (i = 0; i < nfiles; i++) {
+			if (flags & CFLAG && reqfiles[i].fsid == vn.vn_fsid) {
+				break;
+			}
+			else if (reqfiles[i].fsid == vn.vn_fsid &&
+			    reqfiles[i].fileid == vn.vn_fileid) {
+				break;
+			}
+			else if (!(flags & FFLAG) &&
+			    (vn.vn_type == PS_FST_VTYPE_VCHR ||
+			    vn.vn_type == PS_FST_VTYPE_VBLK) &&
+			    vn.vn_fsid == reqfiles[i].fileid) {
+				break;
+			}
+		}
+		if (i == nfiles)
+			continue;	/* No match. */
+
+		/*
+		 * Look for existing entries.
+		 */
+		match = 0;
+		STAILQ_FOREACH(cons, &reqfiles[i].consumers, next)
+			if (cons->pid == kp->ki_pid) {
+				match = 1;
+				break;
+			}
+		if (match == 1) {	/* Use old entry. */
+			cons->flags |= fst->fs_fflags;
+			cons->uflags |= fst->fs_uflags;
+		} else {
+			/*
+			 * Create new entry in the consumer chain.
+			 */
+			cons = calloc(1, sizeof(struct consumer));
+			if (cons == NULL) {
+				warn("malloc()");
+				continue;
+			}
+			cons->uid = kp->ki_uid;
+			cons->pid = kp->ki_pid;
+			cons->uflags = fst->fs_uflags;
+			cons->flags = fst->fs_fflags;
+			STAILQ_INSERT_TAIL(&reqfiles[i].consumers, cons, next);
+		}
+	}
+	procstat_freefiles(procstat, head);
+}
+
+/*
+ * Returns signal number for it's string representation.
+ */
+static int
+str2sig(const char *str)
+{
+	int i;
+
+#define	SIGPREFIX	"sig"
+	if (!strncasecmp(str, SIGPREFIX, sizeof(SIGPREFIX)))
+		str += sizeof(SIGPREFIX);
+	for (i = 1; i < sys_nsig; i++) {
+                if (!strcasecmp(sys_signame[i], str))
+                        return (i);
+        }
+        return (-1);
+}
diff --git a/usr.bin/fstat/main.c b/usr.bin/fstat/main.c
new file mode 100644
index 0000000..4123e64
--- /dev/null
+++ b/usr.bin/fstat/main.c
@@ -0,0 +1,49 @@
+/*-
+ * Copyright (c) 2009 Stanislav Sedov <stas@FreeBSD.org>.
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ *
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <err.h>
+#include <libgen.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "functions.h"
+
+int
+main(int argc, char *argv[])
+{
+	char *p;
+
+	p = basename(argv[0]);
+	if (p == NULL)
+		err(1, "basename(%s)", argv[0]);
+	if (!strcmp(p, "fuser"))
+		return (do_fuser(argc, argv));
+	else
+		return (do_fstat(argc, argv));
+}
diff --git a/usr.bin/procstat/Makefile b/usr.bin/procstat/Makefile
index fa1c3b4..e8e35ed 100644
--- a/usr.bin/procstat/Makefile
+++ b/usr.bin/procstat/Makefile
@@ -13,7 +13,7 @@ SRCS=	procstat.c		\
 	procstat_threads.c	\
 	procstat_vm.c
 
-LDADD+=	-lutil
+LDADD+=	-lutil -lprocstat -lkvm
 DPADD+=	${LIBUTIL}
 
 .include <bsd.prog.mk>
diff --git a/usr.bin/procstat/procstat.c b/usr.bin/procstat/procstat.c
index ee95ae2..69648fd 100644
--- a/usr.bin/procstat/procstat.c
+++ b/usr.bin/procstat/procstat.c
@@ -31,6 +31,7 @@
 #include <sys/user.h>
 
 #include <err.h>
+#include <libprocstat.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <sysexits.h>
@@ -45,36 +46,36 @@ static void
 usage(void)
 {
 
-	fprintf(stderr, "usage: procstat [-h] [-n] [-w interval] [-b | -c | -f | "
-	    "-i | -j | -k | -s | -t | -v]\n");
+	fprintf(stderr, "usage: procstat [-h] [-M core] [-N system] "
+	    "[-w interval] [-b | -c | -f | -i | -j | -k | -s | -t | -v]\n");
 	fprintf(stderr, "                [-a | pid ...]\n");
 	exit(EX_USAGE);
 }
 
 static void
-procstat(pid_t pid, struct kinfo_proc *kipp)
+procstat(struct procstat *prstat, struct kinfo_proc *kipp)
 {
 
 	if (bflag)
-		procstat_bin(pid, kipp);
+		procstat_bin(kipp);
 	else if (cflag)
-		procstat_args(pid, kipp);
+		procstat_args(kipp);
 	else if (fflag)
-		procstat_files(pid, kipp);
+		procstat_files(prstat, kipp);
 	else if (iflag)
-		procstat_sigs(pid, kipp);
+		procstat_sigs(prstat, kipp);
 	else if (jflag)
-		procstat_threads_sigs(pid, kipp);
+		procstat_threads_sigs(prstat, kipp);
 	else if (kflag)
-		procstat_kstack(pid, kipp, kflag);
+		procstat_kstack(kipp, kflag);
 	else if (sflag)
-		procstat_cred(pid, kipp);
+		procstat_cred(kipp);
 	else if (tflag)
-		procstat_threads(pid, kipp);
+		procstat_threads(kipp);
 	else if (vflag)
-		procstat_vm(pid, kipp);
+		procstat_vm(kipp);
 	else
-		procstat_basic(pid, kipp);
+		procstat_basic(kipp);
 }
 
 /*
@@ -104,17 +105,26 @@ kinfo_proc_sort(struct kinfo_proc *kipp, int count)
 int
 main(int argc, char *argv[])
 {
-	int ch, interval, name[4], tmp;
-	unsigned int i;
-	struct kinfo_proc *kipp;
-	size_t len;
+	int ch, interval, tmp;
+	int i;
+	struct kinfo_proc *p;
+	struct procstat *prstat;
 	long l;
 	pid_t pid;
 	char *dummy;
+	char *nlistf, *memf;
+	int cnt;
 
 	interval = 0;
-	while ((ch = getopt(argc, argv, "abcfijknhstvw:")) != -1) {
+	memf = nlistf = NULL;
+	while ((ch = getopt(argc, argv, "N:M:abcfijkhstvw:")) != -1) {
 		switch (ch) {
+		case 'M':
+			memf = optarg;
+			break;
+		case 'N':
+			nlistf = optarg;
+			break;
 		case 'a':
 			aflag++;
 			break;
@@ -194,38 +204,27 @@ main(int argc, char *argv[])
 	if (!(aflag == 1 && argc == 0) && !(aflag == 0 && argc > 0))
 		usage();
 
+	if (memf != NULL)
+		prstat = procstat_open_kvm(nlistf, memf);
+	else
+		prstat = procstat_open_sysctl();
+	if (prstat == NULL)
+		errx(1, "procstat_open()");
 	do {
 		if (aflag) {
-			name[0] = CTL_KERN;
-			name[1] = KERN_PROC;
-			name[2] = KERN_PROC_PROC;
-
-			len = 0;
-			if (sysctl(name, 3, NULL, &len, NULL, 0) < 0)
-				err(-1, "sysctl: kern.proc.all");
-
-			kipp = malloc(len);
-			if (kipp == NULL)
-				err(-1, "malloc");
-
-			if (sysctl(name, 3, kipp, &len, NULL, 0) < 0) {
-				free(kipp);
-				err(-1, "sysctl: kern.proc.all");
-			}
-			if (len % sizeof(*kipp) != 0)
-				err(-1, "kinfo_proc mismatch");
-			if (kipp->ki_structsize != sizeof(*kipp))
-				err(-1, "kinfo_proc structure mismatch");
-			kinfo_proc_sort(kipp, len / sizeof(*kipp));
-			for (i = 0; i < len / sizeof(*kipp); i++) {
-				procstat(kipp[i].ki_pid, &kipp[i]);
+			p = procstat_getprocs(prstat, KERN_PROC_PROC, 0, &cnt);
+			if (p == NULL)
+				errx(1, "procstat_getprocs()");
+			kinfo_proc_sort(p, cnt);
+			for (i = 0; i < cnt; i++) {
+				procstat(prstat, &p[i]);
 
 				/* Suppress header after first process. */
 				hflag = 1;
 			}
-			free(kipp);
+			procstat_freeprocs(prstat, p);
 		}
-		for (i = 0; i < (unsigned int)argc; i++) {
+		for (i = 0; i < argc; i++) {
 			l = strtol(argv[i], &dummy, 10);
 			if (*dummy != '\0')
 				usage();
@@ -233,31 +232,12 @@ main(int argc, char *argv[])
 				usage();
 			pid = l;
 
-			name[0] = CTL_KERN;
-			name[1] = KERN_PROC;
-			name[2] = KERN_PROC_PID;
-			name[3] = pid;
-
-			len = 0;
-			if (sysctl(name, 4, NULL, &len, NULL, 0) < 0)
-				err(-1, "sysctl: kern.proc.pid: %d", pid);
-
-			kipp = malloc(len);
-			if (kipp == NULL)
-				err(-1, "malloc");
-
-			if (sysctl(name, 4, kipp, &len, NULL, 0) < 0) {
-				free(kipp);
-				err(-1, "sysctl: kern.proc.pid: %d", pid);
-			}
-			if (len != sizeof(*kipp))
-				err(-1, "kinfo_proc mismatch");
-			if (kipp->ki_structsize != sizeof(*kipp))
-				errx(-1, "kinfo_proc structure mismatch");
-			if (kipp->ki_pid != pid)
-				errx(-1, "kinfo_proc pid mismatch");
-			procstat(pid, kipp);
-			free(kipp);
+			p = procstat_getprocs(prstat, KERN_PROC_PID, pid, &cnt);
+			if (p == NULL)
+				errx(1, "procstat_getprocs()");
+			if (cnt != 0)
+				procstat(prstat, p);
+			procstat_freeprocs(prstat, p);
 
 			/* Suppress header after first process. */
 			hflag = 1;
@@ -265,5 +245,6 @@ main(int argc, char *argv[])
 		if (interval)
 			sleep(interval);
 	} while (interval);
+	procstat_close(prstat);
 	exit(0);
 }
diff --git a/usr.bin/procstat/procstat.h b/usr.bin/procstat/procstat.h
index d73a203..ad425f3 100644
--- a/usr.bin/procstat/procstat.h
+++ b/usr.bin/procstat/procstat.h
@@ -34,15 +34,15 @@ extern int	hflag, nflag;
 struct kinfo_proc;
 void	kinfo_proc_sort(struct kinfo_proc *kipp, int count);
 
-void	procstat_args(pid_t pid, struct kinfo_proc *kipp);
-void	procstat_basic(pid_t pid, struct kinfo_proc *kipp);
-void	procstat_bin(pid_t pid, struct kinfo_proc *kipp);
-void	procstat_cred(pid_t pid, struct kinfo_proc *kipp);
-void	procstat_files(pid_t pid, struct kinfo_proc *kipp);
-void	procstat_kstack(pid_t pid, struct kinfo_proc *kipp, int kflag);
-void	procstat_sigs(pid_t pid, struct kinfo_proc *kipp);
-void	procstat_threads(pid_t pid, struct kinfo_proc *kipp);
-void	procstat_threads_sigs(pid_t pid, struct kinfo_proc *kipp);
-void	procstat_vm(pid_t pid, struct kinfo_proc *kipp);
+void	procstat_args(struct kinfo_proc *kipp);
+void	procstat_basic(struct kinfo_proc *kipp);
+void	procstat_bin(struct kinfo_proc *kipp);
+void	procstat_cred(struct kinfo_proc *kipp);
+void	procstat_files(struct procstat *prstat, struct kinfo_proc *kipp);
+void	procstat_kstack(struct kinfo_proc *kipp, int kflag);
+void	procstat_sigs(struct procstat *prstat, struct kinfo_proc *kipp);
+void	procstat_threads(struct kinfo_proc *kipp);
+void	procstat_threads_sigs(struct procstat *prstat, struct kinfo_proc *kipp);
+void	procstat_vm(struct kinfo_proc *kipp);
 
 #endif /* !PROCSTAT_H */
diff --git a/usr.bin/procstat/procstat_args.c b/usr.bin/procstat/procstat_args.c
index e5a7acd..e8e6b94 100644
--- a/usr.bin/procstat/procstat_args.c
+++ b/usr.bin/procstat/procstat_args.c
@@ -32,6 +32,7 @@
 
 #include <err.h>
 #include <errno.h>
+#include <libprocstat.h>
 #include <limits.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -42,7 +43,7 @@
 static char args[ARG_MAX];
 
 void
-procstat_args(pid_t pid, struct kinfo_proc *kipp)
+procstat_args(struct kinfo_proc *kipp)
 {
 	int error, name[4];
 	size_t len;
@@ -54,11 +55,11 @@ procstat_args(pid_t pid, struct kinfo_proc *kipp)
 	name[0] = CTL_KERN;
 	name[1] = KERN_PROC;
 	name[2] = KERN_PROC_ARGS;
-	name[3] = pid;
+	name[3] = kipp->ki_pid;
 	len = sizeof(args);
 	error = sysctl(name, 4, args, &len, NULL, 0);
 	if (error < 0 && errno != ESRCH) {
-		warn("sysctl: kern.proc.args: %d", pid);
+		warn("sysctl: kern.proc.args: %d", kipp->ki_pid);
 		return;
 	}
 	if (error < 0)
@@ -68,7 +69,7 @@ procstat_args(pid_t pid, struct kinfo_proc *kipp)
 		len = strlen(args) + 1;
 	}
 
-	printf("%5d ", pid);
+	printf("%5d ", kipp->ki_pid);
 	printf("%-16s ", kipp->ki_comm);
 	for (cp = args; cp < args + len; cp += strlen(cp) + 1)
 		printf("%s%s", cp != args ? " " : "", cp);
diff --git a/usr.bin/procstat/procstat_basic.c b/usr.bin/procstat/procstat_basic.c
index 2775172..af43fd1 100644
--- a/usr.bin/procstat/procstat_basic.c
+++ b/usr.bin/procstat/procstat_basic.c
@@ -31,13 +31,14 @@
 #include <sys/user.h>
 
 #include <err.h>
+#include <libprocstat.h>
 #include <stdio.h>
 #include <string.h>
 
 #include "procstat.h"
 
 void
-procstat_basic(pid_t pid __unused, struct kinfo_proc *kipp)
+procstat_basic(struct kinfo_proc *kipp)
 {
 
 	if (!hflag)
diff --git a/usr.bin/procstat/procstat_bin.c b/usr.bin/procstat/procstat_bin.c
index 8ed5efe..cf4ca5b 100644
--- a/usr.bin/procstat/procstat_bin.c
+++ b/usr.bin/procstat/procstat_bin.c
@@ -32,6 +32,7 @@
 
 #include <err.h>
 #include <errno.h>
+#include <libprocstat.h>
 #include <limits.h>
 #include <stdio.h>
 #include <string.h>
@@ -39,7 +40,7 @@
 #include "procstat.h"
 
 void
-procstat_bin(pid_t pid, struct kinfo_proc *kipp)
+procstat_bin(struct kinfo_proc *kipp)
 {
 	char pathname[PATH_MAX];
 	int error, name[4];
@@ -51,12 +52,12 @@ procstat_bin(pid_t pid, struct kinfo_proc *kipp)
 	name[0] = CTL_KERN;
 	name[1] = KERN_PROC;
 	name[2] = KERN_PROC_PATHNAME;
-	name[3] = pid;
+	name[3] = kipp->ki_pid;
 
 	len = sizeof(pathname);
 	error = sysctl(name, 4, pathname, &len, NULL, 0);
 	if (error < 0 && errno != ESRCH) {
-		warn("sysctl: kern.proc.pathname: %d", pid);
+		warn("sysctl: kern.proc.pathname: %d", kipp->ki_pid);
 		return;
 	}
 	if (error < 0)
@@ -64,7 +65,7 @@ procstat_bin(pid_t pid, struct kinfo_proc *kipp)
 	if (len == 0 || strlen(pathname) == 0)
 		strcpy(pathname, "-");
 
-	printf("%5d ", pid);
+	printf("%5d ", kipp->ki_pid);
 	printf("%-16s ", kipp->ki_comm);
 	printf("%s\n", pathname);
 }
diff --git a/usr.bin/procstat/procstat_cred.c b/usr.bin/procstat/procstat_cred.c
index 1e91a94..ea8fdfd 100644
--- a/usr.bin/procstat/procstat_cred.c
+++ b/usr.bin/procstat/procstat_cred.c
@@ -31,6 +31,7 @@
 #include <sys/user.h>
 
 #include <err.h>
+#include <libprocstat.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <unistd.h>
@@ -38,7 +39,7 @@
 #include "procstat.h"
 
 void
-procstat_cred(pid_t pid, struct kinfo_proc *kipp)
+procstat_cred(struct kinfo_proc *kipp)
 {
 	int i;
 	int mib[4];
@@ -51,7 +52,7 @@ procstat_cred(pid_t pid, struct kinfo_proc *kipp)
 		    "COMM", "EUID", "RUID", "SVUID", "EGID", "RGID", "SVGID",
 		    "GROUPS");
 
-	printf("%5d ", pid);
+	printf("%5d ", kipp->ki_pid);
 	printf("%-16s ", kipp->ki_comm);
 	printf("%5d ", kipp->ki_uid);
 	printf("%5d ", kipp->ki_ruid);
@@ -69,7 +70,7 @@ procstat_cred(pid_t pid, struct kinfo_proc *kipp)
 		mib[0] = CTL_KERN;
 		mib[1] = KERN_PROC;
 		mib[2] = KERN_PROC_GROUPS;
-		mib[3] = pid;
+		mib[3] = kipp->ki_pid;
 
 		ngroups = sysconf(_SC_NGROUPS_MAX) + 1;
 		len = ngroups * sizeof(gid_t);
@@ -78,7 +79,7 @@ procstat_cred(pid_t pid, struct kinfo_proc *kipp)
 
 		if (sysctl(mib, 4, groups, &len, NULL, 0) == -1) {
 			warn("sysctl: kern.proc.groups: %d "
-			    "group list truncated", pid);
+			    "group list truncated", kipp->ki_pid);
 			free(groups);
 			groups = NULL;
 		}
diff --git a/usr.bin/procstat/procstat_files.c b/usr.bin/procstat/procstat_files.c
index debb0e4..f7d91a4 100644
--- a/usr.bin/procstat/procstat_files.c
+++ b/usr.bin/procstat/procstat_files.c
@@ -37,11 +37,11 @@
 #include <arpa/inet.h>
 
 #include <err.h>
+#include <libprocstat.h>
 #include <inttypes.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <libutil.h>
 
 #include "procstat.h"
 
@@ -132,162 +132,165 @@ print_address(struct sockaddr_storage *ss)
 }
 
 void
-procstat_files(pid_t pid, struct kinfo_proc *kipp)
-{
-	struct kinfo_file *freep, *kif;
-	int i, cnt;
+procstat_files(struct procstat *procstat, struct kinfo_proc *kipp)
+{ 
+	struct sockstat sock;
+	struct filestat_list *head;
+	struct filestat *fst;
 	const char *str;
+	struct vnstat vn;
+	int error;
 
 	if (!hflag)
 		printf("%5s %-16s %4s %1s %1s %-8s %3s %7s %-3s %-12s\n",
 		    "PID", "COMM", "FD", "T", "V", "FLAGS", "REF", "OFFSET",
 		    "PRO", "NAME");
 
-	freep = kinfo_getfile(pid, &cnt);
-	if (freep == NULL)
+	head = procstat_getfiles(procstat, kipp, 0);
+	if (head == NULL)
 		return;
-	for (i = 0; i < cnt; i++) {
-		kif = &freep[i];
-		
-		printf("%5d ", pid);
+	STAILQ_FOREACH(fst, head, next) {
+		printf("%5d ", kipp->ki_pid);
 		printf("%-16s ", kipp->ki_comm);
-		switch (kif->kf_fd) {
-		case KF_FD_TYPE_CWD:
+		if (fst->fs_uflags & PS_FST_UFLAG_CTTY)
+			printf("ctty ");
+		else if (fst->fs_uflags & PS_FST_UFLAG_CDIR)
 			printf(" cwd ");
-			break;
-
-		case KF_FD_TYPE_ROOT:
-			printf("root ");
-			break;
-
-		case KF_FD_TYPE_JAIL:
+		else if (fst->fs_uflags & PS_FST_UFLAG_JAIL)
 			printf("jail ");
-			break;
+		else if (fst->fs_uflags & PS_FST_UFLAG_RDIR)
+			printf("root ");
+		else if (fst->fs_uflags & PS_FST_UFLAG_TEXT)
+			printf("text ");
+		else if (fst->fs_uflags & PS_FST_UFLAG_TRACE)
+			printf("trace ");
+		else
+			printf("%4d ", fst->fs_fd);
 
-		default:
-			printf("%4d ", kif->kf_fd);
-			break;
-		}
-		switch (kif->kf_type) {
-		case KF_TYPE_VNODE:
+		switch (fst->fs_type) {
+		case PS_FST_TYPE_VNODE:
 			str = "v";
 			break;
 
-		case KF_TYPE_SOCKET:
+		case PS_FST_TYPE_SOCKET:
 			str = "s";
 			break;
 
-		case KF_TYPE_PIPE:
+		case PS_FST_TYPE_PIPE:
 			str = "p";
 			break;
 
-		case KF_TYPE_FIFO:
+		case PS_FST_TYPE_FIFO:
 			str = "f";
 			break;
 
-		case KF_TYPE_KQUEUE:
+		case PS_FST_TYPE_KQUEUE:
 			str = "k";
 			break;
 
-		case KF_TYPE_CRYPTO:
+		case PS_FST_TYPE_CRYPTO:
 			str = "c";
 			break;
 
-		case KF_TYPE_MQUEUE:
+		case PS_FST_TYPE_MQUEUE:
 			str = "m";
 			break;
 
-		case KF_TYPE_SHM:
+		case PS_FST_TYPE_SHM:
 			str = "h";
 			break;
 
-		case KF_TYPE_PTS:
+		case PS_FST_TYPE_PTS:
 			str = "t";
 			break;
 
-		case KF_TYPE_SEM:
+		case PS_FST_TYPE_SEM:
 			str = "e";
 			break;
 
-		case KF_TYPE_NONE:
-		case KF_TYPE_UNKNOWN:
+		case PS_FST_TYPE_NONE:
+		case PS_FST_TYPE_UNKNOWN:
 		default:
 			str = "?";
 			break;
 		}
 		printf("%1s ", str);
 		str = "-";
-		if (kif->kf_type == KF_TYPE_VNODE) {
-			switch (kif->kf_vnode_type) {
-			case KF_VTYPE_VREG:
+		if (fst->fs_type == PS_FST_TYPE_VNODE) {
+			error = procstat_get_vnode_info(procstat, fst, &vn, NULL);
+			switch (vn.vn_type) {
+			case PS_FST_VTYPE_VREG:
 				str = "r";
 				break;
 
-			case KF_VTYPE_VDIR:
+			case PS_FST_VTYPE_VDIR:
 				str = "d";
 				break;
 
-			case KF_VTYPE_VBLK:
+			case PS_FST_VTYPE_VBLK:
 				str = "b";
 				break;
 
-			case KF_VTYPE_VCHR:
+			case PS_FST_VTYPE_VCHR:
 				str = "c";
 				break;
 
-			case KF_VTYPE_VLNK:
+			case PS_FST_VTYPE_VLNK:
 				str = "l";
 				break;
 
-			case KF_VTYPE_VSOCK:
+			case PS_FST_VTYPE_VSOCK:
 				str = "s";
 				break;
 
-			case KF_VTYPE_VFIFO:
+			case PS_FST_VTYPE_VFIFO:
 				str = "f";
 				break;
 
-			case KF_VTYPE_VBAD:
+			case PS_FST_VTYPE_VBAD:
 				str = "x";
 				break;
 
-			case KF_VTYPE_VNON:
-			case KF_VTYPE_UNKNOWN:
+			case PS_FST_VTYPE_VNON:
+			case PS_FST_VTYPE_UNKNOWN:
 			default:
 				str = "?";
 				break;
 			}
 		}
 		printf("%1s ", str);
-		printf("%s", kif->kf_flags & KF_FLAG_READ ? "r" : "-");
-		printf("%s", kif->kf_flags & KF_FLAG_WRITE ? "w" : "-");
-		printf("%s", kif->kf_flags & KF_FLAG_APPEND ? "a" : "-");
-		printf("%s", kif->kf_flags & KF_FLAG_ASYNC ? "s" : "-");
-		printf("%s", kif->kf_flags & KF_FLAG_FSYNC ? "f" : "-");
-		printf("%s", kif->kf_flags & KF_FLAG_NONBLOCK ? "n" : "-");
-		printf("%s", kif->kf_flags & KF_FLAG_DIRECT ? "d" : "-");
-		printf("%s ", kif->kf_flags & KF_FLAG_HASLOCK ? "l" : "-");
-		if (kif->kf_ref_count > -1)
-			printf("%3d ", kif->kf_ref_count);
+		printf("%s", fst->fs_fflags & PS_FST_FFLAG_READ ? "r" : "-");
+		printf("%s", fst->fs_fflags & PS_FST_FFLAG_WRITE ? "w" : "-");
+		printf("%s", fst->fs_fflags & PS_FST_FFLAG_APPEND ? "a" : "-");
+		printf("%s", fst->fs_fflags & PS_FST_FFLAG_ASYNC ? "s" : "-");
+		printf("%s", fst->fs_fflags & PS_FST_FFLAG_SYNC ? "f" : "-");
+		printf("%s", fst->fs_fflags & PS_FST_FFLAG_NONBLOCK ? "n" : "-");
+		printf("%s", fst->fs_fflags & PS_FST_FFLAG_DIRECT ? "d" : "-");
+		printf("%s ", fst->fs_fflags & PS_FST_FFLAG_HASLOCK ? "l" : "-");
+		if (fst->fs_ref_count > -1)
+			printf("%3d ", fst->fs_ref_count);
 		else
 			printf("%3c ", '-');
-		if (kif->kf_offset > -1)
-			printf("%7jd ", (intmax_t)kif->kf_offset);
+		if (fst->fs_offset > -1)
+			printf("%7jd ", (intmax_t)fst->fs_offset);
 		else
 			printf("%7c ", '-');
 
-		switch (kif->kf_type) {
-		case KF_TYPE_VNODE:
-		case KF_TYPE_FIFO:
-		case KF_TYPE_PTS:
+		switch (fst->fs_type) {
+		case PS_FST_TYPE_VNODE:
+		case PS_FST_TYPE_FIFO:
+		case PS_FST_TYPE_PTS:
 			printf("%-3s ", "-");
-			printf("%-18s", kif->kf_path);
+			printf("%-18s", fst->fs_path != NULL ? fst->fs_path : "-");
 			break;
 
-		case KF_TYPE_SOCKET:
+		case PS_FST_TYPE_SOCKET:
+			error = procstat_get_socket_info(procstat, fst, &sock, NULL);
+			if (error != 0)
+				break;
 			printf("%-3s ",
-			    protocol_to_string(kif->kf_sock_domain,
-			    kif->kf_sock_type, kif->kf_sock_protocol));
+			    protocol_to_string(sock.dom_family,
+			    sock.type, sock.proto));
 			/*
 			 * While generally we like to print two addresses,
 			 * local and peer, for sockets, it turns out to be
@@ -295,18 +298,18 @@ procstat_files(pid_t pid, struct kinfo_proc *kipp)
 			 * local sockets, as typically they aren't bound and
 			 *  connected, and the path strings can get long.
 			 */
-			if (kif->kf_sock_domain == AF_LOCAL) {
+			if (sock.dom_family == AF_LOCAL) {
 				struct sockaddr_un *sun =
-				    (struct sockaddr_un *)&kif->kf_sa_local;
+				    (struct sockaddr_un *)&sock.sa_local;
 
 				if (sun->sun_path[0] != 0)
-					print_address(&kif->kf_sa_local);
+					print_address(&sock.sa_local);
 				else
-					print_address(&kif->kf_sa_peer);
+					print_address(&sock.sa_peer);
 			} else {
-				print_address(&kif->kf_sa_local);
+				print_address(&sock.sa_local);
 				printf(" ");
-				print_address(&kif->kf_sa_peer);
+				print_address(&sock.sa_peer);
 			}
 			break;
 
@@ -317,5 +320,4 @@ procstat_files(pid_t pid, struct kinfo_proc *kipp)
 
 		printf("\n");
 	}
-	free(freep);
 }
diff --git a/usr.bin/procstat/procstat_kstack.c b/usr.bin/procstat/procstat_kstack.c
index 9d5f71e..fd2b9ab 100644
--- a/usr.bin/procstat/procstat_kstack.c
+++ b/usr.bin/procstat/procstat_kstack.c
@@ -32,6 +32,7 @@
 
 #include <err.h>
 #include <errno.h>
+#include <libprocstat.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -124,7 +125,7 @@ kinfo_kstack_sort(struct kinfo_kstack *kkstp, int count)
 
 
 void
-procstat_kstack(pid_t pid, struct kinfo_proc *kipp, int kflag)
+procstat_kstack(struct kinfo_proc *kipp, int kflag)
 {
 	struct kinfo_kstack *kkstp, *kkstp_free;
 	struct kinfo_proc *kip, *kip_free;
@@ -140,12 +141,12 @@ procstat_kstack(pid_t pid, struct kinfo_proc *kipp, int kflag)
 	name[0] = CTL_KERN;
 	name[1] = KERN_PROC;
 	name[2] = KERN_PROC_KSTACK;
-	name[3] = pid;
+	name[3] = kipp->ki_pid;
 
 	kstk_len = 0;
 	error = sysctl(name, 4, NULL, &kstk_len, NULL, 0);
 	if (error < 0 && errno != ESRCH && errno != EPERM && errno != ENOENT) {
-		warn("sysctl: kern.proc.kstack: %d", pid);
+		warn("sysctl: kern.proc.kstack: %d", kipp->ki_pid);
 		return;
 	}
 	if (error < 0 && errno == ENOENT) {
@@ -160,7 +161,7 @@ procstat_kstack(pid_t pid, struct kinfo_proc *kipp, int kflag)
 		err(-1, "malloc");
 
 	if (sysctl(name, 4, kkstp, &kstk_len, NULL, 0) < 0) {
-		warn("sysctl: kern.proc.pid: %d", pid);
+		warn("sysctl: kern.proc.pid: %d", kipp->ki_pid);
 		free(kkstp);
 		return;
 	}
@@ -171,12 +172,12 @@ procstat_kstack(pid_t pid, struct kinfo_proc *kipp, int kflag)
 	name[0] = CTL_KERN;
 	name[1] = KERN_PROC;
 	name[2] = KERN_PROC_PID | KERN_PROC_INC_THREAD;
-	name[3] = pid;
+	name[3] = kipp->ki_pid;
 
 	kip_len = 0;
 	error = sysctl(name, 4, NULL, &kip_len, NULL, 0);
 	if (error < 0 && errno != ESRCH) {
-		warn("sysctl: kern.proc.pid: %d", pid);
+		warn("sysctl: kern.proc.pid: %d", kipp->ki_pid);
 		return;
 	}
 	if (error < 0)
@@ -187,7 +188,7 @@ procstat_kstack(pid_t pid, struct kinfo_proc *kipp, int kflag)
 		err(-1, "malloc");
 
 	if (sysctl(name, 4, kip, &kip_len, NULL, 0) < 0) {
-		warn("sysctl: kern.proc.pid: %d", pid);
+		warn("sysctl: kern.proc.pid: %d", kipp->ki_pid);
 		free(kip);
 		return;
 	}
@@ -209,7 +210,7 @@ procstat_kstack(pid_t pid, struct kinfo_proc *kipp, int kflag)
 		if (kipp == NULL)
 			continue;
 
-		printf("%5d ", pid);
+		printf("%5d ", kipp->ki_pid);
 		printf("%6d ", kkstp->kkst_tid);
 		printf("%-16s ", kipp->ki_comm);
 		printf("%-16s ", (strlen(kipp->ki_ocomm) &&
diff --git a/usr.bin/procstat/procstat_sigs.c b/usr.bin/procstat/procstat_sigs.c
index b1f5e35..70df250 100644
--- a/usr.bin/procstat/procstat_sigs.c
+++ b/usr.bin/procstat/procstat_sigs.c
@@ -37,6 +37,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <libprocstat.h>
 
 #include "procstat.h"
 
@@ -63,10 +64,12 @@ procstat_print_sig(const sigset_t *set, int sig, char flag)
 }
 
 void
-procstat_sigs(pid_t pid, struct kinfo_proc *kipp)
+procstat_sigs(struct procstat *prstat __unused, struct kinfo_proc *kipp)
 {
 	int j;
+	pid_t pid;
 
+	pid = kipp->ki_pid;
 	if (!hflag)
 		printf("%5s %-16s %-7s %4s\n", "PID", "COMM", "SIG", "FLAGS");
 
@@ -83,13 +86,15 @@ procstat_sigs(pid_t pid, struct kinfo_proc *kipp)
 }
 
 void
-procstat_threads_sigs(pid_t pid, struct kinfo_proc *kipp)
+procstat_threads_sigs(struct procstat *prstat __unused, struct kinfo_proc *kipp)
 {
 	struct kinfo_proc *kip;
+	pid_t pid;
 	int error, name[4], j;
 	unsigned int i;
 	size_t len;
 
+	pid = kipp->ki_pid;
 	if (!hflag)
 		printf("%5s %6s %-16s %-7s %4s\n", "PID", "TID", "COMM",
 		     "SIG", "FLAGS");
diff --git a/usr.bin/procstat/procstat_threads.c b/usr.bin/procstat/procstat_threads.c
index 64e0a36..7633608 100644
--- a/usr.bin/procstat/procstat_threads.c
+++ b/usr.bin/procstat/procstat_threads.c
@@ -32,6 +32,7 @@
 
 #include <err.h>
 #include <errno.h>
+#include <libprocstat.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -39,7 +40,7 @@
 #include "procstat.h"
 
 void
-procstat_threads(pid_t pid, struct kinfo_proc *kipp)
+procstat_threads(struct kinfo_proc *kipp)
 {
 	struct kinfo_proc *kip;
 	int error, name[4];
@@ -57,12 +58,12 @@ procstat_threads(pid_t pid, struct kinfo_proc *kipp)
 	name[0] = CTL_KERN;
 	name[1] = KERN_PROC;
 	name[2] = KERN_PROC_PID | KERN_PROC_INC_THREAD;
-	name[3] = pid;
+	name[3] = kipp->ki_pid;
 
 	len = 0;
 	error = sysctl(name, 4, NULL, &len, NULL, 0);
 	if (error < 0 && errno != ESRCH) {
-		warn("sysctl: kern.proc.pid: %d", pid);
+		warn("sysctl: kern.proc.pid: %d", kipp->ki_pid);
 		return;
 	}
 	if (error < 0)
@@ -73,7 +74,7 @@ procstat_threads(pid_t pid, struct kinfo_proc *kipp)
 		err(-1, "malloc");
 
 	if (sysctl(name, 4, kip, &len, NULL, 0) < 0) {
-		warn("sysctl: kern.proc.pid: %d", pid);
+		warn("sysctl: kern.proc.pid: %d", kipp->ki_pid);
 		free(kip);
 		return;
 	}
@@ -81,7 +82,7 @@ procstat_threads(pid_t pid, struct kinfo_proc *kipp)
 	kinfo_proc_sort(kip, len / sizeof(*kipp));
 	for (i = 0; i < len / sizeof(*kipp); i++) {
 		kipp = &kip[i];
-		printf("%5d ", pid);
+		printf("%5d ", kipp->ki_pid);
 		printf("%6d ", kipp->ki_tid);
 		printf("%-16s ", strlen(kipp->ki_comm) ?
 		    kipp->ki_comm : "-");
diff --git a/usr.bin/procstat/procstat_vm.c b/usr.bin/procstat/procstat_vm.c
index 5c965a9..2eada92 100644
--- a/usr.bin/procstat/procstat_vm.c
+++ b/usr.bin/procstat/procstat_vm.c
@@ -32,6 +32,7 @@
 
 #include <err.h>
 #include <errno.h>
+#include <libprocstat.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdint.h>
@@ -40,7 +41,7 @@
 #include "procstat.h"
 
 void
-procstat_vm(pid_t pid, struct kinfo_proc *kipp __unused)
+procstat_vm(struct kinfo_proc *kipp)
 {
 	struct kinfo_vmentry *freep, *kve;
 	int ptrwidth;
@@ -53,12 +54,12 @@ procstat_vm(pid_t pid, struct kinfo_proc *kipp __unused)
 		    "PID", ptrwidth, "START", ptrwidth, "END", "PRT", "RES",
 		    "PRES", "REF", "SHD", "FL", "TP", "PATH");
 
-	freep = kinfo_getvmmap(pid, &cnt);
+	freep = kinfo_getvmmap(kipp->ki_pid, &cnt);
 	if (freep == NULL)
 		return;
 	for (i = 0; i < cnt; i++) {
 		kve = &freep[i];
-		printf("%5d ", pid);
+		printf("%5d ", kipp->ki_pid);
 		printf("%#*jx ", ptrwidth, (uintmax_t)kve->kve_start);
 		printf("%#*jx ", ptrwidth, (uintmax_t)kve->kve_end);
 		printf("%s", kve->kve_protection & KVME_PROT_READ ? "r" : "-");