xref: /freebsd/lib/libprocstat/libprocstat.c (revision 6126f4ea646a3c19647c3efdcf672641cff6954b)
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/param.h>
392ff020d3SMikolaj Golub #include <sys/elf.h>
400daf62d9SStanislav Sedov #include <sys/time.h>
417cc0ebfdSMikolaj Golub #include <sys/resourcevar.h>
421f84c47eSMikolaj Golub #define	_WANT_UCRED
431f84c47eSMikolaj Golub #include <sys/ucred.h>
441f84c47eSMikolaj Golub #undef _WANT_UCRED
450daf62d9SStanislav Sedov #include <sys/proc.h>
460daf62d9SStanislav Sedov #include <sys/user.h>
470daf62d9SStanislav Sedov #include <sys/stat.h>
480daf62d9SStanislav Sedov #include <sys/vnode.h>
490daf62d9SStanislav Sedov #include <sys/socket.h>
500e229f34SGleb Smirnoff #define	_WANT_SOCKET
510daf62d9SStanislav Sedov #include <sys/socketvar.h>
520daf62d9SStanislav Sedov #include <sys/domain.h>
530daf62d9SStanislav Sedov #include <sys/protosw.h>
540daf62d9SStanislav Sedov #include <sys/un.h>
550e229f34SGleb Smirnoff #define	_WANT_UNPCB
560daf62d9SStanislav Sedov #include <sys/unpcb.h>
570daf62d9SStanislav Sedov #include <sys/sysctl.h>
580daf62d9SStanislav Sedov #include <sys/tty.h>
590daf62d9SStanislav Sedov #include <sys/filedesc.h>
600daf62d9SStanislav Sedov #include <sys/queue.h>
610daf62d9SStanislav Sedov #define	_WANT_FILE
620daf62d9SStanislav Sedov #include <sys/file.h>
630daf62d9SStanislav Sedov #include <sys/conf.h>
64958aa575SJohn Baldwin #include <sys/ksem.h>
65e506e182SJohn Baldwin #include <sys/mman.h>
66b881b8beSRobert Watson #include <sys/capsicum.h>
67a4ba6502STycho Nightingale #include <sys/ptrace.h>
68d485c77fSKonstantin Belousov #define	_WANT_MOUNT
690daf62d9SStanislav Sedov #include <sys/mount.h>
709e5787d2SMatt Macy #include <sys/filedesc.h>
710daf62d9SStanislav Sedov #include <sys/pipe.h>
720daf62d9SStanislav Sedov #include <fs/devfs/devfs.h>
730daf62d9SStanislav Sedov #include <fs/devfs/devfs_int.h>
740daf62d9SStanislav Sedov #include <nfs/nfsproto.h>
750daf62d9SStanislav Sedov #include <nfsclient/nfs.h>
760daf62d9SStanislav Sedov #include <nfsclient/nfsnode.h>
770daf62d9SStanislav Sedov 
780daf62d9SStanislav Sedov #include <vm/vm.h>
790daf62d9SStanislav Sedov #include <vm/vm_map.h>
800daf62d9SStanislav Sedov #include <vm/vm_object.h>
810daf62d9SStanislav Sedov 
820daf62d9SStanislav Sedov #include <net/route.h>
830daf62d9SStanislav Sedov #include <netinet/in.h>
840daf62d9SStanislav Sedov #include <netinet/in_systm.h>
850daf62d9SStanislav Sedov #include <netinet/ip.h>
860daf62d9SStanislav Sedov 
870daf62d9SStanislav Sedov #include <assert.h>
880daf62d9SStanislav Sedov #include <ctype.h>
890daf62d9SStanislav Sedov #include <err.h>
900daf62d9SStanislav Sedov #include <fcntl.h>
910daf62d9SStanislav Sedov #include <kvm.h>
920daf62d9SStanislav Sedov #include <libutil.h>
930daf62d9SStanislav Sedov #include <limits.h>
940daf62d9SStanislav Sedov #include <paths.h>
950daf62d9SStanislav Sedov #include <pwd.h>
960daf62d9SStanislav Sedov #include <stdio.h>
970daf62d9SStanislav Sedov #include <stdlib.h>
980daf62d9SStanislav Sedov #include <stddef.h>
990daf62d9SStanislav Sedov #include <string.h>
1000daf62d9SStanislav Sedov #include <unistd.h>
1010daf62d9SStanislav Sedov #include <netdb.h>
1020daf62d9SStanislav Sedov 
1030daf62d9SStanislav Sedov #include <libprocstat.h>
1040daf62d9SStanislav Sedov #include "libprocstat_internal.h"
1050daf62d9SStanislav Sedov #include "common_kvm.h"
1067153ad2bSMikolaj Golub #include "core.h"
1070daf62d9SStanislav Sedov 
1080daf62d9SStanislav Sedov int     statfs(const char *, struct statfs *);	/* XXX */
1090daf62d9SStanislav Sedov 
1100daf62d9SStanislav Sedov #define	PROCSTAT_KVM	1
1110daf62d9SStanislav Sedov #define	PROCSTAT_SYSCTL	2
1127153ad2bSMikolaj Golub #define	PROCSTAT_CORE	3
1130daf62d9SStanislav Sedov 
1144482b5e3SMikolaj Golub static char	**getargv(struct procstat *procstat, struct kinfo_proc *kp,
1154482b5e3SMikolaj Golub     size_t nchr, int env);
1160daf62d9SStanislav Sedov static char	*getmnton(kvm_t *kd, struct mount *m);
11739680c7bSMikolaj Golub static struct kinfo_vmentry *	kinfo_getvmmap_core(struct procstat_core *core,
11839680c7bSMikolaj Golub     int *cntp);
1192ff020d3SMikolaj Golub static Elf_Auxinfo	*procstat_getauxv_core(struct procstat_core *core,
1202ff020d3SMikolaj Golub     unsigned int *cntp);
1212ff020d3SMikolaj Golub static Elf_Auxinfo	*procstat_getauxv_sysctl(pid_t pid, unsigned int *cntp);
1220daf62d9SStanislav Sedov static struct filestat_list	*procstat_getfiles_kvm(
1230daf62d9SStanislav Sedov     struct procstat *procstat, struct kinfo_proc *kp, int mmapped);
1240daf62d9SStanislav Sedov static struct filestat_list	*procstat_getfiles_sysctl(
1250daf62d9SStanislav Sedov     struct procstat *procstat, struct kinfo_proc *kp, int mmapped);
1260daf62d9SStanislav Sedov static int	procstat_get_pipe_info_sysctl(struct filestat *fst,
1270daf62d9SStanislav Sedov     struct pipestat *pipe, char *errbuf);
1280daf62d9SStanislav Sedov static int	procstat_get_pipe_info_kvm(kvm_t *kd, struct filestat *fst,
1290daf62d9SStanislav Sedov     struct pipestat *pipe, char *errbuf);
1300daf62d9SStanislav Sedov static int	procstat_get_pts_info_sysctl(struct filestat *fst,
1310daf62d9SStanislav Sedov     struct ptsstat *pts, char *errbuf);
1320daf62d9SStanislav Sedov static int	procstat_get_pts_info_kvm(kvm_t *kd, struct filestat *fst,
1330daf62d9SStanislav Sedov     struct ptsstat *pts, char *errbuf);
134958aa575SJohn Baldwin static int	procstat_get_sem_info_sysctl(struct filestat *fst,
135958aa575SJohn Baldwin     struct semstat *sem, char *errbuf);
136958aa575SJohn Baldwin static int	procstat_get_sem_info_kvm(kvm_t *kd, struct filestat *fst,
137958aa575SJohn Baldwin     struct semstat *sem, char *errbuf);
138e506e182SJohn Baldwin static int	procstat_get_shm_info_sysctl(struct filestat *fst,
139e506e182SJohn Baldwin     struct shmstat *shm, char *errbuf);
140e506e182SJohn Baldwin static int	procstat_get_shm_info_kvm(kvm_t *kd, struct filestat *fst,
141e506e182SJohn Baldwin     struct shmstat *shm, char *errbuf);
1420daf62d9SStanislav Sedov static int	procstat_get_socket_info_sysctl(struct filestat *fst,
1430daf62d9SStanislav Sedov     struct sockstat *sock, char *errbuf);
1440daf62d9SStanislav Sedov static int	procstat_get_socket_info_kvm(kvm_t *kd, struct filestat *fst,
1450daf62d9SStanislav Sedov     struct sockstat *sock, char *errbuf);
1460daf62d9SStanislav Sedov static int	to_filestat_flags(int flags);
1470daf62d9SStanislav Sedov static int	procstat_get_vnode_info_kvm(kvm_t *kd, struct filestat *fst,
1480daf62d9SStanislav Sedov     struct vnstat *vn, char *errbuf);
1490daf62d9SStanislav Sedov static int	procstat_get_vnode_info_sysctl(struct filestat *fst,
1500daf62d9SStanislav Sedov     struct vnstat *vn, char *errbuf);
1517f1d14e6SMikolaj Golub static gid_t	*procstat_getgroups_core(struct procstat_core *core,
1527f1d14e6SMikolaj Golub     unsigned int *count);
1531f84c47eSMikolaj Golub static gid_t *	procstat_getgroups_kvm(kvm_t *kd, struct kinfo_proc *kp,
1541f84c47eSMikolaj Golub     unsigned int *count);
1557f1d14e6SMikolaj Golub static gid_t	*procstat_getgroups_sysctl(pid_t pid, unsigned int *count);
15689358231SMikolaj Golub static struct kinfo_kstack	*procstat_getkstack_sysctl(pid_t pid,
15789358231SMikolaj Golub     int *cntp);
1581f84c47eSMikolaj Golub static int	procstat_getosrel_core(struct procstat_core *core,
1591f84c47eSMikolaj Golub     int *osrelp);
1601f84c47eSMikolaj Golub static int	procstat_getosrel_kvm(kvm_t *kd, struct kinfo_proc *kp,
1611f84c47eSMikolaj Golub     int *osrelp);
1621f84c47eSMikolaj Golub static int	procstat_getosrel_sysctl(pid_t pid, int *osrelp);
1634cdf9796SMikolaj Golub static int	procstat_getpathname_core(struct procstat_core *core,
1644cdf9796SMikolaj Golub     char *pathname, size_t maxlen);
1654cdf9796SMikolaj Golub static int	procstat_getpathname_sysctl(pid_t pid, char *pathname,
1664cdf9796SMikolaj Golub     size_t maxlen);
1677cc0ebfdSMikolaj Golub static int	procstat_getrlimit_core(struct procstat_core *core, int which,
1687cc0ebfdSMikolaj Golub     struct rlimit* rlimit);
1691f84c47eSMikolaj Golub static int	procstat_getrlimit_kvm(kvm_t *kd, struct kinfo_proc *kp,
1701f84c47eSMikolaj Golub     int which, struct rlimit* rlimit);
1717cc0ebfdSMikolaj Golub static int	procstat_getrlimit_sysctl(pid_t pid, int which,
1727cc0ebfdSMikolaj Golub     struct rlimit* rlimit);
1735b9bcba9SMikolaj Golub static int	procstat_getumask_core(struct procstat_core *core,
1745b9bcba9SMikolaj Golub     unsigned short *maskp);
1751f84c47eSMikolaj Golub static int	procstat_getumask_kvm(kvm_t *kd, struct kinfo_proc *kp,
1761f84c47eSMikolaj Golub     unsigned short *maskp);
1775b9bcba9SMikolaj Golub static int	procstat_getumask_sysctl(pid_t pid, unsigned short *maskp);
1780daf62d9SStanislav Sedov static int	vntype2psfsttype(int type);
1790daf62d9SStanislav Sedov 
1800daf62d9SStanislav Sedov void
1810daf62d9SStanislav Sedov procstat_close(struct procstat *procstat)
1820daf62d9SStanislav Sedov {
1830daf62d9SStanislav Sedov 
1840daf62d9SStanislav Sedov 	assert(procstat);
1850daf62d9SStanislav Sedov 	if (procstat->type == PROCSTAT_KVM)
1860daf62d9SStanislav Sedov 		kvm_close(procstat->kd);
1877153ad2bSMikolaj Golub 	else if (procstat->type == PROCSTAT_CORE)
1887153ad2bSMikolaj Golub 		procstat_core_close(procstat->core);
1894482b5e3SMikolaj Golub 	procstat_freeargv(procstat);
1904482b5e3SMikolaj Golub 	procstat_freeenvv(procstat);
191d7b666aeSSergey Kandaurov 	free(procstat);
1920daf62d9SStanislav Sedov }
1930daf62d9SStanislav Sedov 
1940daf62d9SStanislav Sedov struct procstat *
1950daf62d9SStanislav Sedov procstat_open_sysctl(void)
1960daf62d9SStanislav Sedov {
1970daf62d9SStanislav Sedov 	struct procstat *procstat;
1980daf62d9SStanislav Sedov 
1990daf62d9SStanislav Sedov 	procstat = calloc(1, sizeof(*procstat));
2000daf62d9SStanislav Sedov 	if (procstat == NULL) {
2010daf62d9SStanislav Sedov 		warn("malloc()");
2020daf62d9SStanislav Sedov 		return (NULL);
2030daf62d9SStanislav Sedov 	}
2040daf62d9SStanislav Sedov 	procstat->type = PROCSTAT_SYSCTL;
2050daf62d9SStanislav Sedov 	return (procstat);
2060daf62d9SStanislav Sedov }
2070daf62d9SStanislav Sedov 
2080daf62d9SStanislav Sedov struct procstat *
2090daf62d9SStanislav Sedov procstat_open_kvm(const char *nlistf, const char *memf)
2100daf62d9SStanislav Sedov {
2110daf62d9SStanislav Sedov 	struct procstat *procstat;
2120daf62d9SStanislav Sedov 	kvm_t *kd;
2130daf62d9SStanislav Sedov 	char buf[_POSIX2_LINE_MAX];
2140daf62d9SStanislav Sedov 
2150daf62d9SStanislav Sedov 	procstat = calloc(1, sizeof(*procstat));
2160daf62d9SStanislav Sedov 	if (procstat == NULL) {
2170daf62d9SStanislav Sedov 		warn("malloc()");
2180daf62d9SStanislav Sedov 		return (NULL);
2190daf62d9SStanislav Sedov 	}
2200daf62d9SStanislav Sedov 	kd = kvm_openfiles(nlistf, memf, NULL, O_RDONLY, buf);
2210daf62d9SStanislav Sedov 	if (kd == NULL) {
2220daf62d9SStanislav Sedov 		warnx("kvm_openfiles(): %s", buf);
2230daf62d9SStanislav Sedov 		free(procstat);
2240daf62d9SStanislav Sedov 		return (NULL);
2250daf62d9SStanislav Sedov 	}
2260daf62d9SStanislav Sedov 	procstat->type = PROCSTAT_KVM;
2270daf62d9SStanislav Sedov 	procstat->kd = kd;
2280daf62d9SStanislav Sedov 	return (procstat);
2290daf62d9SStanislav Sedov }
2300daf62d9SStanislav Sedov 
2317153ad2bSMikolaj Golub struct procstat *
2327153ad2bSMikolaj Golub procstat_open_core(const char *filename)
2337153ad2bSMikolaj Golub {
2347153ad2bSMikolaj Golub 	struct procstat *procstat;
2357153ad2bSMikolaj Golub 	struct procstat_core *core;
2367153ad2bSMikolaj Golub 
2377153ad2bSMikolaj Golub 	procstat = calloc(1, sizeof(*procstat));
2387153ad2bSMikolaj Golub 	if (procstat == NULL) {
2397153ad2bSMikolaj Golub 		warn("malloc()");
2407153ad2bSMikolaj Golub 		return (NULL);
2417153ad2bSMikolaj Golub 	}
2427153ad2bSMikolaj Golub 	core = procstat_core_open(filename);
2437153ad2bSMikolaj Golub 	if (core == NULL) {
2447153ad2bSMikolaj Golub 		free(procstat);
2457153ad2bSMikolaj Golub 		return (NULL);
2467153ad2bSMikolaj Golub 	}
2477153ad2bSMikolaj Golub 	procstat->type = PROCSTAT_CORE;
2487153ad2bSMikolaj Golub 	procstat->core = core;
2497153ad2bSMikolaj Golub 	return (procstat);
2507153ad2bSMikolaj Golub }
2517153ad2bSMikolaj Golub 
2520daf62d9SStanislav Sedov struct kinfo_proc *
2530daf62d9SStanislav Sedov procstat_getprocs(struct procstat *procstat, int what, int arg,
2540daf62d9SStanislav Sedov     unsigned int *count)
2550daf62d9SStanislav Sedov {
2560daf62d9SStanislav Sedov 	struct kinfo_proc *p0, *p;
257608203fdSJohn Baldwin 	size_t len, olen;
2580daf62d9SStanislav Sedov 	int name[4];
259391bdfb8SAndriy Gapon 	int cnt;
2600daf62d9SStanislav Sedov 	int error;
2610daf62d9SStanislav Sedov 
2620daf62d9SStanislav Sedov 	assert(procstat);
2630daf62d9SStanislav Sedov 	assert(count);
2640daf62d9SStanislav Sedov 	p = NULL;
2650daf62d9SStanislav Sedov 	if (procstat->type == PROCSTAT_KVM) {
266391bdfb8SAndriy Gapon 		*count = 0;
267391bdfb8SAndriy Gapon 		p0 = kvm_getprocs(procstat->kd, what, arg, &cnt);
268391bdfb8SAndriy Gapon 		if (p0 == NULL || cnt <= 0)
2690daf62d9SStanislav Sedov 			return (NULL);
270391bdfb8SAndriy Gapon 		*count = cnt;
2710daf62d9SStanislav Sedov 		len = *count * sizeof(*p);
2720daf62d9SStanislav Sedov 		p = malloc(len);
2730daf62d9SStanislav Sedov 		if (p == NULL) {
27465869214SJilles Tjoelker 			warnx("malloc(%zu)", len);
2750daf62d9SStanislav Sedov 			goto fail;
2760daf62d9SStanislav Sedov 		}
2770daf62d9SStanislav Sedov 		bcopy(p0, p, len);
2780daf62d9SStanislav Sedov 		return (p);
2790daf62d9SStanislav Sedov 	} else if (procstat->type == PROCSTAT_SYSCTL) {
2800daf62d9SStanislav Sedov 		len = 0;
2810daf62d9SStanislav Sedov 		name[0] = CTL_KERN;
2820daf62d9SStanislav Sedov 		name[1] = KERN_PROC;
2830daf62d9SStanislav Sedov 		name[2] = what;
2840daf62d9SStanislav Sedov 		name[3] = arg;
28575b6a179SEnji Cooper 		error = sysctl(name, nitems(name), NULL, &len, NULL, 0);
2860daf62d9SStanislav Sedov 		if (error < 0 && errno != EPERM) {
2870daf62d9SStanislav Sedov 			warn("sysctl(kern.proc)");
2880daf62d9SStanislav Sedov 			goto fail;
2890daf62d9SStanislav Sedov 		}
2900daf62d9SStanislav Sedov 		if (len == 0) {
2910daf62d9SStanislav Sedov 			warnx("no processes?");
2920daf62d9SStanislav Sedov 			goto fail;
2930daf62d9SStanislav Sedov 		}
294608203fdSJohn Baldwin 		do {
295608203fdSJohn Baldwin 			len += len / 10;
296608203fdSJohn Baldwin 			p = reallocf(p, len);
2970daf62d9SStanislav Sedov 			if (p == NULL) {
298608203fdSJohn Baldwin 				warnx("reallocf(%zu)", len);
2990daf62d9SStanislav Sedov 				goto fail;
3000daf62d9SStanislav Sedov 			}
301608203fdSJohn Baldwin 			olen = len;
30275b6a179SEnji Cooper 			error = sysctl(name, nitems(name), p, &len, NULL, 0);
303608203fdSJohn Baldwin 		} while (error < 0 && errno == ENOMEM && olen == len);
3040daf62d9SStanislav Sedov 		if (error < 0 && errno != EPERM) {
3050daf62d9SStanislav Sedov 			warn("sysctl(kern.proc)");
3060daf62d9SStanislav Sedov 			goto fail;
3070daf62d9SStanislav Sedov 		}
3080daf62d9SStanislav Sedov 		/* Perform simple consistency checks. */
3090daf62d9SStanislav Sedov 		if ((len % sizeof(*p)) != 0 || p->ki_structsize != sizeof(*p)) {
3107153ad2bSMikolaj Golub 			warnx("kinfo_proc structure size mismatch (len = %zu)", len);
3117153ad2bSMikolaj Golub 			goto fail;
3127153ad2bSMikolaj Golub 		}
3137153ad2bSMikolaj Golub 		*count = len / sizeof(*p);
3147153ad2bSMikolaj Golub 		return (p);
3157153ad2bSMikolaj Golub 	} else if (procstat->type == PROCSTAT_CORE) {
3167153ad2bSMikolaj Golub 		p = procstat_core_get(procstat->core, PSC_TYPE_PROC, NULL,
3177153ad2bSMikolaj Golub 		    &len);
3187153ad2bSMikolaj Golub 		if ((len % sizeof(*p)) != 0 || p->ki_structsize != sizeof(*p)) {
3190daf62d9SStanislav Sedov 			warnx("kinfo_proc structure size mismatch");
3200daf62d9SStanislav Sedov 			goto fail;
3210daf62d9SStanislav Sedov 		}
3220daf62d9SStanislav Sedov 		*count = len / sizeof(*p);
3230daf62d9SStanislav Sedov 		return (p);
3240daf62d9SStanislav Sedov 	} else {
32580905c35SJilles Tjoelker 		warnx("unknown access method: %d", procstat->type);
3260daf62d9SStanislav Sedov 		return (NULL);
3270daf62d9SStanislav Sedov 	}
3280daf62d9SStanislav Sedov fail:
3290daf62d9SStanislav Sedov 	if (p)
3300daf62d9SStanislav Sedov 		free(p);
3310daf62d9SStanislav Sedov 	return (NULL);
3320daf62d9SStanislav Sedov }
3330daf62d9SStanislav Sedov 
3340daf62d9SStanislav Sedov void
3350daf62d9SStanislav Sedov procstat_freeprocs(struct procstat *procstat __unused, struct kinfo_proc *p)
3360daf62d9SStanislav Sedov {
3370daf62d9SStanislav Sedov 
3380daf62d9SStanislav Sedov 	if (p != NULL)
3390daf62d9SStanislav Sedov 		free(p);
3400daf62d9SStanislav Sedov 	p = NULL;
3410daf62d9SStanislav Sedov }
3420daf62d9SStanislav Sedov 
3430daf62d9SStanislav Sedov struct filestat_list *
3440daf62d9SStanislav Sedov procstat_getfiles(struct procstat *procstat, struct kinfo_proc *kp, int mmapped)
3450daf62d9SStanislav Sedov {
3460daf62d9SStanislav Sedov 
3477153ad2bSMikolaj Golub 	switch (procstat->type) {
3487153ad2bSMikolaj Golub 	case PROCSTAT_KVM:
3490daf62d9SStanislav Sedov 		return (procstat_getfiles_kvm(procstat, kp, mmapped));
3507153ad2bSMikolaj Golub 	case PROCSTAT_SYSCTL:
3517153ad2bSMikolaj Golub 	case PROCSTAT_CORE:
3527153ad2bSMikolaj Golub 		return (procstat_getfiles_sysctl(procstat, kp, mmapped));
3537153ad2bSMikolaj Golub 	default:
3547153ad2bSMikolaj Golub 		warnx("unknown access method: %d", procstat->type);
3550daf62d9SStanislav Sedov 		return (NULL);
3560daf62d9SStanislav Sedov 	}
3577153ad2bSMikolaj Golub }
3580daf62d9SStanislav Sedov 
3590daf62d9SStanislav Sedov void
3600daf62d9SStanislav Sedov procstat_freefiles(struct procstat *procstat, struct filestat_list *head)
3610daf62d9SStanislav Sedov {
3620daf62d9SStanislav Sedov 	struct filestat *fst, *tmp;
3630daf62d9SStanislav Sedov 
3640daf62d9SStanislav Sedov 	STAILQ_FOREACH_SAFE(fst, head, next, tmp) {
3650daf62d9SStanislav Sedov 		if (fst->fs_path != NULL)
3660daf62d9SStanislav Sedov 			free(fst->fs_path);
3670daf62d9SStanislav Sedov 		free(fst);
3680daf62d9SStanislav Sedov 	}
3690daf62d9SStanislav Sedov 	free(head);
3700daf62d9SStanislav Sedov 	if (procstat->vmentries != NULL) {
3710daf62d9SStanislav Sedov 		free(procstat->vmentries);
3720daf62d9SStanislav Sedov 		procstat->vmentries = NULL;
3730daf62d9SStanislav Sedov 	}
3740daf62d9SStanislav Sedov 	if (procstat->files != NULL) {
3750daf62d9SStanislav Sedov 		free(procstat->files);
3760daf62d9SStanislav Sedov 		procstat->files = NULL;
3770daf62d9SStanislav Sedov 	}
3780daf62d9SStanislav Sedov }
3790daf62d9SStanislav Sedov 
3800daf62d9SStanislav Sedov static struct filestat *
3810daf62d9SStanislav Sedov filestat_new_entry(void *typedep, int type, int fd, int fflags, int uflags,
3827008be5bSPawel Jakub Dawidek     int refcount, off_t offset, char *path, cap_rights_t *cap_rightsp)
3830daf62d9SStanislav Sedov {
3840daf62d9SStanislav Sedov 	struct filestat *entry;
3850daf62d9SStanislav Sedov 
3860daf62d9SStanislav Sedov 	entry = calloc(1, sizeof(*entry));
3870daf62d9SStanislav Sedov 	if (entry == NULL) {
3880daf62d9SStanislav Sedov 		warn("malloc()");
3890daf62d9SStanislav Sedov 		return (NULL);
3900daf62d9SStanislav Sedov 	}
3910daf62d9SStanislav Sedov 	entry->fs_typedep = typedep;
3920daf62d9SStanislav Sedov 	entry->fs_fflags = fflags;
3930daf62d9SStanislav Sedov 	entry->fs_uflags = uflags;
3940daf62d9SStanislav Sedov 	entry->fs_fd = fd;
3950daf62d9SStanislav Sedov 	entry->fs_type = type;
3960daf62d9SStanislav Sedov 	entry->fs_ref_count = refcount;
3970daf62d9SStanislav Sedov 	entry->fs_offset = offset;
3980daf62d9SStanislav Sedov 	entry->fs_path = path;
399772f6645SPawel Jakub Dawidek 	if (cap_rightsp != NULL)
4007008be5bSPawel Jakub Dawidek 		entry->fs_cap_rights = *cap_rightsp;
401772f6645SPawel Jakub Dawidek 	else
402772f6645SPawel Jakub Dawidek 		cap_rights_init(&entry->fs_cap_rights);
4030daf62d9SStanislav Sedov 	return (entry);
4040daf62d9SStanislav Sedov }
4050daf62d9SStanislav Sedov 
4060daf62d9SStanislav Sedov static struct vnode *
4070daf62d9SStanislav Sedov getctty(kvm_t *kd, struct kinfo_proc *kp)
4080daf62d9SStanislav Sedov {
4090daf62d9SStanislav Sedov 	struct pgrp pgrp;
4100daf62d9SStanislav Sedov 	struct proc proc;
4110daf62d9SStanislav Sedov 	struct session sess;
4120daf62d9SStanislav Sedov 	int error;
4130daf62d9SStanislav Sedov 
4140daf62d9SStanislav Sedov 	assert(kp);
4150daf62d9SStanislav Sedov 	error = kvm_read_all(kd, (unsigned long)kp->ki_paddr, &proc,
4160daf62d9SStanislav Sedov 	    sizeof(proc));
4170daf62d9SStanislav Sedov 	if (error == 0) {
4180daf62d9SStanislav Sedov 		warnx("can't read proc struct at %p for pid %d",
4190daf62d9SStanislav Sedov 		    kp->ki_paddr, kp->ki_pid);
4200daf62d9SStanislav Sedov 		return (NULL);
4210daf62d9SStanislav Sedov 	}
4220daf62d9SStanislav Sedov 	if (proc.p_pgrp == NULL)
4230daf62d9SStanislav Sedov 		return (NULL);
4240daf62d9SStanislav Sedov 	error = kvm_read_all(kd, (unsigned long)proc.p_pgrp, &pgrp,
4250daf62d9SStanislav Sedov 	    sizeof(pgrp));
4260daf62d9SStanislav Sedov 	if (error == 0) {
4270daf62d9SStanislav Sedov 		warnx("can't read pgrp struct at %p for pid %d",
4280daf62d9SStanislav Sedov 		    proc.p_pgrp, kp->ki_pid);
4290daf62d9SStanislav Sedov 		return (NULL);
4300daf62d9SStanislav Sedov 	}
4310daf62d9SStanislav Sedov 	error = kvm_read_all(kd, (unsigned long)pgrp.pg_session, &sess,
4320daf62d9SStanislav Sedov 	    sizeof(sess));
4330daf62d9SStanislav Sedov 	if (error == 0) {
4340daf62d9SStanislav Sedov 		warnx("can't read session struct at %p for pid %d",
4350daf62d9SStanislav Sedov 		    pgrp.pg_session, kp->ki_pid);
4360daf62d9SStanislav Sedov 		return (NULL);
4370daf62d9SStanislav Sedov 	}
4380daf62d9SStanislav Sedov 	return (sess.s_ttyvp);
4390daf62d9SStanislav Sedov }
4400daf62d9SStanislav Sedov 
4418b75b1adSDoug Moore static int
4428b75b1adSDoug Moore procstat_vm_map_reader(void *token, vm_map_entry_t addr, vm_map_entry_t dest)
4438b75b1adSDoug Moore {
4448b75b1adSDoug Moore 	kvm_t *kd;
4458b75b1adSDoug Moore 
4468b75b1adSDoug Moore 	kd = (kvm_t *)token;
4478b75b1adSDoug Moore 	return (kvm_read_all(kd, (unsigned long)addr, dest, sizeof(*dest)));
4488b75b1adSDoug Moore }
4498b75b1adSDoug Moore 
4500daf62d9SStanislav Sedov static struct filestat_list *
4510daf62d9SStanislav Sedov procstat_getfiles_kvm(struct procstat *procstat, struct kinfo_proc *kp, int mmapped)
4520daf62d9SStanislav Sedov {
4530daf62d9SStanislav Sedov 	struct file file;
4540daf62d9SStanislav Sedov 	struct filedesc filed;
45585078b85SConrad Meyer 	struct pwddesc pathsd;
456f1221c59SMateusz Guzik 	struct fdescenttbl *fdt;
4578d03b99bSMateusz Guzik 	struct pwd pwd;
458d2222aa0SMateusz Guzik 	unsigned long pwd_addr;
4590daf62d9SStanislav Sedov 	struct vm_map_entry vmentry;
4600daf62d9SStanislav Sedov 	struct vm_object object;
4610daf62d9SStanislav Sedov 	struct vmspace vmspace;
4620daf62d9SStanislav Sedov 	vm_map_entry_t entryp;
4630daf62d9SStanislav Sedov 	vm_object_t objp;
4640daf62d9SStanislav Sedov 	struct vnode *vp;
4650daf62d9SStanislav Sedov 	struct filestat *entry;
4660daf62d9SStanislav Sedov 	struct filestat_list *head;
4670daf62d9SStanislav Sedov 	kvm_t *kd;
4680daf62d9SStanislav Sedov 	void *data;
469f1221c59SMateusz Guzik 	int fflags;
470f1221c59SMateusz Guzik 	unsigned int i;
4710daf62d9SStanislav Sedov 	int prot, type;
472f1221c59SMateusz Guzik 	size_t fdt_size;
4730daf62d9SStanislav Sedov 	unsigned int nfiles;
4748d03b99bSMateusz Guzik 	bool haspwd;
4750daf62d9SStanislav Sedov 
4760daf62d9SStanislav Sedov 	assert(procstat);
4770daf62d9SStanislav Sedov 	kd = procstat->kd;
4780daf62d9SStanislav Sedov 	if (kd == NULL)
4790daf62d9SStanislav Sedov 		return (NULL);
48085078b85SConrad Meyer 	if (kp->ki_fd == NULL || kp->ki_pd == NULL)
4810daf62d9SStanislav Sedov 		return (NULL);
4820daf62d9SStanislav Sedov 	if (!kvm_read_all(kd, (unsigned long)kp->ki_fd, &filed,
4830daf62d9SStanislav Sedov 	    sizeof(filed))) {
4840daf62d9SStanislav Sedov 		warnx("can't read filedesc at %p", (void *)kp->ki_fd);
4850daf62d9SStanislav Sedov 		return (NULL);
4860daf62d9SStanislav Sedov 	}
48785078b85SConrad Meyer 	if (!kvm_read_all(kd, (unsigned long)kp->ki_pd, &pathsd,
48885078b85SConrad Meyer 	    sizeof(pathsd))) {
48985078b85SConrad Meyer 		warnx("can't read pwddesc at %p", (void *)kp->ki_pd);
49085078b85SConrad Meyer 		return (NULL);
49185078b85SConrad Meyer 	}
4928d03b99bSMateusz Guzik 	haspwd = false;
49385078b85SConrad Meyer 	pwd_addr = (unsigned long)(PWDDESC_KVM_LOAD_PWD(&pathsd));
494d2222aa0SMateusz Guzik 	if (pwd_addr != 0) {
495d2222aa0SMateusz Guzik 		if (!kvm_read_all(kd, pwd_addr, &pwd, sizeof(pwd))) {
496d2222aa0SMateusz Guzik 			warnx("can't read fd_pwd at %p", (void *)pwd_addr);
4978d03b99bSMateusz Guzik 			return (NULL);
4988d03b99bSMateusz Guzik 		}
4998d03b99bSMateusz Guzik 		haspwd = true;
5008d03b99bSMateusz Guzik 	}
5010daf62d9SStanislav Sedov 
5020daf62d9SStanislav Sedov 	/*
5030daf62d9SStanislav Sedov 	 * Allocate list head.
5040daf62d9SStanislav Sedov 	 */
5050daf62d9SStanislav Sedov 	head = malloc(sizeof(*head));
5060daf62d9SStanislav Sedov 	if (head == NULL)
5070daf62d9SStanislav Sedov 		return (NULL);
5080daf62d9SStanislav Sedov 	STAILQ_INIT(head);
5090daf62d9SStanislav Sedov 
5100daf62d9SStanislav Sedov 	/* root directory vnode, if one. */
5118d03b99bSMateusz Guzik 	if (haspwd) {
5128d03b99bSMateusz Guzik 		if (pwd.pwd_rdir) {
5138d03b99bSMateusz Guzik 			entry = filestat_new_entry(pwd.pwd_rdir, PS_FST_TYPE_VNODE, -1,
514772f6645SPawel Jakub Dawidek 			    PS_FST_FFLAG_READ, PS_FST_UFLAG_RDIR, 0, 0, NULL, NULL);
5150daf62d9SStanislav Sedov 			if (entry != NULL)
5160daf62d9SStanislav Sedov 				STAILQ_INSERT_TAIL(head, entry, next);
5170daf62d9SStanislav Sedov 		}
5180daf62d9SStanislav Sedov 		/* current working directory vnode. */
5198d03b99bSMateusz Guzik 		if (pwd.pwd_cdir) {
5208d03b99bSMateusz Guzik 			entry = filestat_new_entry(pwd.pwd_cdir, PS_FST_TYPE_VNODE, -1,
521772f6645SPawel Jakub Dawidek 			    PS_FST_FFLAG_READ, PS_FST_UFLAG_CDIR, 0, 0, NULL, NULL);
5220daf62d9SStanislav Sedov 			if (entry != NULL)
5230daf62d9SStanislav Sedov 				STAILQ_INSERT_TAIL(head, entry, next);
5240daf62d9SStanislav Sedov 		}
5250daf62d9SStanislav Sedov 		/* jail root, if any. */
5268d03b99bSMateusz Guzik 		if (pwd.pwd_jdir) {
5278d03b99bSMateusz Guzik 			entry = filestat_new_entry(pwd.pwd_jdir, PS_FST_TYPE_VNODE, -1,
528772f6645SPawel Jakub Dawidek 			    PS_FST_FFLAG_READ, PS_FST_UFLAG_JAIL, 0, 0, NULL, NULL);
5290daf62d9SStanislav Sedov 			if (entry != NULL)
5300daf62d9SStanislav Sedov 				STAILQ_INSERT_TAIL(head, entry, next);
5310daf62d9SStanislav Sedov 		}
5328d03b99bSMateusz Guzik 	}
5330daf62d9SStanislav Sedov 	/* ktrace vnode, if one */
5340daf62d9SStanislav Sedov 	if (kp->ki_tracep) {
5350daf62d9SStanislav Sedov 		entry = filestat_new_entry(kp->ki_tracep, PS_FST_TYPE_VNODE, -1,
5360daf62d9SStanislav Sedov 		    PS_FST_FFLAG_READ | PS_FST_FFLAG_WRITE,
537772f6645SPawel Jakub Dawidek 		    PS_FST_UFLAG_TRACE, 0, 0, NULL, NULL);
5380daf62d9SStanislav Sedov 		if (entry != NULL)
5390daf62d9SStanislav Sedov 			STAILQ_INSERT_TAIL(head, entry, next);
5400daf62d9SStanislav Sedov 	}
5410daf62d9SStanislav Sedov 	/* text vnode, if one */
5420daf62d9SStanislav Sedov 	if (kp->ki_textvp) {
5430daf62d9SStanislav Sedov 		entry = filestat_new_entry(kp->ki_textvp, PS_FST_TYPE_VNODE, -1,
544772f6645SPawel Jakub Dawidek 		    PS_FST_FFLAG_READ, PS_FST_UFLAG_TEXT, 0, 0, NULL, NULL);
5450daf62d9SStanislav Sedov 		if (entry != NULL)
5460daf62d9SStanislav Sedov 			STAILQ_INSERT_TAIL(head, entry, next);
5470daf62d9SStanislav Sedov 	}
5480daf62d9SStanislav Sedov 	/* Controlling terminal. */
5490daf62d9SStanislav Sedov 	if ((vp = getctty(kd, kp)) != NULL) {
5500daf62d9SStanislav Sedov 		entry = filestat_new_entry(vp, PS_FST_TYPE_VNODE, -1,
5510daf62d9SStanislav Sedov 		    PS_FST_FFLAG_READ | PS_FST_FFLAG_WRITE,
552772f6645SPawel Jakub Dawidek 		    PS_FST_UFLAG_CTTY, 0, 0, NULL, NULL);
5530daf62d9SStanislav Sedov 		if (entry != NULL)
5540daf62d9SStanislav Sedov 			STAILQ_INSERT_TAIL(head, entry, next);
5550daf62d9SStanislav Sedov 	}
5560daf62d9SStanislav Sedov 
557f1221c59SMateusz Guzik 	if (!kvm_read_all(kd, (unsigned long)filed.fd_files, &nfiles,
558f1221c59SMateusz Guzik 	    sizeof(nfiles))) {
559f1221c59SMateusz Guzik 		warnx("can't read fd_files at %p", (void *)filed.fd_files);
560f1221c59SMateusz Guzik 		return (NULL);
561f1221c59SMateusz Guzik 	}
562f1221c59SMateusz Guzik 
563f1221c59SMateusz Guzik 	fdt_size = sizeof(*fdt) + nfiles * sizeof(struct filedescent);
564f1221c59SMateusz Guzik 	fdt = malloc(fdt_size);
565f1221c59SMateusz Guzik 	if (fdt == NULL) {
566f1221c59SMateusz Guzik 		warn("malloc(%zu)", fdt_size);
5670daf62d9SStanislav Sedov 		goto do_mmapped;
5680daf62d9SStanislav Sedov 	}
569f1221c59SMateusz Guzik 	if (!kvm_read_all(kd, (unsigned long)filed.fd_files, fdt, fdt_size)) {
570f1221c59SMateusz Guzik 		warnx("cannot read file structures at %p", (void *)filed.fd_files);
571f1221c59SMateusz Guzik 		free(fdt);
5720daf62d9SStanislav Sedov 		goto do_mmapped;
5730daf62d9SStanislav Sedov 	}
574f1221c59SMateusz Guzik 	for (i = 0; i < nfiles; i++) {
575f1221c59SMateusz Guzik 		if (fdt->fdt_ofiles[i].fde_file == NULL) {
5760daf62d9SStanislav Sedov 			continue;
577f1221c59SMateusz Guzik 		}
578f1221c59SMateusz Guzik 		if (!kvm_read_all(kd, (unsigned long)fdt->fdt_ofiles[i].fde_file, &file,
5790daf62d9SStanislav Sedov 		    sizeof(struct file))) {
5800daf62d9SStanislav Sedov 			warnx("can't read file %d at %p", i,
581f1221c59SMateusz Guzik 			    (void *)fdt->fdt_ofiles[i].fde_file);
5820daf62d9SStanislav Sedov 			continue;
5830daf62d9SStanislav Sedov 		}
5840daf62d9SStanislav Sedov 		switch (file.f_type) {
5850daf62d9SStanislav Sedov 		case DTYPE_VNODE:
5860daf62d9SStanislav Sedov 			type = PS_FST_TYPE_VNODE;
5870daf62d9SStanislav Sedov 			data = file.f_vnode;
5880daf62d9SStanislav Sedov 			break;
5890daf62d9SStanislav Sedov 		case DTYPE_SOCKET:
5900daf62d9SStanislav Sedov 			type = PS_FST_TYPE_SOCKET;
5910daf62d9SStanislav Sedov 			data = file.f_data;
5920daf62d9SStanislav Sedov 			break;
5930daf62d9SStanislav Sedov 		case DTYPE_PIPE:
5940daf62d9SStanislav Sedov 			type = PS_FST_TYPE_PIPE;
5950daf62d9SStanislav Sedov 			data = file.f_data;
5960daf62d9SStanislav Sedov 			break;
5970daf62d9SStanislav Sedov 		case DTYPE_FIFO:
5980daf62d9SStanislav Sedov 			type = PS_FST_TYPE_FIFO;
5990daf62d9SStanislav Sedov 			data = file.f_vnode;
6000daf62d9SStanislav Sedov 			break;
6010daf62d9SStanislav Sedov #ifdef DTYPE_PTS
6020daf62d9SStanislav Sedov 		case DTYPE_PTS:
6030daf62d9SStanislav Sedov 			type = PS_FST_TYPE_PTS;
6040daf62d9SStanislav Sedov 			data = file.f_data;
6050daf62d9SStanislav Sedov 			break;
6060daf62d9SStanislav Sedov #endif
607958aa575SJohn Baldwin 		case DTYPE_SEM:
608958aa575SJohn Baldwin 			type = PS_FST_TYPE_SEM;
609958aa575SJohn Baldwin 			data = file.f_data;
610958aa575SJohn Baldwin 			break;
611e506e182SJohn Baldwin 		case DTYPE_SHM:
612e506e182SJohn Baldwin 			type = PS_FST_TYPE_SHM;
613e506e182SJohn Baldwin 			data = file.f_data;
614e506e182SJohn Baldwin 			break;
6153cfa7c6eSEdward Tomasz Napierala 		case DTYPE_PROCDESC:
6163cfa7c6eSEdward Tomasz Napierala 			type = PS_FST_TYPE_PROCDESC;
6173cfa7c6eSEdward Tomasz Napierala 			data = file.f_data;
6183cfa7c6eSEdward Tomasz Napierala 			break;
619a66732deSKonstantin Belousov 		case DTYPE_DEV:
620a66732deSKonstantin Belousov 			type = PS_FST_TYPE_DEV;
621a66732deSKonstantin Belousov 			data = file.f_data;
622a66732deSKonstantin Belousov 			break;
62367af9abaSKonstantin Belousov 		case DTYPE_EVENTFD:
62467af9abaSKonstantin Belousov 			type = PS_FST_TYPE_EVENTFD;
62567af9abaSKonstantin Belousov 			data = file.f_data;
62667af9abaSKonstantin Belousov 			break;
6270daf62d9SStanislav Sedov 		default:
6280daf62d9SStanislav Sedov 			continue;
6290daf62d9SStanislav Sedov 		}
630d57486e2SRobert Watson 		/* XXXRW: No capability rights support for kvm yet. */
6310daf62d9SStanislav Sedov 		entry = filestat_new_entry(data, type, i,
632772f6645SPawel Jakub Dawidek 		    to_filestat_flags(file.f_flag), 0, 0, 0, NULL, NULL);
6330daf62d9SStanislav Sedov 		if (entry != NULL)
6340daf62d9SStanislav Sedov 			STAILQ_INSERT_TAIL(head, entry, next);
6350daf62d9SStanislav Sedov 	}
636f1221c59SMateusz Guzik 	free(fdt);
6370daf62d9SStanislav Sedov 
6380daf62d9SStanislav Sedov do_mmapped:
6390daf62d9SStanislav Sedov 
6400daf62d9SStanislav Sedov 	/*
6410daf62d9SStanislav Sedov 	 * Process mmapped files if requested.
6420daf62d9SStanislav Sedov 	 */
6430daf62d9SStanislav Sedov 	if (mmapped) {
6440daf62d9SStanislav Sedov 		if (!kvm_read_all(kd, (unsigned long)kp->ki_vmspace, &vmspace,
6450daf62d9SStanislav Sedov 		    sizeof(vmspace))) {
6460daf62d9SStanislav Sedov 			warnx("can't read vmspace at %p",
6470daf62d9SStanislav Sedov 			    (void *)kp->ki_vmspace);
6480daf62d9SStanislav Sedov 			goto exit;
6490daf62d9SStanislav Sedov 		}
6500daf62d9SStanislav Sedov 
6518b75b1adSDoug Moore 		vmentry = vmspace.vm_map.header;
6528b75b1adSDoug Moore 		for (entryp = vm_map_entry_read_succ(kd, &vmentry, procstat_vm_map_reader);
6538b75b1adSDoug Moore 		    entryp != NULL && entryp != &kp->ki_vmspace->vm_map.header;
6548b75b1adSDoug Moore 		     entryp = vm_map_entry_read_succ(kd, &vmentry, procstat_vm_map_reader)) {
6550daf62d9SStanislav Sedov 			if (vmentry.eflags & MAP_ENTRY_IS_SUB_MAP)
6560daf62d9SStanislav Sedov 				continue;
6570daf62d9SStanislav Sedov 			if ((objp = vmentry.object.vm_object) == NULL)
6580daf62d9SStanislav Sedov 				continue;
6590daf62d9SStanislav Sedov 			for (; objp; objp = object.backing_object) {
6600daf62d9SStanislav Sedov 				if (!kvm_read_all(kd, (unsigned long)objp,
6610daf62d9SStanislav Sedov 				    &object, sizeof(object))) {
6620daf62d9SStanislav Sedov 					warnx("can't read vm_object at %p",
6630daf62d9SStanislav Sedov 					    (void *)objp);
6640daf62d9SStanislav Sedov 					break;
6650daf62d9SStanislav Sedov 				}
6660daf62d9SStanislav Sedov 			}
6670daf62d9SStanislav Sedov 
6680daf62d9SStanislav Sedov 			/* We want only vnode objects. */
6690daf62d9SStanislav Sedov 			if (object.type != OBJT_VNODE)
6700daf62d9SStanislav Sedov 				continue;
6710daf62d9SStanislav Sedov 
6720daf62d9SStanislav Sedov 			prot = vmentry.protection;
6730daf62d9SStanislav Sedov 			fflags = 0;
6740daf62d9SStanislav Sedov 			if (prot & VM_PROT_READ)
6750daf62d9SStanislav Sedov 				fflags = PS_FST_FFLAG_READ;
676279a233dSJilles Tjoelker 			if ((vmentry.eflags & MAP_ENTRY_COW) == 0 &&
677279a233dSJilles Tjoelker 			    prot & VM_PROT_WRITE)
6780daf62d9SStanislav Sedov 				fflags |= PS_FST_FFLAG_WRITE;
6790daf62d9SStanislav Sedov 
6800daf62d9SStanislav Sedov 			/*
6810daf62d9SStanislav Sedov 			 * Create filestat entry.
6820daf62d9SStanislav Sedov 			 */
6830daf62d9SStanislav Sedov 			entry = filestat_new_entry(object.handle,
6840daf62d9SStanislav Sedov 			    PS_FST_TYPE_VNODE, -1, fflags,
685772f6645SPawel Jakub Dawidek 			    PS_FST_UFLAG_MMAP, 0, 0, NULL, NULL);
6860daf62d9SStanislav Sedov 			if (entry != NULL)
6870daf62d9SStanislav Sedov 				STAILQ_INSERT_TAIL(head, entry, next);
6880daf62d9SStanislav Sedov 		}
6898b75b1adSDoug Moore 		if (entryp == NULL)
6908b75b1adSDoug Moore 			warnx("can't read vm_map_entry");
6910daf62d9SStanislav Sedov 	}
6920daf62d9SStanislav Sedov exit:
6930daf62d9SStanislav Sedov 	return (head);
6940daf62d9SStanislav Sedov }
6950daf62d9SStanislav Sedov 
6960daf62d9SStanislav Sedov /*
6970daf62d9SStanislav Sedov  * kinfo types to filestat translation.
6980daf62d9SStanislav Sedov  */
6990daf62d9SStanislav Sedov static int
7000daf62d9SStanislav Sedov kinfo_type2fst(int kftype)
7010daf62d9SStanislav Sedov {
7020daf62d9SStanislav Sedov 	static struct {
7030daf62d9SStanislav Sedov 		int	kf_type;
7040daf62d9SStanislav Sedov 		int	fst_type;
7050daf62d9SStanislav Sedov 	} kftypes2fst[] = {
7063cfa7c6eSEdward Tomasz Napierala 		{ KF_TYPE_PROCDESC, PS_FST_TYPE_PROCDESC },
707a66732deSKonstantin Belousov 		{ KF_TYPE_DEV, PS_FST_TYPE_DEV },
7080daf62d9SStanislav Sedov 		{ KF_TYPE_FIFO, PS_FST_TYPE_FIFO },
7090daf62d9SStanislav Sedov 		{ KF_TYPE_KQUEUE, PS_FST_TYPE_KQUEUE },
7100daf62d9SStanislav Sedov 		{ KF_TYPE_MQUEUE, PS_FST_TYPE_MQUEUE },
7110daf62d9SStanislav Sedov 		{ KF_TYPE_NONE, PS_FST_TYPE_NONE },
7120daf62d9SStanislav Sedov 		{ KF_TYPE_PIPE, PS_FST_TYPE_PIPE },
7130daf62d9SStanislav Sedov 		{ KF_TYPE_PTS, PS_FST_TYPE_PTS },
7140daf62d9SStanislav Sedov 		{ KF_TYPE_SEM, PS_FST_TYPE_SEM },
7150daf62d9SStanislav Sedov 		{ KF_TYPE_SHM, PS_FST_TYPE_SHM },
7160daf62d9SStanislav Sedov 		{ KF_TYPE_SOCKET, PS_FST_TYPE_SOCKET },
7170daf62d9SStanislav Sedov 		{ KF_TYPE_VNODE, PS_FST_TYPE_VNODE },
71867af9abaSKonstantin Belousov 		{ KF_TYPE_EVENTFD, PS_FST_TYPE_EVENTFD },
7190daf62d9SStanislav Sedov 		{ KF_TYPE_UNKNOWN, PS_FST_TYPE_UNKNOWN }
7200daf62d9SStanislav Sedov 	};
7210daf62d9SStanislav Sedov #define NKFTYPES	(sizeof(kftypes2fst) / sizeof(*kftypes2fst))
7220daf62d9SStanislav Sedov 	unsigned int i;
7230daf62d9SStanislav Sedov 
7240daf62d9SStanislav Sedov 	for (i = 0; i < NKFTYPES; i++)
7250daf62d9SStanislav Sedov 		if (kftypes2fst[i].kf_type == kftype)
7260daf62d9SStanislav Sedov 			break;
7270daf62d9SStanislav Sedov 	if (i == NKFTYPES)
7280daf62d9SStanislav Sedov 		return (PS_FST_TYPE_UNKNOWN);
7290daf62d9SStanislav Sedov 	return (kftypes2fst[i].fst_type);
7300daf62d9SStanislav Sedov }
7310daf62d9SStanislav Sedov 
7320daf62d9SStanislav Sedov /*
7330daf62d9SStanislav Sedov  * kinfo flags to filestat translation.
7340daf62d9SStanislav Sedov  */
7350daf62d9SStanislav Sedov static int
7360daf62d9SStanislav Sedov kinfo_fflags2fst(int kfflags)
7370daf62d9SStanislav Sedov {
7380daf62d9SStanislav Sedov 	static struct {
7390daf62d9SStanislav Sedov 		int	kf_flag;
7400daf62d9SStanislav Sedov 		int	fst_flag;
7410daf62d9SStanislav Sedov 	} kfflags2fst[] = {
7420daf62d9SStanislav Sedov 		{ KF_FLAG_APPEND, PS_FST_FFLAG_APPEND },
7430daf62d9SStanislav Sedov 		{ KF_FLAG_ASYNC, PS_FST_FFLAG_ASYNC },
7440daf62d9SStanislav Sedov 		{ KF_FLAG_CREAT, PS_FST_FFLAG_CREAT },
7450daf62d9SStanislav Sedov 		{ KF_FLAG_DIRECT, PS_FST_FFLAG_DIRECT },
7460daf62d9SStanislav Sedov 		{ KF_FLAG_EXCL, PS_FST_FFLAG_EXCL },
7470daf62d9SStanislav Sedov 		{ KF_FLAG_EXEC, PS_FST_FFLAG_EXEC },
7480daf62d9SStanislav Sedov 		{ KF_FLAG_EXLOCK, PS_FST_FFLAG_EXLOCK },
7490daf62d9SStanislav Sedov 		{ KF_FLAG_FSYNC, PS_FST_FFLAG_SYNC },
7500daf62d9SStanislav Sedov 		{ KF_FLAG_HASLOCK, PS_FST_FFLAG_HASLOCK },
7510daf62d9SStanislav Sedov 		{ KF_FLAG_NOFOLLOW, PS_FST_FFLAG_NOFOLLOW },
7520daf62d9SStanislav Sedov 		{ KF_FLAG_NONBLOCK, PS_FST_FFLAG_NONBLOCK },
7530daf62d9SStanislav Sedov 		{ KF_FLAG_READ, PS_FST_FFLAG_READ },
7540daf62d9SStanislav Sedov 		{ KF_FLAG_SHLOCK, PS_FST_FFLAG_SHLOCK },
7550daf62d9SStanislav Sedov 		{ KF_FLAG_TRUNC, PS_FST_FFLAG_TRUNC },
7560daf62d9SStanislav Sedov 		{ KF_FLAG_WRITE, PS_FST_FFLAG_WRITE }
7570daf62d9SStanislav Sedov 	};
7580daf62d9SStanislav Sedov #define NKFFLAGS	(sizeof(kfflags2fst) / sizeof(*kfflags2fst))
7590daf62d9SStanislav Sedov 	unsigned int i;
7600daf62d9SStanislav Sedov 	int flags;
7610daf62d9SStanislav Sedov 
7620daf62d9SStanislav Sedov 	flags = 0;
7630daf62d9SStanislav Sedov 	for (i = 0; i < NKFFLAGS; i++)
7640daf62d9SStanislav Sedov 		if ((kfflags & kfflags2fst[i].kf_flag) != 0)
7650daf62d9SStanislav Sedov 			flags |= kfflags2fst[i].fst_flag;
7660daf62d9SStanislav Sedov 	return (flags);
7670daf62d9SStanislav Sedov }
7680daf62d9SStanislav Sedov 
7690daf62d9SStanislav Sedov static int
7700daf62d9SStanislav Sedov kinfo_uflags2fst(int fd)
7710daf62d9SStanislav Sedov {
7720daf62d9SStanislav Sedov 
7730daf62d9SStanislav Sedov 	switch (fd) {
7740daf62d9SStanislav Sedov 	case KF_FD_TYPE_CTTY:
7750daf62d9SStanislav Sedov 		return (PS_FST_UFLAG_CTTY);
7760daf62d9SStanislav Sedov 	case KF_FD_TYPE_CWD:
7770daf62d9SStanislav Sedov 		return (PS_FST_UFLAG_CDIR);
7780daf62d9SStanislav Sedov 	case KF_FD_TYPE_JAIL:
7790daf62d9SStanislav Sedov 		return (PS_FST_UFLAG_JAIL);
7800daf62d9SStanislav Sedov 	case KF_FD_TYPE_TEXT:
7810daf62d9SStanislav Sedov 		return (PS_FST_UFLAG_TEXT);
7820daf62d9SStanislav Sedov 	case KF_FD_TYPE_TRACE:
7830daf62d9SStanislav Sedov 		return (PS_FST_UFLAG_TRACE);
7840daf62d9SStanislav Sedov 	case KF_FD_TYPE_ROOT:
7850daf62d9SStanislav Sedov 		return (PS_FST_UFLAG_RDIR);
7860daf62d9SStanislav Sedov 	}
7870daf62d9SStanislav Sedov 	return (0);
7880daf62d9SStanislav Sedov }
7890daf62d9SStanislav Sedov 
7907153ad2bSMikolaj Golub static struct kinfo_file *
7917153ad2bSMikolaj Golub kinfo_getfile_core(struct procstat_core *core, int *cntp)
7927153ad2bSMikolaj Golub {
7937153ad2bSMikolaj Golub 	int cnt;
7947153ad2bSMikolaj Golub 	size_t len;
7957153ad2bSMikolaj Golub 	char *buf, *bp, *eb;
7967153ad2bSMikolaj Golub 	struct kinfo_file *kif, *kp, *kf;
7977153ad2bSMikolaj Golub 
7987153ad2bSMikolaj Golub 	buf = procstat_core_get(core, PSC_TYPE_FILES, NULL, &len);
7997153ad2bSMikolaj Golub 	if (buf == NULL)
8007153ad2bSMikolaj Golub 		return (NULL);
8017153ad2bSMikolaj Golub 	/*
8027153ad2bSMikolaj Golub 	 * XXXMG: The code below is just copy&past from libutil.
8037153ad2bSMikolaj Golub 	 * The code duplication can be avoided if libutil
8047153ad2bSMikolaj Golub 	 * is extended to provide something like:
8057153ad2bSMikolaj Golub 	 *   struct kinfo_file *kinfo_getfile_from_buf(const char *buf,
8067153ad2bSMikolaj Golub 	 *       size_t len, int *cntp);
8077153ad2bSMikolaj Golub 	 */
8087153ad2bSMikolaj Golub 
8097153ad2bSMikolaj Golub 	/* Pass 1: count items */
8107153ad2bSMikolaj Golub 	cnt = 0;
8117153ad2bSMikolaj Golub 	bp = buf;
8127153ad2bSMikolaj Golub 	eb = buf + len;
8137153ad2bSMikolaj Golub 	while (bp < eb) {
8147153ad2bSMikolaj Golub 		kf = (struct kinfo_file *)(uintptr_t)bp;
81514bdbaf2SConrad Meyer 		if (kf->kf_structsize == 0)
81614bdbaf2SConrad Meyer 			break;
8177153ad2bSMikolaj Golub 		bp += kf->kf_structsize;
8187153ad2bSMikolaj Golub 		cnt++;
8197153ad2bSMikolaj Golub 	}
8207153ad2bSMikolaj Golub 
8217153ad2bSMikolaj Golub 	kif = calloc(cnt, sizeof(*kif));
8227153ad2bSMikolaj Golub 	if (kif == NULL) {
8237153ad2bSMikolaj Golub 		free(buf);
8247153ad2bSMikolaj Golub 		return (NULL);
8257153ad2bSMikolaj Golub 	}
8267153ad2bSMikolaj Golub 	bp = buf;
8277153ad2bSMikolaj Golub 	eb = buf + len;
8287153ad2bSMikolaj Golub 	kp = kif;
8297153ad2bSMikolaj Golub 	/* Pass 2: unpack */
8307153ad2bSMikolaj Golub 	while (bp < eb) {
8317153ad2bSMikolaj Golub 		kf = (struct kinfo_file *)(uintptr_t)bp;
83214bdbaf2SConrad Meyer 		if (kf->kf_structsize == 0)
83314bdbaf2SConrad Meyer 			break;
8347153ad2bSMikolaj Golub 		/* Copy/expand into pre-zeroed buffer */
8357153ad2bSMikolaj Golub 		memcpy(kp, kf, kf->kf_structsize);
8367153ad2bSMikolaj Golub 		/* Advance to next packed record */
8377153ad2bSMikolaj Golub 		bp += kf->kf_structsize;
8387153ad2bSMikolaj Golub 		/* Set field size to fixed length, advance */
8397153ad2bSMikolaj Golub 		kp->kf_structsize = sizeof(*kp);
8407153ad2bSMikolaj Golub 		kp++;
8417153ad2bSMikolaj Golub 	}
8427153ad2bSMikolaj Golub 	free(buf);
8437153ad2bSMikolaj Golub 	*cntp = cnt;
8447153ad2bSMikolaj Golub 	return (kif);	/* Caller must free() return value */
8457153ad2bSMikolaj Golub }
8467153ad2bSMikolaj Golub 
8470daf62d9SStanislav Sedov static struct filestat_list *
8487153ad2bSMikolaj Golub procstat_getfiles_sysctl(struct procstat *procstat, struct kinfo_proc *kp,
8497153ad2bSMikolaj Golub     int mmapped)
8500daf62d9SStanislav Sedov {
8510daf62d9SStanislav Sedov 	struct kinfo_file *kif, *files;
8520daf62d9SStanislav Sedov 	struct kinfo_vmentry *kve, *vmentries;
8530daf62d9SStanislav Sedov 	struct filestat_list *head;
8540daf62d9SStanislav Sedov 	struct filestat *entry;
8550daf62d9SStanislav Sedov 	char *path;
8560daf62d9SStanislav Sedov 	off_t offset;
8570daf62d9SStanislav Sedov 	int cnt, fd, fflags;
8580daf62d9SStanislav Sedov 	int i, type, uflags;
8590daf62d9SStanislav Sedov 	int refcount;
860d57486e2SRobert Watson 	cap_rights_t cap_rights;
8610daf62d9SStanislav Sedov 
8620daf62d9SStanislav Sedov 	assert(kp);
8637153ad2bSMikolaj Golub 	switch (procstat->type) {
8647153ad2bSMikolaj Golub 	case PROCSTAT_SYSCTL:
8650daf62d9SStanislav Sedov 		files = kinfo_getfile(kp->ki_pid, &cnt);
8667153ad2bSMikolaj Golub 		break;
8677153ad2bSMikolaj Golub 	case PROCSTAT_CORE:
8687153ad2bSMikolaj Golub 		files = kinfo_getfile_core(procstat->core, &cnt);
8697153ad2bSMikolaj Golub 		break;
8707153ad2bSMikolaj Golub 	default:
8717153ad2bSMikolaj Golub 		assert(!"invalid type");
8727153ad2bSMikolaj Golub 	}
8730daf62d9SStanislav Sedov 	if (files == NULL && errno != EPERM) {
8740daf62d9SStanislav Sedov 		warn("kinfo_getfile()");
8750daf62d9SStanislav Sedov 		return (NULL);
8760daf62d9SStanislav Sedov 	}
8770daf62d9SStanislav Sedov 	procstat->files = files;
8780daf62d9SStanislav Sedov 
8790daf62d9SStanislav Sedov 	/*
8800daf62d9SStanislav Sedov 	 * Allocate list head.
8810daf62d9SStanislav Sedov 	 */
8820daf62d9SStanislav Sedov 	head = malloc(sizeof(*head));
8830daf62d9SStanislav Sedov 	if (head == NULL)
8840daf62d9SStanislav Sedov 		return (NULL);
8850daf62d9SStanislav Sedov 	STAILQ_INIT(head);
8860daf62d9SStanislav Sedov 	for (i = 0; i < cnt; i++) {
8870daf62d9SStanislav Sedov 		kif = &files[i];
8880daf62d9SStanislav Sedov 
8890daf62d9SStanislav Sedov 		type = kinfo_type2fst(kif->kf_type);
8900daf62d9SStanislav Sedov 		fd = kif->kf_fd >= 0 ? kif->kf_fd : -1;
8910daf62d9SStanislav Sedov 		fflags = kinfo_fflags2fst(kif->kf_flags);
8920daf62d9SStanislav Sedov 		uflags = kinfo_uflags2fst(kif->kf_fd);
8930daf62d9SStanislav Sedov 		refcount = kif->kf_ref_count;
8940daf62d9SStanislav Sedov 		offset = kif->kf_offset;
8950daf62d9SStanislav Sedov 		if (*kif->kf_path != '\0')
8960daf62d9SStanislav Sedov 			path = strdup(kif->kf_path);
8970daf62d9SStanislav Sedov 		else
8980daf62d9SStanislav Sedov 			path = NULL;
899d57486e2SRobert Watson 		cap_rights = kif->kf_cap_rights;
9000daf62d9SStanislav Sedov 
9010daf62d9SStanislav Sedov 		/*
9020daf62d9SStanislav Sedov 		 * Create filestat entry.
9030daf62d9SStanislav Sedov 		 */
9040daf62d9SStanislav Sedov 		entry = filestat_new_entry(kif, type, fd, fflags, uflags,
9057008be5bSPawel Jakub Dawidek 		    refcount, offset, path, &cap_rights);
9060daf62d9SStanislav Sedov 		if (entry != NULL)
9070daf62d9SStanislav Sedov 			STAILQ_INSERT_TAIL(head, entry, next);
9080daf62d9SStanislav Sedov 	}
9090daf62d9SStanislav Sedov 	if (mmapped != 0) {
91039680c7bSMikolaj Golub 		vmentries = procstat_getvmmap(procstat, kp, &cnt);
9110daf62d9SStanislav Sedov 		procstat->vmentries = vmentries;
9120daf62d9SStanislav Sedov 		if (vmentries == NULL || cnt == 0)
9130daf62d9SStanislav Sedov 			goto fail;
9140daf62d9SStanislav Sedov 		for (i = 0; i < cnt; i++) {
9150daf62d9SStanislav Sedov 			kve = &vmentries[i];
9160daf62d9SStanislav Sedov 			if (kve->kve_type != KVME_TYPE_VNODE)
9170daf62d9SStanislav Sedov 				continue;
9180daf62d9SStanislav Sedov 			fflags = 0;
9190daf62d9SStanislav Sedov 			if (kve->kve_protection & KVME_PROT_READ)
9200daf62d9SStanislav Sedov 				fflags = PS_FST_FFLAG_READ;
921279a233dSJilles Tjoelker 			if ((kve->kve_flags & KVME_FLAG_COW) == 0 &&
922279a233dSJilles Tjoelker 			    kve->kve_protection & KVME_PROT_WRITE)
9230daf62d9SStanislav Sedov 				fflags |= PS_FST_FFLAG_WRITE;
9240daf62d9SStanislav Sedov 			offset = kve->kve_offset;
9250daf62d9SStanislav Sedov 			refcount = kve->kve_ref_count;
9260daf62d9SStanislav Sedov 			if (*kve->kve_path != '\0')
9270daf62d9SStanislav Sedov 				path = strdup(kve->kve_path);
9280daf62d9SStanislav Sedov 			else
9290daf62d9SStanislav Sedov 				path = NULL;
9300daf62d9SStanislav Sedov 			entry = filestat_new_entry(kve, PS_FST_TYPE_VNODE, -1,
931d57486e2SRobert Watson 			    fflags, PS_FST_UFLAG_MMAP, refcount, offset, path,
932772f6645SPawel Jakub Dawidek 			    NULL);
9330daf62d9SStanislav Sedov 			if (entry != NULL)
9340daf62d9SStanislav Sedov 				STAILQ_INSERT_TAIL(head, entry, next);
9350daf62d9SStanislav Sedov 		}
9360daf62d9SStanislav Sedov 	}
9370daf62d9SStanislav Sedov fail:
9380daf62d9SStanislav Sedov 	return (head);
9390daf62d9SStanislav Sedov }
9400daf62d9SStanislav Sedov 
9410daf62d9SStanislav Sedov int
9420daf62d9SStanislav Sedov procstat_get_pipe_info(struct procstat *procstat, struct filestat *fst,
9430daf62d9SStanislav Sedov     struct pipestat *ps, char *errbuf)
9440daf62d9SStanislav Sedov {
9450daf62d9SStanislav Sedov 
9460daf62d9SStanislav Sedov 	assert(ps);
9470daf62d9SStanislav Sedov 	if (procstat->type == PROCSTAT_KVM) {
9480daf62d9SStanislav Sedov 		return (procstat_get_pipe_info_kvm(procstat->kd, fst, ps,
9490daf62d9SStanislav Sedov 		    errbuf));
9507153ad2bSMikolaj Golub 	} else if (procstat->type == PROCSTAT_SYSCTL ||
9517153ad2bSMikolaj Golub 		procstat->type == PROCSTAT_CORE) {
9520daf62d9SStanislav Sedov 		return (procstat_get_pipe_info_sysctl(fst, ps, errbuf));
9530daf62d9SStanislav Sedov 	} else {
95480905c35SJilles Tjoelker 		warnx("unknown access method: %d", procstat->type);
955467112b4SMikolaj Golub 		if (errbuf != NULL)
9560daf62d9SStanislav Sedov 			snprintf(errbuf, _POSIX2_LINE_MAX, "error");
9570daf62d9SStanislav Sedov 		return (1);
9580daf62d9SStanislav Sedov 	}
9590daf62d9SStanislav Sedov }
9600daf62d9SStanislav Sedov 
9610daf62d9SStanislav Sedov static int
9620daf62d9SStanislav Sedov procstat_get_pipe_info_kvm(kvm_t *kd, struct filestat *fst,
9630daf62d9SStanislav Sedov     struct pipestat *ps, char *errbuf)
9640daf62d9SStanislav Sedov {
9650daf62d9SStanislav Sedov 	struct pipe pi;
9660daf62d9SStanislav Sedov 	void *pipep;
9670daf62d9SStanislav Sedov 
9680daf62d9SStanislav Sedov 	assert(kd);
9690daf62d9SStanislav Sedov 	assert(ps);
9700daf62d9SStanislav Sedov 	assert(fst);
9710daf62d9SStanislav Sedov 	bzero(ps, sizeof(*ps));
9720daf62d9SStanislav Sedov 	pipep = fst->fs_typedep;
9730daf62d9SStanislav Sedov 	if (pipep == NULL)
9740daf62d9SStanislav Sedov 		goto fail;
9750daf62d9SStanislav Sedov 	if (!kvm_read_all(kd, (unsigned long)pipep, &pi, sizeof(struct pipe))) {
9760daf62d9SStanislav Sedov 		warnx("can't read pipe at %p", (void *)pipep);
9770daf62d9SStanislav Sedov 		goto fail;
9780daf62d9SStanislav Sedov 	}
9790daf62d9SStanislav Sedov 	ps->addr = (uintptr_t)pipep;
9800daf62d9SStanislav Sedov 	ps->peer = (uintptr_t)pi.pipe_peer;
9810daf62d9SStanislav Sedov 	ps->buffer_cnt = pi.pipe_buffer.cnt;
9820daf62d9SStanislav Sedov 	return (0);
9830daf62d9SStanislav Sedov 
9840daf62d9SStanislav Sedov fail:
985467112b4SMikolaj Golub 	if (errbuf != NULL)
9860daf62d9SStanislav Sedov 		snprintf(errbuf, _POSIX2_LINE_MAX, "error");
9870daf62d9SStanislav Sedov 	return (1);
9880daf62d9SStanislav Sedov }
9890daf62d9SStanislav Sedov 
9900daf62d9SStanislav Sedov static int
9910daf62d9SStanislav Sedov procstat_get_pipe_info_sysctl(struct filestat *fst, struct pipestat *ps,
9920daf62d9SStanislav Sedov     char *errbuf __unused)
9930daf62d9SStanislav Sedov {
9940daf62d9SStanislav Sedov 	struct kinfo_file *kif;
9950daf62d9SStanislav Sedov 
9960daf62d9SStanislav Sedov 	assert(ps);
9970daf62d9SStanislav Sedov 	assert(fst);
9980daf62d9SStanislav Sedov 	bzero(ps, sizeof(*ps));
9990daf62d9SStanislav Sedov 	kif = fst->fs_typedep;
10000daf62d9SStanislav Sedov 	if (kif == NULL)
10010daf62d9SStanislav Sedov 		return (1);
10020daf62d9SStanislav Sedov 	ps->addr = kif->kf_un.kf_pipe.kf_pipe_addr;
10030daf62d9SStanislav Sedov 	ps->peer = kif->kf_un.kf_pipe.kf_pipe_peer;
10040daf62d9SStanislav Sedov 	ps->buffer_cnt = kif->kf_un.kf_pipe.kf_pipe_buffer_cnt;
10050daf62d9SStanislav Sedov 	return (0);
10060daf62d9SStanislav Sedov }
10070daf62d9SStanislav Sedov 
10080daf62d9SStanislav Sedov int
10090daf62d9SStanislav Sedov procstat_get_pts_info(struct procstat *procstat, struct filestat *fst,
10100daf62d9SStanislav Sedov     struct ptsstat *pts, char *errbuf)
10110daf62d9SStanislav Sedov {
10120daf62d9SStanislav Sedov 
10130daf62d9SStanislav Sedov 	assert(pts);
10140daf62d9SStanislav Sedov 	if (procstat->type == PROCSTAT_KVM) {
10150daf62d9SStanislav Sedov 		return (procstat_get_pts_info_kvm(procstat->kd, fst, pts,
10160daf62d9SStanislav Sedov 		    errbuf));
10177153ad2bSMikolaj Golub 	} else if (procstat->type == PROCSTAT_SYSCTL ||
10187153ad2bSMikolaj Golub 		procstat->type == PROCSTAT_CORE) {
10190daf62d9SStanislav Sedov 		return (procstat_get_pts_info_sysctl(fst, pts, errbuf));
10200daf62d9SStanislav Sedov 	} else {
102180905c35SJilles Tjoelker 		warnx("unknown access method: %d", procstat->type);
1022467112b4SMikolaj Golub 		if (errbuf != NULL)
10230daf62d9SStanislav Sedov 			snprintf(errbuf, _POSIX2_LINE_MAX, "error");
10240daf62d9SStanislav Sedov 		return (1);
10250daf62d9SStanislav Sedov 	}
10260daf62d9SStanislav Sedov }
10270daf62d9SStanislav Sedov 
10280daf62d9SStanislav Sedov static int
10290daf62d9SStanislav Sedov procstat_get_pts_info_kvm(kvm_t *kd, struct filestat *fst,
10300daf62d9SStanislav Sedov     struct ptsstat *pts, char *errbuf)
10310daf62d9SStanislav Sedov {
10320daf62d9SStanislav Sedov 	struct tty tty;
10330daf62d9SStanislav Sedov 	void *ttyp;
10340daf62d9SStanislav Sedov 
10350daf62d9SStanislav Sedov 	assert(kd);
10360daf62d9SStanislav Sedov 	assert(pts);
10370daf62d9SStanislav Sedov 	assert(fst);
10380daf62d9SStanislav Sedov 	bzero(pts, sizeof(*pts));
10390daf62d9SStanislav Sedov 	ttyp = fst->fs_typedep;
10400daf62d9SStanislav Sedov 	if (ttyp == NULL)
10410daf62d9SStanislav Sedov 		goto fail;
10420daf62d9SStanislav Sedov 	if (!kvm_read_all(kd, (unsigned long)ttyp, &tty, sizeof(struct tty))) {
10430daf62d9SStanislav Sedov 		warnx("can't read tty at %p", (void *)ttyp);
10440daf62d9SStanislav Sedov 		goto fail;
10450daf62d9SStanislav Sedov 	}
10460daf62d9SStanislav Sedov 	pts->dev = dev2udev(kd, tty.t_dev);
10470daf62d9SStanislav Sedov 	(void)kdevtoname(kd, tty.t_dev, pts->devname);
10480daf62d9SStanislav Sedov 	return (0);
10490daf62d9SStanislav Sedov 
10500daf62d9SStanislav Sedov fail:
1051467112b4SMikolaj Golub 	if (errbuf != NULL)
10520daf62d9SStanislav Sedov 		snprintf(errbuf, _POSIX2_LINE_MAX, "error");
10530daf62d9SStanislav Sedov 	return (1);
10540daf62d9SStanislav Sedov }
10550daf62d9SStanislav Sedov 
10560daf62d9SStanislav Sedov static int
10570daf62d9SStanislav Sedov procstat_get_pts_info_sysctl(struct filestat *fst, struct ptsstat *pts,
10580daf62d9SStanislav Sedov     char *errbuf __unused)
10590daf62d9SStanislav Sedov {
10600daf62d9SStanislav Sedov 	struct kinfo_file *kif;
10610daf62d9SStanislav Sedov 
10620daf62d9SStanislav Sedov 	assert(pts);
10630daf62d9SStanislav Sedov 	assert(fst);
10640daf62d9SStanislav Sedov 	bzero(pts, sizeof(*pts));
10650daf62d9SStanislav Sedov 	kif = fst->fs_typedep;
10660daf62d9SStanislav Sedov 	if (kif == NULL)
10670daf62d9SStanislav Sedov 		return (0);
10680daf62d9SStanislav Sedov 	pts->dev = kif->kf_un.kf_pts.kf_pts_dev;
10690daf62d9SStanislav Sedov 	strlcpy(pts->devname, kif->kf_path, sizeof(pts->devname));
10700daf62d9SStanislav Sedov 	return (0);
10710daf62d9SStanislav Sedov }
10720daf62d9SStanislav Sedov 
10730daf62d9SStanislav Sedov int
1074958aa575SJohn Baldwin procstat_get_sem_info(struct procstat *procstat, struct filestat *fst,
1075958aa575SJohn Baldwin     struct semstat *sem, char *errbuf)
1076958aa575SJohn Baldwin {
1077958aa575SJohn Baldwin 
1078958aa575SJohn Baldwin 	assert(sem);
1079958aa575SJohn Baldwin 	if (procstat->type == PROCSTAT_KVM) {
1080958aa575SJohn Baldwin 		return (procstat_get_sem_info_kvm(procstat->kd, fst, sem,
1081958aa575SJohn Baldwin 		    errbuf));
1082958aa575SJohn Baldwin 	} else if (procstat->type == PROCSTAT_SYSCTL ||
1083958aa575SJohn Baldwin 	    procstat->type == PROCSTAT_CORE) {
1084958aa575SJohn Baldwin 		return (procstat_get_sem_info_sysctl(fst, sem, errbuf));
1085958aa575SJohn Baldwin 	} else {
1086958aa575SJohn Baldwin 		warnx("unknown access method: %d", procstat->type);
1087467112b4SMikolaj Golub 		if (errbuf != NULL)
1088958aa575SJohn Baldwin 			snprintf(errbuf, _POSIX2_LINE_MAX, "error");
1089958aa575SJohn Baldwin 		return (1);
1090958aa575SJohn Baldwin 	}
1091958aa575SJohn Baldwin }
1092958aa575SJohn Baldwin 
1093958aa575SJohn Baldwin static int
1094958aa575SJohn Baldwin procstat_get_sem_info_kvm(kvm_t *kd, struct filestat *fst,
1095958aa575SJohn Baldwin     struct semstat *sem, char *errbuf)
1096958aa575SJohn Baldwin {
1097958aa575SJohn Baldwin 	struct ksem ksem;
1098958aa575SJohn Baldwin 	void *ksemp;
1099958aa575SJohn Baldwin 	char *path;
1100958aa575SJohn Baldwin 	int i;
1101958aa575SJohn Baldwin 
1102958aa575SJohn Baldwin 	assert(kd);
1103958aa575SJohn Baldwin 	assert(sem);
1104958aa575SJohn Baldwin 	assert(fst);
1105958aa575SJohn Baldwin 	bzero(sem, sizeof(*sem));
1106958aa575SJohn Baldwin 	ksemp = fst->fs_typedep;
1107958aa575SJohn Baldwin 	if (ksemp == NULL)
1108958aa575SJohn Baldwin 		goto fail;
1109958aa575SJohn Baldwin 	if (!kvm_read_all(kd, (unsigned long)ksemp, &ksem,
1110958aa575SJohn Baldwin 	    sizeof(struct ksem))) {
1111958aa575SJohn Baldwin 		warnx("can't read ksem at %p", (void *)ksemp);
1112958aa575SJohn Baldwin 		goto fail;
1113958aa575SJohn Baldwin 	}
1114958aa575SJohn Baldwin 	sem->mode = S_IFREG | ksem.ks_mode;
1115958aa575SJohn Baldwin 	sem->value = ksem.ks_value;
1116958aa575SJohn Baldwin 	if (fst->fs_path == NULL && ksem.ks_path != NULL) {
1117958aa575SJohn Baldwin 		path = malloc(MAXPATHLEN);
1118958aa575SJohn Baldwin 		for (i = 0; i < MAXPATHLEN - 1; i++) {
1119958aa575SJohn Baldwin 			if (!kvm_read_all(kd, (unsigned long)ksem.ks_path + i,
1120958aa575SJohn Baldwin 			    path + i, 1))
1121958aa575SJohn Baldwin 				break;
1122958aa575SJohn Baldwin 			if (path[i] == '\0')
1123958aa575SJohn Baldwin 				break;
1124958aa575SJohn Baldwin 		}
1125958aa575SJohn Baldwin 		path[i] = '\0';
1126958aa575SJohn Baldwin 		if (i == 0)
1127958aa575SJohn Baldwin 			free(path);
1128958aa575SJohn Baldwin 		else
1129958aa575SJohn Baldwin 			fst->fs_path = path;
1130958aa575SJohn Baldwin 	}
1131958aa575SJohn Baldwin 	return (0);
1132958aa575SJohn Baldwin 
1133958aa575SJohn Baldwin fail:
1134467112b4SMikolaj Golub 	if (errbuf != NULL)
1135958aa575SJohn Baldwin 		snprintf(errbuf, _POSIX2_LINE_MAX, "error");
1136958aa575SJohn Baldwin 	return (1);
1137958aa575SJohn Baldwin }
1138958aa575SJohn Baldwin 
1139958aa575SJohn Baldwin static int
1140958aa575SJohn Baldwin procstat_get_sem_info_sysctl(struct filestat *fst, struct semstat *sem,
1141958aa575SJohn Baldwin     char *errbuf __unused)
1142958aa575SJohn Baldwin {
1143958aa575SJohn Baldwin 	struct kinfo_file *kif;
1144958aa575SJohn Baldwin 
1145958aa575SJohn Baldwin 	assert(sem);
1146958aa575SJohn Baldwin 	assert(fst);
1147958aa575SJohn Baldwin 	bzero(sem, sizeof(*sem));
1148958aa575SJohn Baldwin 	kif = fst->fs_typedep;
1149958aa575SJohn Baldwin 	if (kif == NULL)
1150958aa575SJohn Baldwin 		return (0);
1151958aa575SJohn Baldwin 	sem->value = kif->kf_un.kf_sem.kf_sem_value;
1152958aa575SJohn Baldwin 	sem->mode = kif->kf_un.kf_sem.kf_sem_mode;
1153958aa575SJohn Baldwin 	return (0);
1154958aa575SJohn Baldwin }
1155958aa575SJohn Baldwin 
1156958aa575SJohn Baldwin int
1157e506e182SJohn Baldwin procstat_get_shm_info(struct procstat *procstat, struct filestat *fst,
1158e506e182SJohn Baldwin     struct shmstat *shm, char *errbuf)
1159e506e182SJohn Baldwin {
1160e506e182SJohn Baldwin 
1161e506e182SJohn Baldwin 	assert(shm);
1162e506e182SJohn Baldwin 	if (procstat->type == PROCSTAT_KVM) {
1163e506e182SJohn Baldwin 		return (procstat_get_shm_info_kvm(procstat->kd, fst, shm,
1164e506e182SJohn Baldwin 		    errbuf));
11657153ad2bSMikolaj Golub 	} else if (procstat->type == PROCSTAT_SYSCTL ||
11667153ad2bSMikolaj Golub 	    procstat->type == PROCSTAT_CORE) {
1167e506e182SJohn Baldwin 		return (procstat_get_shm_info_sysctl(fst, shm, errbuf));
1168e506e182SJohn Baldwin 	} else {
1169e506e182SJohn Baldwin 		warnx("unknown access method: %d", procstat->type);
1170467112b4SMikolaj Golub 		if (errbuf != NULL)
1171e506e182SJohn Baldwin 			snprintf(errbuf, _POSIX2_LINE_MAX, "error");
1172e506e182SJohn Baldwin 		return (1);
1173e506e182SJohn Baldwin 	}
1174e506e182SJohn Baldwin }
1175e506e182SJohn Baldwin 
1176e506e182SJohn Baldwin static int
1177e506e182SJohn Baldwin procstat_get_shm_info_kvm(kvm_t *kd, struct filestat *fst,
1178e506e182SJohn Baldwin     struct shmstat *shm, char *errbuf)
1179e506e182SJohn Baldwin {
1180e506e182SJohn Baldwin 	struct shmfd shmfd;
1181e506e182SJohn Baldwin 	void *shmfdp;
1182a9f5e425SJohn Baldwin 	char *path;
1183a9f5e425SJohn Baldwin 	int i;
1184e506e182SJohn Baldwin 
1185e506e182SJohn Baldwin 	assert(kd);
1186e506e182SJohn Baldwin 	assert(shm);
1187e506e182SJohn Baldwin 	assert(fst);
1188e506e182SJohn Baldwin 	bzero(shm, sizeof(*shm));
1189e506e182SJohn Baldwin 	shmfdp = fst->fs_typedep;
1190e506e182SJohn Baldwin 	if (shmfdp == NULL)
1191e506e182SJohn Baldwin 		goto fail;
1192e506e182SJohn Baldwin 	if (!kvm_read_all(kd, (unsigned long)shmfdp, &shmfd,
1193e506e182SJohn Baldwin 	    sizeof(struct shmfd))) {
1194e506e182SJohn Baldwin 		warnx("can't read shmfd at %p", (void *)shmfdp);
1195e506e182SJohn Baldwin 		goto fail;
1196e506e182SJohn Baldwin 	}
1197e506e182SJohn Baldwin 	shm->mode = S_IFREG | shmfd.shm_mode;
1198e506e182SJohn Baldwin 	shm->size = shmfd.shm_size;
1199a9f5e425SJohn Baldwin 	if (fst->fs_path == NULL && shmfd.shm_path != NULL) {
1200a9f5e425SJohn Baldwin 		path = malloc(MAXPATHLEN);
1201a9f5e425SJohn Baldwin 		for (i = 0; i < MAXPATHLEN - 1; i++) {
1202a9f5e425SJohn Baldwin 			if (!kvm_read_all(kd, (unsigned long)shmfd.shm_path + i,
1203a9f5e425SJohn Baldwin 			    path + i, 1))
1204a9f5e425SJohn Baldwin 				break;
1205a9f5e425SJohn Baldwin 			if (path[i] == '\0')
1206a9f5e425SJohn Baldwin 				break;
1207a9f5e425SJohn Baldwin 		}
1208a9f5e425SJohn Baldwin 		path[i] = '\0';
1209a9f5e425SJohn Baldwin 		if (i == 0)
1210a9f5e425SJohn Baldwin 			free(path);
1211a9f5e425SJohn Baldwin 		else
1212a9f5e425SJohn Baldwin 			fst->fs_path = path;
1213a9f5e425SJohn Baldwin 	}
1214e506e182SJohn Baldwin 	return (0);
1215e506e182SJohn Baldwin 
1216e506e182SJohn Baldwin fail:
1217467112b4SMikolaj Golub 	if (errbuf != NULL)
1218e506e182SJohn Baldwin 		snprintf(errbuf, _POSIX2_LINE_MAX, "error");
1219e506e182SJohn Baldwin 	return (1);
1220e506e182SJohn Baldwin }
1221e506e182SJohn Baldwin 
1222e506e182SJohn Baldwin static int
1223e506e182SJohn Baldwin procstat_get_shm_info_sysctl(struct filestat *fst, struct shmstat *shm,
1224e506e182SJohn Baldwin     char *errbuf __unused)
1225e506e182SJohn Baldwin {
1226e506e182SJohn Baldwin 	struct kinfo_file *kif;
1227e506e182SJohn Baldwin 
1228e506e182SJohn Baldwin 	assert(shm);
1229e506e182SJohn Baldwin 	assert(fst);
1230e506e182SJohn Baldwin 	bzero(shm, sizeof(*shm));
1231e506e182SJohn Baldwin 	kif = fst->fs_typedep;
1232e506e182SJohn Baldwin 	if (kif == NULL)
1233e506e182SJohn Baldwin 		return (0);
1234e506e182SJohn Baldwin 	shm->size = kif->kf_un.kf_file.kf_file_size;
1235e506e182SJohn Baldwin 	shm->mode = kif->kf_un.kf_file.kf_file_mode;
1236e506e182SJohn Baldwin 	return (0);
1237e506e182SJohn Baldwin }
1238e506e182SJohn Baldwin 
1239e506e182SJohn Baldwin int
12400daf62d9SStanislav Sedov procstat_get_vnode_info(struct procstat *procstat, struct filestat *fst,
12410daf62d9SStanislav Sedov     struct vnstat *vn, char *errbuf)
12420daf62d9SStanislav Sedov {
12430daf62d9SStanislav Sedov 
12440daf62d9SStanislav Sedov 	assert(vn);
12450daf62d9SStanislav Sedov 	if (procstat->type == PROCSTAT_KVM) {
12460daf62d9SStanislav Sedov 		return (procstat_get_vnode_info_kvm(procstat->kd, fst, vn,
12470daf62d9SStanislav Sedov 		    errbuf));
12487153ad2bSMikolaj Golub 	} else if (procstat->type == PROCSTAT_SYSCTL ||
12497153ad2bSMikolaj Golub 		procstat->type == PROCSTAT_CORE) {
12500daf62d9SStanislav Sedov 		return (procstat_get_vnode_info_sysctl(fst, vn, errbuf));
12510daf62d9SStanislav Sedov 	} else {
125280905c35SJilles Tjoelker 		warnx("unknown access method: %d", procstat->type);
1253467112b4SMikolaj Golub 		if (errbuf != NULL)
12540daf62d9SStanislav Sedov 			snprintf(errbuf, _POSIX2_LINE_MAX, "error");
12550daf62d9SStanislav Sedov 		return (1);
12560daf62d9SStanislav Sedov 	}
12570daf62d9SStanislav Sedov }
12580daf62d9SStanislav Sedov 
12590daf62d9SStanislav Sedov static int
12600daf62d9SStanislav Sedov procstat_get_vnode_info_kvm(kvm_t *kd, struct filestat *fst,
12610daf62d9SStanislav Sedov     struct vnstat *vn, char *errbuf)
12620daf62d9SStanislav Sedov {
12630daf62d9SStanislav Sedov 	/* Filesystem specific handlers. */
12640daf62d9SStanislav Sedov 	#define FSTYPE(fst)     {#fst, fst##_filestat}
12650daf62d9SStanislav Sedov 	struct {
12660daf62d9SStanislav Sedov 		const char	*tag;
12670daf62d9SStanislav Sedov 		int		(*handler)(kvm_t *kd, struct vnode *vp,
12680daf62d9SStanislav Sedov 		    struct vnstat *vn);
12690daf62d9SStanislav Sedov 	} fstypes[] = {
12700daf62d9SStanislav Sedov 		FSTYPE(devfs),
12710daf62d9SStanislav Sedov 		FSTYPE(isofs),
12720daf62d9SStanislav Sedov 		FSTYPE(msdosfs),
12730daf62d9SStanislav Sedov 		FSTYPE(nfs),
1274237abf0cSDavide Italiano 		FSTYPE(smbfs),
12750daf62d9SStanislav Sedov 		FSTYPE(udf),
12760daf62d9SStanislav Sedov 		FSTYPE(ufs),
127759ea47d0SStanislav Sedov #ifdef LIBPROCSTAT_ZFS
12780daf62d9SStanislav Sedov 		FSTYPE(zfs),
12790daf62d9SStanislav Sedov #endif
12800daf62d9SStanislav Sedov 	};
12810daf62d9SStanislav Sedov #define	NTYPES	(sizeof(fstypes) / sizeof(*fstypes))
12820daf62d9SStanislav Sedov 	struct vnode vnode;
12830daf62d9SStanislav Sedov 	char tagstr[12];
12840daf62d9SStanislav Sedov 	void *vp;
1285a770b4d8SMarcelo Araujo 	int error;
12860daf62d9SStanislav Sedov 	unsigned int i;
12870daf62d9SStanislav Sedov 
12880daf62d9SStanislav Sedov 	assert(kd);
12890daf62d9SStanislav Sedov 	assert(vn);
12900daf62d9SStanislav Sedov 	assert(fst);
12910daf62d9SStanislav Sedov 	vp = fst->fs_typedep;
12920daf62d9SStanislav Sedov 	if (vp == NULL)
12930daf62d9SStanislav Sedov 		goto fail;
12940daf62d9SStanislav Sedov 	error = kvm_read_all(kd, (unsigned long)vp, &vnode, sizeof(vnode));
12950daf62d9SStanislav Sedov 	if (error == 0) {
12960daf62d9SStanislav Sedov 		warnx("can't read vnode at %p", (void *)vp);
12970daf62d9SStanislav Sedov 		goto fail;
12980daf62d9SStanislav Sedov 	}
12990daf62d9SStanislav Sedov 	bzero(vn, sizeof(*vn));
13000daf62d9SStanislav Sedov 	vn->vn_type = vntype2psfsttype(vnode.v_type);
13010daf62d9SStanislav Sedov 	if (vnode.v_type == VNON || vnode.v_type == VBAD)
13020daf62d9SStanislav Sedov 		return (0);
1303630cb9c5SMateusz Guzik 	error = kvm_read_all(kd, (unsigned long)vnode.v_lock.lock_object.lo_name,
1304630cb9c5SMateusz Guzik 	    tagstr, sizeof(tagstr));
13050daf62d9SStanislav Sedov 	if (error == 0) {
1306630cb9c5SMateusz Guzik 		warnx("can't read lo_name at %p", (void *)vp);
13070daf62d9SStanislav Sedov 		goto fail;
13080daf62d9SStanislav Sedov 	}
13090daf62d9SStanislav Sedov 	tagstr[sizeof(tagstr) - 1] = '\0';
13100daf62d9SStanislav Sedov 
13110daf62d9SStanislav Sedov 	/*
13120daf62d9SStanislav Sedov 	 * Find appropriate handler.
13130daf62d9SStanislav Sedov 	 */
1314a770b4d8SMarcelo Araujo 	for (i = 0; i < NTYPES; i++)
13150daf62d9SStanislav Sedov 		if (!strcmp(fstypes[i].tag, tagstr)) {
13160daf62d9SStanislav Sedov 			if (fstypes[i].handler(kd, &vnode, vn) != 0) {
13170daf62d9SStanislav Sedov 				goto fail;
13180daf62d9SStanislav Sedov 			}
13190daf62d9SStanislav Sedov 			break;
13200daf62d9SStanislav Sedov 		}
13210daf62d9SStanislav Sedov 	if (i == NTYPES) {
1322467112b4SMikolaj Golub 		if (errbuf != NULL)
13230daf62d9SStanislav Sedov 			snprintf(errbuf, _POSIX2_LINE_MAX, "?(%s)", tagstr);
13240daf62d9SStanislav Sedov 		return (1);
13250daf62d9SStanislav Sedov 	}
13260daf62d9SStanislav Sedov 	vn->vn_mntdir = getmnton(kd, vnode.v_mount);
13270daf62d9SStanislav Sedov 	if ((vnode.v_type == VBLK || vnode.v_type == VCHR) &&
13280daf62d9SStanislav Sedov 	    vnode.v_rdev != NULL){
13290daf62d9SStanislav Sedov 		vn->vn_dev = dev2udev(kd, vnode.v_rdev);
13300daf62d9SStanislav Sedov 		(void)kdevtoname(kd, vnode.v_rdev, vn->vn_devname);
13310daf62d9SStanislav Sedov 	} else {
13320daf62d9SStanislav Sedov 		vn->vn_dev = -1;
13330daf62d9SStanislav Sedov 	}
13340daf62d9SStanislav Sedov 	return (0);
13350daf62d9SStanislav Sedov 
13360daf62d9SStanislav Sedov fail:
1337467112b4SMikolaj Golub 	if (errbuf != NULL)
13380daf62d9SStanislav Sedov 		snprintf(errbuf, _POSIX2_LINE_MAX, "error");
13390daf62d9SStanislav Sedov 	return (1);
13400daf62d9SStanislav Sedov }
13410daf62d9SStanislav Sedov 
13420daf62d9SStanislav Sedov /*
13430daf62d9SStanislav Sedov  * kinfo vnode type to filestat translation.
13440daf62d9SStanislav Sedov  */
13450daf62d9SStanislav Sedov static int
13460daf62d9SStanislav Sedov kinfo_vtype2fst(int kfvtype)
13470daf62d9SStanislav Sedov {
13480daf62d9SStanislav Sedov 	static struct {
13490daf62d9SStanislav Sedov 		int	kf_vtype;
13500daf62d9SStanislav Sedov 		int	fst_vtype;
13510daf62d9SStanislav Sedov 	} kfvtypes2fst[] = {
13520daf62d9SStanislav Sedov 		{ KF_VTYPE_VBAD, PS_FST_VTYPE_VBAD },
13530daf62d9SStanislav Sedov 		{ KF_VTYPE_VBLK, PS_FST_VTYPE_VBLK },
13540daf62d9SStanislav Sedov 		{ KF_VTYPE_VCHR, PS_FST_VTYPE_VCHR },
13550daf62d9SStanislav Sedov 		{ KF_VTYPE_VDIR, PS_FST_VTYPE_VDIR },
13560daf62d9SStanislav Sedov 		{ KF_VTYPE_VFIFO, PS_FST_VTYPE_VFIFO },
13570daf62d9SStanislav Sedov 		{ KF_VTYPE_VLNK, PS_FST_VTYPE_VLNK },
13580daf62d9SStanislav Sedov 		{ KF_VTYPE_VNON, PS_FST_VTYPE_VNON },
13590daf62d9SStanislav Sedov 		{ KF_VTYPE_VREG, PS_FST_VTYPE_VREG },
13600daf62d9SStanislav Sedov 		{ KF_VTYPE_VSOCK, PS_FST_VTYPE_VSOCK }
13610daf62d9SStanislav Sedov 	};
13620daf62d9SStanislav Sedov #define	NKFVTYPES	(sizeof(kfvtypes2fst) / sizeof(*kfvtypes2fst))
13630daf62d9SStanislav Sedov 	unsigned int i;
13640daf62d9SStanislav Sedov 
13650daf62d9SStanislav Sedov 	for (i = 0; i < NKFVTYPES; i++)
13660daf62d9SStanislav Sedov 		if (kfvtypes2fst[i].kf_vtype == kfvtype)
13670daf62d9SStanislav Sedov 			break;
13680daf62d9SStanislav Sedov 	if (i == NKFVTYPES)
13690daf62d9SStanislav Sedov 		return (PS_FST_VTYPE_UNKNOWN);
13700daf62d9SStanislav Sedov 	return (kfvtypes2fst[i].fst_vtype);
13710daf62d9SStanislav Sedov }
13720daf62d9SStanislav Sedov 
13730daf62d9SStanislav Sedov static int
13740daf62d9SStanislav Sedov procstat_get_vnode_info_sysctl(struct filestat *fst, struct vnstat *vn,
13750daf62d9SStanislav Sedov     char *errbuf)
13760daf62d9SStanislav Sedov {
13770daf62d9SStanislav Sedov 	struct statfs stbuf;
13780daf62d9SStanislav Sedov 	struct kinfo_file *kif;
13790daf62d9SStanislav Sedov 	struct kinfo_vmentry *kve;
138069921123SKonstantin Belousov 	char *name, *path;
13810daf62d9SStanislav Sedov 	uint64_t fileid;
13820daf62d9SStanislav Sedov 	uint64_t size;
138369921123SKonstantin Belousov 	uint64_t fsid;
138469921123SKonstantin Belousov 	uint64_t rdev;
13850daf62d9SStanislav Sedov 	uint16_t mode;
13860daf62d9SStanislav Sedov 	int vntype;
13870daf62d9SStanislav Sedov 	int status;
13880daf62d9SStanislav Sedov 
13890daf62d9SStanislav Sedov 	assert(fst);
13900daf62d9SStanislav Sedov 	assert(vn);
13910daf62d9SStanislav Sedov 	bzero(vn, sizeof(*vn));
13920daf62d9SStanislav Sedov 	if (fst->fs_typedep == NULL)
13930daf62d9SStanislav Sedov 		return (1);
13940daf62d9SStanislav Sedov 	if (fst->fs_uflags & PS_FST_UFLAG_MMAP) {
13950daf62d9SStanislav Sedov 		kve = fst->fs_typedep;
13960daf62d9SStanislav Sedov 		fileid = kve->kve_vn_fileid;
13970daf62d9SStanislav Sedov 		fsid = kve->kve_vn_fsid;
13980daf62d9SStanislav Sedov 		mode = kve->kve_vn_mode;
13990daf62d9SStanislav Sedov 		path = kve->kve_path;
14000daf62d9SStanislav Sedov 		rdev = kve->kve_vn_rdev;
14010daf62d9SStanislav Sedov 		size = kve->kve_vn_size;
14020daf62d9SStanislav Sedov 		vntype = kinfo_vtype2fst(kve->kve_vn_type);
14030daf62d9SStanislav Sedov 		status = kve->kve_status;
14040daf62d9SStanislav Sedov 	} else {
14050daf62d9SStanislav Sedov 		kif = fst->fs_typedep;
14060daf62d9SStanislav Sedov 		fileid = kif->kf_un.kf_file.kf_file_fileid;
14070daf62d9SStanislav Sedov 		fsid = kif->kf_un.kf_file.kf_file_fsid;
14080daf62d9SStanislav Sedov 		mode = kif->kf_un.kf_file.kf_file_mode;
14090daf62d9SStanislav Sedov 		path = kif->kf_path;
14100daf62d9SStanislav Sedov 		rdev = kif->kf_un.kf_file.kf_file_rdev;
14110daf62d9SStanislav Sedov 		size = kif->kf_un.kf_file.kf_file_size;
14120daf62d9SStanislav Sedov 		vntype = kinfo_vtype2fst(kif->kf_vnode_type);
14130daf62d9SStanislav Sedov 		status = kif->kf_status;
14140daf62d9SStanislav Sedov 	}
14150daf62d9SStanislav Sedov 	vn->vn_type = vntype;
14160daf62d9SStanislav Sedov 	if (vntype == PS_FST_VTYPE_VNON || vntype == PS_FST_VTYPE_VBAD)
14170daf62d9SStanislav Sedov 		return (0);
14180daf62d9SStanislav Sedov 	if ((status & KF_ATTR_VALID) == 0) {
1419467112b4SMikolaj Golub 		if (errbuf != NULL) {
1420467112b4SMikolaj Golub 			snprintf(errbuf, _POSIX2_LINE_MAX,
1421467112b4SMikolaj Golub 			    "? (no info available)");
1422467112b4SMikolaj Golub 		}
14230daf62d9SStanislav Sedov 		return (1);
14240daf62d9SStanislav Sedov 	}
14250daf62d9SStanislav Sedov 	if (path && *path) {
14260daf62d9SStanislav Sedov 		statfs(path, &stbuf);
14270daf62d9SStanislav Sedov 		vn->vn_mntdir = strdup(stbuf.f_mntonname);
14280daf62d9SStanislav Sedov 	} else
14290daf62d9SStanislav Sedov 		vn->vn_mntdir = strdup("-");
14300daf62d9SStanislav Sedov 	vn->vn_dev = rdev;
14310daf62d9SStanislav Sedov 	if (vntype == PS_FST_VTYPE_VBLK) {
14320daf62d9SStanislav Sedov 		name = devname(rdev, S_IFBLK);
14330daf62d9SStanislav Sedov 		if (name != NULL)
14340daf62d9SStanislav Sedov 			strlcpy(vn->vn_devname, name,
14350daf62d9SStanislav Sedov 			    sizeof(vn->vn_devname));
14360daf62d9SStanislav Sedov 	} else if (vntype == PS_FST_VTYPE_VCHR) {
14370daf62d9SStanislav Sedov 		name = devname(vn->vn_dev, S_IFCHR);
14380daf62d9SStanislav Sedov 		if (name != NULL)
14390daf62d9SStanislav Sedov 			strlcpy(vn->vn_devname, name,
14400daf62d9SStanislav Sedov 			    sizeof(vn->vn_devname));
14410daf62d9SStanislav Sedov 	}
14420daf62d9SStanislav Sedov 	vn->vn_fsid = fsid;
14430daf62d9SStanislav Sedov 	vn->vn_fileid = fileid;
14440daf62d9SStanislav Sedov 	vn->vn_size = size;
14450daf62d9SStanislav Sedov 	vn->vn_mode = mode;
14460daf62d9SStanislav Sedov 	return (0);
14470daf62d9SStanislav Sedov }
14480daf62d9SStanislav Sedov 
14490daf62d9SStanislav Sedov int
14500daf62d9SStanislav Sedov procstat_get_socket_info(struct procstat *procstat, struct filestat *fst,
14510daf62d9SStanislav Sedov     struct sockstat *sock, char *errbuf)
14520daf62d9SStanislav Sedov {
14530daf62d9SStanislav Sedov 
14540daf62d9SStanislav Sedov 	assert(sock);
14550daf62d9SStanislav Sedov 	if (procstat->type == PROCSTAT_KVM) {
14560daf62d9SStanislav Sedov 		return (procstat_get_socket_info_kvm(procstat->kd, fst, sock,
14570daf62d9SStanislav Sedov 		    errbuf));
14587153ad2bSMikolaj Golub 	} else if (procstat->type == PROCSTAT_SYSCTL ||
14597153ad2bSMikolaj Golub 		procstat->type == PROCSTAT_CORE) {
14600daf62d9SStanislav Sedov 		return (procstat_get_socket_info_sysctl(fst, sock, errbuf));
14610daf62d9SStanislav Sedov 	} else {
146280905c35SJilles Tjoelker 		warnx("unknown access method: %d", procstat->type);
1463467112b4SMikolaj Golub 		if (errbuf != NULL)
14640daf62d9SStanislav Sedov 			snprintf(errbuf, _POSIX2_LINE_MAX, "error");
14650daf62d9SStanislav Sedov 		return (1);
14660daf62d9SStanislav Sedov 	}
14670daf62d9SStanislav Sedov }
14680daf62d9SStanislav Sedov 
14690daf62d9SStanislav Sedov static int
14700daf62d9SStanislav Sedov procstat_get_socket_info_kvm(kvm_t *kd, struct filestat *fst,
14710daf62d9SStanislav Sedov     struct sockstat *sock, char *errbuf)
14720daf62d9SStanislav Sedov {
14730daf62d9SStanislav Sedov 	struct domain dom;
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;
15221a8d1764SGleb Smirnoff 	sock->sendq = s.so_snd.sb_ccc;
15231a8d1764SGleb Smirnoff 	sock->recvq = s.so_rcv.sb_ccc;
15241a8d1764SGleb Smirnoff 	sock->so_rcv_sb_state = s.so_rcv.sb_state;
15251a8d1764SGleb Smirnoff 	sock->so_snd_sb_state = s.so_snd.sb_state;
15260daf62d9SStanislav Sedov 
15270daf62d9SStanislav Sedov 	/*
15280daf62d9SStanislav Sedov 	 * Protocol specific data.
15290daf62d9SStanislav Sedov 	 */
15300daf62d9SStanislav Sedov 	switch (dom.dom_family) {
15310daf62d9SStanislav Sedov 	case AF_UNIX:
15320daf62d9SStanislav Sedov 		if (s.so_pcb) {
15330daf62d9SStanislav Sedov 			if (kvm_read(kd, (u_long)s.so_pcb, (char *)&unpcb,
15340daf62d9SStanislav Sedov 			    sizeof(struct unpcb)) != sizeof(struct unpcb)){
15350daf62d9SStanislav Sedov 				warnx("can't read unpcb at %p",
15360daf62d9SStanislav Sedov 				    (void *)s.so_pcb);
15370daf62d9SStanislav Sedov 			} else if (unpcb.unp_conn) {
15380daf62d9SStanislav Sedov 				sock->unp_conn = (uintptr_t)unpcb.unp_conn;
15390daf62d9SStanislav Sedov 			}
15400daf62d9SStanislav Sedov 		}
15410daf62d9SStanislav Sedov 		break;
15420daf62d9SStanislav Sedov 	default:
15430daf62d9SStanislav Sedov 		break;
15440daf62d9SStanislav Sedov 	}
15450daf62d9SStanislav Sedov 	return (0);
15460daf62d9SStanislav Sedov 
15470daf62d9SStanislav Sedov fail:
1548467112b4SMikolaj Golub 	if (errbuf != NULL)
15490daf62d9SStanislav Sedov 		snprintf(errbuf, _POSIX2_LINE_MAX, "error");
15500daf62d9SStanislav Sedov 	return (1);
15510daf62d9SStanislav Sedov }
15520daf62d9SStanislav Sedov 
15530daf62d9SStanislav Sedov static int
15540daf62d9SStanislav Sedov procstat_get_socket_info_sysctl(struct filestat *fst, struct sockstat *sock,
15550daf62d9SStanislav Sedov     char *errbuf __unused)
15560daf62d9SStanislav Sedov {
15570daf62d9SStanislav Sedov 	struct kinfo_file *kif;
15580daf62d9SStanislav Sedov 
15590daf62d9SStanislav Sedov 	assert(sock);
15600daf62d9SStanislav Sedov 	assert(fst);
15610daf62d9SStanislav Sedov 	bzero(sock, sizeof(*sock));
15620daf62d9SStanislav Sedov 	kif = fst->fs_typedep;
15630daf62d9SStanislav Sedov 	if (kif == NULL)
15640daf62d9SStanislav Sedov 		return (0);
15650daf62d9SStanislav Sedov 
15660daf62d9SStanislav Sedov 	/*
15670daf62d9SStanislav Sedov 	 * Fill in known data.
15680daf62d9SStanislav Sedov 	 */
15690daf62d9SStanislav Sedov 	sock->type = kif->kf_sock_type;
15700daf62d9SStanislav Sedov 	sock->proto = kif->kf_sock_protocol;
15710daf62d9SStanislav Sedov 	sock->dom_family = kif->kf_sock_domain;
15720daf62d9SStanislav Sedov 	sock->so_pcb = kif->kf_un.kf_sock.kf_sock_pcb;
15730daf62d9SStanislav Sedov 	strlcpy(sock->dname, kif->kf_path, sizeof(sock->dname));
157469921123SKonstantin Belousov 	bcopy(&kif->kf_un.kf_sock.kf_sa_local, &sock->sa_local,
157569921123SKonstantin Belousov 	    kif->kf_un.kf_sock.kf_sa_local.ss_len);
157669921123SKonstantin Belousov 	bcopy(&kif->kf_un.kf_sock.kf_sa_peer, &sock->sa_peer,
157769921123SKonstantin Belousov 	    kif->kf_un.kf_sock.kf_sa_peer.ss_len);
15780daf62d9SStanislav Sedov 
15790daf62d9SStanislav Sedov 	/*
15800daf62d9SStanislav Sedov 	 * Protocol specific data.
15810daf62d9SStanislav Sedov 	 */
15820daf62d9SStanislav Sedov 	switch (sock->dom_family) {
15830daf62d9SStanislav Sedov 	case AF_INET:
15840daf62d9SStanislav Sedov 	case AF_INET6:
158595b97895SConrad Meyer 		if (sock->proto == IPPROTO_TCP) {
158695b97895SConrad Meyer 			sock->sendq = kif->kf_un.kf_sock.kf_sock_sendq;
158795b97895SConrad Meyer 			sock->recvq = kif->kf_un.kf_sock.kf_sock_recvq;
158895b97895SConrad Meyer 		}
15890daf62d9SStanislav Sedov 		break;
15900daf62d9SStanislav Sedov 	case AF_UNIX:
15910daf62d9SStanislav Sedov 		if (kif->kf_un.kf_sock.kf_sock_unpconn != 0) {
15920daf62d9SStanislav Sedov 			sock->so_rcv_sb_state =
15930daf62d9SStanislav Sedov 			    kif->kf_un.kf_sock.kf_sock_rcv_sb_state;
15940daf62d9SStanislav Sedov 			sock->so_snd_sb_state =
15950daf62d9SStanislav Sedov 			    kif->kf_un.kf_sock.kf_sock_snd_sb_state;
15960daf62d9SStanislav Sedov 			sock->unp_conn =
15970daf62d9SStanislav Sedov 			    kif->kf_un.kf_sock.kf_sock_unpconn;
159895b97895SConrad Meyer 			sock->sendq = kif->kf_un.kf_sock.kf_sock_sendq;
159995b97895SConrad Meyer 			sock->recvq = kif->kf_un.kf_sock.kf_sock_recvq;
16000daf62d9SStanislav Sedov 		}
16010daf62d9SStanislav Sedov 		break;
16020daf62d9SStanislav Sedov 	default:
16030daf62d9SStanislav Sedov 		break;
16040daf62d9SStanislav Sedov 	}
16050daf62d9SStanislav Sedov 	return (0);
16060daf62d9SStanislav Sedov }
16070daf62d9SStanislav Sedov 
16080daf62d9SStanislav Sedov /*
16090daf62d9SStanislav Sedov  * Descriptor flags to filestat translation.
16100daf62d9SStanislav Sedov  */
16110daf62d9SStanislav Sedov static int
16120daf62d9SStanislav Sedov to_filestat_flags(int flags)
16130daf62d9SStanislav Sedov {
16140daf62d9SStanislav Sedov 	static struct {
16150daf62d9SStanislav Sedov 		int flag;
16160daf62d9SStanislav Sedov 		int fst_flag;
16170daf62d9SStanislav Sedov 	} fstflags[] = {
16180daf62d9SStanislav Sedov 		{ FREAD, PS_FST_FFLAG_READ },
16190daf62d9SStanislav Sedov 		{ FWRITE, PS_FST_FFLAG_WRITE },
16200daf62d9SStanislav Sedov 		{ O_APPEND, PS_FST_FFLAG_APPEND },
16210daf62d9SStanislav Sedov 		{ O_ASYNC, PS_FST_FFLAG_ASYNC },
16220daf62d9SStanislav Sedov 		{ O_CREAT, PS_FST_FFLAG_CREAT },
16230daf62d9SStanislav Sedov 		{ O_DIRECT, PS_FST_FFLAG_DIRECT },
16240daf62d9SStanislav Sedov 		{ O_EXCL, PS_FST_FFLAG_EXCL },
16250daf62d9SStanislav Sedov 		{ O_EXEC, PS_FST_FFLAG_EXEC },
16260daf62d9SStanislav Sedov 		{ O_EXLOCK, PS_FST_FFLAG_EXLOCK },
16270daf62d9SStanislav Sedov 		{ O_NOFOLLOW, PS_FST_FFLAG_NOFOLLOW },
16280daf62d9SStanislav Sedov 		{ O_NONBLOCK, PS_FST_FFLAG_NONBLOCK },
16290daf62d9SStanislav Sedov 		{ O_SHLOCK, PS_FST_FFLAG_SHLOCK },
16300daf62d9SStanislav Sedov 		{ O_SYNC, PS_FST_FFLAG_SYNC },
16310daf62d9SStanislav Sedov 		{ O_TRUNC, PS_FST_FFLAG_TRUNC }
16320daf62d9SStanislav Sedov 	};
16330daf62d9SStanislav Sedov #define NFSTFLAGS	(sizeof(fstflags) / sizeof(*fstflags))
16340daf62d9SStanislav Sedov 	int fst_flags;
16350daf62d9SStanislav Sedov 	unsigned int i;
16360daf62d9SStanislav Sedov 
16370daf62d9SStanislav Sedov 	fst_flags = 0;
16380daf62d9SStanislav Sedov 	for (i = 0; i < NFSTFLAGS; i++)
16390daf62d9SStanislav Sedov 		if (flags & fstflags[i].flag)
16400daf62d9SStanislav Sedov 			fst_flags |= fstflags[i].fst_flag;
16410daf62d9SStanislav Sedov 	return (fst_flags);
16420daf62d9SStanislav Sedov }
16430daf62d9SStanislav Sedov 
16440daf62d9SStanislav Sedov /*
16450daf62d9SStanislav Sedov  * Vnode type to filestate translation.
16460daf62d9SStanislav Sedov  */
16470daf62d9SStanislav Sedov static int
16480daf62d9SStanislav Sedov vntype2psfsttype(int type)
16490daf62d9SStanislav Sedov {
16500daf62d9SStanislav Sedov 	static struct {
16510daf62d9SStanislav Sedov 		int	vtype;
16520daf62d9SStanislav Sedov 		int	fst_vtype;
16530daf62d9SStanislav Sedov 	} vt2fst[] = {
16540daf62d9SStanislav Sedov 		{ VBAD, PS_FST_VTYPE_VBAD },
16550daf62d9SStanislav Sedov 		{ VBLK, PS_FST_VTYPE_VBLK },
16560daf62d9SStanislav Sedov 		{ VCHR, PS_FST_VTYPE_VCHR },
16570daf62d9SStanislav Sedov 		{ VDIR, PS_FST_VTYPE_VDIR },
16580daf62d9SStanislav Sedov 		{ VFIFO, PS_FST_VTYPE_VFIFO },
16590daf62d9SStanislav Sedov 		{ VLNK, PS_FST_VTYPE_VLNK },
16600daf62d9SStanislav Sedov 		{ VNON, PS_FST_VTYPE_VNON },
16610daf62d9SStanislav Sedov 		{ VREG, PS_FST_VTYPE_VREG },
16620daf62d9SStanislav Sedov 		{ VSOCK, PS_FST_VTYPE_VSOCK }
16630daf62d9SStanislav Sedov 	};
16640daf62d9SStanislav Sedov #define	NVFTYPES	(sizeof(vt2fst) / sizeof(*vt2fst))
16650daf62d9SStanislav Sedov 	unsigned int i, fst_type;
16660daf62d9SStanislav Sedov 
16670daf62d9SStanislav Sedov 	fst_type = PS_FST_VTYPE_UNKNOWN;
16680daf62d9SStanislav Sedov 	for (i = 0; i < NVFTYPES; i++) {
16690daf62d9SStanislav Sedov 		if (type == vt2fst[i].vtype) {
16700daf62d9SStanislav Sedov 			fst_type = vt2fst[i].fst_vtype;
16710daf62d9SStanislav Sedov 			break;
16720daf62d9SStanislav Sedov 		}
16730daf62d9SStanislav Sedov 	}
16740daf62d9SStanislav Sedov 	return (fst_type);
16750daf62d9SStanislav Sedov }
16760daf62d9SStanislav Sedov 
16770daf62d9SStanislav Sedov static char *
16780daf62d9SStanislav Sedov getmnton(kvm_t *kd, struct mount *m)
16790daf62d9SStanislav Sedov {
16805f301949SBen Laurie 	struct mount mnt;
16810daf62d9SStanislav Sedov 	static struct mtab {
16820daf62d9SStanislav Sedov 		struct mtab *next;
16830daf62d9SStanislav Sedov 		struct mount *m;
16840daf62d9SStanislav Sedov 		char mntonname[MNAMELEN + 1];
16850daf62d9SStanislav Sedov 	} *mhead = NULL;
16860daf62d9SStanislav Sedov 	struct mtab *mt;
16870daf62d9SStanislav Sedov 
16880daf62d9SStanislav Sedov 	for (mt = mhead; mt != NULL; mt = mt->next)
16890daf62d9SStanislav Sedov 		if (m == mt->m)
16900daf62d9SStanislav Sedov 			return (mt->mntonname);
16910daf62d9SStanislav Sedov 	if (!kvm_read_all(kd, (unsigned long)m, &mnt, sizeof(struct mount))) {
16920daf62d9SStanislav Sedov 		warnx("can't read mount table at %p", (void *)m);
16930daf62d9SStanislav Sedov 		return (NULL);
16940daf62d9SStanislav Sedov 	}
16950daf62d9SStanislav Sedov 	if ((mt = malloc(sizeof (struct mtab))) == NULL)
16960daf62d9SStanislav Sedov 		err(1, NULL);
16970daf62d9SStanislav Sedov 	mt->m = m;
16980daf62d9SStanislav Sedov 	bcopy(&mnt.mnt_stat.f_mntonname[0], &mt->mntonname[0], MNAMELEN);
16995f301949SBen Laurie 	mt->mntonname[MNAMELEN] = '\0';
17000daf62d9SStanislav Sedov 	mt->next = mhead;
17010daf62d9SStanislav Sedov 	mhead = mt;
17020daf62d9SStanislav Sedov 	return (mt->mntonname);
17030daf62d9SStanislav Sedov }
17047153ad2bSMikolaj Golub 
17054482b5e3SMikolaj Golub /*
17064482b5e3SMikolaj Golub  * Auxiliary structures and functions to get process environment or
17074482b5e3SMikolaj Golub  * command line arguments.
17084482b5e3SMikolaj Golub  */
17094482b5e3SMikolaj Golub struct argvec {
17104482b5e3SMikolaj Golub 	char	*buf;
17114482b5e3SMikolaj Golub 	size_t	bufsize;
17124482b5e3SMikolaj Golub 	char	**argv;
17134482b5e3SMikolaj Golub 	size_t	argc;
17144482b5e3SMikolaj Golub };
17154482b5e3SMikolaj Golub 
17164482b5e3SMikolaj Golub static struct argvec *
17174482b5e3SMikolaj Golub argvec_alloc(size_t bufsize)
17184482b5e3SMikolaj Golub {
17194482b5e3SMikolaj Golub 	struct argvec *av;
17204482b5e3SMikolaj Golub 
17214482b5e3SMikolaj Golub 	av = malloc(sizeof(*av));
17224482b5e3SMikolaj Golub 	if (av == NULL)
17234482b5e3SMikolaj Golub 		return (NULL);
17244482b5e3SMikolaj Golub 	av->bufsize = bufsize;
17254482b5e3SMikolaj Golub 	av->buf = malloc(av->bufsize);
17264482b5e3SMikolaj Golub 	if (av->buf == NULL) {
17274482b5e3SMikolaj Golub 		free(av);
17284482b5e3SMikolaj Golub 		return (NULL);
17294482b5e3SMikolaj Golub 	}
17304482b5e3SMikolaj Golub 	av->argc = 32;
17314482b5e3SMikolaj Golub 	av->argv = malloc(sizeof(char *) * av->argc);
17324482b5e3SMikolaj Golub 	if (av->argv == NULL) {
17334482b5e3SMikolaj Golub 		free(av->buf);
17344482b5e3SMikolaj Golub 		free(av);
17354482b5e3SMikolaj Golub 		return (NULL);
17364482b5e3SMikolaj Golub 	}
17374482b5e3SMikolaj Golub 	return av;
17384482b5e3SMikolaj Golub }
17394482b5e3SMikolaj Golub 
17404482b5e3SMikolaj Golub static void
17414482b5e3SMikolaj Golub argvec_free(struct argvec * av)
17424482b5e3SMikolaj Golub {
17434482b5e3SMikolaj Golub 
17444482b5e3SMikolaj Golub 	free(av->argv);
17454482b5e3SMikolaj Golub 	free(av->buf);
17464482b5e3SMikolaj Golub 	free(av);
17474482b5e3SMikolaj Golub }
17484482b5e3SMikolaj Golub 
17494482b5e3SMikolaj Golub static char **
17504482b5e3SMikolaj Golub getargv(struct procstat *procstat, struct kinfo_proc *kp, size_t nchr, int env)
17514482b5e3SMikolaj Golub {
17524482b5e3SMikolaj Golub 	int error, name[4], argc, i;
17534482b5e3SMikolaj Golub 	struct argvec *av, **avp;
17544482b5e3SMikolaj Golub 	enum psc_type type;
17554482b5e3SMikolaj Golub 	size_t len;
17564482b5e3SMikolaj Golub 	char *p, **argv;
17574482b5e3SMikolaj Golub 
17584482b5e3SMikolaj Golub 	assert(procstat);
17594482b5e3SMikolaj Golub 	assert(kp);
17604482b5e3SMikolaj Golub 	if (procstat->type == PROCSTAT_KVM) {
17614482b5e3SMikolaj Golub 		warnx("can't use kvm access method");
17624482b5e3SMikolaj Golub 		return (NULL);
17634482b5e3SMikolaj Golub 	}
17644482b5e3SMikolaj Golub 	if (procstat->type != PROCSTAT_SYSCTL &&
17654482b5e3SMikolaj Golub 	    procstat->type != PROCSTAT_CORE) {
17664482b5e3SMikolaj Golub 		warnx("unknown access method: %d", procstat->type);
17674482b5e3SMikolaj Golub 		return (NULL);
17684482b5e3SMikolaj Golub 	}
17694482b5e3SMikolaj Golub 
17704482b5e3SMikolaj Golub 	if (nchr == 0 || nchr > ARG_MAX)
17714482b5e3SMikolaj Golub 		nchr = ARG_MAX;
17724482b5e3SMikolaj Golub 
17734482b5e3SMikolaj Golub 	avp = (struct argvec **)(env ? &procstat->argv : &procstat->envv);
17744482b5e3SMikolaj Golub 	av = *avp;
17754482b5e3SMikolaj Golub 
17764482b5e3SMikolaj Golub 	if (av == NULL)
17774482b5e3SMikolaj Golub 	{
17784482b5e3SMikolaj Golub 		av = argvec_alloc(nchr);
17794482b5e3SMikolaj Golub 		if (av == NULL)
17804482b5e3SMikolaj Golub 		{
17814482b5e3SMikolaj Golub 			warn("malloc(%zu)", nchr);
17824482b5e3SMikolaj Golub 			return (NULL);
17834482b5e3SMikolaj Golub 		}
17844482b5e3SMikolaj Golub 		*avp = av;
17854482b5e3SMikolaj Golub 	} else if (av->bufsize < nchr) {
17864482b5e3SMikolaj Golub 		av->buf = reallocf(av->buf, nchr);
17874482b5e3SMikolaj Golub 		if (av->buf == NULL) {
17884482b5e3SMikolaj Golub 			warn("malloc(%zu)", nchr);
17894482b5e3SMikolaj Golub 			return (NULL);
17904482b5e3SMikolaj Golub 		}
17914482b5e3SMikolaj Golub 	}
17924482b5e3SMikolaj Golub 	if (procstat->type == PROCSTAT_SYSCTL) {
17934482b5e3SMikolaj Golub 		name[0] = CTL_KERN;
17944482b5e3SMikolaj Golub 		name[1] = KERN_PROC;
17954482b5e3SMikolaj Golub 		name[2] = env ? KERN_PROC_ENV : KERN_PROC_ARGS;
17964482b5e3SMikolaj Golub 		name[3] = kp->ki_pid;
17974482b5e3SMikolaj Golub 		len = nchr;
179875b6a179SEnji Cooper 		error = sysctl(name, nitems(name), av->buf, &len, NULL, 0);
17994482b5e3SMikolaj Golub 		if (error != 0 && errno != ESRCH && errno != EPERM)
18004482b5e3SMikolaj Golub 			warn("sysctl(kern.proc.%s)", env ? "env" : "args");
18014482b5e3SMikolaj Golub 		if (error != 0 || len == 0)
18024482b5e3SMikolaj Golub 			return (NULL);
18034482b5e3SMikolaj Golub 	} else /* procstat->type == PROCSTAT_CORE */ {
18044482b5e3SMikolaj Golub 		type = env ? PSC_TYPE_ENVV : PSC_TYPE_ARGV;
18054482b5e3SMikolaj Golub 		len = nchr;
18064482b5e3SMikolaj Golub 		if (procstat_core_get(procstat->core, type, av->buf, &len)
18074482b5e3SMikolaj Golub 		    == NULL) {
18084482b5e3SMikolaj Golub 			return (NULL);
18094482b5e3SMikolaj Golub 		}
18104482b5e3SMikolaj Golub 	}
18114482b5e3SMikolaj Golub 
18124482b5e3SMikolaj Golub 	argv = av->argv;
18134482b5e3SMikolaj Golub 	argc = av->argc;
18144482b5e3SMikolaj Golub 	i = 0;
18154482b5e3SMikolaj Golub 	for (p = av->buf; p < av->buf + len; p += strlen(p) + 1) {
18164482b5e3SMikolaj Golub 		argv[i++] = p;
18174482b5e3SMikolaj Golub 		if (i < argc)
18184482b5e3SMikolaj Golub 			continue;
18194482b5e3SMikolaj Golub 		/* Grow argv. */
18204482b5e3SMikolaj Golub 		argc += argc;
18214482b5e3SMikolaj Golub 		argv = realloc(argv, sizeof(char *) * argc);
18224482b5e3SMikolaj Golub 		if (argv == NULL) {
18234482b5e3SMikolaj Golub 			warn("malloc(%zu)", sizeof(char *) * argc);
18244482b5e3SMikolaj Golub 			return (NULL);
18254482b5e3SMikolaj Golub 		}
18264482b5e3SMikolaj Golub 		av->argv = argv;
18274482b5e3SMikolaj Golub 		av->argc = argc;
18284482b5e3SMikolaj Golub 	}
18294482b5e3SMikolaj Golub 	argv[i] = NULL;
18304482b5e3SMikolaj Golub 
18314482b5e3SMikolaj Golub 	return (argv);
18324482b5e3SMikolaj Golub }
18334482b5e3SMikolaj Golub 
18344482b5e3SMikolaj Golub /*
18354482b5e3SMikolaj Golub  * Return process command line arguments.
18364482b5e3SMikolaj Golub  */
18374482b5e3SMikolaj Golub char **
18384482b5e3SMikolaj Golub procstat_getargv(struct procstat *procstat, struct kinfo_proc *p, size_t nchr)
18394482b5e3SMikolaj Golub {
18404482b5e3SMikolaj Golub 
18414482b5e3SMikolaj Golub 	return (getargv(procstat, p, nchr, 0));
18424482b5e3SMikolaj Golub }
18434482b5e3SMikolaj Golub 
18444482b5e3SMikolaj Golub /*
18454482b5e3SMikolaj Golub  * Free the buffer allocated by procstat_getargv().
18464482b5e3SMikolaj Golub  */
18474482b5e3SMikolaj Golub void
18484482b5e3SMikolaj Golub procstat_freeargv(struct procstat *procstat)
18494482b5e3SMikolaj Golub {
18504482b5e3SMikolaj Golub 
18514482b5e3SMikolaj Golub 	if (procstat->argv != NULL) {
18524482b5e3SMikolaj Golub 		argvec_free(procstat->argv);
18534482b5e3SMikolaj Golub 		procstat->argv = NULL;
18544482b5e3SMikolaj Golub 	}
18554482b5e3SMikolaj Golub }
18564482b5e3SMikolaj Golub 
18574482b5e3SMikolaj Golub /*
18584482b5e3SMikolaj Golub  * Return process environment.
18594482b5e3SMikolaj Golub  */
18604482b5e3SMikolaj Golub char **
18614482b5e3SMikolaj Golub procstat_getenvv(struct procstat *procstat, struct kinfo_proc *p, size_t nchr)
18624482b5e3SMikolaj Golub {
18634482b5e3SMikolaj Golub 
18644482b5e3SMikolaj Golub 	return (getargv(procstat, p, nchr, 1));
18654482b5e3SMikolaj Golub }
18664482b5e3SMikolaj Golub 
18674482b5e3SMikolaj Golub /*
18684482b5e3SMikolaj Golub  * Free the buffer allocated by procstat_getenvv().
18694482b5e3SMikolaj Golub  */
18704482b5e3SMikolaj Golub void
18714482b5e3SMikolaj Golub procstat_freeenvv(struct procstat *procstat)
18724482b5e3SMikolaj Golub {
18734482b5e3SMikolaj Golub 	if (procstat->envv != NULL) {
18744482b5e3SMikolaj Golub 		argvec_free(procstat->envv);
18754482b5e3SMikolaj Golub 		procstat->envv = NULL;
18764482b5e3SMikolaj Golub 	}
18774482b5e3SMikolaj Golub }
18784482b5e3SMikolaj Golub 
187939680c7bSMikolaj Golub static struct kinfo_vmentry *
188039680c7bSMikolaj Golub kinfo_getvmmap_core(struct procstat_core *core, int *cntp)
188139680c7bSMikolaj Golub {
188239680c7bSMikolaj Golub 	int cnt;
188339680c7bSMikolaj Golub 	size_t len;
188439680c7bSMikolaj Golub 	char *buf, *bp, *eb;
188539680c7bSMikolaj Golub 	struct kinfo_vmentry *kiv, *kp, *kv;
188639680c7bSMikolaj Golub 
188739680c7bSMikolaj Golub 	buf = procstat_core_get(core, PSC_TYPE_VMMAP, NULL, &len);
188839680c7bSMikolaj Golub 	if (buf == NULL)
188939680c7bSMikolaj Golub 		return (NULL);
189039680c7bSMikolaj Golub 
189139680c7bSMikolaj Golub 	/*
189239680c7bSMikolaj Golub 	 * XXXMG: The code below is just copy&past from libutil.
189339680c7bSMikolaj Golub 	 * The code duplication can be avoided if libutil
189439680c7bSMikolaj Golub 	 * is extended to provide something like:
189539680c7bSMikolaj Golub 	 *   struct kinfo_vmentry *kinfo_getvmmap_from_buf(const char *buf,
189639680c7bSMikolaj Golub 	 *       size_t len, int *cntp);
189739680c7bSMikolaj Golub 	 */
189839680c7bSMikolaj Golub 
189939680c7bSMikolaj Golub 	/* Pass 1: count items */
190039680c7bSMikolaj Golub 	cnt = 0;
190139680c7bSMikolaj Golub 	bp = buf;
190239680c7bSMikolaj Golub 	eb = buf + len;
190339680c7bSMikolaj Golub 	while (bp < eb) {
190439680c7bSMikolaj Golub 		kv = (struct kinfo_vmentry *)(uintptr_t)bp;
1905e6b95927SConrad Meyer 		if (kv->kve_structsize == 0)
1906e6b95927SConrad Meyer 			break;
190739680c7bSMikolaj Golub 		bp += kv->kve_structsize;
190839680c7bSMikolaj Golub 		cnt++;
190939680c7bSMikolaj Golub 	}
191039680c7bSMikolaj Golub 
191139680c7bSMikolaj Golub 	kiv = calloc(cnt, sizeof(*kiv));
191239680c7bSMikolaj Golub 	if (kiv == NULL) {
191339680c7bSMikolaj Golub 		free(buf);
191439680c7bSMikolaj Golub 		return (NULL);
191539680c7bSMikolaj Golub 	}
191639680c7bSMikolaj Golub 	bp = buf;
191739680c7bSMikolaj Golub 	eb = buf + len;
191839680c7bSMikolaj Golub 	kp = kiv;
191939680c7bSMikolaj Golub 	/* Pass 2: unpack */
192039680c7bSMikolaj Golub 	while (bp < eb) {
192139680c7bSMikolaj Golub 		kv = (struct kinfo_vmentry *)(uintptr_t)bp;
1922e6b95927SConrad Meyer 		if (kv->kve_structsize == 0)
1923e6b95927SConrad Meyer 			break;
192439680c7bSMikolaj Golub 		/* Copy/expand into pre-zeroed buffer */
192539680c7bSMikolaj Golub 		memcpy(kp, kv, kv->kve_structsize);
192639680c7bSMikolaj Golub 		/* Advance to next packed record */
192739680c7bSMikolaj Golub 		bp += kv->kve_structsize;
192839680c7bSMikolaj Golub 		/* Set field size to fixed length, advance */
192939680c7bSMikolaj Golub 		kp->kve_structsize = sizeof(*kp);
193039680c7bSMikolaj Golub 		kp++;
193139680c7bSMikolaj Golub 	}
193239680c7bSMikolaj Golub 	free(buf);
193339680c7bSMikolaj Golub 	*cntp = cnt;
193439680c7bSMikolaj Golub 	return (kiv);	/* Caller must free() return value */
193539680c7bSMikolaj Golub }
193639680c7bSMikolaj Golub 
193739680c7bSMikolaj Golub struct kinfo_vmentry *
193839680c7bSMikolaj Golub procstat_getvmmap(struct procstat *procstat, struct kinfo_proc *kp,
193939680c7bSMikolaj Golub     unsigned int *cntp)
194039680c7bSMikolaj Golub {
194189358231SMikolaj Golub 
194239680c7bSMikolaj Golub 	switch (procstat->type) {
194339680c7bSMikolaj Golub 	case PROCSTAT_KVM:
194439680c7bSMikolaj Golub 		warnx("kvm method is not supported");
194539680c7bSMikolaj Golub 		return (NULL);
194639680c7bSMikolaj Golub 	case PROCSTAT_SYSCTL:
194739680c7bSMikolaj Golub 		return (kinfo_getvmmap(kp->ki_pid, cntp));
194839680c7bSMikolaj Golub 	case PROCSTAT_CORE:
194939680c7bSMikolaj Golub 		return (kinfo_getvmmap_core(procstat->core, cntp));
195039680c7bSMikolaj Golub 	default:
195139680c7bSMikolaj Golub 		warnx("unknown access method: %d", procstat->type);
195239680c7bSMikolaj Golub 		return (NULL);
195339680c7bSMikolaj Golub 	}
195439680c7bSMikolaj Golub }
195539680c7bSMikolaj Golub 
195639680c7bSMikolaj Golub void
195739680c7bSMikolaj Golub procstat_freevmmap(struct procstat *procstat __unused,
195839680c7bSMikolaj Golub     struct kinfo_vmentry *vmmap)
195939680c7bSMikolaj Golub {
196039680c7bSMikolaj Golub 
196139680c7bSMikolaj Golub 	free(vmmap);
196239680c7bSMikolaj Golub }
19637f1d14e6SMikolaj Golub 
19647f1d14e6SMikolaj Golub static gid_t *
19651f84c47eSMikolaj Golub procstat_getgroups_kvm(kvm_t *kd, struct kinfo_proc *kp, unsigned int *cntp)
19661f84c47eSMikolaj Golub {
19671f84c47eSMikolaj Golub 	struct proc proc;
19681f84c47eSMikolaj Golub 	struct ucred ucred;
19691f84c47eSMikolaj Golub 	gid_t *groups;
19701f84c47eSMikolaj Golub 	size_t len;
19711f84c47eSMikolaj Golub 
19721f84c47eSMikolaj Golub 	assert(kd != NULL);
19731f84c47eSMikolaj Golub 	assert(kp != NULL);
19741f84c47eSMikolaj Golub 	if (!kvm_read_all(kd, (unsigned long)kp->ki_paddr, &proc,
19751f84c47eSMikolaj Golub 	    sizeof(proc))) {
19761f84c47eSMikolaj Golub 		warnx("can't read proc struct at %p for pid %d",
19771f84c47eSMikolaj Golub 		    kp->ki_paddr, kp->ki_pid);
19781f84c47eSMikolaj Golub 		return (NULL);
19791f84c47eSMikolaj Golub 	}
19801f84c47eSMikolaj Golub 	if (proc.p_ucred == NOCRED)
19811f84c47eSMikolaj Golub 		return (NULL);
19821f84c47eSMikolaj Golub 	if (!kvm_read_all(kd, (unsigned long)proc.p_ucred, &ucred,
19831f84c47eSMikolaj Golub 	    sizeof(ucred))) {
19841f84c47eSMikolaj Golub 		warnx("can't read ucred struct at %p for pid %d",
19851f84c47eSMikolaj Golub 		    proc.p_ucred, kp->ki_pid);
19861f84c47eSMikolaj Golub 		return (NULL);
19871f84c47eSMikolaj Golub 	}
19881f84c47eSMikolaj Golub 	len = ucred.cr_ngroups * sizeof(gid_t);
19891f84c47eSMikolaj Golub 	groups = malloc(len);
19901f84c47eSMikolaj Golub 	if (groups == NULL) {
19911f84c47eSMikolaj Golub 		warn("malloc(%zu)", len);
19921f84c47eSMikolaj Golub 		return (NULL);
19931f84c47eSMikolaj Golub 	}
19941f84c47eSMikolaj Golub 	if (!kvm_read_all(kd, (unsigned long)ucred.cr_groups, groups, len)) {
19951f84c47eSMikolaj Golub 		warnx("can't read groups at %p for pid %d",
19961f84c47eSMikolaj Golub 		    ucred.cr_groups, kp->ki_pid);
19971f84c47eSMikolaj Golub 		free(groups);
19981f84c47eSMikolaj Golub 		return (NULL);
19991f84c47eSMikolaj Golub 	}
20001f84c47eSMikolaj Golub 	*cntp = ucred.cr_ngroups;
20011f84c47eSMikolaj Golub 	return (groups);
20021f84c47eSMikolaj Golub }
20031f84c47eSMikolaj Golub 
20041f84c47eSMikolaj Golub static gid_t *
20057f1d14e6SMikolaj Golub procstat_getgroups_sysctl(pid_t pid, unsigned int *cntp)
20067f1d14e6SMikolaj Golub {
20077f1d14e6SMikolaj Golub 	int mib[4];
20087f1d14e6SMikolaj Golub 	size_t len;
20097f1d14e6SMikolaj Golub 	gid_t *groups;
20107f1d14e6SMikolaj Golub 
20117f1d14e6SMikolaj Golub 	mib[0] = CTL_KERN;
20127f1d14e6SMikolaj Golub 	mib[1] = KERN_PROC;
20137f1d14e6SMikolaj Golub 	mib[2] = KERN_PROC_GROUPS;
20147f1d14e6SMikolaj Golub 	mib[3] = pid;
20157f1d14e6SMikolaj Golub 	len = (sysconf(_SC_NGROUPS_MAX) + 1) * sizeof(gid_t);
20167f1d14e6SMikolaj Golub 	groups = malloc(len);
20177f1d14e6SMikolaj Golub 	if (groups == NULL) {
20187f1d14e6SMikolaj Golub 		warn("malloc(%zu)", len);
20197f1d14e6SMikolaj Golub 		return (NULL);
20207f1d14e6SMikolaj Golub 	}
202175b6a179SEnji Cooper 	if (sysctl(mib, nitems(mib), groups, &len, NULL, 0) == -1) {
20227f1d14e6SMikolaj Golub 		warn("sysctl: kern.proc.groups: %d", pid);
20237f1d14e6SMikolaj Golub 		free(groups);
20247f1d14e6SMikolaj Golub 		return (NULL);
20257f1d14e6SMikolaj Golub 	}
20267f1d14e6SMikolaj Golub 	*cntp = len / sizeof(gid_t);
20277f1d14e6SMikolaj Golub 	return (groups);
20287f1d14e6SMikolaj Golub }
20297f1d14e6SMikolaj Golub 
20307f1d14e6SMikolaj Golub static gid_t *
20317f1d14e6SMikolaj Golub procstat_getgroups_core(struct procstat_core *core, unsigned int *cntp)
20327f1d14e6SMikolaj Golub {
20337f1d14e6SMikolaj Golub 	size_t len;
20347f1d14e6SMikolaj Golub 	gid_t *groups;
20357f1d14e6SMikolaj Golub 
20367f1d14e6SMikolaj Golub 	groups = procstat_core_get(core, PSC_TYPE_GROUPS, NULL, &len);
20377f1d14e6SMikolaj Golub 	if (groups == NULL)
20387f1d14e6SMikolaj Golub 		return (NULL);
20397f1d14e6SMikolaj Golub 	*cntp = len / sizeof(gid_t);
20407f1d14e6SMikolaj Golub 	return (groups);
20417f1d14e6SMikolaj Golub }
20427f1d14e6SMikolaj Golub 
20437f1d14e6SMikolaj Golub gid_t *
20447f1d14e6SMikolaj Golub procstat_getgroups(struct procstat *procstat, struct kinfo_proc *kp,
20457f1d14e6SMikolaj Golub     unsigned int *cntp)
20467f1d14e6SMikolaj Golub {
20477f1d14e6SMikolaj Golub 	switch (procstat->type) {
20487f1d14e6SMikolaj Golub 	case PROCSTAT_KVM:
20491f84c47eSMikolaj Golub 		return (procstat_getgroups_kvm(procstat->kd, kp, cntp));
20507f1d14e6SMikolaj Golub 	case PROCSTAT_SYSCTL:
20517f1d14e6SMikolaj Golub 		return (procstat_getgroups_sysctl(kp->ki_pid, cntp));
20527f1d14e6SMikolaj Golub 	case PROCSTAT_CORE:
20537f1d14e6SMikolaj Golub 		return (procstat_getgroups_core(procstat->core, cntp));
20547f1d14e6SMikolaj Golub 	default:
20557f1d14e6SMikolaj Golub 		warnx("unknown access method: %d", procstat->type);
20567f1d14e6SMikolaj Golub 		return (NULL);
20577f1d14e6SMikolaj Golub 	}
20587f1d14e6SMikolaj Golub }
20597f1d14e6SMikolaj Golub 
20607f1d14e6SMikolaj Golub void
20617f1d14e6SMikolaj Golub procstat_freegroups(struct procstat *procstat __unused, gid_t *groups)
20627f1d14e6SMikolaj Golub {
20637f1d14e6SMikolaj Golub 
20647f1d14e6SMikolaj Golub 	free(groups);
20657f1d14e6SMikolaj Golub }
20665b9bcba9SMikolaj Golub 
20675b9bcba9SMikolaj Golub static int
20681f84c47eSMikolaj Golub procstat_getumask_kvm(kvm_t *kd, struct kinfo_proc *kp, unsigned short *maskp)
20691f84c47eSMikolaj Golub {
207085078b85SConrad Meyer 	struct pwddesc pd;
20711f84c47eSMikolaj Golub 
20721f84c47eSMikolaj Golub 	assert(kd != NULL);
20731f84c47eSMikolaj Golub 	assert(kp != NULL);
207485078b85SConrad Meyer 	if (kp->ki_pd == NULL)
20751f84c47eSMikolaj Golub 		return (-1);
207685078b85SConrad Meyer 	if (!kvm_read_all(kd, (unsigned long)kp->ki_pd, &pd, sizeof(pd))) {
207785078b85SConrad Meyer 		warnx("can't read pwddesc at %p for pid %d", kp->ki_pd,
20781f84c47eSMikolaj Golub 		    kp->ki_pid);
20791f84c47eSMikolaj Golub 		return (-1);
20801f84c47eSMikolaj Golub 	}
208185078b85SConrad Meyer 	*maskp = pd.pd_cmask;
20821f84c47eSMikolaj Golub 	return (0);
20831f84c47eSMikolaj Golub }
20841f84c47eSMikolaj Golub 
20851f84c47eSMikolaj Golub static int
20865b9bcba9SMikolaj Golub procstat_getumask_sysctl(pid_t pid, unsigned short *maskp)
20875b9bcba9SMikolaj Golub {
20885b9bcba9SMikolaj Golub 	int error;
20895b9bcba9SMikolaj Golub 	int mib[4];
20905b9bcba9SMikolaj Golub 	size_t len;
20915b9bcba9SMikolaj Golub 
20925b9bcba9SMikolaj Golub 	mib[0] = CTL_KERN;
20935b9bcba9SMikolaj Golub 	mib[1] = KERN_PROC;
20945b9bcba9SMikolaj Golub 	mib[2] = KERN_PROC_UMASK;
20955b9bcba9SMikolaj Golub 	mib[3] = pid;
20965b9bcba9SMikolaj Golub 	len = sizeof(*maskp);
209775b6a179SEnji Cooper 	error = sysctl(mib, nitems(mib), maskp, &len, NULL, 0);
209809b46be1SRobert Watson 	if (error != 0 && errno != ESRCH && errno != EPERM)
20995b9bcba9SMikolaj Golub 		warn("sysctl: kern.proc.umask: %d", pid);
21005b9bcba9SMikolaj Golub 	return (error);
21015b9bcba9SMikolaj Golub }
21025b9bcba9SMikolaj Golub 
21035b9bcba9SMikolaj Golub static int
21045b9bcba9SMikolaj Golub procstat_getumask_core(struct procstat_core *core, unsigned short *maskp)
21055b9bcba9SMikolaj Golub {
21065b9bcba9SMikolaj Golub 	size_t len;
21075b9bcba9SMikolaj Golub 	unsigned short *buf;
21085b9bcba9SMikolaj Golub 
21095b9bcba9SMikolaj Golub 	buf = procstat_core_get(core, PSC_TYPE_UMASK, NULL, &len);
21105b9bcba9SMikolaj Golub 	if (buf == NULL)
21115b9bcba9SMikolaj Golub 		return (-1);
21125b9bcba9SMikolaj Golub 	if (len < sizeof(*maskp)) {
21135b9bcba9SMikolaj Golub 		free(buf);
21145b9bcba9SMikolaj Golub 		return (-1);
21155b9bcba9SMikolaj Golub 	}
21165b9bcba9SMikolaj Golub 	*maskp = *buf;
21175b9bcba9SMikolaj Golub 	free(buf);
21185b9bcba9SMikolaj Golub 	return (0);
21195b9bcba9SMikolaj Golub }
21205b9bcba9SMikolaj Golub 
21215b9bcba9SMikolaj Golub int
21225b9bcba9SMikolaj Golub procstat_getumask(struct procstat *procstat, struct kinfo_proc *kp,
21235b9bcba9SMikolaj Golub     unsigned short *maskp)
21245b9bcba9SMikolaj Golub {
21255b9bcba9SMikolaj Golub 	switch (procstat->type) {
21265b9bcba9SMikolaj Golub 	case PROCSTAT_KVM:
21271f84c47eSMikolaj Golub 		return (procstat_getumask_kvm(procstat->kd, kp, maskp));
21285b9bcba9SMikolaj Golub 	case PROCSTAT_SYSCTL:
21295b9bcba9SMikolaj Golub 		return (procstat_getumask_sysctl(kp->ki_pid, maskp));
21305b9bcba9SMikolaj Golub 	case PROCSTAT_CORE:
21315b9bcba9SMikolaj Golub 		return (procstat_getumask_core(procstat->core, maskp));
21325b9bcba9SMikolaj Golub 	default:
21335b9bcba9SMikolaj Golub 		warnx("unknown access method: %d", procstat->type);
21345b9bcba9SMikolaj Golub 		return (-1);
21355b9bcba9SMikolaj Golub 	}
21365b9bcba9SMikolaj Golub }
21377cc0ebfdSMikolaj Golub 
21387cc0ebfdSMikolaj Golub static int
21391f84c47eSMikolaj Golub procstat_getrlimit_kvm(kvm_t *kd, struct kinfo_proc *kp, int which,
21401f84c47eSMikolaj Golub     struct rlimit* rlimit)
21411f84c47eSMikolaj Golub {
21421f84c47eSMikolaj Golub 	struct proc proc;
21431f84c47eSMikolaj Golub 	unsigned long offset;
21441f84c47eSMikolaj Golub 
21451f84c47eSMikolaj Golub 	assert(kd != NULL);
21461f84c47eSMikolaj Golub 	assert(kp != NULL);
21471f84c47eSMikolaj Golub 	assert(which >= 0 && which < RLIM_NLIMITS);
21481f84c47eSMikolaj Golub 	if (!kvm_read_all(kd, (unsigned long)kp->ki_paddr, &proc,
21491f84c47eSMikolaj Golub 	    sizeof(proc))) {
21501f84c47eSMikolaj Golub 		warnx("can't read proc struct at %p for pid %d",
21511f84c47eSMikolaj Golub 		    kp->ki_paddr, kp->ki_pid);
21521f84c47eSMikolaj Golub 		return (-1);
21531f84c47eSMikolaj Golub 	}
21541f84c47eSMikolaj Golub 	if (proc.p_limit == NULL)
21551f84c47eSMikolaj Golub 		return (-1);
21561f84c47eSMikolaj Golub 	offset = (unsigned long)proc.p_limit + sizeof(struct rlimit) * which;
21571f84c47eSMikolaj Golub 	if (!kvm_read_all(kd, offset, rlimit, sizeof(*rlimit))) {
21581f84c47eSMikolaj Golub 		warnx("can't read rlimit struct at %p for pid %d",
21591f84c47eSMikolaj Golub 		    (void *)offset, kp->ki_pid);
21601f84c47eSMikolaj Golub 		return (-1);
21611f84c47eSMikolaj Golub 	}
21621f84c47eSMikolaj Golub 	return (0);
21631f84c47eSMikolaj Golub }
21641f84c47eSMikolaj Golub 
21651f84c47eSMikolaj Golub static int
21667cc0ebfdSMikolaj Golub procstat_getrlimit_sysctl(pid_t pid, int which, struct rlimit* rlimit)
21677cc0ebfdSMikolaj Golub {
21687cc0ebfdSMikolaj Golub 	int error, name[5];
21697cc0ebfdSMikolaj Golub 	size_t len;
21707cc0ebfdSMikolaj Golub 
21717cc0ebfdSMikolaj Golub 	name[0] = CTL_KERN;
21727cc0ebfdSMikolaj Golub 	name[1] = KERN_PROC;
21737cc0ebfdSMikolaj Golub 	name[2] = KERN_PROC_RLIMIT;
21747cc0ebfdSMikolaj Golub 	name[3] = pid;
21757cc0ebfdSMikolaj Golub 	name[4] = which;
21767cc0ebfdSMikolaj Golub 	len = sizeof(struct rlimit);
217775b6a179SEnji Cooper 	error = sysctl(name, nitems(name), rlimit, &len, NULL, 0);
21787cc0ebfdSMikolaj Golub 	if (error < 0 && errno != ESRCH) {
21797cc0ebfdSMikolaj Golub 		warn("sysctl: kern.proc.rlimit: %d", pid);
21807cc0ebfdSMikolaj Golub 		return (-1);
21817cc0ebfdSMikolaj Golub 	}
21827cc0ebfdSMikolaj Golub 	if (error < 0 || len != sizeof(struct rlimit))
21837cc0ebfdSMikolaj Golub 		return (-1);
21847cc0ebfdSMikolaj Golub 	return (0);
21857cc0ebfdSMikolaj Golub }
21867cc0ebfdSMikolaj Golub 
21877cc0ebfdSMikolaj Golub static int
21887cc0ebfdSMikolaj Golub procstat_getrlimit_core(struct procstat_core *core, int which,
21897cc0ebfdSMikolaj Golub     struct rlimit* rlimit)
21907cc0ebfdSMikolaj Golub {
21917cc0ebfdSMikolaj Golub 	size_t len;
21927cc0ebfdSMikolaj Golub 	struct rlimit* rlimits;
21937cc0ebfdSMikolaj Golub 
21947cc0ebfdSMikolaj Golub 	if (which < 0 || which >= RLIM_NLIMITS) {
21957cc0ebfdSMikolaj Golub 		errno = EINVAL;
21967cc0ebfdSMikolaj Golub 		warn("getrlimit: which");
21977cc0ebfdSMikolaj Golub 		return (-1);
21987cc0ebfdSMikolaj Golub 	}
21997cc0ebfdSMikolaj Golub 	rlimits = procstat_core_get(core, PSC_TYPE_RLIMIT, NULL, &len);
22007cc0ebfdSMikolaj Golub 	if (rlimits == NULL)
22017cc0ebfdSMikolaj Golub 		return (-1);
22027cc0ebfdSMikolaj Golub 	if (len < sizeof(struct rlimit) * RLIM_NLIMITS) {
22037cc0ebfdSMikolaj Golub 		free(rlimits);
22047cc0ebfdSMikolaj Golub 		return (-1);
22057cc0ebfdSMikolaj Golub 	}
22067cc0ebfdSMikolaj Golub 	*rlimit = rlimits[which];
22079b207441SEric van Gyzen 	free(rlimits);
22087cc0ebfdSMikolaj Golub 	return (0);
22097cc0ebfdSMikolaj Golub }
22107cc0ebfdSMikolaj Golub 
22117cc0ebfdSMikolaj Golub int
22127cc0ebfdSMikolaj Golub procstat_getrlimit(struct procstat *procstat, struct kinfo_proc *kp, int which,
22137cc0ebfdSMikolaj Golub     struct rlimit* rlimit)
22147cc0ebfdSMikolaj Golub {
22157cc0ebfdSMikolaj Golub 	switch (procstat->type) {
22167cc0ebfdSMikolaj Golub 	case PROCSTAT_KVM:
22171f84c47eSMikolaj Golub 		return (procstat_getrlimit_kvm(procstat->kd, kp, which,
22181f84c47eSMikolaj Golub 		    rlimit));
22197cc0ebfdSMikolaj Golub 	case PROCSTAT_SYSCTL:
22207cc0ebfdSMikolaj Golub 		return (procstat_getrlimit_sysctl(kp->ki_pid, which, rlimit));
22217cc0ebfdSMikolaj Golub 	case PROCSTAT_CORE:
22227cc0ebfdSMikolaj Golub 		return (procstat_getrlimit_core(procstat->core, which, rlimit));
22237cc0ebfdSMikolaj Golub 	default:
22247cc0ebfdSMikolaj Golub 		warnx("unknown access method: %d", procstat->type);
22257cc0ebfdSMikolaj Golub 		return (-1);
22267cc0ebfdSMikolaj Golub 	}
22277cc0ebfdSMikolaj Golub }
22284cdf9796SMikolaj Golub 
22294cdf9796SMikolaj Golub static int
22304cdf9796SMikolaj Golub procstat_getpathname_sysctl(pid_t pid, char *pathname, size_t maxlen)
22314cdf9796SMikolaj Golub {
22324cdf9796SMikolaj Golub 	int error, name[4];
22334cdf9796SMikolaj Golub 	size_t len;
22344cdf9796SMikolaj Golub 
22354cdf9796SMikolaj Golub 	name[0] = CTL_KERN;
22364cdf9796SMikolaj Golub 	name[1] = KERN_PROC;
22374cdf9796SMikolaj Golub 	name[2] = KERN_PROC_PATHNAME;
22384cdf9796SMikolaj Golub 	name[3] = pid;
22394cdf9796SMikolaj Golub 	len = maxlen;
224075b6a179SEnji Cooper 	error = sysctl(name, nitems(name), pathname, &len, NULL, 0);
22414cdf9796SMikolaj Golub 	if (error != 0 && errno != ESRCH)
22424cdf9796SMikolaj Golub 		warn("sysctl: kern.proc.pathname: %d", pid);
22434cdf9796SMikolaj Golub 	if (len == 0)
22444cdf9796SMikolaj Golub 		pathname[0] = '\0';
22454cdf9796SMikolaj Golub 	return (error);
22464cdf9796SMikolaj Golub }
22474cdf9796SMikolaj Golub 
22484cdf9796SMikolaj Golub static int
22494cdf9796SMikolaj Golub procstat_getpathname_core(struct procstat_core *core, char *pathname,
22504cdf9796SMikolaj Golub     size_t maxlen)
22514cdf9796SMikolaj Golub {
22524cdf9796SMikolaj Golub 	struct kinfo_file *files;
22534cdf9796SMikolaj Golub 	int cnt, i, result;
22544cdf9796SMikolaj Golub 
22554cdf9796SMikolaj Golub 	files = kinfo_getfile_core(core, &cnt);
22564cdf9796SMikolaj Golub 	if (files == NULL)
22574cdf9796SMikolaj Golub 		return (-1);
22584cdf9796SMikolaj Golub 	result = -1;
22594cdf9796SMikolaj Golub 	for (i = 0; i < cnt; i++) {
22604cdf9796SMikolaj Golub 		if (files[i].kf_fd != KF_FD_TYPE_TEXT)
22614cdf9796SMikolaj Golub 			continue;
22624cdf9796SMikolaj Golub 		strncpy(pathname, files[i].kf_path, maxlen);
22634cdf9796SMikolaj Golub 		result = 0;
22644cdf9796SMikolaj Golub 		break;
22654cdf9796SMikolaj Golub 	}
22664cdf9796SMikolaj Golub 	free(files);
22674cdf9796SMikolaj Golub 	return (result);
22684cdf9796SMikolaj Golub }
22694cdf9796SMikolaj Golub 
22704cdf9796SMikolaj Golub int
22714cdf9796SMikolaj Golub procstat_getpathname(struct procstat *procstat, struct kinfo_proc *kp,
22724cdf9796SMikolaj Golub     char *pathname, size_t maxlen)
22734cdf9796SMikolaj Golub {
22744cdf9796SMikolaj Golub 	switch (procstat->type) {
22754cdf9796SMikolaj Golub 	case PROCSTAT_KVM:
2276dd70ad64SMikolaj Golub 		/* XXX: Return empty string. */
2277dd70ad64SMikolaj Golub 		if (maxlen > 0)
2278dd70ad64SMikolaj Golub 			pathname[0] = '\0';
2279dd70ad64SMikolaj Golub 		return (0);
22804cdf9796SMikolaj Golub 	case PROCSTAT_SYSCTL:
22814cdf9796SMikolaj Golub 		return (procstat_getpathname_sysctl(kp->ki_pid, pathname,
22824cdf9796SMikolaj Golub 		    maxlen));
22834cdf9796SMikolaj Golub 	case PROCSTAT_CORE:
22844cdf9796SMikolaj Golub 		return (procstat_getpathname_core(procstat->core, pathname,
22854cdf9796SMikolaj Golub 		    maxlen));
22864cdf9796SMikolaj Golub 	default:
22874cdf9796SMikolaj Golub 		warnx("unknown access method: %d", procstat->type);
22884cdf9796SMikolaj Golub 		return (-1);
22894cdf9796SMikolaj Golub 	}
22904cdf9796SMikolaj Golub }
2291eec6cb1cSMikolaj Golub 
2292eec6cb1cSMikolaj Golub static int
22931f84c47eSMikolaj Golub procstat_getosrel_kvm(kvm_t *kd, struct kinfo_proc *kp, int *osrelp)
22941f84c47eSMikolaj Golub {
22951f84c47eSMikolaj Golub 	struct proc proc;
22961f84c47eSMikolaj Golub 
22971f84c47eSMikolaj Golub 	assert(kd != NULL);
22981f84c47eSMikolaj Golub 	assert(kp != NULL);
22991f84c47eSMikolaj Golub 	if (!kvm_read_all(kd, (unsigned long)kp->ki_paddr, &proc,
23001f84c47eSMikolaj Golub 	    sizeof(proc))) {
23011f84c47eSMikolaj Golub 		warnx("can't read proc struct at %p for pid %d",
23021f84c47eSMikolaj Golub 		    kp->ki_paddr, kp->ki_pid);
23031f84c47eSMikolaj Golub 		return (-1);
23041f84c47eSMikolaj Golub 	}
23051f84c47eSMikolaj Golub 	*osrelp = proc.p_osrel;
23061f84c47eSMikolaj Golub 	return (0);
23071f84c47eSMikolaj Golub }
23081f84c47eSMikolaj Golub 
23091f84c47eSMikolaj Golub static int
2310eec6cb1cSMikolaj Golub procstat_getosrel_sysctl(pid_t pid, int *osrelp)
2311eec6cb1cSMikolaj Golub {
2312eec6cb1cSMikolaj Golub 	int error, name[4];
2313eec6cb1cSMikolaj Golub 	size_t len;
2314eec6cb1cSMikolaj Golub 
2315eec6cb1cSMikolaj Golub 	name[0] = CTL_KERN;
2316eec6cb1cSMikolaj Golub 	name[1] = KERN_PROC;
2317eec6cb1cSMikolaj Golub 	name[2] = KERN_PROC_OSREL;
2318eec6cb1cSMikolaj Golub 	name[3] = pid;
2319eec6cb1cSMikolaj Golub 	len = sizeof(*osrelp);
232075b6a179SEnji Cooper 	error = sysctl(name, nitems(name), osrelp, &len, NULL, 0);
2321eec6cb1cSMikolaj Golub 	if (error != 0 && errno != ESRCH)
2322eec6cb1cSMikolaj Golub 		warn("sysctl: kern.proc.osrel: %d", pid);
2323eec6cb1cSMikolaj Golub 	return (error);
2324eec6cb1cSMikolaj Golub }
2325eec6cb1cSMikolaj Golub 
2326eec6cb1cSMikolaj Golub static int
2327eec6cb1cSMikolaj Golub procstat_getosrel_core(struct procstat_core *core, int *osrelp)
2328eec6cb1cSMikolaj Golub {
2329eec6cb1cSMikolaj Golub 	size_t len;
2330eec6cb1cSMikolaj Golub 	int *buf;
2331eec6cb1cSMikolaj Golub 
2332eec6cb1cSMikolaj Golub 	buf = procstat_core_get(core, PSC_TYPE_OSREL, NULL, &len);
2333eec6cb1cSMikolaj Golub 	if (buf == NULL)
2334eec6cb1cSMikolaj Golub 		return (-1);
2335eec6cb1cSMikolaj Golub 	if (len < sizeof(*osrelp)) {
2336eec6cb1cSMikolaj Golub 		free(buf);
2337eec6cb1cSMikolaj Golub 		return (-1);
2338eec6cb1cSMikolaj Golub 	}
2339eec6cb1cSMikolaj Golub 	*osrelp = *buf;
2340eec6cb1cSMikolaj Golub 	free(buf);
2341eec6cb1cSMikolaj Golub 	return (0);
2342eec6cb1cSMikolaj Golub }
2343eec6cb1cSMikolaj Golub 
2344eec6cb1cSMikolaj Golub int
2345eec6cb1cSMikolaj Golub procstat_getosrel(struct procstat *procstat, struct kinfo_proc *kp, int *osrelp)
2346eec6cb1cSMikolaj Golub {
2347eec6cb1cSMikolaj Golub 	switch (procstat->type) {
2348eec6cb1cSMikolaj Golub 	case PROCSTAT_KVM:
23491f84c47eSMikolaj Golub 		return (procstat_getosrel_kvm(procstat->kd, kp, osrelp));
2350eec6cb1cSMikolaj Golub 	case PROCSTAT_SYSCTL:
2351eec6cb1cSMikolaj Golub 		return (procstat_getosrel_sysctl(kp->ki_pid, osrelp));
2352eec6cb1cSMikolaj Golub 	case PROCSTAT_CORE:
2353eec6cb1cSMikolaj Golub 		return (procstat_getosrel_core(procstat->core, osrelp));
2354eec6cb1cSMikolaj Golub 	default:
2355eec6cb1cSMikolaj Golub 		warnx("unknown access method: %d", procstat->type);
2356eec6cb1cSMikolaj Golub 		return (-1);
2357eec6cb1cSMikolaj Golub 	}
2358eec6cb1cSMikolaj Golub }
23592ff020d3SMikolaj Golub 
23602ff020d3SMikolaj Golub #define PROC_AUXV_MAX	256
23612ff020d3SMikolaj Golub 
2362248fe3d3SBrooks Davis #ifdef PS_ARCH_HAS_FREEBSD32
23632ff020d3SMikolaj Golub static const char *elf32_sv_names[] = {
23642ff020d3SMikolaj Golub 	"Linux ELF32",
23652ff020d3SMikolaj Golub 	"FreeBSD ELF32",
23662ff020d3SMikolaj Golub };
23672ff020d3SMikolaj Golub 
23682ff020d3SMikolaj Golub static int
23692ff020d3SMikolaj Golub is_elf32_sysctl(pid_t pid)
23702ff020d3SMikolaj Golub {
23712ff020d3SMikolaj Golub 	int error, name[4];
23722ff020d3SMikolaj Golub 	size_t len, i;
237372a4ee26SBrooks Davis 	char sv_name[32];
23742ff020d3SMikolaj Golub 
23752ff020d3SMikolaj Golub 	name[0] = CTL_KERN;
23762ff020d3SMikolaj Golub 	name[1] = KERN_PROC;
23772ff020d3SMikolaj Golub 	name[2] = KERN_PROC_SV_NAME;
23782ff020d3SMikolaj Golub 	name[3] = pid;
23792ff020d3SMikolaj Golub 	len = sizeof(sv_name);
238075b6a179SEnji Cooper 	error = sysctl(name, nitems(name), sv_name, &len, NULL, 0);
23812ff020d3SMikolaj Golub 	if (error != 0 || len == 0)
23822ff020d3SMikolaj Golub 		return (0);
23832ff020d3SMikolaj Golub 	for (i = 0; i < sizeof(elf32_sv_names) / sizeof(*elf32_sv_names); i++) {
23842ff020d3SMikolaj Golub 		if (strncmp(sv_name, elf32_sv_names[i], sizeof(sv_name)) == 0)
23852ff020d3SMikolaj Golub 			return (1);
23862ff020d3SMikolaj Golub 	}
23872ff020d3SMikolaj Golub 	return (0);
23882ff020d3SMikolaj Golub }
23892ff020d3SMikolaj Golub 
23902ff020d3SMikolaj Golub static Elf_Auxinfo *
23912ff020d3SMikolaj Golub procstat_getauxv32_sysctl(pid_t pid, unsigned int *cntp)
23922ff020d3SMikolaj Golub {
23932ff020d3SMikolaj Golub 	Elf_Auxinfo *auxv;
23942ff020d3SMikolaj Golub 	Elf32_Auxinfo *auxv32;
23952ff020d3SMikolaj Golub 	size_t len;
23962ff020d3SMikolaj Golub 	unsigned int i, count;
23972ff020d3SMikolaj Golub 	int name[4];
23982ff020d3SMikolaj Golub 
23992ff020d3SMikolaj Golub 	name[0] = CTL_KERN;
24002ff020d3SMikolaj Golub 	name[1] = KERN_PROC;
24012ff020d3SMikolaj Golub 	name[2] = KERN_PROC_AUXV;
24022ff020d3SMikolaj Golub 	name[3] = pid;
24032ff020d3SMikolaj Golub 	len = PROC_AUXV_MAX * sizeof(Elf32_Auxinfo);
24042ff020d3SMikolaj Golub 	auxv = NULL;
24052ff020d3SMikolaj Golub 	auxv32 = malloc(len);
24062ff020d3SMikolaj Golub 	if (auxv32 == NULL) {
24072ff020d3SMikolaj Golub 		warn("malloc(%zu)", len);
24082ff020d3SMikolaj Golub 		goto out;
24092ff020d3SMikolaj Golub 	}
241075b6a179SEnji Cooper 	if (sysctl(name, nitems(name), auxv32, &len, NULL, 0) == -1) {
24112ff020d3SMikolaj Golub 		if (errno != ESRCH && errno != EPERM)
24122ff020d3SMikolaj Golub 			warn("sysctl: kern.proc.auxv: %d: %d", pid, errno);
24132ff020d3SMikolaj Golub 		goto out;
24142ff020d3SMikolaj Golub 	}
24158f06fabeSBrooks Davis 	count = len / sizeof(Elf32_Auxinfo);
24162ff020d3SMikolaj Golub 	auxv = malloc(count * sizeof(Elf_Auxinfo));
24172ff020d3SMikolaj Golub 	if (auxv == NULL) {
24182ff020d3SMikolaj Golub 		warn("malloc(%zu)", count * sizeof(Elf_Auxinfo));
24192ff020d3SMikolaj Golub 		goto out;
24202ff020d3SMikolaj Golub 	}
24212ff020d3SMikolaj Golub 	for (i = 0; i < count; i++) {
24222ff020d3SMikolaj Golub 		/*
24232ff020d3SMikolaj Golub 		 * XXX: We expect that values for a_type on a 32-bit platform
24242ff020d3SMikolaj Golub 		 * are directly mapped to values on 64-bit one, which is not
24252ff020d3SMikolaj Golub 		 * necessarily true.
24262ff020d3SMikolaj Golub 		 */
24272ff020d3SMikolaj Golub 		auxv[i].a_type = auxv32[i].a_type;
24289735cc0eSBrooks Davis 		/*
24299735cc0eSBrooks Davis 		 * Don't sign extend values.  Existing entries are positive
24309735cc0eSBrooks Davis 		 * integers or pointers.  Under freebsd32, programs typically
24319735cc0eSBrooks Davis 		 * have a full [0, 2^32) address space (perhaps minus the last
24329735cc0eSBrooks Davis 		 * page) and treating this as a signed integer would be
24339735cc0eSBrooks Davis 		 * confusing since these are not kernel pointers.
24349735cc0eSBrooks Davis 		 *
24359735cc0eSBrooks Davis 		 * XXX: A more complete translation would be ABI and
24369735cc0eSBrooks Davis 		 * type-aware.
24379735cc0eSBrooks Davis 		 */
24389735cc0eSBrooks Davis 		auxv[i].a_un.a_val = (uint32_t)auxv32[i].a_un.a_val;
24392ff020d3SMikolaj Golub 	}
24402ff020d3SMikolaj Golub 	*cntp = count;
24412ff020d3SMikolaj Golub out:
24422ff020d3SMikolaj Golub 	free(auxv32);
24432ff020d3SMikolaj Golub 	return (auxv);
24442ff020d3SMikolaj Golub }
2445248fe3d3SBrooks Davis #endif /* PS_ARCH_HAS_FREEBSD32 */
24462ff020d3SMikolaj Golub 
24472ff020d3SMikolaj Golub static Elf_Auxinfo *
24482ff020d3SMikolaj Golub procstat_getauxv_sysctl(pid_t pid, unsigned int *cntp)
24492ff020d3SMikolaj Golub {
24502ff020d3SMikolaj Golub 	Elf_Auxinfo *auxv;
24512ff020d3SMikolaj Golub 	int name[4];
24522ff020d3SMikolaj Golub 	size_t len;
24532ff020d3SMikolaj Golub 
2454248fe3d3SBrooks Davis #ifdef PS_ARCH_HAS_FREEBSD32
24552ff020d3SMikolaj Golub 	if (is_elf32_sysctl(pid))
24562ff020d3SMikolaj Golub 		return (procstat_getauxv32_sysctl(pid, cntp));
24572ff020d3SMikolaj Golub #endif
24582ff020d3SMikolaj Golub 	name[0] = CTL_KERN;
24592ff020d3SMikolaj Golub 	name[1] = KERN_PROC;
24602ff020d3SMikolaj Golub 	name[2] = KERN_PROC_AUXV;
24612ff020d3SMikolaj Golub 	name[3] = pid;
24622ff020d3SMikolaj Golub 	len = PROC_AUXV_MAX * sizeof(Elf_Auxinfo);
24632ff020d3SMikolaj Golub 	auxv = malloc(len);
24642ff020d3SMikolaj Golub 	if (auxv == NULL) {
24652ff020d3SMikolaj Golub 		warn("malloc(%zu)", len);
24662ff020d3SMikolaj Golub 		return (NULL);
24672ff020d3SMikolaj Golub 	}
246875b6a179SEnji Cooper 	if (sysctl(name, nitems(name), auxv, &len, NULL, 0) == -1) {
24692ff020d3SMikolaj Golub 		if (errno != ESRCH && errno != EPERM)
24702ff020d3SMikolaj Golub 			warn("sysctl: kern.proc.auxv: %d: %d", pid, errno);
24712ff020d3SMikolaj Golub 		free(auxv);
24722ff020d3SMikolaj Golub 		return (NULL);
24732ff020d3SMikolaj Golub 	}
24742ff020d3SMikolaj Golub 	*cntp = len / sizeof(Elf_Auxinfo);
24752ff020d3SMikolaj Golub 	return (auxv);
24762ff020d3SMikolaj Golub }
24772ff020d3SMikolaj Golub 
24782ff020d3SMikolaj Golub static Elf_Auxinfo *
24792ff020d3SMikolaj Golub procstat_getauxv_core(struct procstat_core *core, unsigned int *cntp)
24802ff020d3SMikolaj Golub {
24812ff020d3SMikolaj Golub 	Elf_Auxinfo *auxv;
24822ff020d3SMikolaj Golub 	size_t len;
24832ff020d3SMikolaj Golub 
24842ff020d3SMikolaj Golub 	auxv = procstat_core_get(core, PSC_TYPE_AUXV, NULL, &len);
24852ff020d3SMikolaj Golub 	if (auxv == NULL)
24862ff020d3SMikolaj Golub 		return (NULL);
24872ff020d3SMikolaj Golub 	*cntp = len / sizeof(Elf_Auxinfo);
24882ff020d3SMikolaj Golub 	return (auxv);
24892ff020d3SMikolaj Golub }
24902ff020d3SMikolaj Golub 
24912ff020d3SMikolaj Golub Elf_Auxinfo *
24922ff020d3SMikolaj Golub procstat_getauxv(struct procstat *procstat, struct kinfo_proc *kp,
24932ff020d3SMikolaj Golub     unsigned int *cntp)
24942ff020d3SMikolaj Golub {
24952ff020d3SMikolaj Golub 	switch (procstat->type) {
24962ff020d3SMikolaj Golub 	case PROCSTAT_KVM:
24972ff020d3SMikolaj Golub 		warnx("kvm method is not supported");
24982ff020d3SMikolaj Golub 		return (NULL);
24992ff020d3SMikolaj Golub 	case PROCSTAT_SYSCTL:
25002ff020d3SMikolaj Golub 		return (procstat_getauxv_sysctl(kp->ki_pid, cntp));
25012ff020d3SMikolaj Golub 	case PROCSTAT_CORE:
25022ff020d3SMikolaj Golub 		return (procstat_getauxv_core(procstat->core, cntp));
25032ff020d3SMikolaj Golub 	default:
25042ff020d3SMikolaj Golub 		warnx("unknown access method: %d", procstat->type);
25052ff020d3SMikolaj Golub 		return (NULL);
25062ff020d3SMikolaj Golub 	}
25072ff020d3SMikolaj Golub }
25082ff020d3SMikolaj Golub 
25092ff020d3SMikolaj Golub void
25102ff020d3SMikolaj Golub procstat_freeauxv(struct procstat *procstat __unused, Elf_Auxinfo *auxv)
25112ff020d3SMikolaj Golub {
25122ff020d3SMikolaj Golub 
25132ff020d3SMikolaj Golub 	free(auxv);
25142ff020d3SMikolaj Golub }
251589358231SMikolaj Golub 
251686be94fcSTycho Nightingale static struct ptrace_lwpinfo *
251786be94fcSTycho Nightingale procstat_getptlwpinfo_core(struct procstat_core *core, unsigned int *cntp)
251886be94fcSTycho Nightingale {
251986be94fcSTycho Nightingale 	void *buf;
252086be94fcSTycho Nightingale 	struct ptrace_lwpinfo *pl;
252186be94fcSTycho Nightingale 	unsigned int cnt;
252286be94fcSTycho Nightingale 	size_t len;
252386be94fcSTycho Nightingale 
252486be94fcSTycho Nightingale 	cnt = procstat_core_note_count(core, PSC_TYPE_PTLWPINFO);
252586be94fcSTycho Nightingale 	if (cnt == 0)
252686be94fcSTycho Nightingale 		return (NULL);
252786be94fcSTycho Nightingale 
252886be94fcSTycho Nightingale 	len = cnt * sizeof(*pl);
252986be94fcSTycho Nightingale 	buf = calloc(1, len);
253086be94fcSTycho Nightingale 	pl = procstat_core_get(core, PSC_TYPE_PTLWPINFO, buf, &len);
253186be94fcSTycho Nightingale 	if (pl == NULL) {
253286be94fcSTycho Nightingale 		free(buf);
253386be94fcSTycho Nightingale 		return (NULL);
253486be94fcSTycho Nightingale 	}
253586be94fcSTycho Nightingale 	*cntp = len / sizeof(*pl);
253686be94fcSTycho Nightingale 	return (pl);
253786be94fcSTycho Nightingale }
253886be94fcSTycho Nightingale 
253986be94fcSTycho Nightingale struct ptrace_lwpinfo *
254086be94fcSTycho Nightingale procstat_getptlwpinfo(struct procstat *procstat, unsigned int *cntp)
254186be94fcSTycho Nightingale {
254286be94fcSTycho Nightingale 	switch (procstat->type) {
2543a2ae08e7SEnji Cooper 	case PROCSTAT_KVM:
2544a2ae08e7SEnji Cooper 		warnx("kvm method is not supported");
2545a2ae08e7SEnji Cooper 		return (NULL);
2546a2ae08e7SEnji Cooper 	case PROCSTAT_SYSCTL:
2547a2ae08e7SEnji Cooper 		warnx("sysctl method is not supported");
2548a2ae08e7SEnji Cooper 		return (NULL);
254986be94fcSTycho Nightingale 	case PROCSTAT_CORE:
255086be94fcSTycho Nightingale 	 	return (procstat_getptlwpinfo_core(procstat->core, cntp));
255186be94fcSTycho Nightingale 	default:
255286be94fcSTycho Nightingale 		warnx("unknown access method: %d", procstat->type);
255386be94fcSTycho Nightingale 		return (NULL);
255486be94fcSTycho Nightingale 	}
255586be94fcSTycho Nightingale }
255686be94fcSTycho Nightingale 
255786be94fcSTycho Nightingale void
255886be94fcSTycho Nightingale procstat_freeptlwpinfo(struct procstat *procstat __unused,
255986be94fcSTycho Nightingale     struct ptrace_lwpinfo *pl)
256086be94fcSTycho Nightingale {
256186be94fcSTycho Nightingale 	free(pl);
256286be94fcSTycho Nightingale }
256386be94fcSTycho Nightingale 
256489358231SMikolaj Golub static struct kinfo_kstack *
256589358231SMikolaj Golub procstat_getkstack_sysctl(pid_t pid, int *cntp)
256689358231SMikolaj Golub {
256789358231SMikolaj Golub 	struct kinfo_kstack *kkstp;
256889358231SMikolaj Golub 	int error, name[4];
256989358231SMikolaj Golub 	size_t len;
257089358231SMikolaj Golub 
257189358231SMikolaj Golub 	name[0] = CTL_KERN;
257289358231SMikolaj Golub 	name[1] = KERN_PROC;
257389358231SMikolaj Golub 	name[2] = KERN_PROC_KSTACK;
257489358231SMikolaj Golub 	name[3] = pid;
257589358231SMikolaj Golub 
257689358231SMikolaj Golub 	len = 0;
257775b6a179SEnji Cooper 	error = sysctl(name, nitems(name), NULL, &len, NULL, 0);
257889358231SMikolaj Golub 	if (error < 0 && errno != ESRCH && errno != EPERM && errno != ENOENT) {
257989358231SMikolaj Golub 		warn("sysctl: kern.proc.kstack: %d", pid);
258089358231SMikolaj Golub 		return (NULL);
258189358231SMikolaj Golub 	}
258289358231SMikolaj Golub 	if (error == -1 && errno == ENOENT) {
258389358231SMikolaj Golub 		warnx("sysctl: kern.proc.kstack unavailable"
258489358231SMikolaj Golub 		    " (options DDB or options STACK required in kernel)");
258589358231SMikolaj Golub 		return (NULL);
258689358231SMikolaj Golub 	}
258789358231SMikolaj Golub 	if (error == -1)
258889358231SMikolaj Golub 		return (NULL);
258989358231SMikolaj Golub 	kkstp = malloc(len);
259089358231SMikolaj Golub 	if (kkstp == NULL) {
259189358231SMikolaj Golub 		warn("malloc(%zu)", len);
259289358231SMikolaj Golub 		return (NULL);
259389358231SMikolaj Golub 	}
2594427f12f1SEric van Gyzen 	if (sysctl(name, nitems(name), kkstp, &len, NULL, 0) == -1 &&
2595427f12f1SEric van Gyzen 	    errno != ENOMEM) {
259689358231SMikolaj Golub 		warn("sysctl: kern.proc.pid: %d", pid);
259789358231SMikolaj Golub 		free(kkstp);
259889358231SMikolaj Golub 		return (NULL);
259989358231SMikolaj Golub 	}
260089358231SMikolaj Golub 	*cntp = len / sizeof(*kkstp);
260189358231SMikolaj Golub 
260289358231SMikolaj Golub 	return (kkstp);
260389358231SMikolaj Golub }
260489358231SMikolaj Golub 
260589358231SMikolaj Golub struct kinfo_kstack *
260689358231SMikolaj Golub procstat_getkstack(struct procstat *procstat, struct kinfo_proc *kp,
260789358231SMikolaj Golub     unsigned int *cntp)
260889358231SMikolaj Golub {
260989358231SMikolaj Golub 	switch (procstat->type) {
261089358231SMikolaj Golub 	case PROCSTAT_KVM:
261189358231SMikolaj Golub 		warnx("kvm method is not supported");
261289358231SMikolaj Golub 		return (NULL);
261389358231SMikolaj Golub 	case PROCSTAT_SYSCTL:
261489358231SMikolaj Golub 		return (procstat_getkstack_sysctl(kp->ki_pid, cntp));
261589358231SMikolaj Golub 	case PROCSTAT_CORE:
261689358231SMikolaj Golub 		warnx("core method is not supported");
261789358231SMikolaj Golub 		return (NULL);
261889358231SMikolaj Golub 	default:
261989358231SMikolaj Golub 		warnx("unknown access method: %d", procstat->type);
262089358231SMikolaj Golub 		return (NULL);
262189358231SMikolaj Golub 	}
262289358231SMikolaj Golub }
262389358231SMikolaj Golub 
262489358231SMikolaj Golub void
262589358231SMikolaj Golub procstat_freekstack(struct procstat *procstat __unused,
262689358231SMikolaj Golub     struct kinfo_kstack *kkstp)
262789358231SMikolaj Golub {
262889358231SMikolaj Golub 
262989358231SMikolaj Golub 	free(kkstp);
263089358231SMikolaj Golub }
2631039d1496SKonstantin Belousov 
2632039d1496SKonstantin Belousov static struct advlock_list *
2633039d1496SKonstantin Belousov procstat_getadvlock_sysctl(struct procstat *procstat __unused)
2634039d1496SKonstantin Belousov {
2635039d1496SKonstantin Belousov 	struct advlock_list *res;
2636039d1496SKonstantin Belousov 	struct advlock *a;
2637039d1496SKonstantin Belousov 	void *buf;
2638039d1496SKonstantin Belousov 	char *c;
2639039d1496SKonstantin Belousov 	struct kinfo_lockf *kl;
2640039d1496SKonstantin Belousov 	size_t buf_len;
2641039d1496SKonstantin Belousov 	int error;
2642039d1496SKonstantin Belousov 	static const int kl_name[] = { CTL_KERN, KERN_LOCKF };
2643039d1496SKonstantin Belousov 
2644039d1496SKonstantin Belousov 	res = malloc(sizeof(*res));
2645039d1496SKonstantin Belousov 	if (res == NULL)
2646039d1496SKonstantin Belousov 		return (NULL);
2647039d1496SKonstantin Belousov 	STAILQ_INIT(res);
2648039d1496SKonstantin Belousov 	buf = NULL;
2649039d1496SKonstantin Belousov 
2650039d1496SKonstantin Belousov 	buf_len = 0;
2651039d1496SKonstantin Belousov 	error = sysctl(kl_name, nitems(kl_name), NULL, &buf_len, NULL, 0);
2652039d1496SKonstantin Belousov 	if (error != 0) {
2653039d1496SKonstantin Belousov 		warn("sysctl KERN_LOCKF size");
2654039d1496SKonstantin Belousov 		goto fail;
2655039d1496SKonstantin Belousov 	}
2656039d1496SKonstantin Belousov 	buf_len *= 2;
2657039d1496SKonstantin Belousov 	buf = malloc(buf_len);
2658039d1496SKonstantin Belousov 	if (buf == NULL) {
2659039d1496SKonstantin Belousov 		warn("malloc");
2660039d1496SKonstantin Belousov 		goto fail;
2661039d1496SKonstantin Belousov 	}
2662039d1496SKonstantin Belousov 	error = sysctl(kl_name, nitems(kl_name), buf, &buf_len, NULL, 0);
2663039d1496SKonstantin Belousov 	if (error != 0) {
2664039d1496SKonstantin Belousov 		warn("sysctl KERN_LOCKF data");
2665039d1496SKonstantin Belousov 		goto fail;
2666039d1496SKonstantin Belousov 	}
2667039d1496SKonstantin Belousov 
2668039d1496SKonstantin Belousov 	for (c = buf; (char *)c < (char *)buf + buf_len;
2669039d1496SKonstantin Belousov 	    c += kl->kl_structsize) {
2670039d1496SKonstantin Belousov 		kl = (struct kinfo_lockf *)(void *)c;
2671039d1496SKonstantin Belousov 		if (sizeof(*kl) < (size_t)kl->kl_structsize) {
2672039d1496SKonstantin Belousov 			warn("ABI broken");
2673039d1496SKonstantin Belousov 			goto fail;
2674039d1496SKonstantin Belousov 		}
2675039d1496SKonstantin Belousov 		a = malloc(sizeof(*a));
2676039d1496SKonstantin Belousov 		if (a == NULL) {
2677039d1496SKonstantin Belousov 			warn("malloc advlock");
2678039d1496SKonstantin Belousov 			goto fail;
2679039d1496SKonstantin Belousov 		}
2680039d1496SKonstantin Belousov 		switch (kl->kl_rw) {
2681039d1496SKonstantin Belousov 		case KLOCKF_RW_READ:
2682039d1496SKonstantin Belousov 			a->rw = PS_ADVLOCK_RO;
2683039d1496SKonstantin Belousov 			break;
2684039d1496SKonstantin Belousov 		case KLOCKF_RW_WRITE:
2685039d1496SKonstantin Belousov 			a->rw = PS_ADVLOCK_RW;
2686039d1496SKonstantin Belousov 			break;
2687039d1496SKonstantin Belousov 		default:
2688039d1496SKonstantin Belousov 			warn("ABI broken");
2689039d1496SKonstantin Belousov 			free(a);
2690039d1496SKonstantin Belousov 			goto fail;
2691039d1496SKonstantin Belousov 		}
2692039d1496SKonstantin Belousov 		switch (kl->kl_type) {
2693039d1496SKonstantin Belousov 		case KLOCKF_TYPE_FLOCK:
2694039d1496SKonstantin Belousov 			a->type = PS_ADVLOCK_TYPE_FLOCK;
2695039d1496SKonstantin Belousov 			break;
2696039d1496SKonstantin Belousov 		case KLOCKF_TYPE_PID:
2697039d1496SKonstantin Belousov 			a->type = PS_ADVLOCK_TYPE_PID;
2698039d1496SKonstantin Belousov 			break;
2699039d1496SKonstantin Belousov 		case KLOCKF_TYPE_REMOTE:
2700039d1496SKonstantin Belousov 			a->type = PS_ADVLOCK_TYPE_REMOTE;
2701039d1496SKonstantin Belousov 			break;
2702039d1496SKonstantin Belousov 		default:
2703039d1496SKonstantin Belousov 			warn("ABI broken");
2704039d1496SKonstantin Belousov 			free(a);
2705039d1496SKonstantin Belousov 			goto fail;
2706039d1496SKonstantin Belousov 		}
2707039d1496SKonstantin Belousov 		a->pid = kl->kl_pid;
2708039d1496SKonstantin Belousov 		a->sysid = kl->kl_sysid;
2709039d1496SKonstantin Belousov 		a->file_fsid = kl->kl_file_fsid;
2710039d1496SKonstantin Belousov 		a->file_rdev = kl->kl_file_rdev;
2711039d1496SKonstantin Belousov 		a->file_fileid = kl->kl_file_fileid;
2712039d1496SKonstantin Belousov 		a->start = kl->kl_start;
2713039d1496SKonstantin Belousov 		a->len = kl->kl_len;
2714039d1496SKonstantin Belousov 		if (kl->kl_path[0] != '\0') {
2715039d1496SKonstantin Belousov 			a->path = strdup(kl->kl_path);
2716039d1496SKonstantin Belousov 			if (a->path == NULL) {
2717039d1496SKonstantin Belousov 				warn("malloc");
2718039d1496SKonstantin Belousov 				free(a);
2719039d1496SKonstantin Belousov 				goto fail;
2720039d1496SKonstantin Belousov 			}
2721039d1496SKonstantin Belousov 		} else
2722039d1496SKonstantin Belousov 			a->path = NULL;
2723039d1496SKonstantin Belousov 		STAILQ_INSERT_TAIL(res, a, next);
2724039d1496SKonstantin Belousov 	}
2725039d1496SKonstantin Belousov 
2726039d1496SKonstantin Belousov 	free(buf);
2727039d1496SKonstantin Belousov 	return (res);
2728039d1496SKonstantin Belousov 
2729039d1496SKonstantin Belousov fail:
2730039d1496SKonstantin Belousov 	free(buf);
2731039d1496SKonstantin Belousov 	procstat_freeadvlock(procstat, res);
2732039d1496SKonstantin Belousov 	return (NULL);
2733039d1496SKonstantin Belousov }
2734039d1496SKonstantin Belousov 
2735039d1496SKonstantin Belousov struct advlock_list *
2736039d1496SKonstantin Belousov procstat_getadvlock(struct procstat *procstat)
2737039d1496SKonstantin Belousov {
2738039d1496SKonstantin Belousov 	switch (procstat->type) {
2739039d1496SKonstantin Belousov 	case PROCSTAT_KVM:
2740039d1496SKonstantin Belousov 		warnx("kvm method is not supported");
2741039d1496SKonstantin Belousov 		return (NULL);
2742039d1496SKonstantin Belousov 	case PROCSTAT_SYSCTL:
2743039d1496SKonstantin Belousov 		return (procstat_getadvlock_sysctl(procstat));
2744039d1496SKonstantin Belousov 	case PROCSTAT_CORE:
2745039d1496SKonstantin Belousov 		warnx("core method is not supported");
2746039d1496SKonstantin Belousov 		return (NULL);
2747039d1496SKonstantin Belousov 	default:
2748039d1496SKonstantin Belousov 		warnx("unknown access method: %d", procstat->type);
2749039d1496SKonstantin Belousov 		return (NULL);
2750039d1496SKonstantin Belousov 	}
2751039d1496SKonstantin Belousov }
2752039d1496SKonstantin Belousov 
2753039d1496SKonstantin Belousov void
2754039d1496SKonstantin Belousov procstat_freeadvlock(struct procstat *procstat __unused,
2755039d1496SKonstantin Belousov     struct advlock_list *lst)
2756039d1496SKonstantin Belousov {
2757039d1496SKonstantin Belousov 	struct advlock *a, *a1;
2758039d1496SKonstantin Belousov 
2759039d1496SKonstantin Belousov 	STAILQ_FOREACH_SAFE(a, lst, next, a1) {
2760039d1496SKonstantin Belousov 		free(__DECONST(char *, a->path));
2761039d1496SKonstantin Belousov 		free(a);
2762039d1496SKonstantin Belousov 	}
2763039d1496SKonstantin Belousov 	free(lst);
2764039d1496SKonstantin Belousov }
2765039d1496SKonstantin Belousov 
2766*6126f4eaSKonstantin Belousov static rlim_t *
2767*6126f4eaSKonstantin Belousov procstat_getrlimitusage_sysctl(pid_t pid, unsigned *cntp)
2768*6126f4eaSKonstantin Belousov {
2769*6126f4eaSKonstantin Belousov 	int error, name[4];
2770*6126f4eaSKonstantin Belousov 	rlim_t *val;
2771*6126f4eaSKonstantin Belousov 	size_t len;
2772*6126f4eaSKonstantin Belousov 
2773*6126f4eaSKonstantin Belousov 	name[0] = CTL_KERN;
2774*6126f4eaSKonstantin Belousov 	name[1] = KERN_PROC;
2775*6126f4eaSKonstantin Belousov 	name[2] = KERN_PROC_RLIMIT_USAGE;
2776*6126f4eaSKonstantin Belousov 	name[3] = pid;
2777*6126f4eaSKonstantin Belousov 
2778*6126f4eaSKonstantin Belousov 	len = 0;
2779*6126f4eaSKonstantin Belousov 	error = sysctl(name, nitems(name), NULL, &len, NULL, 0);
2780*6126f4eaSKonstantin Belousov 	if (error == -1)
2781*6126f4eaSKonstantin Belousov 		return (NULL);
2782*6126f4eaSKonstantin Belousov 	val = malloc(len);
2783*6126f4eaSKonstantin Belousov 	if (val == NULL)
2784*6126f4eaSKonstantin Belousov 		return (NULL);
2785*6126f4eaSKonstantin Belousov 
2786*6126f4eaSKonstantin Belousov 	error = sysctl(name, nitems(name), val, &len, NULL, 0);
2787*6126f4eaSKonstantin Belousov 	if (error == -1) {
2788*6126f4eaSKonstantin Belousov 		free(val);
2789*6126f4eaSKonstantin Belousov 		return (NULL);
2790*6126f4eaSKonstantin Belousov 	}
2791*6126f4eaSKonstantin Belousov 	*cntp = len / sizeof(rlim_t);
2792*6126f4eaSKonstantin Belousov 	return (val);
2793*6126f4eaSKonstantin Belousov }
2794*6126f4eaSKonstantin Belousov 
2795*6126f4eaSKonstantin Belousov rlim_t *
2796*6126f4eaSKonstantin Belousov procstat_getrlimitusage(struct procstat *procstat, struct kinfo_proc *kp,
2797*6126f4eaSKonstantin Belousov     unsigned int *cntp)
2798*6126f4eaSKonstantin Belousov {
2799*6126f4eaSKonstantin Belousov 	switch (procstat->type) {
2800*6126f4eaSKonstantin Belousov 	case PROCSTAT_KVM:
2801*6126f4eaSKonstantin Belousov 		warnx("kvm method is not supported");
2802*6126f4eaSKonstantin Belousov 		return (NULL);
2803*6126f4eaSKonstantin Belousov 	case PROCSTAT_SYSCTL:
2804*6126f4eaSKonstantin Belousov 		return (procstat_getrlimitusage_sysctl(kp->ki_pid, cntp));
2805*6126f4eaSKonstantin Belousov 	case PROCSTAT_CORE:
2806*6126f4eaSKonstantin Belousov 		warnx("core method is not supported");
2807*6126f4eaSKonstantin Belousov 		return (NULL);
2808*6126f4eaSKonstantin Belousov 	default:
2809*6126f4eaSKonstantin Belousov 		warnx("unknown access method: %d", procstat->type);
2810*6126f4eaSKonstantin Belousov 		return (NULL);
2811*6126f4eaSKonstantin Belousov 	}
2812*6126f4eaSKonstantin Belousov }
2813*6126f4eaSKonstantin Belousov 
2814*6126f4eaSKonstantin Belousov void
2815*6126f4eaSKonstantin Belousov procstat_freerlimitusage(struct procstat *procstat __unused, rlim_t *resusage)
2816*6126f4eaSKonstantin Belousov {
2817*6126f4eaSKonstantin Belousov 	free(resusage);
2818*6126f4eaSKonstantin Belousov }
2819