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