xref: /freebsd/lib/libprocstat/libprocstat.c (revision f1221c59d7cbec2b5b8f65789368fefbbe2cd8fd)
10daf62d9SStanislav Sedov /*-
2df57947fSPedro F. Giffuni  * SPDX-License-Identifier: BSD-4-Clause
3df57947fSPedro F. Giffuni  *
486be94fcSTycho Nightingale  * Copyright (c) 2017 Dell EMC
50daf62d9SStanislav Sedov  * Copyright (c) 2009 Stanislav Sedov <stas@FreeBSD.org>
60daf62d9SStanislav Sedov  * Copyright (c) 1988, 1993
70daf62d9SStanislav Sedov  *      The Regents of the University of California.  All rights reserved.
80daf62d9SStanislav Sedov  *
90daf62d9SStanislav Sedov  * Redistribution and use in source and binary forms, with or without
100daf62d9SStanislav Sedov  * modification, are permitted provided that the following conditions
110daf62d9SStanislav Sedov  * are met:
120daf62d9SStanislav Sedov  * 1. Redistributions of source code must retain the above copyright
130daf62d9SStanislav Sedov  *    notice, this list of conditions and the following disclaimer.
140daf62d9SStanislav Sedov  * 2. Redistributions in binary form must reproduce the above copyright
150daf62d9SStanislav Sedov  *    notice, this list of conditions and the following disclaimer in the
160daf62d9SStanislav Sedov  *    documentation and/or other materials provided with the distribution.
170daf62d9SStanislav Sedov  * 3. All advertising materials mentioning features or use of this software
180daf62d9SStanislav Sedov  *    must display the following acknowledgement:
190daf62d9SStanislav Sedov  *      This product includes software developed by the University of
200daf62d9SStanislav Sedov  *      California, Berkeley and its contributors.
210daf62d9SStanislav Sedov  * 4. Neither the name of the University nor the names of its contributors
220daf62d9SStanislav Sedov  *    may be used to endorse or promote products derived from this software
230daf62d9SStanislav Sedov  *    without specific prior written permission.
240daf62d9SStanislav Sedov  *
250daf62d9SStanislav Sedov  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
260daf62d9SStanislav Sedov  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
270daf62d9SStanislav Sedov  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
280daf62d9SStanislav Sedov  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
290daf62d9SStanislav Sedov  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
300daf62d9SStanislav Sedov  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
310daf62d9SStanislav Sedov  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
320daf62d9SStanislav Sedov  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
330daf62d9SStanislav Sedov  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
340daf62d9SStanislav Sedov  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
350daf62d9SStanislav Sedov  * SUCH DAMAGE.
360daf62d9SStanislav Sedov  */
370daf62d9SStanislav Sedov 
380daf62d9SStanislav Sedov #include <sys/cdefs.h>
390daf62d9SStanislav Sedov __FBSDID("$FreeBSD$");
400daf62d9SStanislav Sedov 
410daf62d9SStanislav Sedov #include <sys/param.h>
422ff020d3SMikolaj Golub #include <sys/elf.h>
430daf62d9SStanislav Sedov #include <sys/time.h>
447cc0ebfdSMikolaj Golub #include <sys/resourcevar.h>
451f84c47eSMikolaj Golub #define	_WANT_UCRED
461f84c47eSMikolaj Golub #include <sys/ucred.h>
471f84c47eSMikolaj Golub #undef _WANT_UCRED
480daf62d9SStanislav Sedov #include <sys/proc.h>
490daf62d9SStanislav Sedov #include <sys/user.h>
500daf62d9SStanislav Sedov #include <sys/stat.h>
510daf62d9SStanislav Sedov #include <sys/vnode.h>
520daf62d9SStanislav Sedov #include <sys/socket.h>
530e229f34SGleb Smirnoff #define	_WANT_SOCKET
540daf62d9SStanislav Sedov #include <sys/socketvar.h>
550daf62d9SStanislav Sedov #include <sys/domain.h>
560daf62d9SStanislav Sedov #include <sys/protosw.h>
570daf62d9SStanislav Sedov #include <sys/un.h>
580e229f34SGleb Smirnoff #define	_WANT_UNPCB
590daf62d9SStanislav Sedov #include <sys/unpcb.h>
600daf62d9SStanislav Sedov #include <sys/sysctl.h>
610daf62d9SStanislav Sedov #include <sys/tty.h>
620daf62d9SStanislav Sedov #include <sys/filedesc.h>
630daf62d9SStanislav Sedov #include <sys/queue.h>
640daf62d9SStanislav Sedov #define	_WANT_FILE
650daf62d9SStanislav Sedov #include <sys/file.h>
660daf62d9SStanislav Sedov #include <sys/conf.h>
67958aa575SJohn Baldwin #include <sys/ksem.h>
68e506e182SJohn Baldwin #include <sys/mman.h>
69b881b8beSRobert Watson #include <sys/capsicum.h>
70a4ba6502STycho Nightingale #include <sys/ptrace.h>
710daf62d9SStanislav Sedov #define	_KERNEL
720daf62d9SStanislav Sedov #include <sys/mount.h>
730daf62d9SStanislav Sedov #include <sys/pipe.h>
740daf62d9SStanislav Sedov #include <ufs/ufs/quota.h>
750daf62d9SStanislav Sedov #include <ufs/ufs/inode.h>
760daf62d9SStanislav Sedov #include <fs/devfs/devfs.h>
770daf62d9SStanislav Sedov #include <fs/devfs/devfs_int.h>
780daf62d9SStanislav Sedov #undef _KERNEL
790daf62d9SStanislav Sedov #include <nfs/nfsproto.h>
800daf62d9SStanislav Sedov #include <nfsclient/nfs.h>
810daf62d9SStanislav Sedov #include <nfsclient/nfsnode.h>
820daf62d9SStanislav Sedov 
830daf62d9SStanislav Sedov #include <vm/vm.h>
840daf62d9SStanislav Sedov #include <vm/vm_map.h>
850daf62d9SStanislav Sedov #include <vm/vm_object.h>
860daf62d9SStanislav Sedov 
870daf62d9SStanislav Sedov #include <net/route.h>
880daf62d9SStanislav Sedov #include <netinet/in.h>
890daf62d9SStanislav Sedov #include <netinet/in_systm.h>
900daf62d9SStanislav Sedov #include <netinet/ip.h>
91cc65eb4eSGleb Smirnoff #define	_WANT_INPCB
920daf62d9SStanislav Sedov #include <netinet/in_pcb.h>
930daf62d9SStanislav Sedov 
940daf62d9SStanislav Sedov #include <assert.h>
950daf62d9SStanislav Sedov #include <ctype.h>
960daf62d9SStanislav Sedov #include <err.h>
970daf62d9SStanislav Sedov #include <fcntl.h>
980daf62d9SStanislav Sedov #include <kvm.h>
990daf62d9SStanislav Sedov #include <libutil.h>
1000daf62d9SStanislav Sedov #include <limits.h>
1010daf62d9SStanislav Sedov #include <paths.h>
1020daf62d9SStanislav Sedov #include <pwd.h>
1030daf62d9SStanislav Sedov #include <stdio.h>
1040daf62d9SStanislav Sedov #include <stdlib.h>
1050daf62d9SStanislav Sedov #include <stddef.h>
1060daf62d9SStanislav Sedov #include <string.h>
1070daf62d9SStanislav Sedov #include <unistd.h>
1080daf62d9SStanislav Sedov #include <netdb.h>
1090daf62d9SStanislav Sedov 
1100daf62d9SStanislav Sedov #include <libprocstat.h>
1110daf62d9SStanislav Sedov #include "libprocstat_internal.h"
1120daf62d9SStanislav Sedov #include "common_kvm.h"
1137153ad2bSMikolaj Golub #include "core.h"
1140daf62d9SStanislav Sedov 
1150daf62d9SStanislav Sedov int     statfs(const char *, struct statfs *);	/* XXX */
1160daf62d9SStanislav Sedov 
1170daf62d9SStanislav Sedov #define	PROCSTAT_KVM	1
1180daf62d9SStanislav Sedov #define	PROCSTAT_SYSCTL	2
1197153ad2bSMikolaj Golub #define	PROCSTAT_CORE	3
1200daf62d9SStanislav Sedov 
1214482b5e3SMikolaj Golub static char	**getargv(struct procstat *procstat, struct kinfo_proc *kp,
1224482b5e3SMikolaj Golub     size_t nchr, int env);
1230daf62d9SStanislav Sedov static char	*getmnton(kvm_t *kd, struct mount *m);
12439680c7bSMikolaj Golub static struct kinfo_vmentry *	kinfo_getvmmap_core(struct procstat_core *core,
12539680c7bSMikolaj Golub     int *cntp);
1262ff020d3SMikolaj Golub static Elf_Auxinfo	*procstat_getauxv_core(struct procstat_core *core,
1272ff020d3SMikolaj Golub     unsigned int *cntp);
1282ff020d3SMikolaj Golub static Elf_Auxinfo	*procstat_getauxv_sysctl(pid_t pid, unsigned int *cntp);
1290daf62d9SStanislav Sedov static struct filestat_list	*procstat_getfiles_kvm(
1300daf62d9SStanislav Sedov     struct procstat *procstat, struct kinfo_proc *kp, int mmapped);
1310daf62d9SStanislav Sedov static struct filestat_list	*procstat_getfiles_sysctl(
1320daf62d9SStanislav Sedov     struct procstat *procstat, struct kinfo_proc *kp, int mmapped);
1330daf62d9SStanislav Sedov static int	procstat_get_pipe_info_sysctl(struct filestat *fst,
1340daf62d9SStanislav Sedov     struct pipestat *pipe, char *errbuf);
1350daf62d9SStanislav Sedov static int	procstat_get_pipe_info_kvm(kvm_t *kd, struct filestat *fst,
1360daf62d9SStanislav Sedov     struct pipestat *pipe, char *errbuf);
1370daf62d9SStanislav Sedov static int	procstat_get_pts_info_sysctl(struct filestat *fst,
1380daf62d9SStanislav Sedov     struct ptsstat *pts, char *errbuf);
1390daf62d9SStanislav Sedov static int	procstat_get_pts_info_kvm(kvm_t *kd, struct filestat *fst,
1400daf62d9SStanislav Sedov     struct ptsstat *pts, char *errbuf);
141958aa575SJohn Baldwin static int	procstat_get_sem_info_sysctl(struct filestat *fst,
142958aa575SJohn Baldwin     struct semstat *sem, char *errbuf);
143958aa575SJohn Baldwin static int	procstat_get_sem_info_kvm(kvm_t *kd, struct filestat *fst,
144958aa575SJohn Baldwin     struct semstat *sem, char *errbuf);
145e506e182SJohn Baldwin static int	procstat_get_shm_info_sysctl(struct filestat *fst,
146e506e182SJohn Baldwin     struct shmstat *shm, char *errbuf);
147e506e182SJohn Baldwin static int	procstat_get_shm_info_kvm(kvm_t *kd, struct filestat *fst,
148e506e182SJohn Baldwin     struct shmstat *shm, char *errbuf);
1490daf62d9SStanislav Sedov static int	procstat_get_socket_info_sysctl(struct filestat *fst,
1500daf62d9SStanislav Sedov     struct sockstat *sock, char *errbuf);
1510daf62d9SStanislav Sedov static int	procstat_get_socket_info_kvm(kvm_t *kd, struct filestat *fst,
1520daf62d9SStanislav Sedov     struct sockstat *sock, char *errbuf);
1530daf62d9SStanislav Sedov static int	to_filestat_flags(int flags);
1540daf62d9SStanislav Sedov static int	procstat_get_vnode_info_kvm(kvm_t *kd, struct filestat *fst,
1550daf62d9SStanislav Sedov     struct vnstat *vn, char *errbuf);
1560daf62d9SStanislav Sedov static int	procstat_get_vnode_info_sysctl(struct filestat *fst,
1570daf62d9SStanislav Sedov     struct vnstat *vn, char *errbuf);
1587f1d14e6SMikolaj Golub static gid_t	*procstat_getgroups_core(struct procstat_core *core,
1597f1d14e6SMikolaj Golub     unsigned int *count);
1601f84c47eSMikolaj Golub static gid_t *	procstat_getgroups_kvm(kvm_t *kd, struct kinfo_proc *kp,
1611f84c47eSMikolaj Golub     unsigned int *count);
1627f1d14e6SMikolaj Golub static gid_t	*procstat_getgroups_sysctl(pid_t pid, unsigned int *count);
16389358231SMikolaj Golub static struct kinfo_kstack	*procstat_getkstack_sysctl(pid_t pid,
16489358231SMikolaj Golub     int *cntp);
1651f84c47eSMikolaj Golub static int	procstat_getosrel_core(struct procstat_core *core,
1661f84c47eSMikolaj Golub     int *osrelp);
1671f84c47eSMikolaj Golub static int	procstat_getosrel_kvm(kvm_t *kd, struct kinfo_proc *kp,
1681f84c47eSMikolaj Golub     int *osrelp);
1691f84c47eSMikolaj Golub static int	procstat_getosrel_sysctl(pid_t pid, int *osrelp);
1704cdf9796SMikolaj Golub static int	procstat_getpathname_core(struct procstat_core *core,
1714cdf9796SMikolaj Golub     char *pathname, size_t maxlen);
1724cdf9796SMikolaj Golub static int	procstat_getpathname_sysctl(pid_t pid, char *pathname,
1734cdf9796SMikolaj Golub     size_t maxlen);
1747cc0ebfdSMikolaj Golub static int	procstat_getrlimit_core(struct procstat_core *core, int which,
1757cc0ebfdSMikolaj Golub     struct rlimit* rlimit);
1761f84c47eSMikolaj Golub static int	procstat_getrlimit_kvm(kvm_t *kd, struct kinfo_proc *kp,
1771f84c47eSMikolaj Golub     int which, struct rlimit* rlimit);
1787cc0ebfdSMikolaj Golub static int	procstat_getrlimit_sysctl(pid_t pid, int which,
1797cc0ebfdSMikolaj Golub     struct rlimit* rlimit);
1805b9bcba9SMikolaj Golub static int	procstat_getumask_core(struct procstat_core *core,
1815b9bcba9SMikolaj Golub     unsigned short *maskp);
1821f84c47eSMikolaj Golub static int	procstat_getumask_kvm(kvm_t *kd, struct kinfo_proc *kp,
1831f84c47eSMikolaj Golub     unsigned short *maskp);
1845b9bcba9SMikolaj Golub static int	procstat_getumask_sysctl(pid_t pid, unsigned short *maskp);
1850daf62d9SStanislav Sedov static int	vntype2psfsttype(int type);
1860daf62d9SStanislav Sedov 
1870daf62d9SStanislav Sedov void
1880daf62d9SStanislav Sedov procstat_close(struct procstat *procstat)
1890daf62d9SStanislav Sedov {
1900daf62d9SStanislav Sedov 
1910daf62d9SStanislav Sedov 	assert(procstat);
1920daf62d9SStanislav Sedov 	if (procstat->type == PROCSTAT_KVM)
1930daf62d9SStanislav Sedov 		kvm_close(procstat->kd);
1947153ad2bSMikolaj Golub 	else if (procstat->type == PROCSTAT_CORE)
1957153ad2bSMikolaj Golub 		procstat_core_close(procstat->core);
1964482b5e3SMikolaj Golub 	procstat_freeargv(procstat);
1974482b5e3SMikolaj Golub 	procstat_freeenvv(procstat);
198d7b666aeSSergey Kandaurov 	free(procstat);
1990daf62d9SStanislav Sedov }
2000daf62d9SStanislav Sedov 
2010daf62d9SStanislav Sedov struct procstat *
2020daf62d9SStanislav Sedov procstat_open_sysctl(void)
2030daf62d9SStanislav Sedov {
2040daf62d9SStanislav Sedov 	struct procstat *procstat;
2050daf62d9SStanislav Sedov 
2060daf62d9SStanislav Sedov 	procstat = calloc(1, sizeof(*procstat));
2070daf62d9SStanislav Sedov 	if (procstat == NULL) {
2080daf62d9SStanislav Sedov 		warn("malloc()");
2090daf62d9SStanislav Sedov 		return (NULL);
2100daf62d9SStanislav Sedov 	}
2110daf62d9SStanislav Sedov 	procstat->type = PROCSTAT_SYSCTL;
2120daf62d9SStanislav Sedov 	return (procstat);
2130daf62d9SStanislav Sedov }
2140daf62d9SStanislav Sedov 
2150daf62d9SStanislav Sedov struct procstat *
2160daf62d9SStanislav Sedov procstat_open_kvm(const char *nlistf, const char *memf)
2170daf62d9SStanislav Sedov {
2180daf62d9SStanislav Sedov 	struct procstat *procstat;
2190daf62d9SStanislav Sedov 	kvm_t *kd;
2200daf62d9SStanislav Sedov 	char buf[_POSIX2_LINE_MAX];
2210daf62d9SStanislav Sedov 
2220daf62d9SStanislav Sedov 	procstat = calloc(1, sizeof(*procstat));
2230daf62d9SStanislav Sedov 	if (procstat == NULL) {
2240daf62d9SStanislav Sedov 		warn("malloc()");
2250daf62d9SStanislav Sedov 		return (NULL);
2260daf62d9SStanislav Sedov 	}
2270daf62d9SStanislav Sedov 	kd = kvm_openfiles(nlistf, memf, NULL, O_RDONLY, buf);
2280daf62d9SStanislav Sedov 	if (kd == NULL) {
2290daf62d9SStanislav Sedov 		warnx("kvm_openfiles(): %s", buf);
2300daf62d9SStanislav Sedov 		free(procstat);
2310daf62d9SStanislav Sedov 		return (NULL);
2320daf62d9SStanislav Sedov 	}
2330daf62d9SStanislav Sedov 	procstat->type = PROCSTAT_KVM;
2340daf62d9SStanislav Sedov 	procstat->kd = kd;
2350daf62d9SStanislav Sedov 	return (procstat);
2360daf62d9SStanislav Sedov }
2370daf62d9SStanislav Sedov 
2387153ad2bSMikolaj Golub struct procstat *
2397153ad2bSMikolaj Golub procstat_open_core(const char *filename)
2407153ad2bSMikolaj Golub {
2417153ad2bSMikolaj Golub 	struct procstat *procstat;
2427153ad2bSMikolaj Golub 	struct procstat_core *core;
2437153ad2bSMikolaj Golub 
2447153ad2bSMikolaj Golub 	procstat = calloc(1, sizeof(*procstat));
2457153ad2bSMikolaj Golub 	if (procstat == NULL) {
2467153ad2bSMikolaj Golub 		warn("malloc()");
2477153ad2bSMikolaj Golub 		return (NULL);
2487153ad2bSMikolaj Golub 	}
2497153ad2bSMikolaj Golub 	core = procstat_core_open(filename);
2507153ad2bSMikolaj Golub 	if (core == NULL) {
2517153ad2bSMikolaj Golub 		free(procstat);
2527153ad2bSMikolaj Golub 		return (NULL);
2537153ad2bSMikolaj Golub 	}
2547153ad2bSMikolaj Golub 	procstat->type = PROCSTAT_CORE;
2557153ad2bSMikolaj Golub 	procstat->core = core;
2567153ad2bSMikolaj Golub 	return (procstat);
2577153ad2bSMikolaj Golub }
2587153ad2bSMikolaj Golub 
2590daf62d9SStanislav Sedov struct kinfo_proc *
2600daf62d9SStanislav Sedov procstat_getprocs(struct procstat *procstat, int what, int arg,
2610daf62d9SStanislav Sedov     unsigned int *count)
2620daf62d9SStanislav Sedov {
2630daf62d9SStanislav Sedov 	struct kinfo_proc *p0, *p;
264608203fdSJohn Baldwin 	size_t len, olen;
2650daf62d9SStanislav Sedov 	int name[4];
266391bdfb8SAndriy Gapon 	int cnt;
2670daf62d9SStanislav Sedov 	int error;
2680daf62d9SStanislav Sedov 
2690daf62d9SStanislav Sedov 	assert(procstat);
2700daf62d9SStanislav Sedov 	assert(count);
2710daf62d9SStanislav Sedov 	p = NULL;
2720daf62d9SStanislav Sedov 	if (procstat->type == PROCSTAT_KVM) {
273391bdfb8SAndriy Gapon 		*count = 0;
274391bdfb8SAndriy Gapon 		p0 = kvm_getprocs(procstat->kd, what, arg, &cnt);
275391bdfb8SAndriy Gapon 		if (p0 == NULL || cnt <= 0)
2760daf62d9SStanislav Sedov 			return (NULL);
277391bdfb8SAndriy Gapon 		*count = cnt;
2780daf62d9SStanislav Sedov 		len = *count * sizeof(*p);
2790daf62d9SStanislav Sedov 		p = malloc(len);
2800daf62d9SStanislav Sedov 		if (p == NULL) {
28165869214SJilles Tjoelker 			warnx("malloc(%zu)", len);
2820daf62d9SStanislav Sedov 			goto fail;
2830daf62d9SStanislav Sedov 		}
2840daf62d9SStanislav Sedov 		bcopy(p0, p, len);
2850daf62d9SStanislav Sedov 		return (p);
2860daf62d9SStanislav Sedov 	} else if (procstat->type == PROCSTAT_SYSCTL) {
2870daf62d9SStanislav Sedov 		len = 0;
2880daf62d9SStanislav Sedov 		name[0] = CTL_KERN;
2890daf62d9SStanislav Sedov 		name[1] = KERN_PROC;
2900daf62d9SStanislav Sedov 		name[2] = what;
2910daf62d9SStanislav Sedov 		name[3] = arg;
29275b6a179SEnji Cooper 		error = sysctl(name, nitems(name), NULL, &len, NULL, 0);
2930daf62d9SStanislav Sedov 		if (error < 0 && errno != EPERM) {
2940daf62d9SStanislav Sedov 			warn("sysctl(kern.proc)");
2950daf62d9SStanislav Sedov 			goto fail;
2960daf62d9SStanislav Sedov 		}
2970daf62d9SStanislav Sedov 		if (len == 0) {
2980daf62d9SStanislav Sedov 			warnx("no processes?");
2990daf62d9SStanislav Sedov 			goto fail;
3000daf62d9SStanislav Sedov 		}
301608203fdSJohn Baldwin 		do {
302608203fdSJohn Baldwin 			len += len / 10;
303608203fdSJohn Baldwin 			p = reallocf(p, len);
3040daf62d9SStanislav Sedov 			if (p == NULL) {
305608203fdSJohn Baldwin 				warnx("reallocf(%zu)", len);
3060daf62d9SStanislav Sedov 				goto fail;
3070daf62d9SStanislav Sedov 			}
308608203fdSJohn Baldwin 			olen = len;
30975b6a179SEnji Cooper 			error = sysctl(name, nitems(name), p, &len, NULL, 0);
310608203fdSJohn Baldwin 		} while (error < 0 && errno == ENOMEM && olen == len);
3110daf62d9SStanislav Sedov 		if (error < 0 && errno != EPERM) {
3120daf62d9SStanislav Sedov 			warn("sysctl(kern.proc)");
3130daf62d9SStanislav Sedov 			goto fail;
3140daf62d9SStanislav Sedov 		}
3150daf62d9SStanislav Sedov 		/* Perform simple consistency checks. */
3160daf62d9SStanislav Sedov 		if ((len % sizeof(*p)) != 0 || p->ki_structsize != sizeof(*p)) {
3177153ad2bSMikolaj Golub 			warnx("kinfo_proc structure size mismatch (len = %zu)", len);
3187153ad2bSMikolaj Golub 			goto fail;
3197153ad2bSMikolaj Golub 		}
3207153ad2bSMikolaj Golub 		*count = len / sizeof(*p);
3217153ad2bSMikolaj Golub 		return (p);
3227153ad2bSMikolaj Golub 	} else if (procstat->type == PROCSTAT_CORE) {
3237153ad2bSMikolaj Golub 		p = procstat_core_get(procstat->core, PSC_TYPE_PROC, NULL,
3247153ad2bSMikolaj Golub 		    &len);
3257153ad2bSMikolaj Golub 		if ((len % sizeof(*p)) != 0 || p->ki_structsize != sizeof(*p)) {
3260daf62d9SStanislav Sedov 			warnx("kinfo_proc structure size mismatch");
3270daf62d9SStanislav Sedov 			goto fail;
3280daf62d9SStanislav Sedov 		}
3290daf62d9SStanislav Sedov 		*count = len / sizeof(*p);
3300daf62d9SStanislav Sedov 		return (p);
3310daf62d9SStanislav Sedov 	} else {
33280905c35SJilles Tjoelker 		warnx("unknown access method: %d", procstat->type);
3330daf62d9SStanislav Sedov 		return (NULL);
3340daf62d9SStanislav Sedov 	}
3350daf62d9SStanislav Sedov fail:
3360daf62d9SStanislav Sedov 	if (p)
3370daf62d9SStanislav Sedov 		free(p);
3380daf62d9SStanislav Sedov 	return (NULL);
3390daf62d9SStanislav Sedov }
3400daf62d9SStanislav Sedov 
3410daf62d9SStanislav Sedov void
3420daf62d9SStanislav Sedov procstat_freeprocs(struct procstat *procstat __unused, struct kinfo_proc *p)
3430daf62d9SStanislav Sedov {
3440daf62d9SStanislav Sedov 
3450daf62d9SStanislav Sedov 	if (p != NULL)
3460daf62d9SStanislav Sedov 		free(p);
3470daf62d9SStanislav Sedov 	p = NULL;
3480daf62d9SStanislav Sedov }
3490daf62d9SStanislav Sedov 
3500daf62d9SStanislav Sedov struct filestat_list *
3510daf62d9SStanislav Sedov procstat_getfiles(struct procstat *procstat, struct kinfo_proc *kp, int mmapped)
3520daf62d9SStanislav Sedov {
3530daf62d9SStanislav Sedov 
3547153ad2bSMikolaj Golub 	switch(procstat->type) {
3557153ad2bSMikolaj Golub 	case PROCSTAT_KVM:
3560daf62d9SStanislav Sedov 		return (procstat_getfiles_kvm(procstat, kp, mmapped));
3577153ad2bSMikolaj Golub 	case PROCSTAT_SYSCTL:
3587153ad2bSMikolaj Golub 	case PROCSTAT_CORE:
3597153ad2bSMikolaj Golub 		return (procstat_getfiles_sysctl(procstat, kp, mmapped));
3607153ad2bSMikolaj Golub 	default:
3617153ad2bSMikolaj Golub 		warnx("unknown access method: %d", procstat->type);
3620daf62d9SStanislav Sedov 		return (NULL);
3630daf62d9SStanislav Sedov 	}
3647153ad2bSMikolaj Golub }
3650daf62d9SStanislav Sedov 
3660daf62d9SStanislav Sedov void
3670daf62d9SStanislav Sedov procstat_freefiles(struct procstat *procstat, struct filestat_list *head)
3680daf62d9SStanislav Sedov {
3690daf62d9SStanislav Sedov 	struct filestat *fst, *tmp;
3700daf62d9SStanislav Sedov 
3710daf62d9SStanislav Sedov 	STAILQ_FOREACH_SAFE(fst, head, next, tmp) {
3720daf62d9SStanislav Sedov 		if (fst->fs_path != NULL)
3730daf62d9SStanislav Sedov 			free(fst->fs_path);
3740daf62d9SStanislav Sedov 		free(fst);
3750daf62d9SStanislav Sedov 	}
3760daf62d9SStanislav Sedov 	free(head);
3770daf62d9SStanislav Sedov 	if (procstat->vmentries != NULL) {
3780daf62d9SStanislav Sedov 		free(procstat->vmentries);
3790daf62d9SStanislav Sedov 		procstat->vmentries = NULL;
3800daf62d9SStanislav Sedov 	}
3810daf62d9SStanislav Sedov 	if (procstat->files != NULL) {
3820daf62d9SStanislav Sedov 		free(procstat->files);
3830daf62d9SStanislav Sedov 		procstat->files = NULL;
3840daf62d9SStanislav Sedov 	}
3850daf62d9SStanislav Sedov }
3860daf62d9SStanislav Sedov 
3870daf62d9SStanislav Sedov static struct filestat *
3880daf62d9SStanislav Sedov filestat_new_entry(void *typedep, int type, int fd, int fflags, int uflags,
3897008be5bSPawel Jakub Dawidek     int refcount, off_t offset, char *path, cap_rights_t *cap_rightsp)
3900daf62d9SStanislav Sedov {
3910daf62d9SStanislav Sedov 	struct filestat *entry;
3920daf62d9SStanislav Sedov 
3930daf62d9SStanislav Sedov 	entry = calloc(1, sizeof(*entry));
3940daf62d9SStanislav Sedov 	if (entry == NULL) {
3950daf62d9SStanislav Sedov 		warn("malloc()");
3960daf62d9SStanislav Sedov 		return (NULL);
3970daf62d9SStanislav Sedov 	}
3980daf62d9SStanislav Sedov 	entry->fs_typedep = typedep;
3990daf62d9SStanislav Sedov 	entry->fs_fflags = fflags;
4000daf62d9SStanislav Sedov 	entry->fs_uflags = uflags;
4010daf62d9SStanislav Sedov 	entry->fs_fd = fd;
4020daf62d9SStanislav Sedov 	entry->fs_type = type;
4030daf62d9SStanislav Sedov 	entry->fs_ref_count = refcount;
4040daf62d9SStanislav Sedov 	entry->fs_offset = offset;
4050daf62d9SStanislav Sedov 	entry->fs_path = path;
406772f6645SPawel Jakub Dawidek 	if (cap_rightsp != NULL)
4077008be5bSPawel Jakub Dawidek 		entry->fs_cap_rights = *cap_rightsp;
408772f6645SPawel Jakub Dawidek 	else
409772f6645SPawel Jakub Dawidek 		cap_rights_init(&entry->fs_cap_rights);
4100daf62d9SStanislav Sedov 	return (entry);
4110daf62d9SStanislav Sedov }
4120daf62d9SStanislav Sedov 
4130daf62d9SStanislav Sedov static struct vnode *
4140daf62d9SStanislav Sedov getctty(kvm_t *kd, struct kinfo_proc *kp)
4150daf62d9SStanislav Sedov {
4160daf62d9SStanislav Sedov 	struct pgrp pgrp;
4170daf62d9SStanislav Sedov 	struct proc proc;
4180daf62d9SStanislav Sedov 	struct session sess;
4190daf62d9SStanislav Sedov 	int error;
4200daf62d9SStanislav Sedov 
4210daf62d9SStanislav Sedov 	assert(kp);
4220daf62d9SStanislav Sedov 	error = kvm_read_all(kd, (unsigned long)kp->ki_paddr, &proc,
4230daf62d9SStanislav Sedov 	    sizeof(proc));
4240daf62d9SStanislav Sedov 	if (error == 0) {
4250daf62d9SStanislav Sedov 		warnx("can't read proc struct at %p for pid %d",
4260daf62d9SStanislav Sedov 		    kp->ki_paddr, kp->ki_pid);
4270daf62d9SStanislav Sedov 		return (NULL);
4280daf62d9SStanislav Sedov 	}
4290daf62d9SStanislav Sedov 	if (proc.p_pgrp == NULL)
4300daf62d9SStanislav Sedov 		return (NULL);
4310daf62d9SStanislav Sedov 	error = kvm_read_all(kd, (unsigned long)proc.p_pgrp, &pgrp,
4320daf62d9SStanislav Sedov 	    sizeof(pgrp));
4330daf62d9SStanislav Sedov 	if (error == 0) {
4340daf62d9SStanislav Sedov 		warnx("can't read pgrp struct at %p for pid %d",
4350daf62d9SStanislav Sedov 		    proc.p_pgrp, kp->ki_pid);
4360daf62d9SStanislav Sedov 		return (NULL);
4370daf62d9SStanislav Sedov 	}
4380daf62d9SStanislav Sedov 	error = kvm_read_all(kd, (unsigned long)pgrp.pg_session, &sess,
4390daf62d9SStanislav Sedov 	    sizeof(sess));
4400daf62d9SStanislav Sedov 	if (error == 0) {
4410daf62d9SStanislav Sedov 		warnx("can't read session struct at %p for pid %d",
4420daf62d9SStanislav Sedov 		    pgrp.pg_session, kp->ki_pid);
4430daf62d9SStanislav Sedov 		return (NULL);
4440daf62d9SStanislav Sedov 	}
4450daf62d9SStanislav Sedov 	return (sess.s_ttyvp);
4460daf62d9SStanislav Sedov }
4470daf62d9SStanislav Sedov 
4488b75b1adSDoug Moore static int
4498b75b1adSDoug Moore procstat_vm_map_reader(void *token, vm_map_entry_t addr, vm_map_entry_t dest)
4508b75b1adSDoug Moore {
4518b75b1adSDoug Moore 	kvm_t *kd;
4528b75b1adSDoug Moore 
4538b75b1adSDoug Moore 	kd = (kvm_t *)token;
4548b75b1adSDoug Moore 	return (kvm_read_all(kd, (unsigned long)addr, dest, sizeof(*dest)));
4558b75b1adSDoug Moore }
4568b75b1adSDoug Moore 
4570daf62d9SStanislav Sedov static struct filestat_list *
4580daf62d9SStanislav Sedov procstat_getfiles_kvm(struct procstat *procstat, struct kinfo_proc *kp, int mmapped)
4590daf62d9SStanislav Sedov {
4600daf62d9SStanislav Sedov 	struct file file;
4610daf62d9SStanislav Sedov 	struct filedesc filed;
462*f1221c59SMateusz Guzik 	struct fdescenttbl *fdt;
4638d03b99bSMateusz Guzik 	struct pwd pwd;
464d2222aa0SMateusz Guzik 	unsigned long pwd_addr;
4650daf62d9SStanislav Sedov 	struct vm_map_entry vmentry;
4660daf62d9SStanislav Sedov 	struct vm_object object;
4670daf62d9SStanislav Sedov 	struct vmspace vmspace;
4680daf62d9SStanislav Sedov 	vm_map_entry_t entryp;
4690daf62d9SStanislav Sedov 	vm_object_t objp;
4700daf62d9SStanislav Sedov 	struct vnode *vp;
4710daf62d9SStanislav Sedov 	struct filestat *entry;
4720daf62d9SStanislav Sedov 	struct filestat_list *head;
4730daf62d9SStanislav Sedov 	kvm_t *kd;
4740daf62d9SStanislav Sedov 	void *data;
475*f1221c59SMateusz Guzik 	int fflags;
476*f1221c59SMateusz Guzik 	unsigned int i;
4770daf62d9SStanislav Sedov 	int prot, type;
478*f1221c59SMateusz Guzik 	size_t fdt_size;
4790daf62d9SStanislav Sedov 	unsigned int nfiles;
4808d03b99bSMateusz Guzik 	bool haspwd;
4810daf62d9SStanislav Sedov 
4820daf62d9SStanislav Sedov 	assert(procstat);
4830daf62d9SStanislav Sedov 	kd = procstat->kd;
4840daf62d9SStanislav Sedov 	if (kd == NULL)
4850daf62d9SStanislav Sedov 		return (NULL);
4860daf62d9SStanislav Sedov 	if (kp->ki_fd == NULL)
4870daf62d9SStanislav Sedov 		return (NULL);
4880daf62d9SStanislav Sedov 	if (!kvm_read_all(kd, (unsigned long)kp->ki_fd, &filed,
4890daf62d9SStanislav Sedov 	    sizeof(filed))) {
4900daf62d9SStanislav Sedov 		warnx("can't read filedesc at %p", (void *)kp->ki_fd);
4910daf62d9SStanislav Sedov 		return (NULL);
4920daf62d9SStanislav Sedov 	}
4938d03b99bSMateusz Guzik 	haspwd = false;
494d2222aa0SMateusz Guzik 	pwd_addr = (unsigned long)(FILEDESC_KVM_LOAD_PWD(&filed));
495d2222aa0SMateusz Guzik 	if (pwd_addr != 0) {
496d2222aa0SMateusz Guzik 		if (!kvm_read_all(kd, pwd_addr, &pwd, sizeof(pwd))) {
497d2222aa0SMateusz Guzik 			warnx("can't read fd_pwd at %p", (void *)pwd_addr);
4988d03b99bSMateusz Guzik 			return (NULL);
4998d03b99bSMateusz Guzik 		}
5008d03b99bSMateusz Guzik 		haspwd = true;
5018d03b99bSMateusz Guzik 	}
5020daf62d9SStanislav Sedov 
5030daf62d9SStanislav Sedov 	/*
5040daf62d9SStanislav Sedov 	 * Allocate list head.
5050daf62d9SStanislav Sedov 	 */
5060daf62d9SStanislav Sedov 	head = malloc(sizeof(*head));
5070daf62d9SStanislav Sedov 	if (head == NULL)
5080daf62d9SStanislav Sedov 		return (NULL);
5090daf62d9SStanislav Sedov 	STAILQ_INIT(head);
5100daf62d9SStanislav Sedov 
5110daf62d9SStanislav Sedov 	/* root directory vnode, if one. */
5128d03b99bSMateusz Guzik 	if (haspwd) {
5138d03b99bSMateusz Guzik 		if (pwd.pwd_rdir) {
5148d03b99bSMateusz Guzik 			entry = filestat_new_entry(pwd.pwd_rdir, PS_FST_TYPE_VNODE, -1,
515772f6645SPawel Jakub Dawidek 			    PS_FST_FFLAG_READ, PS_FST_UFLAG_RDIR, 0, 0, NULL, NULL);
5160daf62d9SStanislav Sedov 			if (entry != NULL)
5170daf62d9SStanislav Sedov 				STAILQ_INSERT_TAIL(head, entry, next);
5180daf62d9SStanislav Sedov 		}
5190daf62d9SStanislav Sedov 		/* current working directory vnode. */
5208d03b99bSMateusz Guzik 		if (pwd.pwd_cdir) {
5218d03b99bSMateusz Guzik 			entry = filestat_new_entry(pwd.pwd_cdir, PS_FST_TYPE_VNODE, -1,
522772f6645SPawel Jakub Dawidek 			    PS_FST_FFLAG_READ, PS_FST_UFLAG_CDIR, 0, 0, NULL, NULL);
5230daf62d9SStanislav Sedov 			if (entry != NULL)
5240daf62d9SStanislav Sedov 				STAILQ_INSERT_TAIL(head, entry, next);
5250daf62d9SStanislav Sedov 		}
5260daf62d9SStanislav Sedov 		/* jail root, if any. */
5278d03b99bSMateusz Guzik 		if (pwd.pwd_jdir) {
5288d03b99bSMateusz Guzik 			entry = filestat_new_entry(pwd.pwd_jdir, PS_FST_TYPE_VNODE, -1,
529772f6645SPawel Jakub Dawidek 			    PS_FST_FFLAG_READ, PS_FST_UFLAG_JAIL, 0, 0, NULL, NULL);
5300daf62d9SStanislav Sedov 			if (entry != NULL)
5310daf62d9SStanislav Sedov 				STAILQ_INSERT_TAIL(head, entry, next);
5320daf62d9SStanislav Sedov 		}
5338d03b99bSMateusz Guzik 	}
5340daf62d9SStanislav Sedov 	/* ktrace vnode, if one */
5350daf62d9SStanislav Sedov 	if (kp->ki_tracep) {
5360daf62d9SStanislav Sedov 		entry = filestat_new_entry(kp->ki_tracep, PS_FST_TYPE_VNODE, -1,
5370daf62d9SStanislav Sedov 		    PS_FST_FFLAG_READ | PS_FST_FFLAG_WRITE,
538772f6645SPawel Jakub Dawidek 		    PS_FST_UFLAG_TRACE, 0, 0, NULL, NULL);
5390daf62d9SStanislav Sedov 		if (entry != NULL)
5400daf62d9SStanislav Sedov 			STAILQ_INSERT_TAIL(head, entry, next);
5410daf62d9SStanislav Sedov 	}
5420daf62d9SStanislav Sedov 	/* text vnode, if one */
5430daf62d9SStanislav Sedov 	if (kp->ki_textvp) {
5440daf62d9SStanislav Sedov 		entry = filestat_new_entry(kp->ki_textvp, PS_FST_TYPE_VNODE, -1,
545772f6645SPawel Jakub Dawidek 		    PS_FST_FFLAG_READ, PS_FST_UFLAG_TEXT, 0, 0, NULL, NULL);
5460daf62d9SStanislav Sedov 		if (entry != NULL)
5470daf62d9SStanislav Sedov 			STAILQ_INSERT_TAIL(head, entry, next);
5480daf62d9SStanislav Sedov 	}
5490daf62d9SStanislav Sedov 	/* Controlling terminal. */
5500daf62d9SStanislav Sedov 	if ((vp = getctty(kd, kp)) != NULL) {
5510daf62d9SStanislav Sedov 		entry = filestat_new_entry(vp, PS_FST_TYPE_VNODE, -1,
5520daf62d9SStanislav Sedov 		    PS_FST_FFLAG_READ | PS_FST_FFLAG_WRITE,
553772f6645SPawel Jakub Dawidek 		    PS_FST_UFLAG_CTTY, 0, 0, NULL, NULL);
5540daf62d9SStanislav Sedov 		if (entry != NULL)
5550daf62d9SStanislav Sedov 			STAILQ_INSERT_TAIL(head, entry, next);
5560daf62d9SStanislav Sedov 	}
5570daf62d9SStanislav Sedov 
558*f1221c59SMateusz Guzik 	if (!kvm_read_all(kd, (unsigned long)filed.fd_files, &nfiles,
559*f1221c59SMateusz Guzik 	    sizeof(nfiles))) {
560*f1221c59SMateusz Guzik 		warnx("can't read fd_files at %p", (void *)filed.fd_files);
561*f1221c59SMateusz Guzik 		return (NULL);
562*f1221c59SMateusz Guzik 	}
563*f1221c59SMateusz Guzik 
564*f1221c59SMateusz Guzik 	fdt_size = sizeof(*fdt) + nfiles * sizeof(struct filedescent);
565*f1221c59SMateusz Guzik 	fdt = malloc(fdt_size);
566*f1221c59SMateusz Guzik 	if (fdt == NULL) {
567*f1221c59SMateusz Guzik 		warn("malloc(%zu)", fdt_size);
5680daf62d9SStanislav Sedov 		goto do_mmapped;
5690daf62d9SStanislav Sedov 	}
570*f1221c59SMateusz Guzik 	if (!kvm_read_all(kd, (unsigned long)filed.fd_files, fdt, fdt_size)) {
571*f1221c59SMateusz Guzik 		warnx("cannot read file structures at %p", (void *)filed.fd_files);
572*f1221c59SMateusz Guzik 		free(fdt);
5730daf62d9SStanislav Sedov 		goto do_mmapped;
5740daf62d9SStanislav Sedov 	}
575*f1221c59SMateusz Guzik 	for (i = 0; i < nfiles; i++) {
576*f1221c59SMateusz Guzik 		if (fdt->fdt_ofiles[i].fde_file == NULL) {
5770daf62d9SStanislav Sedov 			continue;
578*f1221c59SMateusz Guzik 		}
579*f1221c59SMateusz Guzik 		if (!kvm_read_all(kd, (unsigned long)fdt->fdt_ofiles[i].fde_file, &file,
5800daf62d9SStanislav Sedov 		    sizeof(struct file))) {
5810daf62d9SStanislav Sedov 			warnx("can't read file %d at %p", i,
582*f1221c59SMateusz Guzik 			    (void *)fdt->fdt_ofiles[i].fde_file);
5830daf62d9SStanislav Sedov 			continue;
5840daf62d9SStanislav Sedov 		}
5850daf62d9SStanislav Sedov 		switch (file.f_type) {
5860daf62d9SStanislav Sedov 		case DTYPE_VNODE:
5870daf62d9SStanislav Sedov 			type = PS_FST_TYPE_VNODE;
5880daf62d9SStanislav Sedov 			data = file.f_vnode;
5890daf62d9SStanislav Sedov 			break;
5900daf62d9SStanislav Sedov 		case DTYPE_SOCKET:
5910daf62d9SStanislav Sedov 			type = PS_FST_TYPE_SOCKET;
5920daf62d9SStanislav Sedov 			data = file.f_data;
5930daf62d9SStanislav Sedov 			break;
5940daf62d9SStanislav Sedov 		case DTYPE_PIPE:
5950daf62d9SStanislav Sedov 			type = PS_FST_TYPE_PIPE;
5960daf62d9SStanislav Sedov 			data = file.f_data;
5970daf62d9SStanislav Sedov 			break;
5980daf62d9SStanislav Sedov 		case DTYPE_FIFO:
5990daf62d9SStanislav Sedov 			type = PS_FST_TYPE_FIFO;
6000daf62d9SStanislav Sedov 			data = file.f_vnode;
6010daf62d9SStanislav Sedov 			break;
6020daf62d9SStanislav Sedov #ifdef DTYPE_PTS
6030daf62d9SStanislav Sedov 		case DTYPE_PTS:
6040daf62d9SStanislav Sedov 			type = PS_FST_TYPE_PTS;
6050daf62d9SStanislav Sedov 			data = file.f_data;
6060daf62d9SStanislav Sedov 			break;
6070daf62d9SStanislav Sedov #endif
608958aa575SJohn Baldwin 		case DTYPE_SEM:
609958aa575SJohn Baldwin 			type = PS_FST_TYPE_SEM;
610958aa575SJohn Baldwin 			data = file.f_data;
611958aa575SJohn Baldwin 			break;
612e506e182SJohn Baldwin 		case DTYPE_SHM:
613e506e182SJohn Baldwin 			type = PS_FST_TYPE_SHM;
614e506e182SJohn Baldwin 			data = file.f_data;
615e506e182SJohn Baldwin 			break;
6163cfa7c6eSEdward Tomasz Napierala 		case DTYPE_PROCDESC:
6173cfa7c6eSEdward Tomasz Napierala 			type = PS_FST_TYPE_PROCDESC;
6183cfa7c6eSEdward Tomasz Napierala 			data = file.f_data;
6193cfa7c6eSEdward Tomasz Napierala 			break;
620a66732deSKonstantin Belousov 		case DTYPE_DEV:
621a66732deSKonstantin Belousov 			type = PS_FST_TYPE_DEV;
622a66732deSKonstantin Belousov 			data = file.f_data;
623a66732deSKonstantin Belousov 			break;
6240daf62d9SStanislav Sedov 		default:
6250daf62d9SStanislav Sedov 			continue;
6260daf62d9SStanislav Sedov 		}
627d57486e2SRobert Watson 		/* XXXRW: No capability rights support for kvm yet. */
6280daf62d9SStanislav Sedov 		entry = filestat_new_entry(data, type, i,
629772f6645SPawel Jakub Dawidek 		    to_filestat_flags(file.f_flag), 0, 0, 0, NULL, NULL);
6300daf62d9SStanislav Sedov 		if (entry != NULL)
6310daf62d9SStanislav Sedov 			STAILQ_INSERT_TAIL(head, entry, next);
6320daf62d9SStanislav Sedov 	}
633*f1221c59SMateusz Guzik 	free(fdt);
6340daf62d9SStanislav Sedov 
6350daf62d9SStanislav Sedov do_mmapped:
6360daf62d9SStanislav Sedov 
6370daf62d9SStanislav Sedov 	/*
6380daf62d9SStanislav Sedov 	 * Process mmapped files if requested.
6390daf62d9SStanislav Sedov 	 */
6400daf62d9SStanislav Sedov 	if (mmapped) {
6410daf62d9SStanislav Sedov 		if (!kvm_read_all(kd, (unsigned long)kp->ki_vmspace, &vmspace,
6420daf62d9SStanislav Sedov 		    sizeof(vmspace))) {
6430daf62d9SStanislav Sedov 			warnx("can't read vmspace at %p",
6440daf62d9SStanislav Sedov 			    (void *)kp->ki_vmspace);
6450daf62d9SStanislav Sedov 			goto exit;
6460daf62d9SStanislav Sedov 		}
6470daf62d9SStanislav Sedov 
6488b75b1adSDoug Moore 		vmentry = vmspace.vm_map.header;
6498b75b1adSDoug Moore 		for (entryp = vm_map_entry_read_succ(kd, &vmentry, procstat_vm_map_reader);
6508b75b1adSDoug Moore 		    entryp != NULL && entryp != &kp->ki_vmspace->vm_map.header;
6518b75b1adSDoug Moore 		     entryp = vm_map_entry_read_succ(kd, &vmentry, procstat_vm_map_reader)) {
6520daf62d9SStanislav Sedov 			if (vmentry.eflags & MAP_ENTRY_IS_SUB_MAP)
6530daf62d9SStanislav Sedov 				continue;
6540daf62d9SStanislav Sedov 			if ((objp = vmentry.object.vm_object) == NULL)
6550daf62d9SStanislav Sedov 				continue;
6560daf62d9SStanislav Sedov 			for (; objp; objp = object.backing_object) {
6570daf62d9SStanislav Sedov 				if (!kvm_read_all(kd, (unsigned long)objp,
6580daf62d9SStanislav Sedov 				    &object, sizeof(object))) {
6590daf62d9SStanislav Sedov 					warnx("can't read vm_object at %p",
6600daf62d9SStanislav Sedov 					    (void *)objp);
6610daf62d9SStanislav Sedov 					break;
6620daf62d9SStanislav Sedov 				}
6630daf62d9SStanislav Sedov 			}
6640daf62d9SStanislav Sedov 
6650daf62d9SStanislav Sedov 			/* We want only vnode objects. */
6660daf62d9SStanislav Sedov 			if (object.type != OBJT_VNODE)
6670daf62d9SStanislav Sedov 				continue;
6680daf62d9SStanislav Sedov 
6690daf62d9SStanislav Sedov 			prot = vmentry.protection;
6700daf62d9SStanislav Sedov 			fflags = 0;
6710daf62d9SStanislav Sedov 			if (prot & VM_PROT_READ)
6720daf62d9SStanislav Sedov 				fflags = PS_FST_FFLAG_READ;
673279a233dSJilles Tjoelker 			if ((vmentry.eflags & MAP_ENTRY_COW) == 0 &&
674279a233dSJilles Tjoelker 			    prot & VM_PROT_WRITE)
6750daf62d9SStanislav Sedov 				fflags |= PS_FST_FFLAG_WRITE;
6760daf62d9SStanislav Sedov 
6770daf62d9SStanislav Sedov 			/*
6780daf62d9SStanislav Sedov 			 * Create filestat entry.
6790daf62d9SStanislav Sedov 			 */
6800daf62d9SStanislav Sedov 			entry = filestat_new_entry(object.handle,
6810daf62d9SStanislav Sedov 			    PS_FST_TYPE_VNODE, -1, fflags,
682772f6645SPawel Jakub Dawidek 			    PS_FST_UFLAG_MMAP, 0, 0, NULL, NULL);
6830daf62d9SStanislav Sedov 			if (entry != NULL)
6840daf62d9SStanislav Sedov 				STAILQ_INSERT_TAIL(head, entry, next);
6850daf62d9SStanislav Sedov 		}
6868b75b1adSDoug Moore 		if (entryp == NULL)
6878b75b1adSDoug Moore 			warnx("can't read vm_map_entry");
6880daf62d9SStanislav Sedov 	}
6890daf62d9SStanislav Sedov exit:
6900daf62d9SStanislav Sedov 	return (head);
6910daf62d9SStanislav Sedov }
6920daf62d9SStanislav Sedov 
6930daf62d9SStanislav Sedov /*
6940daf62d9SStanislav Sedov  * kinfo types to filestat translation.
6950daf62d9SStanislav Sedov  */
6960daf62d9SStanislav Sedov static int
6970daf62d9SStanislav Sedov kinfo_type2fst(int kftype)
6980daf62d9SStanislav Sedov {
6990daf62d9SStanislav Sedov 	static struct {
7000daf62d9SStanislav Sedov 		int	kf_type;
7010daf62d9SStanislav Sedov 		int	fst_type;
7020daf62d9SStanislav Sedov 	} kftypes2fst[] = {
7033cfa7c6eSEdward Tomasz Napierala 		{ KF_TYPE_PROCDESC, PS_FST_TYPE_PROCDESC },
7040daf62d9SStanislav Sedov 		{ KF_TYPE_CRYPTO, PS_FST_TYPE_CRYPTO },
705a66732deSKonstantin Belousov 		{ KF_TYPE_DEV, PS_FST_TYPE_DEV },
7060daf62d9SStanislav Sedov 		{ KF_TYPE_FIFO, PS_FST_TYPE_FIFO },
7070daf62d9SStanislav Sedov 		{ KF_TYPE_KQUEUE, PS_FST_TYPE_KQUEUE },
7080daf62d9SStanislav Sedov 		{ KF_TYPE_MQUEUE, PS_FST_TYPE_MQUEUE },
7090daf62d9SStanislav Sedov 		{ KF_TYPE_NONE, PS_FST_TYPE_NONE },
7100daf62d9SStanislav Sedov 		{ KF_TYPE_PIPE, PS_FST_TYPE_PIPE },
7110daf62d9SStanislav Sedov 		{ KF_TYPE_PTS, PS_FST_TYPE_PTS },
7120daf62d9SStanislav Sedov 		{ KF_TYPE_SEM, PS_FST_TYPE_SEM },
7130daf62d9SStanislav Sedov 		{ KF_TYPE_SHM, PS_FST_TYPE_SHM },
7140daf62d9SStanislav Sedov 		{ KF_TYPE_SOCKET, PS_FST_TYPE_SOCKET },
7150daf62d9SStanislav Sedov 		{ KF_TYPE_VNODE, PS_FST_TYPE_VNODE },
7160daf62d9SStanislav Sedov 		{ KF_TYPE_UNKNOWN, PS_FST_TYPE_UNKNOWN }
7170daf62d9SStanislav Sedov 	};
7180daf62d9SStanislav Sedov #define NKFTYPES	(sizeof(kftypes2fst) / sizeof(*kftypes2fst))
7190daf62d9SStanislav Sedov 	unsigned int i;
7200daf62d9SStanislav Sedov 
7210daf62d9SStanislav Sedov 	for (i = 0; i < NKFTYPES; i++)
7220daf62d9SStanislav Sedov 		if (kftypes2fst[i].kf_type == kftype)
7230daf62d9SStanislav Sedov 			break;
7240daf62d9SStanislav Sedov 	if (i == NKFTYPES)
7250daf62d9SStanislav Sedov 		return (PS_FST_TYPE_UNKNOWN);
7260daf62d9SStanislav Sedov 	return (kftypes2fst[i].fst_type);
7270daf62d9SStanislav Sedov }
7280daf62d9SStanislav Sedov 
7290daf62d9SStanislav Sedov /*
7300daf62d9SStanislav Sedov  * kinfo flags to filestat translation.
7310daf62d9SStanislav Sedov  */
7320daf62d9SStanislav Sedov static int
7330daf62d9SStanislav Sedov kinfo_fflags2fst(int kfflags)
7340daf62d9SStanislav Sedov {
7350daf62d9SStanislav Sedov 	static struct {
7360daf62d9SStanislav Sedov 		int	kf_flag;
7370daf62d9SStanislav Sedov 		int	fst_flag;
7380daf62d9SStanislav Sedov 	} kfflags2fst[] = {
7390daf62d9SStanislav Sedov 		{ KF_FLAG_APPEND, PS_FST_FFLAG_APPEND },
7400daf62d9SStanislav Sedov 		{ KF_FLAG_ASYNC, PS_FST_FFLAG_ASYNC },
7410daf62d9SStanislav Sedov 		{ KF_FLAG_CREAT, PS_FST_FFLAG_CREAT },
7420daf62d9SStanislav Sedov 		{ KF_FLAG_DIRECT, PS_FST_FFLAG_DIRECT },
7430daf62d9SStanislav Sedov 		{ KF_FLAG_EXCL, PS_FST_FFLAG_EXCL },
7440daf62d9SStanislav Sedov 		{ KF_FLAG_EXEC, PS_FST_FFLAG_EXEC },
7450daf62d9SStanislav Sedov 		{ KF_FLAG_EXLOCK, PS_FST_FFLAG_EXLOCK },
7460daf62d9SStanislav Sedov 		{ KF_FLAG_FSYNC, PS_FST_FFLAG_SYNC },
7470daf62d9SStanislav Sedov 		{ KF_FLAG_HASLOCK, PS_FST_FFLAG_HASLOCK },
7480daf62d9SStanislav Sedov 		{ KF_FLAG_NOFOLLOW, PS_FST_FFLAG_NOFOLLOW },
7490daf62d9SStanislav Sedov 		{ KF_FLAG_NONBLOCK, PS_FST_FFLAG_NONBLOCK },
7500daf62d9SStanislav Sedov 		{ KF_FLAG_READ, PS_FST_FFLAG_READ },
7510daf62d9SStanislav Sedov 		{ KF_FLAG_SHLOCK, PS_FST_FFLAG_SHLOCK },
7520daf62d9SStanislav Sedov 		{ KF_FLAG_TRUNC, PS_FST_FFLAG_TRUNC },
7530daf62d9SStanislav Sedov 		{ KF_FLAG_WRITE, PS_FST_FFLAG_WRITE }
7540daf62d9SStanislav Sedov 	};
7550daf62d9SStanislav Sedov #define NKFFLAGS	(sizeof(kfflags2fst) / sizeof(*kfflags2fst))
7560daf62d9SStanislav Sedov 	unsigned int i;
7570daf62d9SStanislav Sedov 	int flags;
7580daf62d9SStanislav Sedov 
7590daf62d9SStanislav Sedov 	flags = 0;
7600daf62d9SStanislav Sedov 	for (i = 0; i < NKFFLAGS; i++)
7610daf62d9SStanislav Sedov 		if ((kfflags & kfflags2fst[i].kf_flag) != 0)
7620daf62d9SStanislav Sedov 			flags |= kfflags2fst[i].fst_flag;
7630daf62d9SStanislav Sedov 	return (flags);
7640daf62d9SStanislav Sedov }
7650daf62d9SStanislav Sedov 
7660daf62d9SStanislav Sedov static int
7670daf62d9SStanislav Sedov kinfo_uflags2fst(int fd)
7680daf62d9SStanislav Sedov {
7690daf62d9SStanislav Sedov 
7700daf62d9SStanislav Sedov 	switch (fd) {
7710daf62d9SStanislav Sedov 	case KF_FD_TYPE_CTTY:
7720daf62d9SStanislav Sedov 		return (PS_FST_UFLAG_CTTY);
7730daf62d9SStanislav Sedov 	case KF_FD_TYPE_CWD:
7740daf62d9SStanislav Sedov 		return (PS_FST_UFLAG_CDIR);
7750daf62d9SStanislav Sedov 	case KF_FD_TYPE_JAIL:
7760daf62d9SStanislav Sedov 		return (PS_FST_UFLAG_JAIL);
7770daf62d9SStanislav Sedov 	case KF_FD_TYPE_TEXT:
7780daf62d9SStanislav Sedov 		return (PS_FST_UFLAG_TEXT);
7790daf62d9SStanislav Sedov 	case KF_FD_TYPE_TRACE:
7800daf62d9SStanislav Sedov 		return (PS_FST_UFLAG_TRACE);
7810daf62d9SStanislav Sedov 	case KF_FD_TYPE_ROOT:
7820daf62d9SStanislav Sedov 		return (PS_FST_UFLAG_RDIR);
7830daf62d9SStanislav Sedov 	}
7840daf62d9SStanislav Sedov 	return (0);
7850daf62d9SStanislav Sedov }
7860daf62d9SStanislav Sedov 
7877153ad2bSMikolaj Golub static struct kinfo_file *
7887153ad2bSMikolaj Golub kinfo_getfile_core(struct procstat_core *core, int *cntp)
7897153ad2bSMikolaj Golub {
7907153ad2bSMikolaj Golub 	int cnt;
7917153ad2bSMikolaj Golub 	size_t len;
7927153ad2bSMikolaj Golub 	char *buf, *bp, *eb;
7937153ad2bSMikolaj Golub 	struct kinfo_file *kif, *kp, *kf;
7947153ad2bSMikolaj Golub 
7957153ad2bSMikolaj Golub 	buf = procstat_core_get(core, PSC_TYPE_FILES, NULL, &len);
7967153ad2bSMikolaj Golub 	if (buf == NULL)
7977153ad2bSMikolaj Golub 		return (NULL);
7987153ad2bSMikolaj Golub 	/*
7997153ad2bSMikolaj Golub 	 * XXXMG: The code below is just copy&past from libutil.
8007153ad2bSMikolaj Golub 	 * The code duplication can be avoided if libutil
8017153ad2bSMikolaj Golub 	 * is extended to provide something like:
8027153ad2bSMikolaj Golub 	 *   struct kinfo_file *kinfo_getfile_from_buf(const char *buf,
8037153ad2bSMikolaj Golub 	 *       size_t len, int *cntp);
8047153ad2bSMikolaj Golub 	 */
8057153ad2bSMikolaj Golub 
8067153ad2bSMikolaj Golub 	/* Pass 1: count items */
8077153ad2bSMikolaj Golub 	cnt = 0;
8087153ad2bSMikolaj Golub 	bp = buf;
8097153ad2bSMikolaj Golub 	eb = buf + len;
8107153ad2bSMikolaj Golub 	while (bp < eb) {
8117153ad2bSMikolaj Golub 		kf = (struct kinfo_file *)(uintptr_t)bp;
81214bdbaf2SConrad Meyer 		if (kf->kf_structsize == 0)
81314bdbaf2SConrad Meyer 			break;
8147153ad2bSMikolaj Golub 		bp += kf->kf_structsize;
8157153ad2bSMikolaj Golub 		cnt++;
8167153ad2bSMikolaj Golub 	}
8177153ad2bSMikolaj Golub 
8187153ad2bSMikolaj Golub 	kif = calloc(cnt, sizeof(*kif));
8197153ad2bSMikolaj Golub 	if (kif == NULL) {
8207153ad2bSMikolaj Golub 		free(buf);
8217153ad2bSMikolaj Golub 		return (NULL);
8227153ad2bSMikolaj Golub 	}
8237153ad2bSMikolaj Golub 	bp = buf;
8247153ad2bSMikolaj Golub 	eb = buf + len;
8257153ad2bSMikolaj Golub 	kp = kif;
8267153ad2bSMikolaj Golub 	/* Pass 2: unpack */
8277153ad2bSMikolaj Golub 	while (bp < eb) {
8287153ad2bSMikolaj Golub 		kf = (struct kinfo_file *)(uintptr_t)bp;
82914bdbaf2SConrad Meyer 		if (kf->kf_structsize == 0)
83014bdbaf2SConrad Meyer 			break;
8317153ad2bSMikolaj Golub 		/* Copy/expand into pre-zeroed buffer */
8327153ad2bSMikolaj Golub 		memcpy(kp, kf, kf->kf_structsize);
8337153ad2bSMikolaj Golub 		/* Advance to next packed record */
8347153ad2bSMikolaj Golub 		bp += kf->kf_structsize;
8357153ad2bSMikolaj Golub 		/* Set field size to fixed length, advance */
8367153ad2bSMikolaj Golub 		kp->kf_structsize = sizeof(*kp);
8377153ad2bSMikolaj Golub 		kp++;
8387153ad2bSMikolaj Golub 	}
8397153ad2bSMikolaj Golub 	free(buf);
8407153ad2bSMikolaj Golub 	*cntp = cnt;
8417153ad2bSMikolaj Golub 	return (kif);	/* Caller must free() return value */
8427153ad2bSMikolaj Golub }
8437153ad2bSMikolaj Golub 
8440daf62d9SStanislav Sedov static struct filestat_list *
8457153ad2bSMikolaj Golub procstat_getfiles_sysctl(struct procstat *procstat, struct kinfo_proc *kp,
8467153ad2bSMikolaj Golub     int mmapped)
8470daf62d9SStanislav Sedov {
8480daf62d9SStanislav Sedov 	struct kinfo_file *kif, *files;
8490daf62d9SStanislav Sedov 	struct kinfo_vmentry *kve, *vmentries;
8500daf62d9SStanislav Sedov 	struct filestat_list *head;
8510daf62d9SStanislav Sedov 	struct filestat *entry;
8520daf62d9SStanislav Sedov 	char *path;
8530daf62d9SStanislav Sedov 	off_t offset;
8540daf62d9SStanislav Sedov 	int cnt, fd, fflags;
8550daf62d9SStanislav Sedov 	int i, type, uflags;
8560daf62d9SStanislav Sedov 	int refcount;
857d57486e2SRobert Watson 	cap_rights_t cap_rights;
8580daf62d9SStanislav Sedov 
8590daf62d9SStanislav Sedov 	assert(kp);
8600daf62d9SStanislav Sedov 	if (kp->ki_fd == NULL)
8610daf62d9SStanislav Sedov 		return (NULL);
8627153ad2bSMikolaj Golub 	switch(procstat->type) {
8637153ad2bSMikolaj Golub 	case PROCSTAT_SYSCTL:
8640daf62d9SStanislav Sedov 		files = kinfo_getfile(kp->ki_pid, &cnt);
8657153ad2bSMikolaj Golub 		break;
8667153ad2bSMikolaj Golub 	case PROCSTAT_CORE:
8677153ad2bSMikolaj Golub 		files = kinfo_getfile_core(procstat->core, &cnt);
8687153ad2bSMikolaj Golub 		break;
8697153ad2bSMikolaj Golub 	default:
8707153ad2bSMikolaj Golub 		assert(!"invalid type");
8717153ad2bSMikolaj Golub 	}
8720daf62d9SStanislav Sedov 	if (files == NULL && errno != EPERM) {
8730daf62d9SStanislav Sedov 		warn("kinfo_getfile()");
8740daf62d9SStanislav Sedov 		return (NULL);
8750daf62d9SStanislav Sedov 	}
8760daf62d9SStanislav Sedov 	procstat->files = files;
8770daf62d9SStanislav Sedov 
8780daf62d9SStanislav Sedov 	/*
8790daf62d9SStanislav Sedov 	 * Allocate list head.
8800daf62d9SStanislav Sedov 	 */
8810daf62d9SStanislav Sedov 	head = malloc(sizeof(*head));
8820daf62d9SStanislav Sedov 	if (head == NULL)
8830daf62d9SStanislav Sedov 		return (NULL);
8840daf62d9SStanislav Sedov 	STAILQ_INIT(head);
8850daf62d9SStanislav Sedov 	for (i = 0; i < cnt; i++) {
8860daf62d9SStanislav Sedov 		kif = &files[i];
8870daf62d9SStanislav Sedov 
8880daf62d9SStanislav Sedov 		type = kinfo_type2fst(kif->kf_type);
8890daf62d9SStanislav Sedov 		fd = kif->kf_fd >= 0 ? kif->kf_fd : -1;
8900daf62d9SStanislav Sedov 		fflags = kinfo_fflags2fst(kif->kf_flags);
8910daf62d9SStanislav Sedov 		uflags = kinfo_uflags2fst(kif->kf_fd);
8920daf62d9SStanislav Sedov 		refcount = kif->kf_ref_count;
8930daf62d9SStanislav Sedov 		offset = kif->kf_offset;
8940daf62d9SStanislav Sedov 		if (*kif->kf_path != '\0')
8950daf62d9SStanislav Sedov 			path = strdup(kif->kf_path);
8960daf62d9SStanislav Sedov 		else
8970daf62d9SStanislav Sedov 			path = NULL;
898d57486e2SRobert Watson 		cap_rights = kif->kf_cap_rights;
8990daf62d9SStanislav Sedov 
9000daf62d9SStanislav Sedov 		/*
9010daf62d9SStanislav Sedov 		 * Create filestat entry.
9020daf62d9SStanislav Sedov 		 */
9030daf62d9SStanislav Sedov 		entry = filestat_new_entry(kif, type, fd, fflags, uflags,
9047008be5bSPawel Jakub Dawidek 		    refcount, offset, path, &cap_rights);
9050daf62d9SStanislav Sedov 		if (entry != NULL)
9060daf62d9SStanislav Sedov 			STAILQ_INSERT_TAIL(head, entry, next);
9070daf62d9SStanislav Sedov 	}
9080daf62d9SStanislav Sedov 	if (mmapped != 0) {
90939680c7bSMikolaj Golub 		vmentries = procstat_getvmmap(procstat, kp, &cnt);
9100daf62d9SStanislav Sedov 		procstat->vmentries = vmentries;
9110daf62d9SStanislav Sedov 		if (vmentries == NULL || cnt == 0)
9120daf62d9SStanislav Sedov 			goto fail;
9130daf62d9SStanislav Sedov 		for (i = 0; i < cnt; i++) {
9140daf62d9SStanislav Sedov 			kve = &vmentries[i];
9150daf62d9SStanislav Sedov 			if (kve->kve_type != KVME_TYPE_VNODE)
9160daf62d9SStanislav Sedov 				continue;
9170daf62d9SStanislav Sedov 			fflags = 0;
9180daf62d9SStanislav Sedov 			if (kve->kve_protection & KVME_PROT_READ)
9190daf62d9SStanislav Sedov 				fflags = PS_FST_FFLAG_READ;
920279a233dSJilles Tjoelker 			if ((kve->kve_flags & KVME_FLAG_COW) == 0 &&
921279a233dSJilles Tjoelker 			    kve->kve_protection & KVME_PROT_WRITE)
9220daf62d9SStanislav Sedov 				fflags |= PS_FST_FFLAG_WRITE;
9230daf62d9SStanislav Sedov 			offset = kve->kve_offset;
9240daf62d9SStanislav Sedov 			refcount = kve->kve_ref_count;
9250daf62d9SStanislav Sedov 			if (*kve->kve_path != '\0')
9260daf62d9SStanislav Sedov 				path = strdup(kve->kve_path);
9270daf62d9SStanislav Sedov 			else
9280daf62d9SStanislav Sedov 				path = NULL;
9290daf62d9SStanislav Sedov 			entry = filestat_new_entry(kve, PS_FST_TYPE_VNODE, -1,
930d57486e2SRobert Watson 			    fflags, PS_FST_UFLAG_MMAP, refcount, offset, path,
931772f6645SPawel Jakub Dawidek 			    NULL);
9320daf62d9SStanislav Sedov 			if (entry != NULL)
9330daf62d9SStanislav Sedov 				STAILQ_INSERT_TAIL(head, entry, next);
9340daf62d9SStanislav Sedov 		}
9350daf62d9SStanislav Sedov 	}
9360daf62d9SStanislav Sedov fail:
9370daf62d9SStanislav Sedov 	return (head);
9380daf62d9SStanislav Sedov }
9390daf62d9SStanislav Sedov 
9400daf62d9SStanislav Sedov int
9410daf62d9SStanislav Sedov procstat_get_pipe_info(struct procstat *procstat, struct filestat *fst,
9420daf62d9SStanislav Sedov     struct pipestat *ps, char *errbuf)
9430daf62d9SStanislav Sedov {
9440daf62d9SStanislav Sedov 
9450daf62d9SStanislav Sedov 	assert(ps);
9460daf62d9SStanislav Sedov 	if (procstat->type == PROCSTAT_KVM) {
9470daf62d9SStanislav Sedov 		return (procstat_get_pipe_info_kvm(procstat->kd, fst, ps,
9480daf62d9SStanislav Sedov 		    errbuf));
9497153ad2bSMikolaj Golub 	} else if (procstat->type == PROCSTAT_SYSCTL ||
9507153ad2bSMikolaj Golub 		procstat->type == PROCSTAT_CORE) {
9510daf62d9SStanislav Sedov 		return (procstat_get_pipe_info_sysctl(fst, ps, errbuf));
9520daf62d9SStanislav Sedov 	} else {
95380905c35SJilles Tjoelker 		warnx("unknown access method: %d", procstat->type);
954467112b4SMikolaj Golub 		if (errbuf != NULL)
9550daf62d9SStanislav Sedov 			snprintf(errbuf, _POSIX2_LINE_MAX, "error");
9560daf62d9SStanislav Sedov 		return (1);
9570daf62d9SStanislav Sedov 	}
9580daf62d9SStanislav Sedov }
9590daf62d9SStanislav Sedov 
9600daf62d9SStanislav Sedov static int
9610daf62d9SStanislav Sedov procstat_get_pipe_info_kvm(kvm_t *kd, struct filestat *fst,
9620daf62d9SStanislav Sedov     struct pipestat *ps, char *errbuf)
9630daf62d9SStanislav Sedov {
9640daf62d9SStanislav Sedov 	struct pipe pi;
9650daf62d9SStanislav Sedov 	void *pipep;
9660daf62d9SStanislav Sedov 
9670daf62d9SStanislav Sedov 	assert(kd);
9680daf62d9SStanislav Sedov 	assert(ps);
9690daf62d9SStanislav Sedov 	assert(fst);
9700daf62d9SStanislav Sedov 	bzero(ps, sizeof(*ps));
9710daf62d9SStanislav Sedov 	pipep = fst->fs_typedep;
9720daf62d9SStanislav Sedov 	if (pipep == NULL)
9730daf62d9SStanislav Sedov 		goto fail;
9740daf62d9SStanislav Sedov 	if (!kvm_read_all(kd, (unsigned long)pipep, &pi, sizeof(struct pipe))) {
9750daf62d9SStanislav Sedov 		warnx("can't read pipe at %p", (void *)pipep);
9760daf62d9SStanislav Sedov 		goto fail;
9770daf62d9SStanislav Sedov 	}
9780daf62d9SStanislav Sedov 	ps->addr = (uintptr_t)pipep;
9790daf62d9SStanislav Sedov 	ps->peer = (uintptr_t)pi.pipe_peer;
9800daf62d9SStanislav Sedov 	ps->buffer_cnt = pi.pipe_buffer.cnt;
9810daf62d9SStanislav Sedov 	return (0);
9820daf62d9SStanislav Sedov 
9830daf62d9SStanislav Sedov fail:
984467112b4SMikolaj Golub 	if (errbuf != NULL)
9850daf62d9SStanislav Sedov 		snprintf(errbuf, _POSIX2_LINE_MAX, "error");
9860daf62d9SStanislav Sedov 	return (1);
9870daf62d9SStanislav Sedov }
9880daf62d9SStanislav Sedov 
9890daf62d9SStanislav Sedov static int
9900daf62d9SStanislav Sedov procstat_get_pipe_info_sysctl(struct filestat *fst, struct pipestat *ps,
9910daf62d9SStanislav Sedov     char *errbuf __unused)
9920daf62d9SStanislav Sedov {
9930daf62d9SStanislav Sedov 	struct kinfo_file *kif;
9940daf62d9SStanislav Sedov 
9950daf62d9SStanislav Sedov 	assert(ps);
9960daf62d9SStanislav Sedov 	assert(fst);
9970daf62d9SStanislav Sedov 	bzero(ps, sizeof(*ps));
9980daf62d9SStanislav Sedov 	kif = fst->fs_typedep;
9990daf62d9SStanislav Sedov 	if (kif == NULL)
10000daf62d9SStanislav Sedov 		return (1);
10010daf62d9SStanislav Sedov 	ps->addr = kif->kf_un.kf_pipe.kf_pipe_addr;
10020daf62d9SStanislav Sedov 	ps->peer = kif->kf_un.kf_pipe.kf_pipe_peer;
10030daf62d9SStanislav Sedov 	ps->buffer_cnt = kif->kf_un.kf_pipe.kf_pipe_buffer_cnt;
10040daf62d9SStanislav Sedov 	return (0);
10050daf62d9SStanislav Sedov }
10060daf62d9SStanislav Sedov 
10070daf62d9SStanislav Sedov int
10080daf62d9SStanislav Sedov procstat_get_pts_info(struct procstat *procstat, struct filestat *fst,
10090daf62d9SStanislav Sedov     struct ptsstat *pts, char *errbuf)
10100daf62d9SStanislav Sedov {
10110daf62d9SStanislav Sedov 
10120daf62d9SStanislav Sedov 	assert(pts);
10130daf62d9SStanislav Sedov 	if (procstat->type == PROCSTAT_KVM) {
10140daf62d9SStanislav Sedov 		return (procstat_get_pts_info_kvm(procstat->kd, fst, pts,
10150daf62d9SStanislav Sedov 		    errbuf));
10167153ad2bSMikolaj Golub 	} else if (procstat->type == PROCSTAT_SYSCTL ||
10177153ad2bSMikolaj Golub 		procstat->type == PROCSTAT_CORE) {
10180daf62d9SStanislav Sedov 		return (procstat_get_pts_info_sysctl(fst, pts, errbuf));
10190daf62d9SStanislav Sedov 	} else {
102080905c35SJilles Tjoelker 		warnx("unknown access method: %d", procstat->type);
1021467112b4SMikolaj Golub 		if (errbuf != NULL)
10220daf62d9SStanislav Sedov 			snprintf(errbuf, _POSIX2_LINE_MAX, "error");
10230daf62d9SStanislav Sedov 		return (1);
10240daf62d9SStanislav Sedov 	}
10250daf62d9SStanislav Sedov }
10260daf62d9SStanislav Sedov 
10270daf62d9SStanislav Sedov static int
10280daf62d9SStanislav Sedov procstat_get_pts_info_kvm(kvm_t *kd, struct filestat *fst,
10290daf62d9SStanislav Sedov     struct ptsstat *pts, char *errbuf)
10300daf62d9SStanislav Sedov {
10310daf62d9SStanislav Sedov 	struct tty tty;
10320daf62d9SStanislav Sedov 	void *ttyp;
10330daf62d9SStanislav Sedov 
10340daf62d9SStanislav Sedov 	assert(kd);
10350daf62d9SStanislav Sedov 	assert(pts);
10360daf62d9SStanislav Sedov 	assert(fst);
10370daf62d9SStanislav Sedov 	bzero(pts, sizeof(*pts));
10380daf62d9SStanislav Sedov 	ttyp = fst->fs_typedep;
10390daf62d9SStanislav Sedov 	if (ttyp == NULL)
10400daf62d9SStanislav Sedov 		goto fail;
10410daf62d9SStanislav Sedov 	if (!kvm_read_all(kd, (unsigned long)ttyp, &tty, sizeof(struct tty))) {
10420daf62d9SStanislav Sedov 		warnx("can't read tty at %p", (void *)ttyp);
10430daf62d9SStanislav Sedov 		goto fail;
10440daf62d9SStanislav Sedov 	}
10450daf62d9SStanislav Sedov 	pts->dev = dev2udev(kd, tty.t_dev);
10460daf62d9SStanislav Sedov 	(void)kdevtoname(kd, tty.t_dev, pts->devname);
10470daf62d9SStanislav Sedov 	return (0);
10480daf62d9SStanislav Sedov 
10490daf62d9SStanislav Sedov fail:
1050467112b4SMikolaj Golub 	if (errbuf != NULL)
10510daf62d9SStanislav Sedov 		snprintf(errbuf, _POSIX2_LINE_MAX, "error");
10520daf62d9SStanislav Sedov 	return (1);
10530daf62d9SStanislav Sedov }
10540daf62d9SStanislav Sedov 
10550daf62d9SStanislav Sedov static int
10560daf62d9SStanislav Sedov procstat_get_pts_info_sysctl(struct filestat *fst, struct ptsstat *pts,
10570daf62d9SStanislav Sedov     char *errbuf __unused)
10580daf62d9SStanislav Sedov {
10590daf62d9SStanislav Sedov 	struct kinfo_file *kif;
10600daf62d9SStanislav Sedov 
10610daf62d9SStanislav Sedov 	assert(pts);
10620daf62d9SStanislav Sedov 	assert(fst);
10630daf62d9SStanislav Sedov 	bzero(pts, sizeof(*pts));
10640daf62d9SStanislav Sedov 	kif = fst->fs_typedep;
10650daf62d9SStanislav Sedov 	if (kif == NULL)
10660daf62d9SStanislav Sedov 		return (0);
10670daf62d9SStanislav Sedov 	pts->dev = kif->kf_un.kf_pts.kf_pts_dev;
10680daf62d9SStanislav Sedov 	strlcpy(pts->devname, kif->kf_path, sizeof(pts->devname));
10690daf62d9SStanislav Sedov 	return (0);
10700daf62d9SStanislav Sedov }
10710daf62d9SStanislav Sedov 
10720daf62d9SStanislav Sedov int
1073958aa575SJohn Baldwin procstat_get_sem_info(struct procstat *procstat, struct filestat *fst,
1074958aa575SJohn Baldwin     struct semstat *sem, char *errbuf)
1075958aa575SJohn Baldwin {
1076958aa575SJohn Baldwin 
1077958aa575SJohn Baldwin 	assert(sem);
1078958aa575SJohn Baldwin 	if (procstat->type == PROCSTAT_KVM) {
1079958aa575SJohn Baldwin 		return (procstat_get_sem_info_kvm(procstat->kd, fst, sem,
1080958aa575SJohn Baldwin 		    errbuf));
1081958aa575SJohn Baldwin 	} else if (procstat->type == PROCSTAT_SYSCTL ||
1082958aa575SJohn Baldwin 	    procstat->type == PROCSTAT_CORE) {
1083958aa575SJohn Baldwin 		return (procstat_get_sem_info_sysctl(fst, sem, errbuf));
1084958aa575SJohn Baldwin 	} else {
1085958aa575SJohn Baldwin 		warnx("unknown access method: %d", procstat->type);
1086467112b4SMikolaj Golub 		if (errbuf != NULL)
1087958aa575SJohn Baldwin 			snprintf(errbuf, _POSIX2_LINE_MAX, "error");
1088958aa575SJohn Baldwin 		return (1);
1089958aa575SJohn Baldwin 	}
1090958aa575SJohn Baldwin }
1091958aa575SJohn Baldwin 
1092958aa575SJohn Baldwin static int
1093958aa575SJohn Baldwin procstat_get_sem_info_kvm(kvm_t *kd, struct filestat *fst,
1094958aa575SJohn Baldwin     struct semstat *sem, char *errbuf)
1095958aa575SJohn Baldwin {
1096958aa575SJohn Baldwin 	struct ksem ksem;
1097958aa575SJohn Baldwin 	void *ksemp;
1098958aa575SJohn Baldwin 	char *path;
1099958aa575SJohn Baldwin 	int i;
1100958aa575SJohn Baldwin 
1101958aa575SJohn Baldwin 	assert(kd);
1102958aa575SJohn Baldwin 	assert(sem);
1103958aa575SJohn Baldwin 	assert(fst);
1104958aa575SJohn Baldwin 	bzero(sem, sizeof(*sem));
1105958aa575SJohn Baldwin 	ksemp = fst->fs_typedep;
1106958aa575SJohn Baldwin 	if (ksemp == NULL)
1107958aa575SJohn Baldwin 		goto fail;
1108958aa575SJohn Baldwin 	if (!kvm_read_all(kd, (unsigned long)ksemp, &ksem,
1109958aa575SJohn Baldwin 	    sizeof(struct ksem))) {
1110958aa575SJohn Baldwin 		warnx("can't read ksem at %p", (void *)ksemp);
1111958aa575SJohn Baldwin 		goto fail;
1112958aa575SJohn Baldwin 	}
1113958aa575SJohn Baldwin 	sem->mode = S_IFREG | ksem.ks_mode;
1114958aa575SJohn Baldwin 	sem->value = ksem.ks_value;
1115958aa575SJohn Baldwin 	if (fst->fs_path == NULL && ksem.ks_path != NULL) {
1116958aa575SJohn Baldwin 		path = malloc(MAXPATHLEN);
1117958aa575SJohn Baldwin 		for (i = 0; i < MAXPATHLEN - 1; i++) {
1118958aa575SJohn Baldwin 			if (!kvm_read_all(kd, (unsigned long)ksem.ks_path + i,
1119958aa575SJohn Baldwin 			    path + i, 1))
1120958aa575SJohn Baldwin 				break;
1121958aa575SJohn Baldwin 			if (path[i] == '\0')
1122958aa575SJohn Baldwin 				break;
1123958aa575SJohn Baldwin 		}
1124958aa575SJohn Baldwin 		path[i] = '\0';
1125958aa575SJohn Baldwin 		if (i == 0)
1126958aa575SJohn Baldwin 			free(path);
1127958aa575SJohn Baldwin 		else
1128958aa575SJohn Baldwin 			fst->fs_path = path;
1129958aa575SJohn Baldwin 	}
1130958aa575SJohn Baldwin 	return (0);
1131958aa575SJohn Baldwin 
1132958aa575SJohn Baldwin fail:
1133467112b4SMikolaj Golub 	if (errbuf != NULL)
1134958aa575SJohn Baldwin 		snprintf(errbuf, _POSIX2_LINE_MAX, "error");
1135958aa575SJohn Baldwin 	return (1);
1136958aa575SJohn Baldwin }
1137958aa575SJohn Baldwin 
1138958aa575SJohn Baldwin static int
1139958aa575SJohn Baldwin procstat_get_sem_info_sysctl(struct filestat *fst, struct semstat *sem,
1140958aa575SJohn Baldwin     char *errbuf __unused)
1141958aa575SJohn Baldwin {
1142958aa575SJohn Baldwin 	struct kinfo_file *kif;
1143958aa575SJohn Baldwin 
1144958aa575SJohn Baldwin 	assert(sem);
1145958aa575SJohn Baldwin 	assert(fst);
1146958aa575SJohn Baldwin 	bzero(sem, sizeof(*sem));
1147958aa575SJohn Baldwin 	kif = fst->fs_typedep;
1148958aa575SJohn Baldwin 	if (kif == NULL)
1149958aa575SJohn Baldwin 		return (0);
1150958aa575SJohn Baldwin 	sem->value = kif->kf_un.kf_sem.kf_sem_value;
1151958aa575SJohn Baldwin 	sem->mode = kif->kf_un.kf_sem.kf_sem_mode;
1152958aa575SJohn Baldwin 	return (0);
1153958aa575SJohn Baldwin }
1154958aa575SJohn Baldwin 
1155958aa575SJohn Baldwin int
1156e506e182SJohn Baldwin procstat_get_shm_info(struct procstat *procstat, struct filestat *fst,
1157e506e182SJohn Baldwin     struct shmstat *shm, char *errbuf)
1158e506e182SJohn Baldwin {
1159e506e182SJohn Baldwin 
1160e506e182SJohn Baldwin 	assert(shm);
1161e506e182SJohn Baldwin 	if (procstat->type == PROCSTAT_KVM) {
1162e506e182SJohn Baldwin 		return (procstat_get_shm_info_kvm(procstat->kd, fst, shm,
1163e506e182SJohn Baldwin 		    errbuf));
11647153ad2bSMikolaj Golub 	} else if (procstat->type == PROCSTAT_SYSCTL ||
11657153ad2bSMikolaj Golub 	    procstat->type == PROCSTAT_CORE) {
1166e506e182SJohn Baldwin 		return (procstat_get_shm_info_sysctl(fst, shm, errbuf));
1167e506e182SJohn Baldwin 	} else {
1168e506e182SJohn Baldwin 		warnx("unknown access method: %d", procstat->type);
1169467112b4SMikolaj Golub 		if (errbuf != NULL)
1170e506e182SJohn Baldwin 			snprintf(errbuf, _POSIX2_LINE_MAX, "error");
1171e506e182SJohn Baldwin 		return (1);
1172e506e182SJohn Baldwin 	}
1173e506e182SJohn Baldwin }
1174e506e182SJohn Baldwin 
1175e506e182SJohn Baldwin static int
1176e506e182SJohn Baldwin procstat_get_shm_info_kvm(kvm_t *kd, struct filestat *fst,
1177e506e182SJohn Baldwin     struct shmstat *shm, char *errbuf)
1178e506e182SJohn Baldwin {
1179e506e182SJohn Baldwin 	struct shmfd shmfd;
1180e506e182SJohn Baldwin 	void *shmfdp;
1181a9f5e425SJohn Baldwin 	char *path;
1182a9f5e425SJohn Baldwin 	int i;
1183e506e182SJohn Baldwin 
1184e506e182SJohn Baldwin 	assert(kd);
1185e506e182SJohn Baldwin 	assert(shm);
1186e506e182SJohn Baldwin 	assert(fst);
1187e506e182SJohn Baldwin 	bzero(shm, sizeof(*shm));
1188e506e182SJohn Baldwin 	shmfdp = fst->fs_typedep;
1189e506e182SJohn Baldwin 	if (shmfdp == NULL)
1190e506e182SJohn Baldwin 		goto fail;
1191e506e182SJohn Baldwin 	if (!kvm_read_all(kd, (unsigned long)shmfdp, &shmfd,
1192e506e182SJohn Baldwin 	    sizeof(struct shmfd))) {
1193e506e182SJohn Baldwin 		warnx("can't read shmfd at %p", (void *)shmfdp);
1194e506e182SJohn Baldwin 		goto fail;
1195e506e182SJohn Baldwin 	}
1196e506e182SJohn Baldwin 	shm->mode = S_IFREG | shmfd.shm_mode;
1197e506e182SJohn Baldwin 	shm->size = shmfd.shm_size;
1198a9f5e425SJohn Baldwin 	if (fst->fs_path == NULL && shmfd.shm_path != NULL) {
1199a9f5e425SJohn Baldwin 		path = malloc(MAXPATHLEN);
1200a9f5e425SJohn Baldwin 		for (i = 0; i < MAXPATHLEN - 1; i++) {
1201a9f5e425SJohn Baldwin 			if (!kvm_read_all(kd, (unsigned long)shmfd.shm_path + i,
1202a9f5e425SJohn Baldwin 			    path + i, 1))
1203a9f5e425SJohn Baldwin 				break;
1204a9f5e425SJohn Baldwin 			if (path[i] == '\0')
1205a9f5e425SJohn Baldwin 				break;
1206a9f5e425SJohn Baldwin 		}
1207a9f5e425SJohn Baldwin 		path[i] = '\0';
1208a9f5e425SJohn Baldwin 		if (i == 0)
1209a9f5e425SJohn Baldwin 			free(path);
1210a9f5e425SJohn Baldwin 		else
1211a9f5e425SJohn Baldwin 			fst->fs_path = path;
1212a9f5e425SJohn Baldwin 	}
1213e506e182SJohn Baldwin 	return (0);
1214e506e182SJohn Baldwin 
1215e506e182SJohn Baldwin fail:
1216467112b4SMikolaj Golub 	if (errbuf != NULL)
1217e506e182SJohn Baldwin 		snprintf(errbuf, _POSIX2_LINE_MAX, "error");
1218e506e182SJohn Baldwin 	return (1);
1219e506e182SJohn Baldwin }
1220e506e182SJohn Baldwin 
1221e506e182SJohn Baldwin static int
1222e506e182SJohn Baldwin procstat_get_shm_info_sysctl(struct filestat *fst, struct shmstat *shm,
1223e506e182SJohn Baldwin     char *errbuf __unused)
1224e506e182SJohn Baldwin {
1225e506e182SJohn Baldwin 	struct kinfo_file *kif;
1226e506e182SJohn Baldwin 
1227e506e182SJohn Baldwin 	assert(shm);
1228e506e182SJohn Baldwin 	assert(fst);
1229e506e182SJohn Baldwin 	bzero(shm, sizeof(*shm));
1230e506e182SJohn Baldwin 	kif = fst->fs_typedep;
1231e506e182SJohn Baldwin 	if (kif == NULL)
1232e506e182SJohn Baldwin 		return (0);
1233e506e182SJohn Baldwin 	shm->size = kif->kf_un.kf_file.kf_file_size;
1234e506e182SJohn Baldwin 	shm->mode = kif->kf_un.kf_file.kf_file_mode;
1235e506e182SJohn Baldwin 	return (0);
1236e506e182SJohn Baldwin }
1237e506e182SJohn Baldwin 
1238e506e182SJohn Baldwin int
12390daf62d9SStanislav Sedov procstat_get_vnode_info(struct procstat *procstat, struct filestat *fst,
12400daf62d9SStanislav Sedov     struct vnstat *vn, char *errbuf)
12410daf62d9SStanislav Sedov {
12420daf62d9SStanislav Sedov 
12430daf62d9SStanislav Sedov 	assert(vn);
12440daf62d9SStanislav Sedov 	if (procstat->type == PROCSTAT_KVM) {
12450daf62d9SStanislav Sedov 		return (procstat_get_vnode_info_kvm(procstat->kd, fst, vn,
12460daf62d9SStanislav Sedov 		    errbuf));
12477153ad2bSMikolaj Golub 	} else if (procstat->type == PROCSTAT_SYSCTL ||
12487153ad2bSMikolaj Golub 		procstat->type == PROCSTAT_CORE) {
12490daf62d9SStanislav Sedov 		return (procstat_get_vnode_info_sysctl(fst, vn, errbuf));
12500daf62d9SStanislav Sedov 	} else {
125180905c35SJilles Tjoelker 		warnx("unknown access method: %d", procstat->type);
1252467112b4SMikolaj Golub 		if (errbuf != NULL)
12530daf62d9SStanislav Sedov 			snprintf(errbuf, _POSIX2_LINE_MAX, "error");
12540daf62d9SStanislav Sedov 		return (1);
12550daf62d9SStanislav Sedov 	}
12560daf62d9SStanislav Sedov }
12570daf62d9SStanislav Sedov 
12580daf62d9SStanislav Sedov static int
12590daf62d9SStanislav Sedov procstat_get_vnode_info_kvm(kvm_t *kd, struct filestat *fst,
12600daf62d9SStanislav Sedov     struct vnstat *vn, char *errbuf)
12610daf62d9SStanislav Sedov {
12620daf62d9SStanislav Sedov 	/* Filesystem specific handlers. */
12630daf62d9SStanislav Sedov 	#define FSTYPE(fst)     {#fst, fst##_filestat}
12640daf62d9SStanislav Sedov 	struct {
12650daf62d9SStanislav Sedov 		const char	*tag;
12660daf62d9SStanislav Sedov 		int		(*handler)(kvm_t *kd, struct vnode *vp,
12670daf62d9SStanislav Sedov 		    struct vnstat *vn);
12680daf62d9SStanislav Sedov 	} fstypes[] = {
12690daf62d9SStanislav Sedov 		FSTYPE(devfs),
12700daf62d9SStanislav Sedov 		FSTYPE(isofs),
12710daf62d9SStanislav Sedov 		FSTYPE(msdosfs),
12720daf62d9SStanislav Sedov 		FSTYPE(nfs),
1273237abf0cSDavide Italiano 		FSTYPE(smbfs),
12740daf62d9SStanislav Sedov 		FSTYPE(udf),
12750daf62d9SStanislav Sedov 		FSTYPE(ufs),
127659ea47d0SStanislav Sedov #ifdef LIBPROCSTAT_ZFS
12770daf62d9SStanislav Sedov 		FSTYPE(zfs),
12780daf62d9SStanislav Sedov #endif
12790daf62d9SStanislav Sedov 	};
12800daf62d9SStanislav Sedov #define	NTYPES	(sizeof(fstypes) / sizeof(*fstypes))
12810daf62d9SStanislav Sedov 	struct vnode vnode;
12820daf62d9SStanislav Sedov 	char tagstr[12];
12830daf62d9SStanislav Sedov 	void *vp;
1284a770b4d8SMarcelo Araujo 	int error;
12850daf62d9SStanislav Sedov 	unsigned int i;
12860daf62d9SStanislav Sedov 
12870daf62d9SStanislav Sedov 	assert(kd);
12880daf62d9SStanislav Sedov 	assert(vn);
12890daf62d9SStanislav Sedov 	assert(fst);
12900daf62d9SStanislav Sedov 	vp = fst->fs_typedep;
12910daf62d9SStanislav Sedov 	if (vp == NULL)
12920daf62d9SStanislav Sedov 		goto fail;
12930daf62d9SStanislav Sedov 	error = kvm_read_all(kd, (unsigned long)vp, &vnode, sizeof(vnode));
12940daf62d9SStanislav Sedov 	if (error == 0) {
12950daf62d9SStanislav Sedov 		warnx("can't read vnode at %p", (void *)vp);
12960daf62d9SStanislav Sedov 		goto fail;
12970daf62d9SStanislav Sedov 	}
12980daf62d9SStanislav Sedov 	bzero(vn, sizeof(*vn));
12990daf62d9SStanislav Sedov 	vn->vn_type = vntype2psfsttype(vnode.v_type);
13000daf62d9SStanislav Sedov 	if (vnode.v_type == VNON || vnode.v_type == VBAD)
13010daf62d9SStanislav Sedov 		return (0);
1302630cb9c5SMateusz Guzik 	error = kvm_read_all(kd, (unsigned long)vnode.v_lock.lock_object.lo_name,
1303630cb9c5SMateusz Guzik 	    tagstr, sizeof(tagstr));
13040daf62d9SStanislav Sedov 	if (error == 0) {
1305630cb9c5SMateusz Guzik 		warnx("can't read lo_name at %p", (void *)vp);
13060daf62d9SStanislav Sedov 		goto fail;
13070daf62d9SStanislav Sedov 	}
13080daf62d9SStanislav Sedov 	tagstr[sizeof(tagstr) - 1] = '\0';
13090daf62d9SStanislav Sedov 
13100daf62d9SStanislav Sedov 	/*
13110daf62d9SStanislav Sedov 	 * Find appropriate handler.
13120daf62d9SStanislav Sedov 	 */
1313a770b4d8SMarcelo Araujo 	for (i = 0; i < NTYPES; i++)
13140daf62d9SStanislav Sedov 		if (!strcmp(fstypes[i].tag, tagstr)) {
13150daf62d9SStanislav Sedov 			if (fstypes[i].handler(kd, &vnode, vn) != 0) {
13160daf62d9SStanislav Sedov 				goto fail;
13170daf62d9SStanislav Sedov 			}
13180daf62d9SStanislav Sedov 			break;
13190daf62d9SStanislav Sedov 		}
13200daf62d9SStanislav Sedov 	if (i == NTYPES) {
1321467112b4SMikolaj Golub 		if (errbuf != NULL)
13220daf62d9SStanislav Sedov 			snprintf(errbuf, _POSIX2_LINE_MAX, "?(%s)", tagstr);
13230daf62d9SStanislav Sedov 		return (1);
13240daf62d9SStanislav Sedov 	}
13250daf62d9SStanislav Sedov 	vn->vn_mntdir = getmnton(kd, vnode.v_mount);
13260daf62d9SStanislav Sedov 	if ((vnode.v_type == VBLK || vnode.v_type == VCHR) &&
13270daf62d9SStanislav Sedov 	    vnode.v_rdev != NULL){
13280daf62d9SStanislav Sedov 		vn->vn_dev = dev2udev(kd, vnode.v_rdev);
13290daf62d9SStanislav Sedov 		(void)kdevtoname(kd, vnode.v_rdev, vn->vn_devname);
13300daf62d9SStanislav Sedov 	} else {
13310daf62d9SStanislav Sedov 		vn->vn_dev = -1;
13320daf62d9SStanislav Sedov 	}
13330daf62d9SStanislav Sedov 	return (0);
13340daf62d9SStanislav Sedov 
13350daf62d9SStanislav Sedov fail:
1336467112b4SMikolaj Golub 	if (errbuf != NULL)
13370daf62d9SStanislav Sedov 		snprintf(errbuf, _POSIX2_LINE_MAX, "error");
13380daf62d9SStanislav Sedov 	return (1);
13390daf62d9SStanislav Sedov }
13400daf62d9SStanislav Sedov 
13410daf62d9SStanislav Sedov /*
13420daf62d9SStanislav Sedov  * kinfo vnode type to filestat translation.
13430daf62d9SStanislav Sedov  */
13440daf62d9SStanislav Sedov static int
13450daf62d9SStanislav Sedov kinfo_vtype2fst(int kfvtype)
13460daf62d9SStanislav Sedov {
13470daf62d9SStanislav Sedov 	static struct {
13480daf62d9SStanislav Sedov 		int	kf_vtype;
13490daf62d9SStanislav Sedov 		int	fst_vtype;
13500daf62d9SStanislav Sedov 	} kfvtypes2fst[] = {
13510daf62d9SStanislav Sedov 		{ KF_VTYPE_VBAD, PS_FST_VTYPE_VBAD },
13520daf62d9SStanislav Sedov 		{ KF_VTYPE_VBLK, PS_FST_VTYPE_VBLK },
13530daf62d9SStanislav Sedov 		{ KF_VTYPE_VCHR, PS_FST_VTYPE_VCHR },
13540daf62d9SStanislav Sedov 		{ KF_VTYPE_VDIR, PS_FST_VTYPE_VDIR },
13550daf62d9SStanislav Sedov 		{ KF_VTYPE_VFIFO, PS_FST_VTYPE_VFIFO },
13560daf62d9SStanislav Sedov 		{ KF_VTYPE_VLNK, PS_FST_VTYPE_VLNK },
13570daf62d9SStanislav Sedov 		{ KF_VTYPE_VNON, PS_FST_VTYPE_VNON },
13580daf62d9SStanislav Sedov 		{ KF_VTYPE_VREG, PS_FST_VTYPE_VREG },
13590daf62d9SStanislav Sedov 		{ KF_VTYPE_VSOCK, PS_FST_VTYPE_VSOCK }
13600daf62d9SStanislav Sedov 	};
13610daf62d9SStanislav Sedov #define	NKFVTYPES	(sizeof(kfvtypes2fst) / sizeof(*kfvtypes2fst))
13620daf62d9SStanislav Sedov 	unsigned int i;
13630daf62d9SStanislav Sedov 
13640daf62d9SStanislav Sedov 	for (i = 0; i < NKFVTYPES; i++)
13650daf62d9SStanislav Sedov 		if (kfvtypes2fst[i].kf_vtype == kfvtype)
13660daf62d9SStanislav Sedov 			break;
13670daf62d9SStanislav Sedov 	if (i == NKFVTYPES)
13680daf62d9SStanislav Sedov 		return (PS_FST_VTYPE_UNKNOWN);
13690daf62d9SStanislav Sedov 	return (kfvtypes2fst[i].fst_vtype);
13700daf62d9SStanislav Sedov }
13710daf62d9SStanislav Sedov 
13720daf62d9SStanislav Sedov static int
13730daf62d9SStanislav Sedov procstat_get_vnode_info_sysctl(struct filestat *fst, struct vnstat *vn,
13740daf62d9SStanislav Sedov     char *errbuf)
13750daf62d9SStanislav Sedov {
13760daf62d9SStanislav Sedov 	struct statfs stbuf;
13770daf62d9SStanislav Sedov 	struct kinfo_file *kif;
13780daf62d9SStanislav Sedov 	struct kinfo_vmentry *kve;
137969921123SKonstantin Belousov 	char *name, *path;
13800daf62d9SStanislav Sedov 	uint64_t fileid;
13810daf62d9SStanislav Sedov 	uint64_t size;
138269921123SKonstantin Belousov 	uint64_t fsid;
138369921123SKonstantin Belousov 	uint64_t rdev;
13840daf62d9SStanislav Sedov 	uint16_t mode;
13850daf62d9SStanislav Sedov 	int vntype;
13860daf62d9SStanislav Sedov 	int status;
13870daf62d9SStanislav Sedov 
13880daf62d9SStanislav Sedov 	assert(fst);
13890daf62d9SStanislav Sedov 	assert(vn);
13900daf62d9SStanislav Sedov 	bzero(vn, sizeof(*vn));
13910daf62d9SStanislav Sedov 	if (fst->fs_typedep == NULL)
13920daf62d9SStanislav Sedov 		return (1);
13930daf62d9SStanislav Sedov 	if (fst->fs_uflags & PS_FST_UFLAG_MMAP) {
13940daf62d9SStanislav Sedov 		kve = fst->fs_typedep;
13950daf62d9SStanislav Sedov 		fileid = kve->kve_vn_fileid;
13960daf62d9SStanislav Sedov 		fsid = kve->kve_vn_fsid;
13970daf62d9SStanislav Sedov 		mode = kve->kve_vn_mode;
13980daf62d9SStanislav Sedov 		path = kve->kve_path;
13990daf62d9SStanislav Sedov 		rdev = kve->kve_vn_rdev;
14000daf62d9SStanislav Sedov 		size = kve->kve_vn_size;
14010daf62d9SStanislav Sedov 		vntype = kinfo_vtype2fst(kve->kve_vn_type);
14020daf62d9SStanislav Sedov 		status = kve->kve_status;
14030daf62d9SStanislav Sedov 	} else {
14040daf62d9SStanislav Sedov 		kif = fst->fs_typedep;
14050daf62d9SStanislav Sedov 		fileid = kif->kf_un.kf_file.kf_file_fileid;
14060daf62d9SStanislav Sedov 		fsid = kif->kf_un.kf_file.kf_file_fsid;
14070daf62d9SStanislav Sedov 		mode = kif->kf_un.kf_file.kf_file_mode;
14080daf62d9SStanislav Sedov 		path = kif->kf_path;
14090daf62d9SStanislav Sedov 		rdev = kif->kf_un.kf_file.kf_file_rdev;
14100daf62d9SStanislav Sedov 		size = kif->kf_un.kf_file.kf_file_size;
14110daf62d9SStanislav Sedov 		vntype = kinfo_vtype2fst(kif->kf_vnode_type);
14120daf62d9SStanislav Sedov 		status = kif->kf_status;
14130daf62d9SStanislav Sedov 	}
14140daf62d9SStanislav Sedov 	vn->vn_type = vntype;
14150daf62d9SStanislav Sedov 	if (vntype == PS_FST_VTYPE_VNON || vntype == PS_FST_VTYPE_VBAD)
14160daf62d9SStanislav Sedov 		return (0);
14170daf62d9SStanislav Sedov 	if ((status & KF_ATTR_VALID) == 0) {
1418467112b4SMikolaj Golub 		if (errbuf != NULL) {
1419467112b4SMikolaj Golub 			snprintf(errbuf, _POSIX2_LINE_MAX,
1420467112b4SMikolaj Golub 			    "? (no info available)");
1421467112b4SMikolaj Golub 		}
14220daf62d9SStanislav Sedov 		return (1);
14230daf62d9SStanislav Sedov 	}
14240daf62d9SStanislav Sedov 	if (path && *path) {
14250daf62d9SStanislav Sedov 		statfs(path, &stbuf);
14260daf62d9SStanislav Sedov 		vn->vn_mntdir = strdup(stbuf.f_mntonname);
14270daf62d9SStanislav Sedov 	} else
14280daf62d9SStanislav Sedov 		vn->vn_mntdir = strdup("-");
14290daf62d9SStanislav Sedov 	vn->vn_dev = rdev;
14300daf62d9SStanislav Sedov 	if (vntype == PS_FST_VTYPE_VBLK) {
14310daf62d9SStanislav Sedov 		name = devname(rdev, S_IFBLK);
14320daf62d9SStanislav Sedov 		if (name != NULL)
14330daf62d9SStanislav Sedov 			strlcpy(vn->vn_devname, name,
14340daf62d9SStanislav Sedov 			    sizeof(vn->vn_devname));
14350daf62d9SStanislav Sedov 	} else if (vntype == PS_FST_VTYPE_VCHR) {
14360daf62d9SStanislav Sedov 		name = devname(vn->vn_dev, S_IFCHR);
14370daf62d9SStanislav Sedov 		if (name != NULL)
14380daf62d9SStanislav Sedov 			strlcpy(vn->vn_devname, name,
14390daf62d9SStanislav Sedov 			    sizeof(vn->vn_devname));
14400daf62d9SStanislav Sedov 	}
14410daf62d9SStanislav Sedov 	vn->vn_fsid = fsid;
14420daf62d9SStanislav Sedov 	vn->vn_fileid = fileid;
14430daf62d9SStanislav Sedov 	vn->vn_size = size;
14440daf62d9SStanislav Sedov 	vn->vn_mode = mode;
14450daf62d9SStanislav Sedov 	return (0);
14460daf62d9SStanislav Sedov }
14470daf62d9SStanislav Sedov 
14480daf62d9SStanislav Sedov int
14490daf62d9SStanislav Sedov procstat_get_socket_info(struct procstat *procstat, struct filestat *fst,
14500daf62d9SStanislav Sedov     struct sockstat *sock, char *errbuf)
14510daf62d9SStanislav Sedov {
14520daf62d9SStanislav Sedov 
14530daf62d9SStanislav Sedov 	assert(sock);
14540daf62d9SStanislav Sedov 	if (procstat->type == PROCSTAT_KVM) {
14550daf62d9SStanislav Sedov 		return (procstat_get_socket_info_kvm(procstat->kd, fst, sock,
14560daf62d9SStanislav Sedov 		    errbuf));
14577153ad2bSMikolaj Golub 	} else if (procstat->type == PROCSTAT_SYSCTL ||
14587153ad2bSMikolaj Golub 		procstat->type == PROCSTAT_CORE) {
14590daf62d9SStanislav Sedov 		return (procstat_get_socket_info_sysctl(fst, sock, errbuf));
14600daf62d9SStanislav Sedov 	} else {
146180905c35SJilles Tjoelker 		warnx("unknown access method: %d", procstat->type);
1462467112b4SMikolaj Golub 		if (errbuf != NULL)
14630daf62d9SStanislav Sedov 			snprintf(errbuf, _POSIX2_LINE_MAX, "error");
14640daf62d9SStanislav Sedov 		return (1);
14650daf62d9SStanislav Sedov 	}
14660daf62d9SStanislav Sedov }
14670daf62d9SStanislav Sedov 
14680daf62d9SStanislav Sedov static int
14690daf62d9SStanislav Sedov procstat_get_socket_info_kvm(kvm_t *kd, struct filestat *fst,
14700daf62d9SStanislav Sedov     struct sockstat *sock, char *errbuf)
14710daf62d9SStanislav Sedov {
14720daf62d9SStanislav Sedov 	struct domain dom;
14730daf62d9SStanislav Sedov 	struct inpcb inpcb;
14740daf62d9SStanislav Sedov 	struct protosw proto;
14750daf62d9SStanislav Sedov 	struct socket s;
14760daf62d9SStanislav Sedov 	struct unpcb unpcb;
14770daf62d9SStanislav Sedov 	ssize_t len;
14780daf62d9SStanislav Sedov 	void *so;
14790daf62d9SStanislav Sedov 
14800daf62d9SStanislav Sedov 	assert(kd);
14810daf62d9SStanislav Sedov 	assert(sock);
14820daf62d9SStanislav Sedov 	assert(fst);
14830daf62d9SStanislav Sedov 	bzero(sock, sizeof(*sock));
14840daf62d9SStanislav Sedov 	so = fst->fs_typedep;
14850daf62d9SStanislav Sedov 	if (so == NULL)
14860daf62d9SStanislav Sedov 		goto fail;
14870daf62d9SStanislav Sedov 	sock->so_addr = (uintptr_t)so;
14880daf62d9SStanislav Sedov 	/* fill in socket */
14890daf62d9SStanislav Sedov 	if (!kvm_read_all(kd, (unsigned long)so, &s,
14900daf62d9SStanislav Sedov 	    sizeof(struct socket))) {
14910daf62d9SStanislav Sedov 		warnx("can't read sock at %p", (void *)so);
14920daf62d9SStanislav Sedov 		goto fail;
14930daf62d9SStanislav Sedov 	}
14940daf62d9SStanislav Sedov 	/* fill in protosw entry */
14950daf62d9SStanislav Sedov 	if (!kvm_read_all(kd, (unsigned long)s.so_proto, &proto,
14960daf62d9SStanislav Sedov 	    sizeof(struct protosw))) {
14970daf62d9SStanislav Sedov 		warnx("can't read protosw at %p", (void *)s.so_proto);
14980daf62d9SStanislav Sedov 		goto fail;
14990daf62d9SStanislav Sedov 	}
15000daf62d9SStanislav Sedov 	/* fill in domain */
15010daf62d9SStanislav Sedov 	if (!kvm_read_all(kd, (unsigned long)proto.pr_domain, &dom,
15020daf62d9SStanislav Sedov 	    sizeof(struct domain))) {
15030daf62d9SStanislav Sedov 		warnx("can't read domain at %p",
15040daf62d9SStanislav Sedov 		    (void *)proto.pr_domain);
15050daf62d9SStanislav Sedov 		goto fail;
15060daf62d9SStanislav Sedov 	}
15070daf62d9SStanislav Sedov 	if ((len = kvm_read(kd, (unsigned long)dom.dom_name, sock->dname,
15080daf62d9SStanislav Sedov 	    sizeof(sock->dname) - 1)) < 0) {
15090daf62d9SStanislav Sedov 		warnx("can't read domain name at %p", (void *)dom.dom_name);
15100daf62d9SStanislav Sedov 		sock->dname[0] = '\0';
15110daf62d9SStanislav Sedov 	}
15120daf62d9SStanislav Sedov 	else
15130daf62d9SStanislav Sedov 		sock->dname[len] = '\0';
15140daf62d9SStanislav Sedov 
15150daf62d9SStanislav Sedov 	/*
15160daf62d9SStanislav Sedov 	 * Fill in known data.
15170daf62d9SStanislav Sedov 	 */
15180daf62d9SStanislav Sedov 	sock->type = s.so_type;
15190daf62d9SStanislav Sedov 	sock->proto = proto.pr_protocol;
15200daf62d9SStanislav Sedov 	sock->dom_family = dom.dom_family;
15210daf62d9SStanislav Sedov 	sock->so_pcb = (uintptr_t)s.so_pcb;
15220daf62d9SStanislav Sedov 
15230daf62d9SStanislav Sedov 	/*
15240daf62d9SStanislav Sedov 	 * Protocol specific data.
15250daf62d9SStanislav Sedov 	 */
15260daf62d9SStanislav Sedov 	switch(dom.dom_family) {
15270daf62d9SStanislav Sedov 	case AF_INET:
15280daf62d9SStanislav Sedov 	case AF_INET6:
15290daf62d9SStanislav Sedov 		if (proto.pr_protocol == IPPROTO_TCP) {
15300daf62d9SStanislav Sedov 			if (s.so_pcb) {
15310daf62d9SStanislav Sedov 				if (kvm_read(kd, (u_long)s.so_pcb,
15320daf62d9SStanislav Sedov 				    (char *)&inpcb, sizeof(struct inpcb))
15330daf62d9SStanislav Sedov 				    != sizeof(struct inpcb)) {
15340daf62d9SStanislav Sedov 					warnx("can't read inpcb at %p",
15350daf62d9SStanislav Sedov 					    (void *)s.so_pcb);
15360daf62d9SStanislav Sedov 				} else
15370daf62d9SStanislav Sedov 					sock->inp_ppcb =
15380daf62d9SStanislav Sedov 					    (uintptr_t)inpcb.inp_ppcb;
153995b97895SConrad Meyer 				sock->sendq = s.so_snd.sb_ccc;
154095b97895SConrad Meyer 				sock->recvq = s.so_rcv.sb_ccc;
15410daf62d9SStanislav Sedov 			}
15420daf62d9SStanislav Sedov 		}
15430daf62d9SStanislav Sedov 		break;
15440daf62d9SStanislav Sedov 	case AF_UNIX:
15450daf62d9SStanislav Sedov 		if (s.so_pcb) {
15460daf62d9SStanislav Sedov 			if (kvm_read(kd, (u_long)s.so_pcb, (char *)&unpcb,
15470daf62d9SStanislav Sedov 			    sizeof(struct unpcb)) != sizeof(struct unpcb)){
15480daf62d9SStanislav Sedov 				warnx("can't read unpcb at %p",
15490daf62d9SStanislav Sedov 				    (void *)s.so_pcb);
15500daf62d9SStanislav Sedov 			} else if (unpcb.unp_conn) {
15510daf62d9SStanislav Sedov 				sock->so_rcv_sb_state = s.so_rcv.sb_state;
15520daf62d9SStanislav Sedov 				sock->so_snd_sb_state = s.so_snd.sb_state;
15530daf62d9SStanislav Sedov 				sock->unp_conn = (uintptr_t)unpcb.unp_conn;
155495b97895SConrad Meyer 				sock->sendq = s.so_snd.sb_ccc;
155595b97895SConrad Meyer 				sock->recvq = s.so_rcv.sb_ccc;
15560daf62d9SStanislav Sedov 			}
15570daf62d9SStanislav Sedov 		}
15580daf62d9SStanislav Sedov 		break;
15590daf62d9SStanislav Sedov 	default:
15600daf62d9SStanislav Sedov 		break;
15610daf62d9SStanislav Sedov 	}
15620daf62d9SStanislav Sedov 	return (0);
15630daf62d9SStanislav Sedov 
15640daf62d9SStanislav Sedov fail:
1565467112b4SMikolaj Golub 	if (errbuf != NULL)
15660daf62d9SStanislav Sedov 		snprintf(errbuf, _POSIX2_LINE_MAX, "error");
15670daf62d9SStanislav Sedov 	return (1);
15680daf62d9SStanislav Sedov }
15690daf62d9SStanislav Sedov 
15700daf62d9SStanislav Sedov static int
15710daf62d9SStanislav Sedov procstat_get_socket_info_sysctl(struct filestat *fst, struct sockstat *sock,
15720daf62d9SStanislav Sedov     char *errbuf __unused)
15730daf62d9SStanislav Sedov {
15740daf62d9SStanislav Sedov 	struct kinfo_file *kif;
15750daf62d9SStanislav Sedov 
15760daf62d9SStanislav Sedov 	assert(sock);
15770daf62d9SStanislav Sedov 	assert(fst);
15780daf62d9SStanislav Sedov 	bzero(sock, sizeof(*sock));
15790daf62d9SStanislav Sedov 	kif = fst->fs_typedep;
15800daf62d9SStanislav Sedov 	if (kif == NULL)
15810daf62d9SStanislav Sedov 		return (0);
15820daf62d9SStanislav Sedov 
15830daf62d9SStanislav Sedov 	/*
15840daf62d9SStanislav Sedov 	 * Fill in known data.
15850daf62d9SStanislav Sedov 	 */
15860daf62d9SStanislav Sedov 	sock->type = kif->kf_sock_type;
15870daf62d9SStanislav Sedov 	sock->proto = kif->kf_sock_protocol;
15880daf62d9SStanislav Sedov 	sock->dom_family = kif->kf_sock_domain;
15890daf62d9SStanislav Sedov 	sock->so_pcb = kif->kf_un.kf_sock.kf_sock_pcb;
15900daf62d9SStanislav Sedov 	strlcpy(sock->dname, kif->kf_path, sizeof(sock->dname));
159169921123SKonstantin Belousov 	bcopy(&kif->kf_un.kf_sock.kf_sa_local, &sock->sa_local,
159269921123SKonstantin Belousov 	    kif->kf_un.kf_sock.kf_sa_local.ss_len);
159369921123SKonstantin Belousov 	bcopy(&kif->kf_un.kf_sock.kf_sa_peer, &sock->sa_peer,
159469921123SKonstantin Belousov 	    kif->kf_un.kf_sock.kf_sa_peer.ss_len);
15950daf62d9SStanislav Sedov 
15960daf62d9SStanislav Sedov 	/*
15970daf62d9SStanislav Sedov 	 * Protocol specific data.
15980daf62d9SStanislav Sedov 	 */
15990daf62d9SStanislav Sedov 	switch(sock->dom_family) {
16000daf62d9SStanislav Sedov 	case AF_INET:
16010daf62d9SStanislav Sedov 	case AF_INET6:
160295b97895SConrad Meyer 		if (sock->proto == IPPROTO_TCP) {
16030daf62d9SStanislav Sedov 			sock->inp_ppcb = kif->kf_un.kf_sock.kf_sock_inpcb;
160495b97895SConrad Meyer 			sock->sendq = kif->kf_un.kf_sock.kf_sock_sendq;
160595b97895SConrad Meyer 			sock->recvq = kif->kf_un.kf_sock.kf_sock_recvq;
160695b97895SConrad Meyer 		}
16070daf62d9SStanislav Sedov 		break;
16080daf62d9SStanislav Sedov 	case AF_UNIX:
16090daf62d9SStanislav Sedov 		if (kif->kf_un.kf_sock.kf_sock_unpconn != 0) {
16100daf62d9SStanislav Sedov 			sock->so_rcv_sb_state =
16110daf62d9SStanislav Sedov 			    kif->kf_un.kf_sock.kf_sock_rcv_sb_state;
16120daf62d9SStanislav Sedov 			sock->so_snd_sb_state =
16130daf62d9SStanislav Sedov 			    kif->kf_un.kf_sock.kf_sock_snd_sb_state;
16140daf62d9SStanislav Sedov 			sock->unp_conn =
16150daf62d9SStanislav Sedov 			    kif->kf_un.kf_sock.kf_sock_unpconn;
161695b97895SConrad Meyer 			sock->sendq = kif->kf_un.kf_sock.kf_sock_sendq;
161795b97895SConrad Meyer 			sock->recvq = kif->kf_un.kf_sock.kf_sock_recvq;
16180daf62d9SStanislav Sedov 		}
16190daf62d9SStanislav Sedov 		break;
16200daf62d9SStanislav Sedov 	default:
16210daf62d9SStanislav Sedov 		break;
16220daf62d9SStanislav Sedov 	}
16230daf62d9SStanislav Sedov 	return (0);
16240daf62d9SStanislav Sedov }
16250daf62d9SStanislav Sedov 
16260daf62d9SStanislav Sedov /*
16270daf62d9SStanislav Sedov  * Descriptor flags to filestat translation.
16280daf62d9SStanislav Sedov  */
16290daf62d9SStanislav Sedov static int
16300daf62d9SStanislav Sedov to_filestat_flags(int flags)
16310daf62d9SStanislav Sedov {
16320daf62d9SStanislav Sedov 	static struct {
16330daf62d9SStanislav Sedov 		int flag;
16340daf62d9SStanislav Sedov 		int fst_flag;
16350daf62d9SStanislav Sedov 	} fstflags[] = {
16360daf62d9SStanislav Sedov 		{ FREAD, PS_FST_FFLAG_READ },
16370daf62d9SStanislav Sedov 		{ FWRITE, PS_FST_FFLAG_WRITE },
16380daf62d9SStanislav Sedov 		{ O_APPEND, PS_FST_FFLAG_APPEND },
16390daf62d9SStanislav Sedov 		{ O_ASYNC, PS_FST_FFLAG_ASYNC },
16400daf62d9SStanislav Sedov 		{ O_CREAT, PS_FST_FFLAG_CREAT },
16410daf62d9SStanislav Sedov 		{ O_DIRECT, PS_FST_FFLAG_DIRECT },
16420daf62d9SStanislav Sedov 		{ O_EXCL, PS_FST_FFLAG_EXCL },
16430daf62d9SStanislav Sedov 		{ O_EXEC, PS_FST_FFLAG_EXEC },
16440daf62d9SStanislav Sedov 		{ O_EXLOCK, PS_FST_FFLAG_EXLOCK },
16450daf62d9SStanislav Sedov 		{ O_NOFOLLOW, PS_FST_FFLAG_NOFOLLOW },
16460daf62d9SStanislav Sedov 		{ O_NONBLOCK, PS_FST_FFLAG_NONBLOCK },
16470daf62d9SStanislav Sedov 		{ O_SHLOCK, PS_FST_FFLAG_SHLOCK },
16480daf62d9SStanislav Sedov 		{ O_SYNC, PS_FST_FFLAG_SYNC },
16490daf62d9SStanislav Sedov 		{ O_TRUNC, PS_FST_FFLAG_TRUNC }
16500daf62d9SStanislav Sedov 	};
16510daf62d9SStanislav Sedov #define NFSTFLAGS	(sizeof(fstflags) / sizeof(*fstflags))
16520daf62d9SStanislav Sedov 	int fst_flags;
16530daf62d9SStanislav Sedov 	unsigned int i;
16540daf62d9SStanislav Sedov 
16550daf62d9SStanislav Sedov 	fst_flags = 0;
16560daf62d9SStanislav Sedov 	for (i = 0; i < NFSTFLAGS; i++)
16570daf62d9SStanislav Sedov 		if (flags & fstflags[i].flag)
16580daf62d9SStanislav Sedov 			fst_flags |= fstflags[i].fst_flag;
16590daf62d9SStanislav Sedov 	return (fst_flags);
16600daf62d9SStanislav Sedov }
16610daf62d9SStanislav Sedov 
16620daf62d9SStanislav Sedov /*
16630daf62d9SStanislav Sedov  * Vnode type to filestate translation.
16640daf62d9SStanislav Sedov  */
16650daf62d9SStanislav Sedov static int
16660daf62d9SStanislav Sedov vntype2psfsttype(int type)
16670daf62d9SStanislav Sedov {
16680daf62d9SStanislav Sedov 	static struct {
16690daf62d9SStanislav Sedov 		int	vtype;
16700daf62d9SStanislav Sedov 		int	fst_vtype;
16710daf62d9SStanislav Sedov 	} vt2fst[] = {
16720daf62d9SStanislav Sedov 		{ VBAD, PS_FST_VTYPE_VBAD },
16730daf62d9SStanislav Sedov 		{ VBLK, PS_FST_VTYPE_VBLK },
16740daf62d9SStanislav Sedov 		{ VCHR, PS_FST_VTYPE_VCHR },
16750daf62d9SStanislav Sedov 		{ VDIR, PS_FST_VTYPE_VDIR },
16760daf62d9SStanislav Sedov 		{ VFIFO, PS_FST_VTYPE_VFIFO },
16770daf62d9SStanislav Sedov 		{ VLNK, PS_FST_VTYPE_VLNK },
16780daf62d9SStanislav Sedov 		{ VNON, PS_FST_VTYPE_VNON },
16790daf62d9SStanislav Sedov 		{ VREG, PS_FST_VTYPE_VREG },
16800daf62d9SStanislav Sedov 		{ VSOCK, PS_FST_VTYPE_VSOCK }
16810daf62d9SStanislav Sedov 	};
16820daf62d9SStanislav Sedov #define	NVFTYPES	(sizeof(vt2fst) / sizeof(*vt2fst))
16830daf62d9SStanislav Sedov 	unsigned int i, fst_type;
16840daf62d9SStanislav Sedov 
16850daf62d9SStanislav Sedov 	fst_type = PS_FST_VTYPE_UNKNOWN;
16860daf62d9SStanislav Sedov 	for (i = 0; i < NVFTYPES; i++) {
16870daf62d9SStanislav Sedov 		if (type == vt2fst[i].vtype) {
16880daf62d9SStanislav Sedov 			fst_type = vt2fst[i].fst_vtype;
16890daf62d9SStanislav Sedov 			break;
16900daf62d9SStanislav Sedov 		}
16910daf62d9SStanislav Sedov 	}
16920daf62d9SStanislav Sedov 	return (fst_type);
16930daf62d9SStanislav Sedov }
16940daf62d9SStanislav Sedov 
16950daf62d9SStanislav Sedov static char *
16960daf62d9SStanislav Sedov getmnton(kvm_t *kd, struct mount *m)
16970daf62d9SStanislav Sedov {
16985f301949SBen Laurie 	struct mount mnt;
16990daf62d9SStanislav Sedov 	static struct mtab {
17000daf62d9SStanislav Sedov 		struct mtab *next;
17010daf62d9SStanislav Sedov 		struct mount *m;
17020daf62d9SStanislav Sedov 		char mntonname[MNAMELEN + 1];
17030daf62d9SStanislav Sedov 	} *mhead = NULL;
17040daf62d9SStanislav Sedov 	struct mtab *mt;
17050daf62d9SStanislav Sedov 
17060daf62d9SStanislav Sedov 	for (mt = mhead; mt != NULL; mt = mt->next)
17070daf62d9SStanislav Sedov 		if (m == mt->m)
17080daf62d9SStanislav Sedov 			return (mt->mntonname);
17090daf62d9SStanislav Sedov 	if (!kvm_read_all(kd, (unsigned long)m, &mnt, sizeof(struct mount))) {
17100daf62d9SStanislav Sedov 		warnx("can't read mount table at %p", (void *)m);
17110daf62d9SStanislav Sedov 		return (NULL);
17120daf62d9SStanislav Sedov 	}
17130daf62d9SStanislav Sedov 	if ((mt = malloc(sizeof (struct mtab))) == NULL)
17140daf62d9SStanislav Sedov 		err(1, NULL);
17150daf62d9SStanislav Sedov 	mt->m = m;
17160daf62d9SStanislav Sedov 	bcopy(&mnt.mnt_stat.f_mntonname[0], &mt->mntonname[0], MNAMELEN);
17175f301949SBen Laurie 	mt->mntonname[MNAMELEN] = '\0';
17180daf62d9SStanislav Sedov 	mt->next = mhead;
17190daf62d9SStanislav Sedov 	mhead = mt;
17200daf62d9SStanislav Sedov 	return (mt->mntonname);
17210daf62d9SStanislav Sedov }
17227153ad2bSMikolaj Golub 
17234482b5e3SMikolaj Golub /*
17244482b5e3SMikolaj Golub  * Auxiliary structures and functions to get process environment or
17254482b5e3SMikolaj Golub  * command line arguments.
17264482b5e3SMikolaj Golub  */
17274482b5e3SMikolaj Golub struct argvec {
17284482b5e3SMikolaj Golub 	char	*buf;
17294482b5e3SMikolaj Golub 	size_t	bufsize;
17304482b5e3SMikolaj Golub 	char	**argv;
17314482b5e3SMikolaj Golub 	size_t	argc;
17324482b5e3SMikolaj Golub };
17334482b5e3SMikolaj Golub 
17344482b5e3SMikolaj Golub static struct argvec *
17354482b5e3SMikolaj Golub argvec_alloc(size_t bufsize)
17364482b5e3SMikolaj Golub {
17374482b5e3SMikolaj Golub 	struct argvec *av;
17384482b5e3SMikolaj Golub 
17394482b5e3SMikolaj Golub 	av = malloc(sizeof(*av));
17404482b5e3SMikolaj Golub 	if (av == NULL)
17414482b5e3SMikolaj Golub 		return (NULL);
17424482b5e3SMikolaj Golub 	av->bufsize = bufsize;
17434482b5e3SMikolaj Golub 	av->buf = malloc(av->bufsize);
17444482b5e3SMikolaj Golub 	if (av->buf == NULL) {
17454482b5e3SMikolaj Golub 		free(av);
17464482b5e3SMikolaj Golub 		return (NULL);
17474482b5e3SMikolaj Golub 	}
17484482b5e3SMikolaj Golub 	av->argc = 32;
17494482b5e3SMikolaj Golub 	av->argv = malloc(sizeof(char *) * av->argc);
17504482b5e3SMikolaj Golub 	if (av->argv == NULL) {
17514482b5e3SMikolaj Golub 		free(av->buf);
17524482b5e3SMikolaj Golub 		free(av);
17534482b5e3SMikolaj Golub 		return (NULL);
17544482b5e3SMikolaj Golub 	}
17554482b5e3SMikolaj Golub 	return av;
17564482b5e3SMikolaj Golub }
17574482b5e3SMikolaj Golub 
17584482b5e3SMikolaj Golub static void
17594482b5e3SMikolaj Golub argvec_free(struct argvec * av)
17604482b5e3SMikolaj Golub {
17614482b5e3SMikolaj Golub 
17624482b5e3SMikolaj Golub 	free(av->argv);
17634482b5e3SMikolaj Golub 	free(av->buf);
17644482b5e3SMikolaj Golub 	free(av);
17654482b5e3SMikolaj Golub }
17664482b5e3SMikolaj Golub 
17674482b5e3SMikolaj Golub static char **
17684482b5e3SMikolaj Golub getargv(struct procstat *procstat, struct kinfo_proc *kp, size_t nchr, int env)
17694482b5e3SMikolaj Golub {
17704482b5e3SMikolaj Golub 	int error, name[4], argc, i;
17714482b5e3SMikolaj Golub 	struct argvec *av, **avp;
17724482b5e3SMikolaj Golub 	enum psc_type type;
17734482b5e3SMikolaj Golub 	size_t len;
17744482b5e3SMikolaj Golub 	char *p, **argv;
17754482b5e3SMikolaj Golub 
17764482b5e3SMikolaj Golub 	assert(procstat);
17774482b5e3SMikolaj Golub 	assert(kp);
17784482b5e3SMikolaj Golub 	if (procstat->type == PROCSTAT_KVM) {
17794482b5e3SMikolaj Golub 		warnx("can't use kvm access method");
17804482b5e3SMikolaj Golub 		return (NULL);
17814482b5e3SMikolaj Golub 	}
17824482b5e3SMikolaj Golub 	if (procstat->type != PROCSTAT_SYSCTL &&
17834482b5e3SMikolaj Golub 	    procstat->type != PROCSTAT_CORE) {
17844482b5e3SMikolaj Golub 		warnx("unknown access method: %d", procstat->type);
17854482b5e3SMikolaj Golub 		return (NULL);
17864482b5e3SMikolaj Golub 	}
17874482b5e3SMikolaj Golub 
17884482b5e3SMikolaj Golub 	if (nchr == 0 || nchr > ARG_MAX)
17894482b5e3SMikolaj Golub 		nchr = ARG_MAX;
17904482b5e3SMikolaj Golub 
17914482b5e3SMikolaj Golub 	avp = (struct argvec **)(env ? &procstat->argv : &procstat->envv);
17924482b5e3SMikolaj Golub 	av = *avp;
17934482b5e3SMikolaj Golub 
17944482b5e3SMikolaj Golub 	if (av == NULL)
17954482b5e3SMikolaj Golub 	{
17964482b5e3SMikolaj Golub 		av = argvec_alloc(nchr);
17974482b5e3SMikolaj Golub 		if (av == NULL)
17984482b5e3SMikolaj Golub 		{
17994482b5e3SMikolaj Golub 			warn("malloc(%zu)", nchr);
18004482b5e3SMikolaj Golub 			return (NULL);
18014482b5e3SMikolaj Golub 		}
18024482b5e3SMikolaj Golub 		*avp = av;
18034482b5e3SMikolaj Golub 	} else if (av->bufsize < nchr) {
18044482b5e3SMikolaj Golub 		av->buf = reallocf(av->buf, nchr);
18054482b5e3SMikolaj Golub 		if (av->buf == NULL) {
18064482b5e3SMikolaj Golub 			warn("malloc(%zu)", nchr);
18074482b5e3SMikolaj Golub 			return (NULL);
18084482b5e3SMikolaj Golub 		}
18094482b5e3SMikolaj Golub 	}
18104482b5e3SMikolaj Golub 	if (procstat->type == PROCSTAT_SYSCTL) {
18114482b5e3SMikolaj Golub 		name[0] = CTL_KERN;
18124482b5e3SMikolaj Golub 		name[1] = KERN_PROC;
18134482b5e3SMikolaj Golub 		name[2] = env ? KERN_PROC_ENV : KERN_PROC_ARGS;
18144482b5e3SMikolaj Golub 		name[3] = kp->ki_pid;
18154482b5e3SMikolaj Golub 		len = nchr;
181675b6a179SEnji Cooper 		error = sysctl(name, nitems(name), av->buf, &len, NULL, 0);
18174482b5e3SMikolaj Golub 		if (error != 0 && errno != ESRCH && errno != EPERM)
18184482b5e3SMikolaj Golub 			warn("sysctl(kern.proc.%s)", env ? "env" : "args");
18194482b5e3SMikolaj Golub 		if (error != 0 || len == 0)
18204482b5e3SMikolaj Golub 			return (NULL);
18214482b5e3SMikolaj Golub 	} else /* procstat->type == PROCSTAT_CORE */ {
18224482b5e3SMikolaj Golub 		type = env ? PSC_TYPE_ENVV : PSC_TYPE_ARGV;
18234482b5e3SMikolaj Golub 		len = nchr;
18244482b5e3SMikolaj Golub 		if (procstat_core_get(procstat->core, type, av->buf, &len)
18254482b5e3SMikolaj Golub 		    == NULL) {
18264482b5e3SMikolaj Golub 			return (NULL);
18274482b5e3SMikolaj Golub 		}
18284482b5e3SMikolaj Golub 	}
18294482b5e3SMikolaj Golub 
18304482b5e3SMikolaj Golub 	argv = av->argv;
18314482b5e3SMikolaj Golub 	argc = av->argc;
18324482b5e3SMikolaj Golub 	i = 0;
18334482b5e3SMikolaj Golub 	for (p = av->buf; p < av->buf + len; p += strlen(p) + 1) {
18344482b5e3SMikolaj Golub 		argv[i++] = p;
18354482b5e3SMikolaj Golub 		if (i < argc)
18364482b5e3SMikolaj Golub 			continue;
18374482b5e3SMikolaj Golub 		/* Grow argv. */
18384482b5e3SMikolaj Golub 		argc += argc;
18394482b5e3SMikolaj Golub 		argv = realloc(argv, sizeof(char *) * argc);
18404482b5e3SMikolaj Golub 		if (argv == NULL) {
18414482b5e3SMikolaj Golub 			warn("malloc(%zu)", sizeof(char *) * argc);
18424482b5e3SMikolaj Golub 			return (NULL);
18434482b5e3SMikolaj Golub 		}
18444482b5e3SMikolaj Golub 		av->argv = argv;
18454482b5e3SMikolaj Golub 		av->argc = argc;
18464482b5e3SMikolaj Golub 	}
18474482b5e3SMikolaj Golub 	argv[i] = NULL;
18484482b5e3SMikolaj Golub 
18494482b5e3SMikolaj Golub 	return (argv);
18504482b5e3SMikolaj Golub }
18514482b5e3SMikolaj Golub 
18524482b5e3SMikolaj Golub /*
18534482b5e3SMikolaj Golub  * Return process command line arguments.
18544482b5e3SMikolaj Golub  */
18554482b5e3SMikolaj Golub char **
18564482b5e3SMikolaj Golub procstat_getargv(struct procstat *procstat, struct kinfo_proc *p, size_t nchr)
18574482b5e3SMikolaj Golub {
18584482b5e3SMikolaj Golub 
18594482b5e3SMikolaj Golub 	return (getargv(procstat, p, nchr, 0));
18604482b5e3SMikolaj Golub }
18614482b5e3SMikolaj Golub 
18624482b5e3SMikolaj Golub /*
18634482b5e3SMikolaj Golub  * Free the buffer allocated by procstat_getargv().
18644482b5e3SMikolaj Golub  */
18654482b5e3SMikolaj Golub void
18664482b5e3SMikolaj Golub procstat_freeargv(struct procstat *procstat)
18674482b5e3SMikolaj Golub {
18684482b5e3SMikolaj Golub 
18694482b5e3SMikolaj Golub 	if (procstat->argv != NULL) {
18704482b5e3SMikolaj Golub 		argvec_free(procstat->argv);
18714482b5e3SMikolaj Golub 		procstat->argv = NULL;
18724482b5e3SMikolaj Golub 	}
18734482b5e3SMikolaj Golub }
18744482b5e3SMikolaj Golub 
18754482b5e3SMikolaj Golub /*
18764482b5e3SMikolaj Golub  * Return process environment.
18774482b5e3SMikolaj Golub  */
18784482b5e3SMikolaj Golub char **
18794482b5e3SMikolaj Golub procstat_getenvv(struct procstat *procstat, struct kinfo_proc *p, size_t nchr)
18804482b5e3SMikolaj Golub {
18814482b5e3SMikolaj Golub 
18824482b5e3SMikolaj Golub 	return (getargv(procstat, p, nchr, 1));
18834482b5e3SMikolaj Golub }
18844482b5e3SMikolaj Golub 
18854482b5e3SMikolaj Golub /*
18864482b5e3SMikolaj Golub  * Free the buffer allocated by procstat_getenvv().
18874482b5e3SMikolaj Golub  */
18884482b5e3SMikolaj Golub void
18894482b5e3SMikolaj Golub procstat_freeenvv(struct procstat *procstat)
18904482b5e3SMikolaj Golub {
18914482b5e3SMikolaj Golub 	if (procstat->envv != NULL) {
18924482b5e3SMikolaj Golub 		argvec_free(procstat->envv);
18934482b5e3SMikolaj Golub 		procstat->envv = NULL;
18944482b5e3SMikolaj Golub 	}
18954482b5e3SMikolaj Golub }
18964482b5e3SMikolaj Golub 
189739680c7bSMikolaj Golub static struct kinfo_vmentry *
189839680c7bSMikolaj Golub kinfo_getvmmap_core(struct procstat_core *core, int *cntp)
189939680c7bSMikolaj Golub {
190039680c7bSMikolaj Golub 	int cnt;
190139680c7bSMikolaj Golub 	size_t len;
190239680c7bSMikolaj Golub 	char *buf, *bp, *eb;
190339680c7bSMikolaj Golub 	struct kinfo_vmentry *kiv, *kp, *kv;
190439680c7bSMikolaj Golub 
190539680c7bSMikolaj Golub 	buf = procstat_core_get(core, PSC_TYPE_VMMAP, NULL, &len);
190639680c7bSMikolaj Golub 	if (buf == NULL)
190739680c7bSMikolaj Golub 		return (NULL);
190839680c7bSMikolaj Golub 
190939680c7bSMikolaj Golub 	/*
191039680c7bSMikolaj Golub 	 * XXXMG: The code below is just copy&past from libutil.
191139680c7bSMikolaj Golub 	 * The code duplication can be avoided if libutil
191239680c7bSMikolaj Golub 	 * is extended to provide something like:
191339680c7bSMikolaj Golub 	 *   struct kinfo_vmentry *kinfo_getvmmap_from_buf(const char *buf,
191439680c7bSMikolaj Golub 	 *       size_t len, int *cntp);
191539680c7bSMikolaj Golub 	 */
191639680c7bSMikolaj Golub 
191739680c7bSMikolaj Golub 	/* Pass 1: count items */
191839680c7bSMikolaj Golub 	cnt = 0;
191939680c7bSMikolaj Golub 	bp = buf;
192039680c7bSMikolaj Golub 	eb = buf + len;
192139680c7bSMikolaj Golub 	while (bp < eb) {
192239680c7bSMikolaj Golub 		kv = (struct kinfo_vmentry *)(uintptr_t)bp;
1923e6b95927SConrad Meyer 		if (kv->kve_structsize == 0)
1924e6b95927SConrad Meyer 			break;
192539680c7bSMikolaj Golub 		bp += kv->kve_structsize;
192639680c7bSMikolaj Golub 		cnt++;
192739680c7bSMikolaj Golub 	}
192839680c7bSMikolaj Golub 
192939680c7bSMikolaj Golub 	kiv = calloc(cnt, sizeof(*kiv));
193039680c7bSMikolaj Golub 	if (kiv == NULL) {
193139680c7bSMikolaj Golub 		free(buf);
193239680c7bSMikolaj Golub 		return (NULL);
193339680c7bSMikolaj Golub 	}
193439680c7bSMikolaj Golub 	bp = buf;
193539680c7bSMikolaj Golub 	eb = buf + len;
193639680c7bSMikolaj Golub 	kp = kiv;
193739680c7bSMikolaj Golub 	/* Pass 2: unpack */
193839680c7bSMikolaj Golub 	while (bp < eb) {
193939680c7bSMikolaj Golub 		kv = (struct kinfo_vmentry *)(uintptr_t)bp;
1940e6b95927SConrad Meyer 		if (kv->kve_structsize == 0)
1941e6b95927SConrad Meyer 			break;
194239680c7bSMikolaj Golub 		/* Copy/expand into pre-zeroed buffer */
194339680c7bSMikolaj Golub 		memcpy(kp, kv, kv->kve_structsize);
194439680c7bSMikolaj Golub 		/* Advance to next packed record */
194539680c7bSMikolaj Golub 		bp += kv->kve_structsize;
194639680c7bSMikolaj Golub 		/* Set field size to fixed length, advance */
194739680c7bSMikolaj Golub 		kp->kve_structsize = sizeof(*kp);
194839680c7bSMikolaj Golub 		kp++;
194939680c7bSMikolaj Golub 	}
195039680c7bSMikolaj Golub 	free(buf);
195139680c7bSMikolaj Golub 	*cntp = cnt;
195239680c7bSMikolaj Golub 	return (kiv);	/* Caller must free() return value */
195339680c7bSMikolaj Golub }
195439680c7bSMikolaj Golub 
195539680c7bSMikolaj Golub struct kinfo_vmentry *
195639680c7bSMikolaj Golub procstat_getvmmap(struct procstat *procstat, struct kinfo_proc *kp,
195739680c7bSMikolaj Golub     unsigned int *cntp)
195839680c7bSMikolaj Golub {
195989358231SMikolaj Golub 
196039680c7bSMikolaj Golub 	switch(procstat->type) {
196139680c7bSMikolaj Golub 	case PROCSTAT_KVM:
196239680c7bSMikolaj Golub 		warnx("kvm method is not supported");
196339680c7bSMikolaj Golub 		return (NULL);
196439680c7bSMikolaj Golub 	case PROCSTAT_SYSCTL:
196539680c7bSMikolaj Golub 		return (kinfo_getvmmap(kp->ki_pid, cntp));
196639680c7bSMikolaj Golub 	case PROCSTAT_CORE:
196739680c7bSMikolaj Golub 		return (kinfo_getvmmap_core(procstat->core, cntp));
196839680c7bSMikolaj Golub 	default:
196939680c7bSMikolaj Golub 		warnx("unknown access method: %d", procstat->type);
197039680c7bSMikolaj Golub 		return (NULL);
197139680c7bSMikolaj Golub 	}
197239680c7bSMikolaj Golub }
197339680c7bSMikolaj Golub 
197439680c7bSMikolaj Golub void
197539680c7bSMikolaj Golub procstat_freevmmap(struct procstat *procstat __unused,
197639680c7bSMikolaj Golub     struct kinfo_vmentry *vmmap)
197739680c7bSMikolaj Golub {
197839680c7bSMikolaj Golub 
197939680c7bSMikolaj Golub 	free(vmmap);
198039680c7bSMikolaj Golub }
19817f1d14e6SMikolaj Golub 
19827f1d14e6SMikolaj Golub static gid_t *
19831f84c47eSMikolaj Golub procstat_getgroups_kvm(kvm_t *kd, struct kinfo_proc *kp, unsigned int *cntp)
19841f84c47eSMikolaj Golub {
19851f84c47eSMikolaj Golub 	struct proc proc;
19861f84c47eSMikolaj Golub 	struct ucred ucred;
19871f84c47eSMikolaj Golub 	gid_t *groups;
19881f84c47eSMikolaj Golub 	size_t len;
19891f84c47eSMikolaj Golub 
19901f84c47eSMikolaj Golub 	assert(kd != NULL);
19911f84c47eSMikolaj Golub 	assert(kp != NULL);
19921f84c47eSMikolaj Golub 	if (!kvm_read_all(kd, (unsigned long)kp->ki_paddr, &proc,
19931f84c47eSMikolaj Golub 	    sizeof(proc))) {
19941f84c47eSMikolaj Golub 		warnx("can't read proc struct at %p for pid %d",
19951f84c47eSMikolaj Golub 		    kp->ki_paddr, kp->ki_pid);
19961f84c47eSMikolaj Golub 		return (NULL);
19971f84c47eSMikolaj Golub 	}
19981f84c47eSMikolaj Golub 	if (proc.p_ucred == NOCRED)
19991f84c47eSMikolaj Golub 		return (NULL);
20001f84c47eSMikolaj Golub 	if (!kvm_read_all(kd, (unsigned long)proc.p_ucred, &ucred,
20011f84c47eSMikolaj Golub 	    sizeof(ucred))) {
20021f84c47eSMikolaj Golub 		warnx("can't read ucred struct at %p for pid %d",
20031f84c47eSMikolaj Golub 		    proc.p_ucred, kp->ki_pid);
20041f84c47eSMikolaj Golub 		return (NULL);
20051f84c47eSMikolaj Golub 	}
20061f84c47eSMikolaj Golub 	len = ucred.cr_ngroups * sizeof(gid_t);
20071f84c47eSMikolaj Golub 	groups = malloc(len);
20081f84c47eSMikolaj Golub 	if (groups == NULL) {
20091f84c47eSMikolaj Golub 		warn("malloc(%zu)", len);
20101f84c47eSMikolaj Golub 		return (NULL);
20111f84c47eSMikolaj Golub 	}
20121f84c47eSMikolaj Golub 	if (!kvm_read_all(kd, (unsigned long)ucred.cr_groups, groups, len)) {
20131f84c47eSMikolaj Golub 		warnx("can't read groups at %p for pid %d",
20141f84c47eSMikolaj Golub 		    ucred.cr_groups, kp->ki_pid);
20151f84c47eSMikolaj Golub 		free(groups);
20161f84c47eSMikolaj Golub 		return (NULL);
20171f84c47eSMikolaj Golub 	}
20181f84c47eSMikolaj Golub 	*cntp = ucred.cr_ngroups;
20191f84c47eSMikolaj Golub 	return (groups);
20201f84c47eSMikolaj Golub }
20211f84c47eSMikolaj Golub 
20221f84c47eSMikolaj Golub static gid_t *
20237f1d14e6SMikolaj Golub procstat_getgroups_sysctl(pid_t pid, unsigned int *cntp)
20247f1d14e6SMikolaj Golub {
20257f1d14e6SMikolaj Golub 	int mib[4];
20267f1d14e6SMikolaj Golub 	size_t len;
20277f1d14e6SMikolaj Golub 	gid_t *groups;
20287f1d14e6SMikolaj Golub 
20297f1d14e6SMikolaj Golub 	mib[0] = CTL_KERN;
20307f1d14e6SMikolaj Golub 	mib[1] = KERN_PROC;
20317f1d14e6SMikolaj Golub 	mib[2] = KERN_PROC_GROUPS;
20327f1d14e6SMikolaj Golub 	mib[3] = pid;
20337f1d14e6SMikolaj Golub 	len = (sysconf(_SC_NGROUPS_MAX) + 1) * sizeof(gid_t);
20347f1d14e6SMikolaj Golub 	groups = malloc(len);
20357f1d14e6SMikolaj Golub 	if (groups == NULL) {
20367f1d14e6SMikolaj Golub 		warn("malloc(%zu)", len);
20377f1d14e6SMikolaj Golub 		return (NULL);
20387f1d14e6SMikolaj Golub 	}
203975b6a179SEnji Cooper 	if (sysctl(mib, nitems(mib), groups, &len, NULL, 0) == -1) {
20407f1d14e6SMikolaj Golub 		warn("sysctl: kern.proc.groups: %d", pid);
20417f1d14e6SMikolaj Golub 		free(groups);
20427f1d14e6SMikolaj Golub 		return (NULL);
20437f1d14e6SMikolaj Golub 	}
20447f1d14e6SMikolaj Golub 	*cntp = len / sizeof(gid_t);
20457f1d14e6SMikolaj Golub 	return (groups);
20467f1d14e6SMikolaj Golub }
20477f1d14e6SMikolaj Golub 
20487f1d14e6SMikolaj Golub static gid_t *
20497f1d14e6SMikolaj Golub procstat_getgroups_core(struct procstat_core *core, unsigned int *cntp)
20507f1d14e6SMikolaj Golub {
20517f1d14e6SMikolaj Golub 	size_t len;
20527f1d14e6SMikolaj Golub 	gid_t *groups;
20537f1d14e6SMikolaj Golub 
20547f1d14e6SMikolaj Golub 	groups = procstat_core_get(core, PSC_TYPE_GROUPS, NULL, &len);
20557f1d14e6SMikolaj Golub 	if (groups == NULL)
20567f1d14e6SMikolaj Golub 		return (NULL);
20577f1d14e6SMikolaj Golub 	*cntp = len / sizeof(gid_t);
20587f1d14e6SMikolaj Golub 	return (groups);
20597f1d14e6SMikolaj Golub }
20607f1d14e6SMikolaj Golub 
20617f1d14e6SMikolaj Golub gid_t *
20627f1d14e6SMikolaj Golub procstat_getgroups(struct procstat *procstat, struct kinfo_proc *kp,
20637f1d14e6SMikolaj Golub     unsigned int *cntp)
20647f1d14e6SMikolaj Golub {
20657f1d14e6SMikolaj Golub 	switch(procstat->type) {
20667f1d14e6SMikolaj Golub 	case PROCSTAT_KVM:
20671f84c47eSMikolaj Golub 		return (procstat_getgroups_kvm(procstat->kd, kp, cntp));
20687f1d14e6SMikolaj Golub 	case PROCSTAT_SYSCTL:
20697f1d14e6SMikolaj Golub 		return (procstat_getgroups_sysctl(kp->ki_pid, cntp));
20707f1d14e6SMikolaj Golub 	case PROCSTAT_CORE:
20717f1d14e6SMikolaj Golub 		return (procstat_getgroups_core(procstat->core, cntp));
20727f1d14e6SMikolaj Golub 	default:
20737f1d14e6SMikolaj Golub 		warnx("unknown access method: %d", procstat->type);
20747f1d14e6SMikolaj Golub 		return (NULL);
20757f1d14e6SMikolaj Golub 	}
20767f1d14e6SMikolaj Golub }
20777f1d14e6SMikolaj Golub 
20787f1d14e6SMikolaj Golub void
20797f1d14e6SMikolaj Golub procstat_freegroups(struct procstat *procstat __unused, gid_t *groups)
20807f1d14e6SMikolaj Golub {
20817f1d14e6SMikolaj Golub 
20827f1d14e6SMikolaj Golub 	free(groups);
20837f1d14e6SMikolaj Golub }
20845b9bcba9SMikolaj Golub 
20855b9bcba9SMikolaj Golub static int
20861f84c47eSMikolaj Golub procstat_getumask_kvm(kvm_t *kd, struct kinfo_proc *kp, unsigned short *maskp)
20871f84c47eSMikolaj Golub {
20881f84c47eSMikolaj Golub 	struct filedesc fd;
20891f84c47eSMikolaj Golub 
20901f84c47eSMikolaj Golub 	assert(kd != NULL);
20911f84c47eSMikolaj Golub 	assert(kp != NULL);
20921f84c47eSMikolaj Golub 	if (kp->ki_fd == NULL)
20931f84c47eSMikolaj Golub 		return (-1);
20941f84c47eSMikolaj Golub 	if (!kvm_read_all(kd, (unsigned long)kp->ki_fd, &fd, sizeof(fd))) {
20951f84c47eSMikolaj Golub 		warnx("can't read filedesc at %p for pid %d", kp->ki_fd,
20961f84c47eSMikolaj Golub 		    kp->ki_pid);
20971f84c47eSMikolaj Golub 		return (-1);
20981f84c47eSMikolaj Golub 	}
20991f84c47eSMikolaj Golub 	*maskp = fd.fd_cmask;
21001f84c47eSMikolaj Golub 	return (0);
21011f84c47eSMikolaj Golub }
21021f84c47eSMikolaj Golub 
21031f84c47eSMikolaj Golub static int
21045b9bcba9SMikolaj Golub procstat_getumask_sysctl(pid_t pid, unsigned short *maskp)
21055b9bcba9SMikolaj Golub {
21065b9bcba9SMikolaj Golub 	int error;
21075b9bcba9SMikolaj Golub 	int mib[4];
21085b9bcba9SMikolaj Golub 	size_t len;
21095b9bcba9SMikolaj Golub 
21105b9bcba9SMikolaj Golub 	mib[0] = CTL_KERN;
21115b9bcba9SMikolaj Golub 	mib[1] = KERN_PROC;
21125b9bcba9SMikolaj Golub 	mib[2] = KERN_PROC_UMASK;
21135b9bcba9SMikolaj Golub 	mib[3] = pid;
21145b9bcba9SMikolaj Golub 	len = sizeof(*maskp);
211575b6a179SEnji Cooper 	error = sysctl(mib, nitems(mib), maskp, &len, NULL, 0);
211609b46be1SRobert Watson 	if (error != 0 && errno != ESRCH && errno != EPERM)
21175b9bcba9SMikolaj Golub 		warn("sysctl: kern.proc.umask: %d", pid);
21185b9bcba9SMikolaj Golub 	return (error);
21195b9bcba9SMikolaj Golub }
21205b9bcba9SMikolaj Golub 
21215b9bcba9SMikolaj Golub static int
21225b9bcba9SMikolaj Golub procstat_getumask_core(struct procstat_core *core, unsigned short *maskp)
21235b9bcba9SMikolaj Golub {
21245b9bcba9SMikolaj Golub 	size_t len;
21255b9bcba9SMikolaj Golub 	unsigned short *buf;
21265b9bcba9SMikolaj Golub 
21275b9bcba9SMikolaj Golub 	buf = procstat_core_get(core, PSC_TYPE_UMASK, NULL, &len);
21285b9bcba9SMikolaj Golub 	if (buf == NULL)
21295b9bcba9SMikolaj Golub 		return (-1);
21305b9bcba9SMikolaj Golub 	if (len < sizeof(*maskp)) {
21315b9bcba9SMikolaj Golub 		free(buf);
21325b9bcba9SMikolaj Golub 		return (-1);
21335b9bcba9SMikolaj Golub 	}
21345b9bcba9SMikolaj Golub 	*maskp = *buf;
21355b9bcba9SMikolaj Golub 	free(buf);
21365b9bcba9SMikolaj Golub 	return (0);
21375b9bcba9SMikolaj Golub }
21385b9bcba9SMikolaj Golub 
21395b9bcba9SMikolaj Golub int
21405b9bcba9SMikolaj Golub procstat_getumask(struct procstat *procstat, struct kinfo_proc *kp,
21415b9bcba9SMikolaj Golub     unsigned short *maskp)
21425b9bcba9SMikolaj Golub {
21435b9bcba9SMikolaj Golub 	switch(procstat->type) {
21445b9bcba9SMikolaj Golub 	case PROCSTAT_KVM:
21451f84c47eSMikolaj Golub 		return (procstat_getumask_kvm(procstat->kd, kp, maskp));
21465b9bcba9SMikolaj Golub 	case PROCSTAT_SYSCTL:
21475b9bcba9SMikolaj Golub 		return (procstat_getumask_sysctl(kp->ki_pid, maskp));
21485b9bcba9SMikolaj Golub 	case PROCSTAT_CORE:
21495b9bcba9SMikolaj Golub 		return (procstat_getumask_core(procstat->core, maskp));
21505b9bcba9SMikolaj Golub 	default:
21515b9bcba9SMikolaj Golub 		warnx("unknown access method: %d", procstat->type);
21525b9bcba9SMikolaj Golub 		return (-1);
21535b9bcba9SMikolaj Golub 	}
21545b9bcba9SMikolaj Golub }
21557cc0ebfdSMikolaj Golub 
21567cc0ebfdSMikolaj Golub static int
21571f84c47eSMikolaj Golub procstat_getrlimit_kvm(kvm_t *kd, struct kinfo_proc *kp, int which,
21581f84c47eSMikolaj Golub     struct rlimit* rlimit)
21591f84c47eSMikolaj Golub {
21601f84c47eSMikolaj Golub 	struct proc proc;
21611f84c47eSMikolaj Golub 	unsigned long offset;
21621f84c47eSMikolaj Golub 
21631f84c47eSMikolaj Golub 	assert(kd != NULL);
21641f84c47eSMikolaj Golub 	assert(kp != NULL);
21651f84c47eSMikolaj Golub 	assert(which >= 0 && which < RLIM_NLIMITS);
21661f84c47eSMikolaj Golub 	if (!kvm_read_all(kd, (unsigned long)kp->ki_paddr, &proc,
21671f84c47eSMikolaj Golub 	    sizeof(proc))) {
21681f84c47eSMikolaj Golub 		warnx("can't read proc struct at %p for pid %d",
21691f84c47eSMikolaj Golub 		    kp->ki_paddr, kp->ki_pid);
21701f84c47eSMikolaj Golub 		return (-1);
21711f84c47eSMikolaj Golub 	}
21721f84c47eSMikolaj Golub 	if (proc.p_limit == NULL)
21731f84c47eSMikolaj Golub 		return (-1);
21741f84c47eSMikolaj Golub 	offset = (unsigned long)proc.p_limit + sizeof(struct rlimit) * which;
21751f84c47eSMikolaj Golub 	if (!kvm_read_all(kd, offset, rlimit, sizeof(*rlimit))) {
21761f84c47eSMikolaj Golub 		warnx("can't read rlimit struct at %p for pid %d",
21771f84c47eSMikolaj Golub 		    (void *)offset, kp->ki_pid);
21781f84c47eSMikolaj Golub 		return (-1);
21791f84c47eSMikolaj Golub 	}
21801f84c47eSMikolaj Golub 	return (0);
21811f84c47eSMikolaj Golub }
21821f84c47eSMikolaj Golub 
21831f84c47eSMikolaj Golub static int
21847cc0ebfdSMikolaj Golub procstat_getrlimit_sysctl(pid_t pid, int which, struct rlimit* rlimit)
21857cc0ebfdSMikolaj Golub {
21867cc0ebfdSMikolaj Golub 	int error, name[5];
21877cc0ebfdSMikolaj Golub 	size_t len;
21887cc0ebfdSMikolaj Golub 
21897cc0ebfdSMikolaj Golub 	name[0] = CTL_KERN;
21907cc0ebfdSMikolaj Golub 	name[1] = KERN_PROC;
21917cc0ebfdSMikolaj Golub 	name[2] = KERN_PROC_RLIMIT;
21927cc0ebfdSMikolaj Golub 	name[3] = pid;
21937cc0ebfdSMikolaj Golub 	name[4] = which;
21947cc0ebfdSMikolaj Golub 	len = sizeof(struct rlimit);
219575b6a179SEnji Cooper 	error = sysctl(name, nitems(name), rlimit, &len, NULL, 0);
21967cc0ebfdSMikolaj Golub 	if (error < 0 && errno != ESRCH) {
21977cc0ebfdSMikolaj Golub 		warn("sysctl: kern.proc.rlimit: %d", pid);
21987cc0ebfdSMikolaj Golub 		return (-1);
21997cc0ebfdSMikolaj Golub 	}
22007cc0ebfdSMikolaj Golub 	if (error < 0 || len != sizeof(struct rlimit))
22017cc0ebfdSMikolaj Golub 		return (-1);
22027cc0ebfdSMikolaj Golub 	return (0);
22037cc0ebfdSMikolaj Golub }
22047cc0ebfdSMikolaj Golub 
22057cc0ebfdSMikolaj Golub static int
22067cc0ebfdSMikolaj Golub procstat_getrlimit_core(struct procstat_core *core, int which,
22077cc0ebfdSMikolaj Golub     struct rlimit* rlimit)
22087cc0ebfdSMikolaj Golub {
22097cc0ebfdSMikolaj Golub 	size_t len;
22107cc0ebfdSMikolaj Golub 	struct rlimit* rlimits;
22117cc0ebfdSMikolaj Golub 
22127cc0ebfdSMikolaj Golub 	if (which < 0 || which >= RLIM_NLIMITS) {
22137cc0ebfdSMikolaj Golub 		errno = EINVAL;
22147cc0ebfdSMikolaj Golub 		warn("getrlimit: which");
22157cc0ebfdSMikolaj Golub 		return (-1);
22167cc0ebfdSMikolaj Golub 	}
22177cc0ebfdSMikolaj Golub 	rlimits = procstat_core_get(core, PSC_TYPE_RLIMIT, NULL, &len);
22187cc0ebfdSMikolaj Golub 	if (rlimits == NULL)
22197cc0ebfdSMikolaj Golub 		return (-1);
22207cc0ebfdSMikolaj Golub 	if (len < sizeof(struct rlimit) * RLIM_NLIMITS) {
22217cc0ebfdSMikolaj Golub 		free(rlimits);
22227cc0ebfdSMikolaj Golub 		return (-1);
22237cc0ebfdSMikolaj Golub 	}
22247cc0ebfdSMikolaj Golub 	*rlimit = rlimits[which];
22259b207441SEric van Gyzen 	free(rlimits);
22267cc0ebfdSMikolaj Golub 	return (0);
22277cc0ebfdSMikolaj Golub }
22287cc0ebfdSMikolaj Golub 
22297cc0ebfdSMikolaj Golub int
22307cc0ebfdSMikolaj Golub procstat_getrlimit(struct procstat *procstat, struct kinfo_proc *kp, int which,
22317cc0ebfdSMikolaj Golub     struct rlimit* rlimit)
22327cc0ebfdSMikolaj Golub {
22337cc0ebfdSMikolaj Golub 	switch(procstat->type) {
22347cc0ebfdSMikolaj Golub 	case PROCSTAT_KVM:
22351f84c47eSMikolaj Golub 		return (procstat_getrlimit_kvm(procstat->kd, kp, which,
22361f84c47eSMikolaj Golub 		    rlimit));
22377cc0ebfdSMikolaj Golub 	case PROCSTAT_SYSCTL:
22387cc0ebfdSMikolaj Golub 		return (procstat_getrlimit_sysctl(kp->ki_pid, which, rlimit));
22397cc0ebfdSMikolaj Golub 	case PROCSTAT_CORE:
22407cc0ebfdSMikolaj Golub 		return (procstat_getrlimit_core(procstat->core, which, rlimit));
22417cc0ebfdSMikolaj Golub 	default:
22427cc0ebfdSMikolaj Golub 		warnx("unknown access method: %d", procstat->type);
22437cc0ebfdSMikolaj Golub 		return (-1);
22447cc0ebfdSMikolaj Golub 	}
22457cc0ebfdSMikolaj Golub }
22464cdf9796SMikolaj Golub 
22474cdf9796SMikolaj Golub static int
22484cdf9796SMikolaj Golub procstat_getpathname_sysctl(pid_t pid, char *pathname, size_t maxlen)
22494cdf9796SMikolaj Golub {
22504cdf9796SMikolaj Golub 	int error, name[4];
22514cdf9796SMikolaj Golub 	size_t len;
22524cdf9796SMikolaj Golub 
22534cdf9796SMikolaj Golub 	name[0] = CTL_KERN;
22544cdf9796SMikolaj Golub 	name[1] = KERN_PROC;
22554cdf9796SMikolaj Golub 	name[2] = KERN_PROC_PATHNAME;
22564cdf9796SMikolaj Golub 	name[3] = pid;
22574cdf9796SMikolaj Golub 	len = maxlen;
225875b6a179SEnji Cooper 	error = sysctl(name, nitems(name), pathname, &len, NULL, 0);
22594cdf9796SMikolaj Golub 	if (error != 0 && errno != ESRCH)
22604cdf9796SMikolaj Golub 		warn("sysctl: kern.proc.pathname: %d", pid);
22614cdf9796SMikolaj Golub 	if (len == 0)
22624cdf9796SMikolaj Golub 		pathname[0] = '\0';
22634cdf9796SMikolaj Golub 	return (error);
22644cdf9796SMikolaj Golub }
22654cdf9796SMikolaj Golub 
22664cdf9796SMikolaj Golub static int
22674cdf9796SMikolaj Golub procstat_getpathname_core(struct procstat_core *core, char *pathname,
22684cdf9796SMikolaj Golub     size_t maxlen)
22694cdf9796SMikolaj Golub {
22704cdf9796SMikolaj Golub 	struct kinfo_file *files;
22714cdf9796SMikolaj Golub 	int cnt, i, result;
22724cdf9796SMikolaj Golub 
22734cdf9796SMikolaj Golub 	files = kinfo_getfile_core(core, &cnt);
22744cdf9796SMikolaj Golub 	if (files == NULL)
22754cdf9796SMikolaj Golub 		return (-1);
22764cdf9796SMikolaj Golub 	result = -1;
22774cdf9796SMikolaj Golub 	for (i = 0; i < cnt; i++) {
22784cdf9796SMikolaj Golub 		if (files[i].kf_fd != KF_FD_TYPE_TEXT)
22794cdf9796SMikolaj Golub 			continue;
22804cdf9796SMikolaj Golub 		strncpy(pathname, files[i].kf_path, maxlen);
22814cdf9796SMikolaj Golub 		result = 0;
22824cdf9796SMikolaj Golub 		break;
22834cdf9796SMikolaj Golub 	}
22844cdf9796SMikolaj Golub 	free(files);
22854cdf9796SMikolaj Golub 	return (result);
22864cdf9796SMikolaj Golub }
22874cdf9796SMikolaj Golub 
22884cdf9796SMikolaj Golub int
22894cdf9796SMikolaj Golub procstat_getpathname(struct procstat *procstat, struct kinfo_proc *kp,
22904cdf9796SMikolaj Golub     char *pathname, size_t maxlen)
22914cdf9796SMikolaj Golub {
22924cdf9796SMikolaj Golub 	switch(procstat->type) {
22934cdf9796SMikolaj Golub 	case PROCSTAT_KVM:
2294dd70ad64SMikolaj Golub 		/* XXX: Return empty string. */
2295dd70ad64SMikolaj Golub 		if (maxlen > 0)
2296dd70ad64SMikolaj Golub 			pathname[0] = '\0';
2297dd70ad64SMikolaj Golub 		return (0);
22984cdf9796SMikolaj Golub 	case PROCSTAT_SYSCTL:
22994cdf9796SMikolaj Golub 		return (procstat_getpathname_sysctl(kp->ki_pid, pathname,
23004cdf9796SMikolaj Golub 		    maxlen));
23014cdf9796SMikolaj Golub 	case PROCSTAT_CORE:
23024cdf9796SMikolaj Golub 		return (procstat_getpathname_core(procstat->core, pathname,
23034cdf9796SMikolaj Golub 		    maxlen));
23044cdf9796SMikolaj Golub 	default:
23054cdf9796SMikolaj Golub 		warnx("unknown access method: %d", procstat->type);
23064cdf9796SMikolaj Golub 		return (-1);
23074cdf9796SMikolaj Golub 	}
23084cdf9796SMikolaj Golub }
2309eec6cb1cSMikolaj Golub 
2310eec6cb1cSMikolaj Golub static int
23111f84c47eSMikolaj Golub procstat_getosrel_kvm(kvm_t *kd, struct kinfo_proc *kp, int *osrelp)
23121f84c47eSMikolaj Golub {
23131f84c47eSMikolaj Golub 	struct proc proc;
23141f84c47eSMikolaj Golub 
23151f84c47eSMikolaj Golub 	assert(kd != NULL);
23161f84c47eSMikolaj Golub 	assert(kp != NULL);
23171f84c47eSMikolaj Golub 	if (!kvm_read_all(kd, (unsigned long)kp->ki_paddr, &proc,
23181f84c47eSMikolaj Golub 	    sizeof(proc))) {
23191f84c47eSMikolaj Golub 		warnx("can't read proc struct at %p for pid %d",
23201f84c47eSMikolaj Golub 		    kp->ki_paddr, kp->ki_pid);
23211f84c47eSMikolaj Golub 		return (-1);
23221f84c47eSMikolaj Golub 	}
23231f84c47eSMikolaj Golub 	*osrelp = proc.p_osrel;
23241f84c47eSMikolaj Golub 	return (0);
23251f84c47eSMikolaj Golub }
23261f84c47eSMikolaj Golub 
23271f84c47eSMikolaj Golub static int
2328eec6cb1cSMikolaj Golub procstat_getosrel_sysctl(pid_t pid, int *osrelp)
2329eec6cb1cSMikolaj Golub {
2330eec6cb1cSMikolaj Golub 	int error, name[4];
2331eec6cb1cSMikolaj Golub 	size_t len;
2332eec6cb1cSMikolaj Golub 
2333eec6cb1cSMikolaj Golub 	name[0] = CTL_KERN;
2334eec6cb1cSMikolaj Golub 	name[1] = KERN_PROC;
2335eec6cb1cSMikolaj Golub 	name[2] = KERN_PROC_OSREL;
2336eec6cb1cSMikolaj Golub 	name[3] = pid;
2337eec6cb1cSMikolaj Golub 	len = sizeof(*osrelp);
233875b6a179SEnji Cooper 	error = sysctl(name, nitems(name), osrelp, &len, NULL, 0);
2339eec6cb1cSMikolaj Golub 	if (error != 0 && errno != ESRCH)
2340eec6cb1cSMikolaj Golub 		warn("sysctl: kern.proc.osrel: %d", pid);
2341eec6cb1cSMikolaj Golub 	return (error);
2342eec6cb1cSMikolaj Golub }
2343eec6cb1cSMikolaj Golub 
2344eec6cb1cSMikolaj Golub static int
2345eec6cb1cSMikolaj Golub procstat_getosrel_core(struct procstat_core *core, int *osrelp)
2346eec6cb1cSMikolaj Golub {
2347eec6cb1cSMikolaj Golub 	size_t len;
2348eec6cb1cSMikolaj Golub 	int *buf;
2349eec6cb1cSMikolaj Golub 
2350eec6cb1cSMikolaj Golub 	buf = procstat_core_get(core, PSC_TYPE_OSREL, NULL, &len);
2351eec6cb1cSMikolaj Golub 	if (buf == NULL)
2352eec6cb1cSMikolaj Golub 		return (-1);
2353eec6cb1cSMikolaj Golub 	if (len < sizeof(*osrelp)) {
2354eec6cb1cSMikolaj Golub 		free(buf);
2355eec6cb1cSMikolaj Golub 		return (-1);
2356eec6cb1cSMikolaj Golub 	}
2357eec6cb1cSMikolaj Golub 	*osrelp = *buf;
2358eec6cb1cSMikolaj Golub 	free(buf);
2359eec6cb1cSMikolaj Golub 	return (0);
2360eec6cb1cSMikolaj Golub }
2361eec6cb1cSMikolaj Golub 
2362eec6cb1cSMikolaj Golub int
2363eec6cb1cSMikolaj Golub procstat_getosrel(struct procstat *procstat, struct kinfo_proc *kp, int *osrelp)
2364eec6cb1cSMikolaj Golub {
2365eec6cb1cSMikolaj Golub 	switch(procstat->type) {
2366eec6cb1cSMikolaj Golub 	case PROCSTAT_KVM:
23671f84c47eSMikolaj Golub 		return (procstat_getosrel_kvm(procstat->kd, kp, osrelp));
2368eec6cb1cSMikolaj Golub 	case PROCSTAT_SYSCTL:
2369eec6cb1cSMikolaj Golub 		return (procstat_getosrel_sysctl(kp->ki_pid, osrelp));
2370eec6cb1cSMikolaj Golub 	case PROCSTAT_CORE:
2371eec6cb1cSMikolaj Golub 		return (procstat_getosrel_core(procstat->core, osrelp));
2372eec6cb1cSMikolaj Golub 	default:
2373eec6cb1cSMikolaj Golub 		warnx("unknown access method: %d", procstat->type);
2374eec6cb1cSMikolaj Golub 		return (-1);
2375eec6cb1cSMikolaj Golub 	}
2376eec6cb1cSMikolaj Golub }
23772ff020d3SMikolaj Golub 
23782ff020d3SMikolaj Golub #define PROC_AUXV_MAX	256
23792ff020d3SMikolaj Golub 
23802ff020d3SMikolaj Golub #if __ELF_WORD_SIZE == 64
23812ff020d3SMikolaj Golub static const char *elf32_sv_names[] = {
23822ff020d3SMikolaj Golub 	"Linux ELF32",
23832ff020d3SMikolaj Golub 	"FreeBSD ELF32",
23842ff020d3SMikolaj Golub };
23852ff020d3SMikolaj Golub 
23862ff020d3SMikolaj Golub static int
23872ff020d3SMikolaj Golub is_elf32_sysctl(pid_t pid)
23882ff020d3SMikolaj Golub {
23892ff020d3SMikolaj Golub 	int error, name[4];
23902ff020d3SMikolaj Golub 	size_t len, i;
23912ff020d3SMikolaj Golub 	static char sv_name[256];
23922ff020d3SMikolaj Golub 
23932ff020d3SMikolaj Golub 	name[0] = CTL_KERN;
23942ff020d3SMikolaj Golub 	name[1] = KERN_PROC;
23952ff020d3SMikolaj Golub 	name[2] = KERN_PROC_SV_NAME;
23962ff020d3SMikolaj Golub 	name[3] = pid;
23972ff020d3SMikolaj Golub 	len = sizeof(sv_name);
239875b6a179SEnji Cooper 	error = sysctl(name, nitems(name), sv_name, &len, NULL, 0);
23992ff020d3SMikolaj Golub 	if (error != 0 || len == 0)
24002ff020d3SMikolaj Golub 		return (0);
24012ff020d3SMikolaj Golub 	for (i = 0; i < sizeof(elf32_sv_names) / sizeof(*elf32_sv_names); i++) {
24022ff020d3SMikolaj Golub 		if (strncmp(sv_name, elf32_sv_names[i], sizeof(sv_name)) == 0)
24032ff020d3SMikolaj Golub 			return (1);
24042ff020d3SMikolaj Golub 	}
24052ff020d3SMikolaj Golub 	return (0);
24062ff020d3SMikolaj Golub }
24072ff020d3SMikolaj Golub 
24082ff020d3SMikolaj Golub static Elf_Auxinfo *
24092ff020d3SMikolaj Golub procstat_getauxv32_sysctl(pid_t pid, unsigned int *cntp)
24102ff020d3SMikolaj Golub {
24112ff020d3SMikolaj Golub 	Elf_Auxinfo *auxv;
24122ff020d3SMikolaj Golub 	Elf32_Auxinfo *auxv32;
24132ff020d3SMikolaj Golub 	void *ptr;
24142ff020d3SMikolaj Golub 	size_t len;
24152ff020d3SMikolaj Golub 	unsigned int i, count;
24162ff020d3SMikolaj Golub 	int name[4];
24172ff020d3SMikolaj Golub 
24182ff020d3SMikolaj Golub 	name[0] = CTL_KERN;
24192ff020d3SMikolaj Golub 	name[1] = KERN_PROC;
24202ff020d3SMikolaj Golub 	name[2] = KERN_PROC_AUXV;
24212ff020d3SMikolaj Golub 	name[3] = pid;
24222ff020d3SMikolaj Golub 	len = PROC_AUXV_MAX * sizeof(Elf32_Auxinfo);
24232ff020d3SMikolaj Golub 	auxv = NULL;
24242ff020d3SMikolaj Golub 	auxv32 = malloc(len);
24252ff020d3SMikolaj Golub 	if (auxv32 == NULL) {
24262ff020d3SMikolaj Golub 		warn("malloc(%zu)", len);
24272ff020d3SMikolaj Golub 		goto out;
24282ff020d3SMikolaj Golub 	}
242975b6a179SEnji Cooper 	if (sysctl(name, nitems(name), auxv32, &len, NULL, 0) == -1) {
24302ff020d3SMikolaj Golub 		if (errno != ESRCH && errno != EPERM)
24312ff020d3SMikolaj Golub 			warn("sysctl: kern.proc.auxv: %d: %d", pid, errno);
24322ff020d3SMikolaj Golub 		goto out;
24332ff020d3SMikolaj Golub 	}
24342ff020d3SMikolaj Golub 	count = len / sizeof(Elf_Auxinfo);
24352ff020d3SMikolaj Golub 	auxv = malloc(count  * sizeof(Elf_Auxinfo));
24362ff020d3SMikolaj Golub 	if (auxv == NULL) {
24372ff020d3SMikolaj Golub 		warn("malloc(%zu)", count * sizeof(Elf_Auxinfo));
24382ff020d3SMikolaj Golub 		goto out;
24392ff020d3SMikolaj Golub 	}
24402ff020d3SMikolaj Golub 	for (i = 0; i < count; i++) {
24412ff020d3SMikolaj Golub 		/*
24422ff020d3SMikolaj Golub 		 * XXX: We expect that values for a_type on a 32-bit platform
24432ff020d3SMikolaj Golub 		 * are directly mapped to values on 64-bit one, which is not
24442ff020d3SMikolaj Golub 		 * necessarily true.
24452ff020d3SMikolaj Golub 		 */
24462ff020d3SMikolaj Golub 		auxv[i].a_type = auxv32[i].a_type;
24472ff020d3SMikolaj Golub 		ptr = &auxv32[i].a_un;
24482ff020d3SMikolaj Golub 		auxv[i].a_un.a_val = *((uint32_t *)ptr);
24492ff020d3SMikolaj Golub 	}
24502ff020d3SMikolaj Golub 	*cntp = count;
24512ff020d3SMikolaj Golub out:
24522ff020d3SMikolaj Golub 	free(auxv32);
24532ff020d3SMikolaj Golub 	return (auxv);
24542ff020d3SMikolaj Golub }
24552ff020d3SMikolaj Golub #endif /* __ELF_WORD_SIZE == 64 */
24562ff020d3SMikolaj Golub 
24572ff020d3SMikolaj Golub static Elf_Auxinfo *
24582ff020d3SMikolaj Golub procstat_getauxv_sysctl(pid_t pid, unsigned int *cntp)
24592ff020d3SMikolaj Golub {
24602ff020d3SMikolaj Golub 	Elf_Auxinfo *auxv;
24612ff020d3SMikolaj Golub 	int name[4];
24622ff020d3SMikolaj Golub 	size_t len;
24632ff020d3SMikolaj Golub 
24642ff020d3SMikolaj Golub #if __ELF_WORD_SIZE == 64
24652ff020d3SMikolaj Golub 	if (is_elf32_sysctl(pid))
24662ff020d3SMikolaj Golub 		return (procstat_getauxv32_sysctl(pid, cntp));
24672ff020d3SMikolaj Golub #endif
24682ff020d3SMikolaj Golub 	name[0] = CTL_KERN;
24692ff020d3SMikolaj Golub 	name[1] = KERN_PROC;
24702ff020d3SMikolaj Golub 	name[2] = KERN_PROC_AUXV;
24712ff020d3SMikolaj Golub 	name[3] = pid;
24722ff020d3SMikolaj Golub 	len = PROC_AUXV_MAX * sizeof(Elf_Auxinfo);
24732ff020d3SMikolaj Golub 	auxv = malloc(len);
24742ff020d3SMikolaj Golub 	if (auxv == NULL) {
24752ff020d3SMikolaj Golub 		warn("malloc(%zu)", len);
24762ff020d3SMikolaj Golub 		return (NULL);
24772ff020d3SMikolaj Golub 	}
247875b6a179SEnji Cooper 	if (sysctl(name, nitems(name), auxv, &len, NULL, 0) == -1) {
24792ff020d3SMikolaj Golub 		if (errno != ESRCH && errno != EPERM)
24802ff020d3SMikolaj Golub 			warn("sysctl: kern.proc.auxv: %d: %d", pid, errno);
24812ff020d3SMikolaj Golub 		free(auxv);
24822ff020d3SMikolaj Golub 		return (NULL);
24832ff020d3SMikolaj Golub 	}
24842ff020d3SMikolaj Golub 	*cntp = len / sizeof(Elf_Auxinfo);
24852ff020d3SMikolaj Golub 	return (auxv);
24862ff020d3SMikolaj Golub }
24872ff020d3SMikolaj Golub 
24882ff020d3SMikolaj Golub static Elf_Auxinfo *
24892ff020d3SMikolaj Golub procstat_getauxv_core(struct procstat_core *core, unsigned int *cntp)
24902ff020d3SMikolaj Golub {
24912ff020d3SMikolaj Golub 	Elf_Auxinfo *auxv;
24922ff020d3SMikolaj Golub 	size_t len;
24932ff020d3SMikolaj Golub 
24942ff020d3SMikolaj Golub 	auxv = procstat_core_get(core, PSC_TYPE_AUXV, NULL, &len);
24952ff020d3SMikolaj Golub 	if (auxv == NULL)
24962ff020d3SMikolaj Golub 		return (NULL);
24972ff020d3SMikolaj Golub 	*cntp = len / sizeof(Elf_Auxinfo);
24982ff020d3SMikolaj Golub 	return (auxv);
24992ff020d3SMikolaj Golub }
25002ff020d3SMikolaj Golub 
25012ff020d3SMikolaj Golub Elf_Auxinfo *
25022ff020d3SMikolaj Golub procstat_getauxv(struct procstat *procstat, struct kinfo_proc *kp,
25032ff020d3SMikolaj Golub     unsigned int *cntp)
25042ff020d3SMikolaj Golub {
25052ff020d3SMikolaj Golub 	switch(procstat->type) {
25062ff020d3SMikolaj Golub 	case PROCSTAT_KVM:
25072ff020d3SMikolaj Golub 		warnx("kvm method is not supported");
25082ff020d3SMikolaj Golub 		return (NULL);
25092ff020d3SMikolaj Golub 	case PROCSTAT_SYSCTL:
25102ff020d3SMikolaj Golub 		return (procstat_getauxv_sysctl(kp->ki_pid, cntp));
25112ff020d3SMikolaj Golub 	case PROCSTAT_CORE:
25122ff020d3SMikolaj Golub 		return (procstat_getauxv_core(procstat->core, cntp));
25132ff020d3SMikolaj Golub 	default:
25142ff020d3SMikolaj Golub 		warnx("unknown access method: %d", procstat->type);
25152ff020d3SMikolaj Golub 		return (NULL);
25162ff020d3SMikolaj Golub 	}
25172ff020d3SMikolaj Golub }
25182ff020d3SMikolaj Golub 
25192ff020d3SMikolaj Golub void
25202ff020d3SMikolaj Golub procstat_freeauxv(struct procstat *procstat __unused, Elf_Auxinfo *auxv)
25212ff020d3SMikolaj Golub {
25222ff020d3SMikolaj Golub 
25232ff020d3SMikolaj Golub 	free(auxv);
25242ff020d3SMikolaj Golub }
252589358231SMikolaj Golub 
252686be94fcSTycho Nightingale static struct ptrace_lwpinfo *
252786be94fcSTycho Nightingale procstat_getptlwpinfo_core(struct procstat_core *core, unsigned int *cntp)
252886be94fcSTycho Nightingale {
252986be94fcSTycho Nightingale 	void *buf;
253086be94fcSTycho Nightingale 	struct ptrace_lwpinfo *pl;
253186be94fcSTycho Nightingale 	unsigned int cnt;
253286be94fcSTycho Nightingale 	size_t len;
253386be94fcSTycho Nightingale 
253486be94fcSTycho Nightingale 	cnt = procstat_core_note_count(core, PSC_TYPE_PTLWPINFO);
253586be94fcSTycho Nightingale 	if (cnt == 0)
253686be94fcSTycho Nightingale 		return (NULL);
253786be94fcSTycho Nightingale 
253886be94fcSTycho Nightingale 	len = cnt * sizeof(*pl);
253986be94fcSTycho Nightingale 	buf = calloc(1, len);
254086be94fcSTycho Nightingale 	pl = procstat_core_get(core, PSC_TYPE_PTLWPINFO, buf, &len);
254186be94fcSTycho Nightingale 	if (pl == NULL) {
254286be94fcSTycho Nightingale 		free(buf);
254386be94fcSTycho Nightingale 		return (NULL);
254486be94fcSTycho Nightingale 	}
254586be94fcSTycho Nightingale 	*cntp = len / sizeof(*pl);
254686be94fcSTycho Nightingale 	return (pl);
254786be94fcSTycho Nightingale }
254886be94fcSTycho Nightingale 
254986be94fcSTycho Nightingale struct ptrace_lwpinfo *
255086be94fcSTycho Nightingale procstat_getptlwpinfo(struct procstat *procstat, unsigned int *cntp)
255186be94fcSTycho Nightingale {
255286be94fcSTycho Nightingale 	switch (procstat->type) {
2553a2ae08e7SEnji Cooper 	case PROCSTAT_KVM:
2554a2ae08e7SEnji Cooper 		warnx("kvm method is not supported");
2555a2ae08e7SEnji Cooper 		return (NULL);
2556a2ae08e7SEnji Cooper 	case PROCSTAT_SYSCTL:
2557a2ae08e7SEnji Cooper 		warnx("sysctl method is not supported");
2558a2ae08e7SEnji Cooper 		return (NULL);
255986be94fcSTycho Nightingale 	case PROCSTAT_CORE:
256086be94fcSTycho Nightingale 	 	return (procstat_getptlwpinfo_core(procstat->core, cntp));
256186be94fcSTycho Nightingale 	default:
256286be94fcSTycho Nightingale 		warnx("unknown access method: %d", procstat->type);
256386be94fcSTycho Nightingale 		return (NULL);
256486be94fcSTycho Nightingale 	}
256586be94fcSTycho Nightingale }
256686be94fcSTycho Nightingale 
256786be94fcSTycho Nightingale void
256886be94fcSTycho Nightingale procstat_freeptlwpinfo(struct procstat *procstat __unused,
256986be94fcSTycho Nightingale     struct ptrace_lwpinfo *pl)
257086be94fcSTycho Nightingale {
257186be94fcSTycho Nightingale 	free(pl);
257286be94fcSTycho Nightingale }
257386be94fcSTycho Nightingale 
257489358231SMikolaj Golub static struct kinfo_kstack *
257589358231SMikolaj Golub procstat_getkstack_sysctl(pid_t pid, int *cntp)
257689358231SMikolaj Golub {
257789358231SMikolaj Golub 	struct kinfo_kstack *kkstp;
257889358231SMikolaj Golub 	int error, name[4];
257989358231SMikolaj Golub 	size_t len;
258089358231SMikolaj Golub 
258189358231SMikolaj Golub 	name[0] = CTL_KERN;
258289358231SMikolaj Golub 	name[1] = KERN_PROC;
258389358231SMikolaj Golub 	name[2] = KERN_PROC_KSTACK;
258489358231SMikolaj Golub 	name[3] = pid;
258589358231SMikolaj Golub 
258689358231SMikolaj Golub 	len = 0;
258775b6a179SEnji Cooper 	error = sysctl(name, nitems(name), NULL, &len, NULL, 0);
258889358231SMikolaj Golub 	if (error < 0 && errno != ESRCH && errno != EPERM && errno != ENOENT) {
258989358231SMikolaj Golub 		warn("sysctl: kern.proc.kstack: %d", pid);
259089358231SMikolaj Golub 		return (NULL);
259189358231SMikolaj Golub 	}
259289358231SMikolaj Golub 	if (error == -1 && errno == ENOENT) {
259389358231SMikolaj Golub 		warnx("sysctl: kern.proc.kstack unavailable"
259489358231SMikolaj Golub 		    " (options DDB or options STACK required in kernel)");
259589358231SMikolaj Golub 		return (NULL);
259689358231SMikolaj Golub 	}
259789358231SMikolaj Golub 	if (error == -1)
259889358231SMikolaj Golub 		return (NULL);
259989358231SMikolaj Golub 	kkstp = malloc(len);
260089358231SMikolaj Golub 	if (kkstp == NULL) {
260189358231SMikolaj Golub 		warn("malloc(%zu)", len);
260289358231SMikolaj Golub 		return (NULL);
260389358231SMikolaj Golub 	}
260475b6a179SEnji Cooper 	if (sysctl(name, nitems(name), kkstp, &len, NULL, 0) == -1) {
260589358231SMikolaj Golub 		warn("sysctl: kern.proc.pid: %d", pid);
260689358231SMikolaj Golub 		free(kkstp);
260789358231SMikolaj Golub 		return (NULL);
260889358231SMikolaj Golub 	}
260989358231SMikolaj Golub 	*cntp = len / sizeof(*kkstp);
261089358231SMikolaj Golub 
261189358231SMikolaj Golub 	return (kkstp);
261289358231SMikolaj Golub }
261389358231SMikolaj Golub 
261489358231SMikolaj Golub struct kinfo_kstack *
261589358231SMikolaj Golub procstat_getkstack(struct procstat *procstat, struct kinfo_proc *kp,
261689358231SMikolaj Golub     unsigned int *cntp)
261789358231SMikolaj Golub {
261889358231SMikolaj Golub 	switch(procstat->type) {
261989358231SMikolaj Golub 	case PROCSTAT_KVM:
262089358231SMikolaj Golub 		warnx("kvm method is not supported");
262189358231SMikolaj Golub 		return (NULL);
262289358231SMikolaj Golub 	case PROCSTAT_SYSCTL:
262389358231SMikolaj Golub 		return (procstat_getkstack_sysctl(kp->ki_pid, cntp));
262489358231SMikolaj Golub 	case PROCSTAT_CORE:
262589358231SMikolaj Golub 		warnx("core method is not supported");
262689358231SMikolaj Golub 		return (NULL);
262789358231SMikolaj Golub 	default:
262889358231SMikolaj Golub 		warnx("unknown access method: %d", procstat->type);
262989358231SMikolaj Golub 		return (NULL);
263089358231SMikolaj Golub 	}
263189358231SMikolaj Golub }
263289358231SMikolaj Golub 
263389358231SMikolaj Golub void
263489358231SMikolaj Golub procstat_freekstack(struct procstat *procstat __unused,
263589358231SMikolaj Golub     struct kinfo_kstack *kkstp)
263689358231SMikolaj Golub {
263789358231SMikolaj Golub 
263889358231SMikolaj Golub 	free(kkstp);
263989358231SMikolaj Golub }
2640