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