lib/libprocstat/libprocstat.c

   1 /*-
   2  * Copyright (c) 2009 Stanislav Sedov <stas@FreeBSD.org>
   3  * Copyright (c) 1988, 1993
   4  *      The Regents of the University of California.  All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  * 3. All advertising materials mentioning features or use of this software
  15  *    must display the following acknowledgement:
  16  *      This product includes software developed by the University of
  17  *      California, Berkeley and its contributors.
  18  * 4. Neither the name of the University nor the names of its contributors
  19  *    may be used to endorse or promote products derived from this software
  20  *    without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  */
  34
  35 #include <sys/cdefs.h>
  36 __FBSDID("$FreeBSD$");
  37
  38 #include <sys/param.h>
  39 #include <sys/elf.h>
  40 #include <sys/time.h>
  41 #include <sys/resourcevar.h>
  42 #include <sys/proc.h>
  43 #include <sys/user.h>
  44 #include <sys/stat.h>
  45 #include <sys/vnode.h>
  46 #include <sys/socket.h>
  47 #include <sys/socketvar.h>
  48 #include <sys/domain.h>
  49 #include <sys/protosw.h>
  50 #include <sys/un.h>
  51 #include <sys/unpcb.h>
  52 #include <sys/sysctl.h>
  53 #include <sys/tty.h>
  54 #include <sys/filedesc.h>
  55 #include <sys/queue.h>
  56 #define _WANT_FILE
  57 #include <sys/file.h>
  58 #include <sys/conf.h>
  59 #include <sys/mman.h>
  60 #define _KERNEL
  61 #include <sys/mount.h>
  62 #include <sys/pipe.h>
  63 #include <ufs/ufs/quota.h>
  64 #include <ufs/ufs/inode.h>
  65 #include <fs/devfs/devfs.h>
  66 #include <fs/devfs/devfs_int.h>
  67 #undef _KERNEL
  68 #include <nfs/nfsproto.h>
  69 #include <nfsclient/nfs.h>
  70 #include <nfsclient/nfsnode.h>
  71
  72 #include <vm/vm.h>
  73 #include <vm/vm_map.h>
  74 #include <vm/vm_object.h>
  75
  76 #include <net/route.h>
  77 #include <netinet/in.h>
  78 #include <netinet/in_systm.h>
  79 #include <netinet/ip.h>
  80 #include <netinet/in_pcb.h>
  81
  82 #include <assert.h>
  83 #include <ctype.h>
  84 #include <err.h>
  85 #include <fcntl.h>
  86 #include <kvm.h>
  87 #include <libutil.h>
  88 #include <limits.h>
  89 #include <paths.h>
  90 #include <pwd.h>
  91 #include <stdio.h>
  92 #include <stdlib.h>
  93 #include <stddef.h>
  94 #include <string.h>
  95 #include <unistd.h>
  96 #include <netdb.h>
  97
  98 #include <libprocstat.h>
  99 #include "libprocstat_internal.h"
 100 #include "common_kvm.h"
 101 #include "core.h"
 102
 103 int     statfs(const char *, struct statfs *);  /* XXX */
 104
 105 #define PROCSTAT_KVM    1
 106 #define PROCSTAT_SYSCTL 2
 107 #define PROCSTAT_CORE   3
 108
 109 static char     **getargv(struct procstat *procstat, struct kinfo_proc *kp,
 110     size_t nchr, int env);
 111 static char     *getmnton(kvm_t *kd, struct mount *m);
 112 static struct kinfo_vmentry *   kinfo_getvmmap_core(struct procstat_core *core,
 113     int *cntp);
 114 static Elf_Auxinfo      *procstat_getauxv_core(struct procstat_core *core,
 115     unsigned int *cntp);
 116 static Elf_Auxinfo      *procstat_getauxv_sysctl(pid_t pid, unsigned int *cntp);
 117 static struct filestat_list     *procstat_getfiles_kvm(
 118     struct procstat *procstat, struct kinfo_proc *kp, int mmapped);
 119 static struct filestat_list     *procstat_getfiles_sysctl(
 120     struct procstat *procstat, struct kinfo_proc *kp, int mmapped);
 121 static int      procstat_get_pipe_info_sysctl(struct filestat *fst,
 122     struct pipestat *pipe, char *errbuf);
 123 static int      procstat_get_pipe_info_kvm(kvm_t *kd, struct filestat *fst,
 124     struct pipestat *pipe, char *errbuf);
 125 static int      procstat_get_pts_info_sysctl(struct filestat *fst,
 126     struct ptsstat *pts, char *errbuf);
 127 static int      procstat_get_pts_info_kvm(kvm_t *kd, struct filestat *fst,
 128     struct ptsstat *pts, char *errbuf);
 129 static int      procstat_get_shm_info_sysctl(struct filestat *fst,
 130     struct shmstat *shm, char *errbuf);
 131 static int      procstat_get_shm_info_kvm(kvm_t *kd, struct filestat *fst,
 132     struct shmstat *shm, char *errbuf);
 133 static int      procstat_get_socket_info_sysctl(struct filestat *fst,
 134     struct sockstat *sock, char *errbuf);
 135 static int      procstat_get_socket_info_kvm(kvm_t *kd, struct filestat *fst,
 136     struct sockstat *sock, char *errbuf);
 137 static int      to_filestat_flags(int flags);
 138 static int      procstat_get_vnode_info_kvm(kvm_t *kd, struct filestat *fst,
 139     struct vnstat *vn, char *errbuf);
 140 static int      procstat_get_vnode_info_sysctl(struct filestat *fst,
 141     struct vnstat *vn, char *errbuf);
 142 static gid_t    *procstat_getgroups_core(struct procstat_core *core,
 143     unsigned int *count);
 144 static gid_t    *procstat_getgroups_sysctl(pid_t pid, unsigned int *count);
 145 static struct kinfo_kstack      *procstat_getkstack_sysctl(pid_t pid,
 146     int *cntp);
 147 static int      procstat_getpathname_core(struct procstat_core *core,
 148     char *pathname, size_t maxlen);
 149 static int      procstat_getpathname_sysctl(pid_t pid, char *pathname,
 150     size_t maxlen);
 151 static int      procstat_getrlimit_core(struct procstat_core *core, int which,
 152     struct rlimit* rlimit);
 153 static int      procstat_getrlimit_sysctl(pid_t pid, int which,
 154     struct rlimit* rlimit);
 155 static int      procstat_getumask_core(struct procstat_core *core,
 156     unsigned short *maskp);
 157 static int      procstat_getumask_sysctl(pid_t pid, unsigned short *maskp);
 158 static int      vntype2psfsttype(int type);
 159
 160 void
 161 procstat_close(struct procstat *procstat)
 162 {
 163
 164         assert(procstat);
 165         if (procstat->type == PROCSTAT_KVM)
 166                 kvm_close(procstat->kd);
 167         else if (procstat->type == PROCSTAT_CORE)
 168                 procstat_core_close(procstat->core);
 169         procstat_freeargv(procstat);
 170         procstat_freeenvv(procstat);
 171         free(procstat);
 172 }
 173
 174 struct procstat *
 175 procstat_open_sysctl(void)
 176 {
 177         struct procstat *procstat;
 178
 179         procstat = calloc(1, sizeof(*procstat));
 180         if (procstat == NULL) {
 181                 warn("malloc()");
 182                 return (NULL);
 183         }
 184         procstat->type = PROCSTAT_SYSCTL;
 185         return (procstat);
 186 }
 187
 188 struct procstat *
 189 procstat_open_kvm(const char *nlistf, const char *memf)
 190 {
 191         struct procstat *procstat;
 192         kvm_t *kd;
 193         char buf[_POSIX2_LINE_MAX];
 194
 195         procstat = calloc(1, sizeof(*procstat));
 196         if (procstat == NULL) {
 197                 warn("malloc()");
 198                 return (NULL);
 199         }
 200         kd = kvm_openfiles(nlistf, memf, NULL, O_RDONLY, buf);
 201         if (kd == NULL) {
 202                 warnx("kvm_openfiles(): %s", buf);
 203                 free(procstat);
 204                 return (NULL);
 205         }
 206         procstat->type = PROCSTAT_KVM;
 207         procstat->kd = kd;
 208         return (procstat);
 209 }
 210
 211 struct procstat *
 212 procstat_open_core(const char *filename)
 213 {
 214         struct procstat *procstat;
 215         struct procstat_core *core;
 216
 217         procstat = calloc(1, sizeof(*procstat));
 218         if (procstat == NULL) {
 219                 warn("malloc()");
 220                 return (NULL);
 221         }
 222         core = procstat_core_open(filename);
 223         if (core == NULL) {
 224                 free(procstat);
 225                 return (NULL);
 226         }
 227         procstat->type = PROCSTAT_CORE;
 228         procstat->core = core;
 229         return (procstat);
 230 }
 231
 232 struct kinfo_proc *
 233 procstat_getprocs(struct procstat *procstat, int what, int arg,
 234     unsigned int *count)
 235 {
 236         struct kinfo_proc *p0, *p;
 237         size_t len;
 238         int name[4];
 239         int cnt;
 240         int error;
 241
 242         assert(procstat);
 243         assert(count);
 244         p = NULL;
 245         if (procstat->type == PROCSTAT_KVM) {
 246                 *count = 0;
 247                 p0 = kvm_getprocs(procstat->kd, what, arg, &cnt);
 248                 if (p0 == NULL || cnt <= 0)
 249                         return (NULL);
 250                 *count = cnt;
 251                 len = *count * sizeof(*p);
 252                 p = malloc(len);
 253                 if (p == NULL) {
 254                         warnx("malloc(%zu)", len);
 255                         goto fail;
 256                 }
 257                 bcopy(p0, p, len);
 258                 return (p);
 259         } else if (procstat->type == PROCSTAT_SYSCTL) {
 260                 len = 0;
 261                 name[0] = CTL_KERN;
 262                 name[1] = KERN_PROC;
 263                 name[2] = what;
 264                 name[3] = arg;
 265                 error = sysctl(name, 4, NULL, &len, NULL, 0);
 266                 if (error < 0 && errno != EPERM) {
 267                         warn("sysctl(kern.proc)");
 268                         goto fail;
 269                 }
 270                 if (len == 0) {
 271                         warnx("no processes?");
 272                         goto fail;
 273                 }
 274                 p = malloc(len);
 275                 if (p == NULL) {
 276                         warnx("malloc(%zu)", len);
 277                         goto fail;
 278                 }
 279                 error = sysctl(name, 4, p, &len, NULL, 0);
 280                 if (error < 0 && errno != EPERM) {
 281                         warn("sysctl(kern.proc)");
 282                         goto fail;
 283                 }
 284                 /* Perform simple consistency checks. */
 285                 if ((len % sizeof(*p)) != 0 || p->ki_structsize != sizeof(*p)) {
 286                         warnx("kinfo_proc structure size mismatch (len = %zu)", len);
 287                         goto fail;
 288                 }
 289                 *count = len / sizeof(*p);
 290                 return (p);
 291         } else if (procstat->type == PROCSTAT_CORE) {
 292                 p = procstat_core_get(procstat->core, PSC_TYPE_PROC, NULL,
 293                     &len);
 294                 if ((len % sizeof(*p)) != 0 || p->ki_structsize != sizeof(*p)) {
 295                         warnx("kinfo_proc structure size mismatch");
 296                         goto fail;
 297                 }
 298                 *count = len / sizeof(*p);
 299                 return (p);
 300         } else {
 301                 warnx("unknown access method: %d", procstat->type);
 302                 return (NULL);
 303         }
 304 fail:
 305         if (p)
 306                 free(p);
 307         return (NULL);
 308 }
 309
 310 void
 311 procstat_freeprocs(struct procstat *procstat __unused, struct kinfo_proc *p)
 312 {
 313
 314         if (p != NULL)
 315                 free(p);
 316         p = NULL;
 317 }
 318
 319 struct filestat_list *
 320 procstat_getfiles(struct procstat *procstat, struct kinfo_proc *kp, int mmapped)
 321 {
 322
 323         switch(procstat->type) {
 324         case PROCSTAT_KVM:
 325                 return (procstat_getfiles_kvm(procstat, kp, mmapped));
 326         case PROCSTAT_SYSCTL:
 327         case PROCSTAT_CORE:
 328                 return (procstat_getfiles_sysctl(procstat, kp, mmapped));
 329         default:
 330                 warnx("unknown access method: %d", procstat->type);
 331                 return (NULL);
 332         }
 333 }
 334
 335 void
 336 procstat_freefiles(struct procstat *procstat, struct filestat_list *head)
 337 {
 338         struct filestat *fst, *tmp;
 339
 340         STAILQ_FOREACH_SAFE(fst, head, next, tmp) {
 341                 if (fst->fs_path != NULL)
 342                         free(fst->fs_path);
 343                 free(fst);
 344         }
 345         free(head);
 346         if (procstat->vmentries != NULL) {
 347                 free(procstat->vmentries);
 348                 procstat->vmentries = NULL;
 349         }
 350         if (procstat->files != NULL) {
 351                 free(procstat->files);
 352                 procstat->files = NULL;
 353         }
 354 }
 355
 356 static struct filestat *
 357 filestat_new_entry(void *typedep, int type, int fd, int fflags, int uflags,
 358     int refcount, off_t offset, char *path, cap_rights_t cap_rights)
 359 {
 360         struct filestat *entry;
 361
 362         entry = calloc(1, sizeof(*entry));
 363         if (entry == NULL) {
 364                 warn("malloc()");
 365                 return (NULL);
 366         }
 367         entry->fs_typedep = typedep;
 368         entry->fs_fflags = fflags;
 369         entry->fs_uflags = uflags;
 370         entry->fs_fd = fd;
 371         entry->fs_type = type;
 372         entry->fs_ref_count = refcount;
 373         entry->fs_offset = offset;
 374         entry->fs_path = path;
 375         entry->fs_cap_rights = cap_rights;
 376         return (entry);
 377 }
 378
 379 static struct vnode *
 380 getctty(kvm_t *kd, struct kinfo_proc *kp)
 381 {
 382         struct pgrp pgrp;
 383         struct proc proc;
 384         struct session sess;
 385         int error;
 386
 387         assert(kp);
 388         error = kvm_read_all(kd, (unsigned long)kp->ki_paddr, &proc,
 389             sizeof(proc));
 390         if (error == 0) {
 391                 warnx("can't read proc struct at %p for pid %d",
 392                     kp->ki_paddr, kp->ki_pid);
 393                 return (NULL);
 394         }
 395         if (proc.p_pgrp == NULL)
 396                 return (NULL);
 397         error = kvm_read_all(kd, (unsigned long)proc.p_pgrp, &pgrp,
 398             sizeof(pgrp));
 399         if (error == 0) {
 400                 warnx("can't read pgrp struct at %p for pid %d",
 401                     proc.p_pgrp, kp->ki_pid);
 402                 return (NULL);
 403         }
 404         error = kvm_read_all(kd, (unsigned long)pgrp.pg_session, &sess,
 405             sizeof(sess));
 406         if (error == 0) {
 407                 warnx("can't read session struct at %p for pid %d",
 408                     pgrp.pg_session, kp->ki_pid);
 409                 return (NULL);
 410         }
 411         return (sess.s_ttyvp);
 412 }
 413
 414 static struct filestat_list *
 415 procstat_getfiles_kvm(struct procstat *procstat, struct kinfo_proc *kp, int mmapped)
 416 {
 417         struct file file;
 418         struct filedesc filed;
 419         struct vm_map_entry vmentry;
 420         struct vm_object object;
 421         struct vmspace vmspace;
 422         vm_map_entry_t entryp;
 423         vm_map_t map;
 424         vm_object_t objp;
 425         struct vnode *vp;
 426         struct file **ofiles;
 427         struct filestat *entry;
 428         struct filestat_list *head;
 429         kvm_t *kd;
 430         void *data;
 431         int i, fflags;
 432         int prot, type;
 433         unsigned int nfiles;
 434
 435         assert(procstat);
 436         kd = procstat->kd;
 437         if (kd == NULL)
 438                 return (NULL);
 439         if (kp->ki_fd == NULL)
 440                 return (NULL);
 441         if (!kvm_read_all(kd, (unsigned long)kp->ki_fd, &filed,
 442             sizeof(filed))) {
 443                 warnx("can't read filedesc at %p", (void *)kp->ki_fd);
 444                 return (NULL);
 445         }
 446
 447         /*
 448          * Allocate list head.
 449          */
 450         head = malloc(sizeof(*head));
 451         if (head == NULL)
 452                 return (NULL);
 453         STAILQ_INIT(head);
 454
 455         /* root directory vnode, if one. */
 456         if (filed.fd_rdir) {
 457                 entry = filestat_new_entry(filed.fd_rdir, PS_FST_TYPE_VNODE, -1,
 458                     PS_FST_FFLAG_READ, PS_FST_UFLAG_RDIR, 0, 0, NULL, 0);
 459                 if (entry != NULL)
 460                         STAILQ_INSERT_TAIL(head, entry, next);
 461         }
 462         /* current working directory vnode. */
 463         if (filed.fd_cdir) {
 464                 entry = filestat_new_entry(filed.fd_cdir, PS_FST_TYPE_VNODE, -1,
 465                     PS_FST_FFLAG_READ, PS_FST_UFLAG_CDIR, 0, 0, NULL, 0);
 466                 if (entry != NULL)
 467                         STAILQ_INSERT_TAIL(head, entry, next);
 468         }
 469         /* jail root, if any. */
 470         if (filed.fd_jdir) {
 471                 entry = filestat_new_entry(filed.fd_jdir, PS_FST_TYPE_VNODE, -1,
 472                     PS_FST_FFLAG_READ, PS_FST_UFLAG_JAIL, 0, 0, NULL, 0);
 473                 if (entry != NULL)
 474                         STAILQ_INSERT_TAIL(head, entry, next);
 475         }
 476         /* ktrace vnode, if one */
 477         if (kp->ki_tracep) {
 478                 entry = filestat_new_entry(kp->ki_tracep, PS_FST_TYPE_VNODE, -1,
 479                     PS_FST_FFLAG_READ | PS_FST_FFLAG_WRITE,
 480                     PS_FST_UFLAG_TRACE, 0, 0, NULL, 0);
 481                 if (entry != NULL)
 482                         STAILQ_INSERT_TAIL(head, entry, next);
 483         }
 484         /* text vnode, if one */
 485         if (kp->ki_textvp) {
 486                 entry = filestat_new_entry(kp->ki_textvp, PS_FST_TYPE_VNODE, -1,
 487                     PS_FST_FFLAG_READ, PS_FST_UFLAG_TEXT, 0, 0, NULL, 0);
 488                 if (entry != NULL)
 489                         STAILQ_INSERT_TAIL(head, entry, next);
 490         }
 491         /* Controlling terminal. */
 492         if ((vp = getctty(kd, kp)) != NULL) {
 493                 entry = filestat_new_entry(vp, PS_FST_TYPE_VNODE, -1,
 494                     PS_FST_FFLAG_READ | PS_FST_FFLAG_WRITE,
 495                     PS_FST_UFLAG_CTTY, 0, 0, NULL, 0);
 496                 if (entry != NULL)
 497                         STAILQ_INSERT_TAIL(head, entry, next);
 498         }
 499
 500         nfiles = filed.fd_lastfile + 1;
 501         ofiles = malloc(nfiles * sizeof(struct file *));
 502         if (ofiles == NULL) {
 503                 warn("malloc(%zu)", nfiles * sizeof(struct file *));
 504                 goto do_mmapped;
 505         }
 506         if (!kvm_read_all(kd, (unsigned long)filed.fd_ofiles, ofiles,
 507             nfiles * sizeof(struct file *))) {
 508                 warnx("cannot read file structures at %p",
 509                     (void *)filed.fd_ofiles);
 510                 free(ofiles);
 511                 goto do_mmapped;
 512         }
 513         for (i = 0; i <= filed.fd_lastfile; i++) {
 514                 if (ofiles[i] == NULL)
 515                         continue;
 516                 if (!kvm_read_all(kd, (unsigned long)ofiles[i], &file,
 517                     sizeof(struct file))) {
 518                         warnx("can't read file %d at %p", i,
 519                             (void *)ofiles[i]);
 520                         continue;
 521                 }
 522                 switch (file.f_type) {
 523                 case DTYPE_VNODE:
 524                         type = PS_FST_TYPE_VNODE;
 525                         data = file.f_vnode;
 526                         break;
 527                 case DTYPE_SOCKET:
 528                         type = PS_FST_TYPE_SOCKET;
 529                         data = file.f_data;
 530                         break;
 531                 case DTYPE_PIPE:
 532                         type = PS_FST_TYPE_PIPE;
 533                         data = file.f_data;
 534                         break;
 535                 case DTYPE_FIFO:
 536                         type = PS_FST_TYPE_FIFO;
 537                         data = file.f_vnode;
 538                         break;
 539 #ifdef DTYPE_PTS
 540                 case DTYPE_PTS:
 541                         type = PS_FST_TYPE_PTS;
 542                         data = file.f_data;
 543                         break;
 544 #endif
 545                 case DTYPE_SHM:
 546                         type = PS_FST_TYPE_SHM;
 547                         data = file.f_data;
 548                         break;
 549                 default:
 550                         continue;
 551                 }
 552                 /* XXXRW: No capability rights support for kvm yet. */
 553                 entry = filestat_new_entry(data, type, i,
 554                     to_filestat_flags(file.f_flag), 0, 0, 0, NULL, 0);
 555                 if (entry != NULL)
 556                         STAILQ_INSERT_TAIL(head, entry, next);
 557         }
 558         free(ofiles);
 559
 560 do_mmapped:
 561
 562         /*
 563          * Process mmapped files if requested.
 564          */
 565         if (mmapped) {
 566                 if (!kvm_read_all(kd, (unsigned long)kp->ki_vmspace, &vmspace,
 567                     sizeof(vmspace))) {
 568                         warnx("can't read vmspace at %p",
 569                             (void *)kp->ki_vmspace);
 570                         goto exit;
 571                 }
 572                 map = &vmspace.vm_map;
 573
 574                 for (entryp = map->header.next;
 575                     entryp != &kp->ki_vmspace->vm_map.header;
 576                     entryp = vmentry.next) {
 577                         if (!kvm_read_all(kd, (unsigned long)entryp, &vmentry,
 578                             sizeof(vmentry))) {
 579                                 warnx("can't read vm_map_entry at %p",
 580                                     (void *)entryp);
 581                                 continue;
 582                         }
 583                         if (vmentry.eflags & MAP_ENTRY_IS_SUB_MAP)
 584                                 continue;
 585                         if ((objp = vmentry.object.vm_object) == NULL)
 586                                 continue;
 587                         for (; objp; objp = object.backing_object) {
 588                                 if (!kvm_read_all(kd, (unsigned long)objp,
 589                                     &object, sizeof(object))) {
 590                                         warnx("can't read vm_object at %p",
 591                                             (void *)objp);
 592                                         break;
 593                                 }
 594                         }
 595
 596                         /* We want only vnode objects. */
 597                         if (object.type != OBJT_VNODE)
 598                                 continue;
 599
 600                         prot = vmentry.protection;
 601                         fflags = 0;
 602                         if (prot & VM_PROT_READ)
 603                                 fflags = PS_FST_FFLAG_READ;
 604                         if ((vmentry.eflags & MAP_ENTRY_COW) == 0 &&
 605                             prot & VM_PROT_WRITE)
 606                                 fflags |= PS_FST_FFLAG_WRITE;
 607
 608                         /*
 609                          * Create filestat entry.
 610                          */
 611                         entry = filestat_new_entry(object.handle,
 612                             PS_FST_TYPE_VNODE, -1, fflags,
 613                             PS_FST_UFLAG_MMAP, 0, 0, NULL, 0);
 614                         if (entry != NULL)
 615                                 STAILQ_INSERT_TAIL(head, entry, next);
 616                 }
 617         }
 618 exit:
 619         return (head);
 620 }
 621
 622 /*
 623  * kinfo types to filestat translation.
 624  */
 625 static int
 626 kinfo_type2fst(int kftype)
 627 {
 628         static struct {
 629                 int     kf_type;
 630                 int     fst_type;
 631         } kftypes2fst[] = {
 632                 { KF_TYPE_CRYPTO, PS_FST_TYPE_CRYPTO },
 633                 { KF_TYPE_FIFO, PS_FST_TYPE_FIFO },
 634                 { KF_TYPE_KQUEUE, PS_FST_TYPE_KQUEUE },
 635                 { KF_TYPE_MQUEUE, PS_FST_TYPE_MQUEUE },
 636                 { KF_TYPE_NONE, PS_FST_TYPE_NONE },
 637                 { KF_TYPE_PIPE, PS_FST_TYPE_PIPE },
 638                 { KF_TYPE_PTS, PS_FST_TYPE_PTS },
 639                 { KF_TYPE_SEM, PS_FST_TYPE_SEM },
 640                 { KF_TYPE_SHM, PS_FST_TYPE_SHM },
 641                 { KF_TYPE_SOCKET, PS_FST_TYPE_SOCKET },
 642                 { KF_TYPE_VNODE, PS_FST_TYPE_VNODE },
 643                 { KF_TYPE_UNKNOWN, PS_FST_TYPE_UNKNOWN }
 644         };
 645 #define NKFTYPES        (sizeof(kftypes2fst) / sizeof(*kftypes2fst))
 646         unsigned int i;
 647
 648         for (i = 0; i < NKFTYPES; i++)
 649                 if (kftypes2fst[i].kf_type == kftype)
 650                         break;
 651         if (i == NKFTYPES)
 652                 return (PS_FST_TYPE_UNKNOWN);
 653         return (kftypes2fst[i].fst_type);
 654 }
 655
 656 /*
 657  * kinfo flags to filestat translation.
 658  */
 659 static int
 660 kinfo_fflags2fst(int kfflags)
 661 {
 662         static struct {
 663                 int     kf_flag;
 664                 int     fst_flag;
 665         } kfflags2fst[] = {
 666                 { KF_FLAG_APPEND, PS_FST_FFLAG_APPEND },
 667                 { KF_FLAG_ASYNC, PS_FST_FFLAG_ASYNC },
 668                 { KF_FLAG_CREAT, PS_FST_FFLAG_CREAT },
 669                 { KF_FLAG_DIRECT, PS_FST_FFLAG_DIRECT },
 670                 { KF_FLAG_EXCL, PS_FST_FFLAG_EXCL },
 671                 { KF_FLAG_EXEC, PS_FST_FFLAG_EXEC },
 672                 { KF_FLAG_EXLOCK, PS_FST_FFLAG_EXLOCK },
 673                 { KF_FLAG_FSYNC, PS_FST_FFLAG_SYNC },
 674                 { KF_FLAG_HASLOCK, PS_FST_FFLAG_HASLOCK },
 675                 { KF_FLAG_NOFOLLOW, PS_FST_FFLAG_NOFOLLOW },
 676                 { KF_FLAG_NONBLOCK, PS_FST_FFLAG_NONBLOCK },
 677                 { KF_FLAG_READ, PS_FST_FFLAG_READ },
 678                 { KF_FLAG_SHLOCK, PS_FST_FFLAG_SHLOCK },
 679                 { KF_FLAG_TRUNC, PS_FST_FFLAG_TRUNC },
 680                 { KF_FLAG_WRITE, PS_FST_FFLAG_WRITE }
 681         };
 682 #define NKFFLAGS        (sizeof(kfflags2fst) / sizeof(*kfflags2fst))
 683         unsigned int i;
 684         int flags;
 685
 686         flags = 0;
 687         for (i = 0; i < NKFFLAGS; i++)
 688                 if ((kfflags & kfflags2fst[i].kf_flag) != 0)
 689                         flags |= kfflags2fst[i].fst_flag;
 690         return (flags);
 691 }
 692
 693 static int
 694 kinfo_uflags2fst(int fd)
 695 {
 696
 697         switch (fd) {
 698         case KF_FD_TYPE_CTTY:
 699                 return (PS_FST_UFLAG_CTTY);
 700         case KF_FD_TYPE_CWD:
 701                 return (PS_FST_UFLAG_CDIR);
 702         case KF_FD_TYPE_JAIL:
 703                 return (PS_FST_UFLAG_JAIL);
 704         case KF_FD_TYPE_TEXT:
 705                 return (PS_FST_UFLAG_TEXT);
 706         case KF_FD_TYPE_TRACE:
 707                 return (PS_FST_UFLAG_TRACE);
 708         case KF_FD_TYPE_ROOT:
 709                 return (PS_FST_UFLAG_RDIR);
 710         }
 711         return (0);
 712 }
 713
 714 static struct kinfo_file *
 715 kinfo_getfile_core(struct procstat_core *core, int *cntp)
 716 {
 717         int cnt;
 718         size_t len;
 719         char *buf, *bp, *eb;
 720         struct kinfo_file *kif, *kp, *kf;
 721
 722         buf = procstat_core_get(core, PSC_TYPE_FILES, NULL, &len);
 723         if (buf == NULL)
 724                 return (NULL);
 725         /*
 726          * XXXMG: The code below is just copy&past from libutil.
 727          * The code duplication can be avoided if libutil
 728          * is extended to provide something like:
 729          *   struct kinfo_file *kinfo_getfile_from_buf(const char *buf,
 730          *       size_t len, int *cntp);
 731          */
 732
 733         /* Pass 1: count items */
 734         cnt = 0;
 735         bp = buf;
 736         eb = buf + len;
 737         while (bp < eb) {
 738                 kf = (struct kinfo_file *)(uintptr_t)bp;
 739                 bp += kf->kf_structsize;
 740                 cnt++;
 741         }
 742
 743         kif = calloc(cnt, sizeof(*kif));
 744         if (kif == NULL) {
 745                 free(buf);
 746                 return (NULL);
 747         }
 748         bp = buf;
 749         eb = buf + len;
 750         kp = kif;
 751         /* Pass 2: unpack */
 752         while (bp < eb) {
 753                 kf = (struct kinfo_file *)(uintptr_t)bp;
 754                 /* Copy/expand into pre-zeroed buffer */
 755                 memcpy(kp, kf, kf->kf_structsize);
 756                 /* Advance to next packed record */
 757                 bp += kf->kf_structsize;
 758                 /* Set field size to fixed length, advance */
 759                 kp->kf_structsize = sizeof(*kp);
 760                 kp++;
 761         }
 762         free(buf);
 763         *cntp = cnt;
 764         return (kif);   /* Caller must free() return value */
 765 }
 766
 767 static struct filestat_list *
 768 procstat_getfiles_sysctl(struct procstat *procstat, struct kinfo_proc *kp,
 769     int mmapped)
 770 {
 771         struct kinfo_file *kif, *files;
 772         struct kinfo_vmentry *kve, *vmentries;
 773         struct filestat_list *head;
 774         struct filestat *entry;
 775         char *path;
 776         off_t offset;
 777         int cnt, fd, fflags;
 778         int i, type, uflags;
 779         int refcount;
 780         cap_rights_t cap_rights;
 781
 782         assert(kp);
 783         if (kp->ki_fd == NULL)
 784                 return (NULL);
 785         switch(procstat->type) {
 786         case PROCSTAT_SYSCTL:
 787                 files = kinfo_getfile(kp->ki_pid, &cnt);
 788                 break;
 789         case PROCSTAT_CORE:
 790                 files = kinfo_getfile_core(procstat->core, &cnt);
 791                 break;
 792         default:
 793                 assert(!"invalid type");
 794         }
 795         if (files == NULL && errno != EPERM) {
 796                 warn("kinfo_getfile()");
 797                 return (NULL);
 798         }
 799         procstat->files = files;
 800
 801         /*
 802          * Allocate list head.
 803          */
 804         head = malloc(sizeof(*head));
 805         if (head == NULL)
 806                 return (NULL);
 807         STAILQ_INIT(head);
 808         for (i = 0; i < cnt; i++) {
 809                 kif = &files[i];
 810
 811                 type = kinfo_type2fst(kif->kf_type);
 812                 fd = kif->kf_fd >= 0 ? kif->kf_fd : -1;
 813                 fflags = kinfo_fflags2fst(kif->kf_flags);
 814                 uflags = kinfo_uflags2fst(kif->kf_fd);
 815                 refcount = kif->kf_ref_count;
 816                 offset = kif->kf_offset;
 817                 if (*kif->kf_path != '\0')
 818                         path = strdup(kif->kf_path);
 819                 else
 820                         path = NULL;
 821                 cap_rights = kif->kf_cap_rights;
 822
 823                 /*
 824                  * Create filestat entry.
 825                  */
 826                 entry = filestat_new_entry(kif, type, fd, fflags, uflags,
 827                     refcount, offset, path, cap_rights);
 828                 if (entry != NULL)
 829                         STAILQ_INSERT_TAIL(head, entry, next);
 830         }
 831         if (mmapped != 0) {
 832                 vmentries = procstat_getvmmap(procstat, kp, &cnt);
 833                 procstat->vmentries = vmentries;
 834                 if (vmentries == NULL || cnt == 0)
 835                         goto fail;
 836                 for (i = 0; i < cnt; i++) {
 837                         kve = &vmentries[i];
 838                         if (kve->kve_type != KVME_TYPE_VNODE)
 839                                 continue;
 840                         fflags = 0;
 841                         if (kve->kve_protection & KVME_PROT_READ)
 842                                 fflags = PS_FST_FFLAG_READ;
 843                         if ((kve->kve_flags & KVME_FLAG_COW) == 0 &&
 844                             kve->kve_protection & KVME_PROT_WRITE)
 845                                 fflags |= PS_FST_FFLAG_WRITE;
 846                         offset = kve->kve_offset;
 847                         refcount = kve->kve_ref_count;
 848                         if (*kve->kve_path != '\0')
 849                                 path = strdup(kve->kve_path);
 850                         else
 851                                 path = NULL;
 852                         entry = filestat_new_entry(kve, PS_FST_TYPE_VNODE, -1,
 853                             fflags, PS_FST_UFLAG_MMAP, refcount, offset, path,
 854                             0);
 855                         if (entry != NULL)
 856                                 STAILQ_INSERT_TAIL(head, entry, next);
 857                 }
 858         }
 859 fail:
 860         return (head);
 861 }
 862
 863 int
 864 procstat_get_pipe_info(struct procstat *procstat, struct filestat *fst,
 865     struct pipestat *ps, char *errbuf)
 866 {
 867
 868         assert(ps);
 869         if (procstat->type == PROCSTAT_KVM) {
 870                 return (procstat_get_pipe_info_kvm(procstat->kd, fst, ps,
 871                     errbuf));
 872         } else if (procstat->type == PROCSTAT_SYSCTL ||
 873                 procstat->type == PROCSTAT_CORE) {
 874                 return (procstat_get_pipe_info_sysctl(fst, ps, errbuf));
 875         } else {
 876                 warnx("unknown access method: %d", procstat->type);
 877                 snprintf(errbuf, _POSIX2_LINE_MAX, "error");
 878                 return (1);
 879         }
 880 }
 881
 882 static int
 883 procstat_get_pipe_info_kvm(kvm_t *kd, struct filestat *fst,
 884     struct pipestat *ps, char *errbuf)
 885 {
 886         struct pipe pi;
 887         void *pipep;
 888
 889         assert(kd);
 890         assert(ps);
 891         assert(fst);
 892         bzero(ps, sizeof(*ps));
 893         pipep = fst->fs_typedep;
 894         if (pipep == NULL)
 895                 goto fail;
 896         if (!kvm_read_all(kd, (unsigned long)pipep, &pi, sizeof(struct pipe))) {
 897                 warnx("can't read pipe at %p", (void *)pipep);
 898                 goto fail;
 899         }
 900         ps->addr = (uintptr_t)pipep;
 901         ps->peer = (uintptr_t)pi.pipe_peer;
 902         ps->buffer_cnt = pi.pipe_buffer.cnt;
 903         return (0);
 904
 905 fail:
 906         snprintf(errbuf, _POSIX2_LINE_MAX, "error");
 907         return (1);
 908 }
 909
 910 static int
 911 procstat_get_pipe_info_sysctl(struct filestat *fst, struct pipestat *ps,
 912     char *errbuf __unused)
 913 {
 914         struct kinfo_file *kif;
 915
 916         assert(ps);
 917         assert(fst);
 918         bzero(ps, sizeof(*ps));
 919         kif = fst->fs_typedep;
 920         if (kif == NULL)
 921                 return (1);
 922         ps->addr = kif->kf_un.kf_pipe.kf_pipe_addr;
 923         ps->peer = kif->kf_un.kf_pipe.kf_pipe_peer;
 924         ps->buffer_cnt = kif->kf_un.kf_pipe.kf_pipe_buffer_cnt;
 925         return (0);
 926 }
 927
 928 int
 929 procstat_get_pts_info(struct procstat *procstat, struct filestat *fst,
 930     struct ptsstat *pts, char *errbuf)
 931 {
 932
 933         assert(pts);
 934         if (procstat->type == PROCSTAT_KVM) {
 935                 return (procstat_get_pts_info_kvm(procstat->kd, fst, pts,
 936                     errbuf));
 937         } else if (procstat->type == PROCSTAT_SYSCTL ||
 938                 procstat->type == PROCSTAT_CORE) {
 939                 return (procstat_get_pts_info_sysctl(fst, pts, errbuf));
 940         } else {
 941                 warnx("unknown access method: %d", procstat->type);
 942                 snprintf(errbuf, _POSIX2_LINE_MAX, "error");
 943                 return (1);
 944         }
 945 }
 946
 947 static int
 948 procstat_get_pts_info_kvm(kvm_t *kd, struct filestat *fst,
 949     struct ptsstat *pts, char *errbuf)
 950 {
 951         struct tty tty;
 952         void *ttyp;
 953
 954         assert(kd);
 955         assert(pts);
 956         assert(fst);
 957         bzero(pts, sizeof(*pts));
 958         ttyp = fst->fs_typedep;
 959         if (ttyp == NULL)
 960                 goto fail;
 961         if (!kvm_read_all(kd, (unsigned long)ttyp, &tty, sizeof(struct tty))) {
 962                 warnx("can't read tty at %p", (void *)ttyp);
 963                 goto fail;
 964         }
 965         pts->dev = dev2udev(kd, tty.t_dev);
 966         (void)kdevtoname(kd, tty.t_dev, pts->devname);
 967         return (0);
 968
 969 fail:
 970         snprintf(errbuf, _POSIX2_LINE_MAX, "error");
 971         return (1);
 972 }
 973
 974 static int
 975 procstat_get_pts_info_sysctl(struct filestat *fst, struct ptsstat *pts,
 976     char *errbuf __unused)
 977 {
 978         struct kinfo_file *kif;
 979
 980         assert(pts);
 981         assert(fst);
 982         bzero(pts, sizeof(*pts));
 983         kif = fst->fs_typedep;
 984         if (kif == NULL)
 985                 return (0);
 986         pts->dev = kif->kf_un.kf_pts.kf_pts_dev;
 987         strlcpy(pts->devname, kif->kf_path, sizeof(pts->devname));
 988         return (0);
 989 }
 990
 991 int
 992 procstat_get_shm_info(struct procstat *procstat, struct filestat *fst,
 993     struct shmstat *shm, char *errbuf)
 994 {
 995
 996         assert(shm);
 997         if (procstat->type == PROCSTAT_KVM) {
 998                 return (procstat_get_shm_info_kvm(procstat->kd, fst, shm,
 999                     errbuf));
1000         } else if (procstat->type == PROCSTAT_SYSCTL ||
1001             procstat->type == PROCSTAT_CORE) {
1002                 return (procstat_get_shm_info_sysctl(fst, shm, errbuf));
1003         } else {
1004                 warnx("unknown access method: %d", procstat->type);
1005                 snprintf(errbuf, _POSIX2_LINE_MAX, "error");
1006                 return (1);
1007         }
1008 }
1009
1010 static int
1011 procstat_get_shm_info_kvm(kvm_t *kd, struct filestat *fst,
1012     struct shmstat *shm, char *errbuf)
1013 {
1014         struct shmfd shmfd;
1015         void *shmfdp;
1016         char *path;
1017         int i;
1018
1019         assert(kd);
1020         assert(shm);
1021         assert(fst);
1022         bzero(shm, sizeof(*shm));
1023         shmfdp = fst->fs_typedep;
1024         if (shmfdp == NULL)
1025                 goto fail;
1026         if (!kvm_read_all(kd, (unsigned long)shmfdp, &shmfd,
1027             sizeof(struct shmfd))) {
1028                 warnx("can't read shmfd at %p", (void *)shmfdp);
1029                 goto fail;
1030         }
1031         shm->mode = S_IFREG | shmfd.shm_mode;
1032         shm->size = shmfd.shm_size;
1033         if (fst->fs_path == NULL && shmfd.shm_path != NULL) {
1034                 path = malloc(MAXPATHLEN);
1035                 for (i = 0; i < MAXPATHLEN - 1; i++) {
1036                         if (!kvm_read_all(kd, (unsigned long)shmfd.shm_path + i,
1037                             path + i, 1))
1038                                 break;
1039                         if (path[i] == '\0')
1040                                 break;
1041                 }
1042                 path[i] = '\0';
1043                 if (i == 0)
1044                         free(path);
1045                 else
1046                         fst->fs_path = path;
1047         }
1048         return (0);
1049
1050 fail:
1051         snprintf(errbuf, _POSIX2_LINE_MAX, "error");
1052         return (1);
1053 }
1054
1055 static int
1056 procstat_get_shm_info_sysctl(struct filestat *fst, struct shmstat *shm,
1057     char *errbuf __unused)
1058 {
1059         struct kinfo_file *kif;
1060
1061         assert(shm);
1062         assert(fst);
1063         bzero(shm, sizeof(*shm));
1064         kif = fst->fs_typedep;
1065         if (kif == NULL)
1066                 return (0);
1067         shm->size = kif->kf_un.kf_file.kf_file_size;
1068         shm->mode = kif->kf_un.kf_file.kf_file_mode;
1069         return (0);
1070 }
1071
1072 int
1073 procstat_get_vnode_info(struct procstat *procstat, struct filestat *fst,
1074     struct vnstat *vn, char *errbuf)
1075 {
1076
1077         assert(vn);
1078         if (procstat->type == PROCSTAT_KVM) {
1079                 return (procstat_get_vnode_info_kvm(procstat->kd, fst, vn,
1080                     errbuf));
1081         } else if (procstat->type == PROCSTAT_SYSCTL ||
1082                 procstat->type == PROCSTAT_CORE) {
1083                 return (procstat_get_vnode_info_sysctl(fst, vn, errbuf));
1084         } else {
1085                 warnx("unknown access method: %d", procstat->type);
1086                 snprintf(errbuf, _POSIX2_LINE_MAX, "error");
1087                 return (1);
1088         }
1089 }
1090
1091 static int
1092 procstat_get_vnode_info_kvm(kvm_t *kd, struct filestat *fst,
1093     struct vnstat *vn, char *errbuf)
1094 {
1095         /* Filesystem specific handlers. */
1096         #define FSTYPE(fst)     {#fst, fst##_filestat}
1097         struct {
1098                 const char      *tag;
1099                 int             (*handler)(kvm_t *kd, struct vnode *vp,
1100                     struct vnstat *vn);
1101         } fstypes[] = {
1102                 FSTYPE(devfs),
1103                 FSTYPE(isofs),
1104                 FSTYPE(msdosfs),
1105                 FSTYPE(nfs),
1106                 FSTYPE(udf),
1107                 FSTYPE(ufs),
1108 #ifdef LIBPROCSTAT_ZFS
1109                 FSTYPE(zfs),
1110 #endif
1111         };
1112 #define NTYPES  (sizeof(fstypes) / sizeof(*fstypes))
1113         struct vnode vnode;
1114         char tagstr[12];
1115         void *vp;
1116         int error, found;
1117         unsigned int i;
1118
1119         assert(kd);
1120         assert(vn);
1121         assert(fst);
1122         vp = fst->fs_typedep;
1123         if (vp == NULL)
1124                 goto fail;
1125         error = kvm_read_all(kd, (unsigned long)vp, &vnode, sizeof(vnode));
1126         if (error == 0) {
1127                 warnx("can't read vnode at %p", (void *)vp);
1128                 goto fail;
1129         }
1130         bzero(vn, sizeof(*vn));
1131         vn->vn_type = vntype2psfsttype(vnode.v_type);
1132         if (vnode.v_type == VNON || vnode.v_type == VBAD)
1133                 return (0);
1134         error = kvm_read_all(kd, (unsigned long)vnode.v_tag, tagstr,
1135             sizeof(tagstr));
1136         if (error == 0) {
1137                 warnx("can't read v_tag at %p", (void *)vp);
1138                 goto fail;
1139         }
1140         tagstr[sizeof(tagstr) - 1] = '\0';
1141
1142         /*
1143          * Find appropriate handler.
1144          */
1145         for (i = 0, found = 0; i < NTYPES; i++)
1146                 if (!strcmp(fstypes[i].tag, tagstr)) {
1147                         if (fstypes[i].handler(kd, &vnode, vn) != 0) {
1148                                 goto fail;
1149                         }
1150                         break;
1151                 }
1152         if (i == NTYPES) {
1153                 snprintf(errbuf, _POSIX2_LINE_MAX, "?(%s)", tagstr);
1154                 return (1);
1155         }
1156         vn->vn_mntdir = getmnton(kd, vnode.v_mount);
1157         if ((vnode.v_type == VBLK || vnode.v_type == VCHR) &&
1158             vnode.v_rdev != NULL){
1159                 vn->vn_dev = dev2udev(kd, vnode.v_rdev);
1160                 (void)kdevtoname(kd, vnode.v_rdev, vn->vn_devname);
1161         } else {
1162                 vn->vn_dev = -1;
1163         }
1164         return (0);
1165
1166 fail:
1167         snprintf(errbuf, _POSIX2_LINE_MAX, "error");
1168         return (1);
1169 }
1170
1171 /*
1172  * kinfo vnode type to filestat translation.
1173  */
1174 static int
1175 kinfo_vtype2fst(int kfvtype)
1176 {
1177         static struct {
1178                 int     kf_vtype;
1179                 int     fst_vtype;
1180         } kfvtypes2fst[] = {
1181                 { KF_VTYPE_VBAD, PS_FST_VTYPE_VBAD },
1182                 { KF_VTYPE_VBLK, PS_FST_VTYPE_VBLK },
1183                 { KF_VTYPE_VCHR, PS_FST_VTYPE_VCHR },
1184                 { KF_VTYPE_VDIR, PS_FST_VTYPE_VDIR },
1185                 { KF_VTYPE_VFIFO, PS_FST_VTYPE_VFIFO },
1186                 { KF_VTYPE_VLNK, PS_FST_VTYPE_VLNK },
1187                 { KF_VTYPE_VNON, PS_FST_VTYPE_VNON },
1188                 { KF_VTYPE_VREG, PS_FST_VTYPE_VREG },
1189                 { KF_VTYPE_VSOCK, PS_FST_VTYPE_VSOCK }
1190         };
1191 #define NKFVTYPES       (sizeof(kfvtypes2fst) / sizeof(*kfvtypes2fst))
1192         unsigned int i;
1193
1194         for (i = 0; i < NKFVTYPES; i++)
1195                 if (kfvtypes2fst[i].kf_vtype == kfvtype)
1196                         break;
1197         if (i == NKFVTYPES)
1198                 return (PS_FST_VTYPE_UNKNOWN);
1199         return (kfvtypes2fst[i].fst_vtype);
1200 }
1201
1202 static int
1203 procstat_get_vnode_info_sysctl(struct filestat *fst, struct vnstat *vn,
1204     char *errbuf)
1205 {
1206         struct statfs stbuf;
1207         struct kinfo_file *kif;
1208         struct kinfo_vmentry *kve;
1209         uint64_t fileid;
1210         uint64_t size;
1211         char *name, *path;
1212         uint32_t fsid;
1213         uint16_t mode;
1214         uint32_t rdev;
1215         int vntype;
1216         int status;
1217
1218         assert(fst);
1219         assert(vn);
1220         bzero(vn, sizeof(*vn));
1221         if (fst->fs_typedep == NULL)
1222                 return (1);
1223         if (fst->fs_uflags & PS_FST_UFLAG_MMAP) {
1224                 kve = fst->fs_typedep;
1225                 fileid = kve->kve_vn_fileid;
1226                 fsid = kve->kve_vn_fsid;
1227                 mode = kve->kve_vn_mode;
1228                 path = kve->kve_path;
1229                 rdev = kve->kve_vn_rdev;
1230                 size = kve->kve_vn_size;
1231                 vntype = kinfo_vtype2fst(kve->kve_vn_type);
1232                 status = kve->kve_status;
1233         } else {
1234                 kif = fst->fs_typedep;
1235                 fileid = kif->kf_un.kf_file.kf_file_fileid;
1236                 fsid = kif->kf_un.kf_file.kf_file_fsid;
1237                 mode = kif->kf_un.kf_file.kf_file_mode;
1238                 path = kif->kf_path;
1239                 rdev = kif->kf_un.kf_file.kf_file_rdev;
1240                 size = kif->kf_un.kf_file.kf_file_size;
1241                 vntype = kinfo_vtype2fst(kif->kf_vnode_type);
1242                 status = kif->kf_status;
1243         }
1244         vn->vn_type = vntype;
1245         if (vntype == PS_FST_VTYPE_VNON || vntype == PS_FST_VTYPE_VBAD)
1246                 return (0);
1247         if ((status & KF_ATTR_VALID) == 0) {
1248                 snprintf(errbuf, _POSIX2_LINE_MAX, "? (no info available)");
1249                 return (1);
1250         }
1251         if (path && *path) {
1252                 statfs(path, &stbuf);
1253                 vn->vn_mntdir = strdup(stbuf.f_mntonname);
1254         } else
1255                 vn->vn_mntdir = strdup("-");
1256         vn->vn_dev = rdev;
1257         if (vntype == PS_FST_VTYPE_VBLK) {
1258                 name = devname(rdev, S_IFBLK);
1259                 if (name != NULL)
1260                         strlcpy(vn->vn_devname, name,
1261                             sizeof(vn->vn_devname));
1262         } else if (vntype == PS_FST_VTYPE_VCHR) {
1263                 name = devname(vn->vn_dev, S_IFCHR);
1264                 if (name != NULL)
1265                         strlcpy(vn->vn_devname, name,
1266                             sizeof(vn->vn_devname));
1267         }
1268         vn->vn_fsid = fsid;
1269         vn->vn_fileid = fileid;
1270         vn->vn_size = size;
1271         vn->vn_mode = mode;
1272         return (0);
1273 }
1274
1275 int
1276 procstat_get_socket_info(struct procstat *procstat, struct filestat *fst,
1277     struct sockstat *sock, char *errbuf)
1278 {
1279
1280         assert(sock);
1281         if (procstat->type == PROCSTAT_KVM) {
1282                 return (procstat_get_socket_info_kvm(procstat->kd, fst, sock,
1283                     errbuf));
1284         } else if (procstat->type == PROCSTAT_SYSCTL ||
1285                 procstat->type == PROCSTAT_CORE) {
1286                 return (procstat_get_socket_info_sysctl(fst, sock, errbuf));
1287         } else {
1288                 warnx("unknown access method: %d", procstat->type);
1289                 snprintf(errbuf, _POSIX2_LINE_MAX, "error");
1290                 return (1);
1291         }
1292 }
1293
1294 static int
1295 procstat_get_socket_info_kvm(kvm_t *kd, struct filestat *fst,
1296     struct sockstat *sock, char *errbuf)
1297 {
1298         struct domain dom;
1299         struct inpcb inpcb;
1300         struct protosw proto;
1301         struct socket s;
1302         struct unpcb unpcb;
1303         ssize_t len;
1304         void *so;
1305
1306         assert(kd);
1307         assert(sock);
1308         assert(fst);
1309         bzero(sock, sizeof(*sock));
1310         so = fst->fs_typedep;
1311         if (so == NULL)
1312                 goto fail;
1313         sock->so_addr = (uintptr_t)so;
1314         /* fill in socket */
1315         if (!kvm_read_all(kd, (unsigned long)so, &s,
1316             sizeof(struct socket))) {
1317                 warnx("can't read sock at %p", (void *)so);
1318                 goto fail;
1319         }
1320         /* fill in protosw entry */
1321         if (!kvm_read_all(kd, (unsigned long)s.so_proto, &proto,
1322             sizeof(struct protosw))) {
1323                 warnx("can't read protosw at %p", (void *)s.so_proto);
1324                 goto fail;
1325         }
1326         /* fill in domain */
1327         if (!kvm_read_all(kd, (unsigned long)proto.pr_domain, &dom,
1328             sizeof(struct domain))) {
1329                 warnx("can't read domain at %p",
1330                     (void *)proto.pr_domain);
1331                 goto fail;
1332         }
1333         if ((len = kvm_read(kd, (unsigned long)dom.dom_name, sock->dname,
1334             sizeof(sock->dname) - 1)) < 0) {
1335                 warnx("can't read domain name at %p", (void *)dom.dom_name);
1336                 sock->dname[0] = '\0';
1337         }
1338         else
1339                 sock->dname[len] = '\0';
1340
1341         /*
1342          * Fill in known data.
1343          */
1344         sock->type = s.so_type;
1345         sock->proto = proto.pr_protocol;
1346         sock->dom_family = dom.dom_family;
1347         sock->so_pcb = (uintptr_t)s.so_pcb;
1348
1349         /*
1350          * Protocol specific data.
1351          */
1352         switch(dom.dom_family) {
1353         case AF_INET:
1354         case AF_INET6:
1355                 if (proto.pr_protocol == IPPROTO_TCP) {
1356                         if (s.so_pcb) {
1357                                 if (kvm_read(kd, (u_long)s.so_pcb,
1358                                     (char *)&inpcb, sizeof(struct inpcb))
1359                                     != sizeof(struct inpcb)) {
1360                                         warnx("can't read inpcb at %p",
1361                                             (void *)s.so_pcb);
1362                                 } else
1363                                         sock->inp_ppcb =
1364                                             (uintptr_t)inpcb.inp_ppcb;
1365                         }
1366                 }
1367                 break;
1368         case AF_UNIX:
1369                 if (s.so_pcb) {
1370                         if (kvm_read(kd, (u_long)s.so_pcb, (char *)&unpcb,
1371                             sizeof(struct unpcb)) != sizeof(struct unpcb)){
1372                                 warnx("can't read unpcb at %p",
1373                                     (void *)s.so_pcb);
1374                         } else if (unpcb.unp_conn) {
1375                                 sock->so_rcv_sb_state = s.so_rcv.sb_state;
1376                                 sock->so_snd_sb_state = s.so_snd.sb_state;
1377                                 sock->unp_conn = (uintptr_t)unpcb.unp_conn;
1378                         }
1379                 }
1380                 break;
1381         default:
1382                 break;
1383         }
1384         return (0);
1385
1386 fail:
1387         snprintf(errbuf, _POSIX2_LINE_MAX, "error");
1388         return (1);
1389 }
1390
1391 static int
1392 procstat_get_socket_info_sysctl(struct filestat *fst, struct sockstat *sock,
1393     char *errbuf __unused)
1394 {
1395         struct kinfo_file *kif;
1396
1397         assert(sock);
1398         assert(fst);
1399         bzero(sock, sizeof(*sock));
1400         kif = fst->fs_typedep;
1401         if (kif == NULL)
1402                 return (0);
1403
1404         /*
1405          * Fill in known data.
1406          */
1407         sock->type = kif->kf_sock_type;
1408         sock->proto = kif->kf_sock_protocol;
1409         sock->dom_family = kif->kf_sock_domain;
1410         sock->so_pcb = kif->kf_un.kf_sock.kf_sock_pcb;
1411         strlcpy(sock->dname, kif->kf_path, sizeof(sock->dname));
1412         bcopy(&kif->kf_sa_local, &sock->sa_local, kif->kf_sa_local.ss_len);
1413         bcopy(&kif->kf_sa_peer, &sock->sa_peer, kif->kf_sa_peer.ss_len);
1414
1415         /*
1416          * Protocol specific data.
1417          */
1418         switch(sock->dom_family) {
1419         case AF_INET:
1420         case AF_INET6:
1421                 if (sock->proto == IPPROTO_TCP)
1422                         sock->inp_ppcb = kif->kf_un.kf_sock.kf_sock_inpcb;
1423                 break;
1424         case AF_UNIX:
1425                 if (kif->kf_un.kf_sock.kf_sock_unpconn != 0) {
1426                                 sock->so_rcv_sb_state =
1427                                     kif->kf_un.kf_sock.kf_sock_rcv_sb_state;
1428                                 sock->so_snd_sb_state =
1429                                     kif->kf_un.kf_sock.kf_sock_snd_sb_state;
1430                                 sock->unp_conn =
1431                                     kif->kf_un.kf_sock.kf_sock_unpconn;
1432                 }
1433                 break;
1434         default:
1435                 break;
1436         }
1437         return (0);
1438 }
1439
1440 /*
1441  * Descriptor flags to filestat translation.
1442  */
1443 static int
1444 to_filestat_flags(int flags)
1445 {
1446         static struct {
1447                 int flag;
1448                 int fst_flag;
1449         } fstflags[] = {
1450                 { FREAD, PS_FST_FFLAG_READ },
1451                 { FWRITE, PS_FST_FFLAG_WRITE },
1452                 { O_APPEND, PS_FST_FFLAG_APPEND },
1453                 { O_ASYNC, PS_FST_FFLAG_ASYNC },
1454                 { O_CREAT, PS_FST_FFLAG_CREAT },
1455                 { O_DIRECT, PS_FST_FFLAG_DIRECT },
1456                 { O_EXCL, PS_FST_FFLAG_EXCL },
1457                 { O_EXEC, PS_FST_FFLAG_EXEC },
1458                 { O_EXLOCK, PS_FST_FFLAG_EXLOCK },
1459                 { O_NOFOLLOW, PS_FST_FFLAG_NOFOLLOW },
1460                 { O_NONBLOCK, PS_FST_FFLAG_NONBLOCK },
1461                 { O_SHLOCK, PS_FST_FFLAG_SHLOCK },
1462                 { O_SYNC, PS_FST_FFLAG_SYNC },
1463                 { O_TRUNC, PS_FST_FFLAG_TRUNC }
1464         };
1465 #define NFSTFLAGS       (sizeof(fstflags) / sizeof(*fstflags))
1466         int fst_flags;
1467         unsigned int i;
1468
1469         fst_flags = 0;
1470         for (i = 0; i < NFSTFLAGS; i++)
1471                 if (flags & fstflags[i].flag)
1472                         fst_flags |= fstflags[i].fst_flag;
1473         return (fst_flags);
1474 }
1475
1476 /*
1477  * Vnode type to filestate translation.
1478  */
1479 static int
1480 vntype2psfsttype(int type)
1481 {
1482         static struct {
1483                 int     vtype;
1484                 int     fst_vtype;
1485         } vt2fst[] = {
1486                 { VBAD, PS_FST_VTYPE_VBAD },
1487                 { VBLK, PS_FST_VTYPE_VBLK },
1488                 { VCHR, PS_FST_VTYPE_VCHR },
1489                 { VDIR, PS_FST_VTYPE_VDIR },
1490                 { VFIFO, PS_FST_VTYPE_VFIFO },
1491                 { VLNK, PS_FST_VTYPE_VLNK },
1492                 { VNON, PS_FST_VTYPE_VNON },
1493                 { VREG, PS_FST_VTYPE_VREG },
1494                 { VSOCK, PS_FST_VTYPE_VSOCK }
1495         };
1496 #define NVFTYPES        (sizeof(vt2fst) / sizeof(*vt2fst))
1497         unsigned int i, fst_type;
1498
1499         fst_type = PS_FST_VTYPE_UNKNOWN;
1500         for (i = 0; i < NVFTYPES; i++) {
1501                 if (type == vt2fst[i].vtype) {
1502                         fst_type = vt2fst[i].fst_vtype;
1503                         break;
1504                 }
1505         }
1506         return (fst_type);
1507 }
1508
1509 static char *
1510 getmnton(kvm_t *kd, struct mount *m)
1511 {
1512         struct mount mnt;
1513         static struct mtab {
1514                 struct mtab *next;
1515                 struct mount *m;
1516                 char mntonname[MNAMELEN + 1];
1517         } *mhead = NULL;
1518         struct mtab *mt;
1519
1520         for (mt = mhead; mt != NULL; mt = mt->next)
1521                 if (m == mt->m)
1522                         return (mt->mntonname);
1523         if (!kvm_read_all(kd, (unsigned long)m, &mnt, sizeof(struct mount))) {
1524                 warnx("can't read mount table at %p", (void *)m);
1525                 return (NULL);
1526         }
1527         if ((mt = malloc(sizeof (struct mtab))) == NULL)
1528                 err(1, NULL);
1529         mt->m = m;
1530         bcopy(&mnt.mnt_stat.f_mntonname[0], &mt->mntonname[0], MNAMELEN);
1531         mt->mntonname[MNAMELEN] = '\0';
1532         mt->next = mhead;
1533         mhead = mt;
1534         return (mt->mntonname);
1535 }
1536
1537 /*
1538  * Auxiliary structures and functions to get process environment or
1539  * command line arguments.
1540  */
1541 struct argvec {
1542         char    *buf;
1543         size_t  bufsize;
1544         char    **argv;
1545         size_t  argc;
1546 };
1547
1548 static struct argvec *
1549 argvec_alloc(size_t bufsize)
1550 {
1551         struct argvec *av;
1552
1553         av = malloc(sizeof(*av));
1554         if (av == NULL)
1555                 return (NULL);
1556         av->bufsize = bufsize;
1557         av->buf = malloc(av->bufsize);
1558         if (av->buf == NULL) {
1559                 free(av);
1560                 return (NULL);
1561         }
1562         av->argc = 32;
1563         av->argv = malloc(sizeof(char *) * av->argc);
1564         if (av->argv == NULL) {
1565                 free(av->buf);
1566                 free(av);
1567                 return (NULL);
1568         }
1569         return av;
1570 }
1571
1572 static void
1573 argvec_free(struct argvec * av)
1574 {
1575
1576         free(av->argv);
1577         free(av->buf);
1578         free(av);
1579 }
1580
1581 static char **
1582 getargv(struct procstat *procstat, struct kinfo_proc *kp, size_t nchr, int env)
1583 {
1584         int error, name[4], argc, i;
1585         struct argvec *av, **avp;
1586         enum psc_type type;
1587         size_t len;
1588         char *p, **argv;
1589
1590         assert(procstat);
1591         assert(kp);
1592         if (procstat->type == PROCSTAT_KVM) {
1593                 warnx("can't use kvm access method");
1594                 return (NULL);
1595         }
1596         if (procstat->type != PROCSTAT_SYSCTL &&
1597             procstat->type != PROCSTAT_CORE) {
1598                 warnx("unknown access method: %d", procstat->type);
1599                 return (NULL);
1600         }
1601
1602         if (nchr == 0 || nchr > ARG_MAX)
1603                 nchr = ARG_MAX;
1604
1605         avp = (struct argvec **)(env ? &procstat->argv : &procstat->envv);
1606         av = *avp;
1607
1608         if (av == NULL)
1609         {
1610                 av = argvec_alloc(nchr);
1611                 if (av == NULL)
1612                 {
1613                         warn("malloc(%zu)", nchr);
1614                         return (NULL);
1615                 }
1616                 *avp = av;
1617         } else if (av->bufsize < nchr) {
1618                 av->buf = reallocf(av->buf, nchr);
1619                 if (av->buf == NULL) {
1620                         warn("malloc(%zu)", nchr);
1621                         return (NULL);
1622                 }
1623         }
1624         if (procstat->type == PROCSTAT_SYSCTL) {
1625                 name[0] = CTL_KERN;
1626                 name[1] = KERN_PROC;
1627                 name[2] = env ? KERN_PROC_ENV : KERN_PROC_ARGS;
1628                 name[3] = kp->ki_pid;
1629                 len = nchr;
1630                 error = sysctl(name, 4, av->buf, &len, NULL, 0);
1631                 if (error != 0 && errno != ESRCH && errno != EPERM)
1632                         warn("sysctl(kern.proc.%s)", env ? "env" : "args");
1633                 if (error != 0 || len == 0)
1634                         return (NULL);
1635         } else /* procstat->type == PROCSTAT_CORE */ {
1636                 type = env ? PSC_TYPE_ENVV : PSC_TYPE_ARGV;
1637                 len = nchr;
1638                 if (procstat_core_get(procstat->core, type, av->buf, &len)
1639                     == NULL) {
1640                         return (NULL);
1641                 }
1642         }
1643
1644         argv = av->argv;
1645         argc = av->argc;
1646         i = 0;
1647         for (p = av->buf; p < av->buf + len; p += strlen(p) + 1) {
1648                 argv[i++] = p;
1649                 if (i < argc)
1650                         continue;
1651                 /* Grow argv. */
1652                 argc += argc;
1653                 argv = realloc(argv, sizeof(char *) * argc);
1654                 if (argv == NULL) {
1655                         warn("malloc(%zu)", sizeof(char *) * argc);
1656                         return (NULL);
1657                 }
1658                 av->argv = argv;
1659                 av->argc = argc;
1660         }
1661         argv[i] = NULL;
1662
1663         return (argv);
1664 }
1665
1666 /*
1667  * Return process command line arguments.
1668  */
1669 char **
1670 procstat_getargv(struct procstat *procstat, struct kinfo_proc *p, size_t nchr)
1671 {
1672
1673         return (getargv(procstat, p, nchr, 0));
1674 }
1675
1676 /*
1677  * Free the buffer allocated by procstat_getargv().
1678  */
1679 void
1680 procstat_freeargv(struct procstat *procstat)
1681 {
1682
1683         if (procstat->argv != NULL) {
1684                 argvec_free(procstat->argv);
1685                 procstat->argv = NULL;
1686         }
1687 }
1688
1689 /*
1690  * Return process environment.
1691  */
1692 char **
1693 procstat_getenvv(struct procstat *procstat, struct kinfo_proc *p, size_t nchr)
1694 {
1695
1696         return (getargv(procstat, p, nchr, 1));
1697 }
1698
1699 /*
1700  * Free the buffer allocated by procstat_getenvv().
1701  */
1702 void
1703 procstat_freeenvv(struct procstat *procstat)
1704 {
1705         if (procstat->envv != NULL) {
1706                 argvec_free(procstat->envv);
1707                 procstat->envv = NULL;
1708         }
1709 }
1710
1711 static struct kinfo_vmentry *
1712 kinfo_getvmmap_core(struct procstat_core *core, int *cntp)
1713 {
1714         int cnt;
1715         size_t len;
1716         char *buf, *bp, *eb;
1717         struct kinfo_vmentry *kiv, *kp, *kv;
1718
1719         buf = procstat_core_get(core, PSC_TYPE_VMMAP, NULL, &len);
1720         if (buf == NULL)
1721                 return (NULL);
1722
1723         /*
1724          * XXXMG: The code below is just copy&past from libutil.
1725          * The code duplication can be avoided if libutil
1726          * is extended to provide something like:
1727          *   struct kinfo_vmentry *kinfo_getvmmap_from_buf(const char *buf,
1728          *       size_t len, int *cntp);
1729          */
1730
1731         /* Pass 1: count items */
1732         cnt = 0;
1733         bp = buf;
1734         eb = buf + len;
1735         while (bp < eb) {
1736                 kv = (struct kinfo_vmentry *)(uintptr_t)bp;
1737                 bp += kv->kve_structsize;
1738                 cnt++;
1739         }
1740
1741         kiv = calloc(cnt, sizeof(*kiv));
1742         if (kiv == NULL) {
1743                 free(buf);
1744                 return (NULL);
1745         }
1746         bp = buf;
1747         eb = buf + len;
1748         kp = kiv;
1749         /* Pass 2: unpack */
1750         while (bp < eb) {
1751                 kv = (struct kinfo_vmentry *)(uintptr_t)bp;
1752                 /* Copy/expand into pre-zeroed buffer */
1753                 memcpy(kp, kv, kv->kve_structsize);
1754                 /* Advance to next packed record */
1755                 bp += kv->kve_structsize;
1756                 /* Set field size to fixed length, advance */
1757                 kp->kve_structsize = sizeof(*kp);
1758                 kp++;
1759         }
1760         free(buf);
1761         *cntp = cnt;
1762         return (kiv);   /* Caller must free() return value */
1763 }
1764
1765 struct kinfo_vmentry *
1766 procstat_getvmmap(struct procstat *procstat, struct kinfo_proc *kp,
1767     unsigned int *cntp)
1768 {
1769
1770         switch(procstat->type) {
1771         case PROCSTAT_KVM:
1772                 warnx("kvm method is not supported");
1773                 return (NULL);
1774         case PROCSTAT_SYSCTL:
1775                 return (kinfo_getvmmap(kp->ki_pid, cntp));
1776         case PROCSTAT_CORE:
1777                 return (kinfo_getvmmap_core(procstat->core, cntp));
1778         default:
1779                 warnx("unknown access method: %d", procstat->type);
1780                 return (NULL);
1781         }
1782 }
1783
1784 void
1785 procstat_freevmmap(struct procstat *procstat __unused,
1786     struct kinfo_vmentry *vmmap)
1787 {
1788
1789         free(vmmap);
1790 }
1791
1792 static gid_t *
1793 procstat_getgroups_sysctl(pid_t pid, unsigned int *cntp)
1794 {
1795         int mib[4];
1796         size_t len;
1797         gid_t *groups;
1798
1799         mib[0] = CTL_KERN;
1800         mib[1] = KERN_PROC;
1801         mib[2] = KERN_PROC_GROUPS;
1802         mib[3] = pid;
1803         len = (sysconf(_SC_NGROUPS_MAX) + 1) * sizeof(gid_t);
1804         groups = malloc(len);
1805         if (groups == NULL) {
1806                 warn("malloc(%zu)", len);
1807                 return (NULL);
1808         }
1809         if (sysctl(mib, 4, groups, &len, NULL, 0) == -1) {
1810                 warn("sysctl: kern.proc.groups: %d", pid);
1811                 free(groups);
1812                 return (NULL);
1813         }
1814         *cntp = len / sizeof(gid_t);
1815         return (groups);
1816 }
1817
1818 static gid_t *
1819 procstat_getgroups_core(struct procstat_core *core, unsigned int *cntp)
1820 {
1821         size_t len;
1822         gid_t *groups;
1823
1824         groups = procstat_core_get(core, PSC_TYPE_GROUPS, NULL, &len);
1825         if (groups == NULL)
1826                 return (NULL);
1827         *cntp = len / sizeof(gid_t);
1828         return (groups);
1829 }
1830
1831 gid_t *
1832 procstat_getgroups(struct procstat *procstat, struct kinfo_proc *kp,
1833     unsigned int *cntp)
1834 {
1835         switch(procstat->type) {
1836         case PROCSTAT_KVM:
1837                 warnx("kvm method is not supported");
1838                 return (NULL);
1839         case PROCSTAT_SYSCTL:
1840                 return (procstat_getgroups_sysctl(kp->ki_pid, cntp));
1841         case PROCSTAT_CORE:
1842                 return (procstat_getgroups_core(procstat->core, cntp));
1843         default:
1844                 warnx("unknown access method: %d", procstat->type);
1845                 return (NULL);
1846         }
1847 }
1848
1849 void
1850 procstat_freegroups(struct procstat *procstat __unused, gid_t *groups)
1851 {
1852
1853         free(groups);
1854 }
1855
1856 static int
1857 procstat_getumask_sysctl(pid_t pid, unsigned short *maskp)
1858 {
1859         int error;
1860         int mib[4];
1861         size_t len;
1862
1863         mib[0] = CTL_KERN;
1864         mib[1] = KERN_PROC;
1865         mib[2] = KERN_PROC_UMASK;
1866         mib[3] = pid;
1867         len = sizeof(*maskp);
1868         error = sysctl(mib, 4, maskp, &len, NULL, 0);
1869         if (error != 0 && errno != ESRCH)
1870                 warn("sysctl: kern.proc.umask: %d", pid);
1871         return (error);
1872 }
1873
1874 static int
1875 procstat_getumask_core(struct procstat_core *core, unsigned short *maskp)
1876 {
1877         size_t len;
1878         unsigned short *buf;
1879
1880         buf = procstat_core_get(core, PSC_TYPE_UMASK, NULL, &len);
1881         if (buf == NULL)
1882                 return (-1);
1883         if (len < sizeof(*maskp)) {
1884                 free(buf);
1885                 return (-1);
1886         }
1887         *maskp = *buf;
1888         free(buf);
1889         return (0);
1890 }
1891
1892 int
1893 procstat_getumask(struct procstat *procstat, struct kinfo_proc *kp,
1894     unsigned short *maskp)
1895 {
1896         switch(procstat->type) {
1897         case PROCSTAT_KVM:
1898                 warnx("kvm method is not supported");
1899                 return (-1);
1900         case PROCSTAT_SYSCTL:
1901                 return (procstat_getumask_sysctl(kp->ki_pid, maskp));
1902         case PROCSTAT_CORE:
1903                 return (procstat_getumask_core(procstat->core, maskp));
1904         default:
1905                 warnx("unknown access method: %d", procstat->type);
1906                 return (-1);
1907         }
1908 }
1909
1910 static int
1911 procstat_getrlimit_sysctl(pid_t pid, int which, struct rlimit* rlimit)
1912 {
1913         int error, name[5];
1914         size_t len;
1915
1916         name[0] = CTL_KERN;
1917         name[1] = KERN_PROC;
1918         name[2] = KERN_PROC_RLIMIT;
1919         name[3] = pid;
1920         name[4] = which;
1921         len = sizeof(struct rlimit);
1922         error = sysctl(name, 5, rlimit, &len, NULL, 0);
1923         if (error < 0 && errno != ESRCH) {
1924                 warn("sysctl: kern.proc.rlimit: %d", pid);
1925                 return (-1);
1926         }
1927         if (error < 0 || len != sizeof(struct rlimit))
1928                 return (-1);
1929         return (0);
1930 }
1931
1932 static int
1933 procstat_getrlimit_core(struct procstat_core *core, int which,
1934     struct rlimit* rlimit)
1935 {
1936         size_t len;
1937         struct rlimit* rlimits;
1938
1939         if (which < 0 || which >= RLIM_NLIMITS) {
1940                 errno = EINVAL;
1941                 warn("getrlimit: which");
1942                 return (-1);
1943         }
1944         rlimits = procstat_core_get(core, PSC_TYPE_RLIMIT, NULL, &len);
1945         if (rlimits == NULL)
1946                 return (-1);
1947         if (len < sizeof(struct rlimit) * RLIM_NLIMITS) {
1948                 free(rlimits);
1949                 return (-1);
1950         }
1951         *rlimit = rlimits[which];
1952         return (0);
1953 }
1954
1955 int
1956 procstat_getrlimit(struct procstat *procstat, struct kinfo_proc *kp, int which,
1957     struct rlimit* rlimit)
1958 {
1959         switch(procstat->type) {
1960         case PROCSTAT_KVM:
1961                 warnx("kvm method is not supported");
1962                 return (-1);
1963         case PROCSTAT_SYSCTL:
1964                 return (procstat_getrlimit_sysctl(kp->ki_pid, which, rlimit));
1965         case PROCSTAT_CORE:
1966                 return (procstat_getrlimit_core(procstat->core, which, rlimit));
1967         default:
1968                 warnx("unknown access method: %d", procstat->type);
1969                 return (-1);
1970         }
1971 }
1972
1973 static int
1974 procstat_getpathname_sysctl(pid_t pid, char *pathname, size_t maxlen)
1975 {
1976         int error, name[4];
1977         size_t len;
1978
1979         name[0] = CTL_KERN;
1980         name[1] = KERN_PROC;
1981         name[2] = KERN_PROC_PATHNAME;
1982         name[3] = pid;
1983         len = maxlen;
1984         error = sysctl(name, 4, pathname, &len, NULL, 0);
1985         if (error != 0 && errno != ESRCH)
1986                 warn("sysctl: kern.proc.pathname: %d", pid);
1987         if (len == 0)
1988                 pathname[0] = '\0';
1989         return (error);
1990 }
1991
1992 static int
1993 procstat_getpathname_core(struct procstat_core *core, char *pathname,
1994     size_t maxlen)
1995 {
1996         struct kinfo_file *files;
1997         int cnt, i, result;
1998
1999         files = kinfo_getfile_core(core, &cnt);
2000         if (files == NULL)
2001                 return (-1);
2002         result = -1;
2003         for (i = 0; i < cnt; i++) {
2004                 if (files[i].kf_fd != KF_FD_TYPE_TEXT)
2005                         continue;
2006                 strncpy(pathname, files[i].kf_path, maxlen);
2007                 result = 0;
2008                 break;
2009         }
2010         free(files);
2011         return (result);
2012 }
2013
2014 int
2015 procstat_getpathname(struct procstat *procstat, struct kinfo_proc *kp,
2016     char *pathname, size_t maxlen)
2017 {
2018         switch(procstat->type) {
2019         case PROCSTAT_KVM:
2020                 warnx("kvm method is not supported");
2021                 return (-1);
2022         case PROCSTAT_SYSCTL:
2023                 return (procstat_getpathname_sysctl(kp->ki_pid, pathname,
2024                     maxlen));
2025         case PROCSTAT_CORE:
2026                 return (procstat_getpathname_core(procstat->core, pathname,
2027                     maxlen));
2028         default:
2029                 warnx("unknown access method: %d", procstat->type);
2030                 return (-1);
2031         }
2032 }
2033
2034 static int
2035 procstat_getosrel_sysctl(pid_t pid, int *osrelp)
2036 {
2037         int error, name[4];
2038         size_t len;
2039
2040         name[0] = CTL_KERN;
2041         name[1] = KERN_PROC;
2042         name[2] = KERN_PROC_OSREL;
2043         name[3] = pid;
2044         len = sizeof(*osrelp);
2045         error = sysctl(name, 4, osrelp, &len, NULL, 0);
2046         if (error != 0 && errno != ESRCH)
2047                 warn("sysctl: kern.proc.osrel: %d", pid);
2048         return (error);
2049 }
2050
2051 static int
2052 procstat_getosrel_core(struct procstat_core *core, int *osrelp)
2053 {
2054         size_t len;
2055         int *buf;
2056
2057         buf = procstat_core_get(core, PSC_TYPE_OSREL, NULL, &len);
2058         if (buf == NULL)
2059                 return (-1);
2060         if (len < sizeof(*osrelp)) {
2061                 free(buf);
2062                 return (-1);
2063         }
2064         *osrelp = *buf;
2065         free(buf);
2066         return (0);
2067 }
2068
2069 int
2070 procstat_getosrel(struct procstat *procstat, struct kinfo_proc *kp, int *osrelp)
2071 {
2072         switch(procstat->type) {
2073         case PROCSTAT_KVM:
2074                 warnx("kvm method is not supported");
2075                 return (-1);
2076         case PROCSTAT_SYSCTL:
2077                 return (procstat_getosrel_sysctl(kp->ki_pid, osrelp));
2078         case PROCSTAT_CORE:
2079                 return (procstat_getosrel_core(procstat->core, osrelp));
2080         default:
2081                 warnx("unknown access method: %d", procstat->type);
2082                 return (-1);
2083         }
2084 }
2085
2086 #define PROC_AUXV_MAX   256
2087
2088 #if __ELF_WORD_SIZE == 64
2089 static const char *elf32_sv_names[] = {
2090         "Linux ELF32",
2091         "FreeBSD ELF32",
2092 };
2093
2094 static int
2095 is_elf32_sysctl(pid_t pid)
2096 {
2097         int error, name[4];
2098         size_t len, i;
2099         static char sv_name[256];
2100
2101         name[0] = CTL_KERN;
2102         name[1] = KERN_PROC;
2103         name[2] = KERN_PROC_SV_NAME;
2104         name[3] = pid;
2105         len = sizeof(sv_name);
2106         error = sysctl(name, 4, sv_name, &len, NULL, 0);
2107         if (error != 0 || len == 0)
2108                 return (0);
2109         for (i = 0; i < sizeof(elf32_sv_names) / sizeof(*elf32_sv_names); i++) {
2110                 if (strncmp(sv_name, elf32_sv_names[i], sizeof(sv_name)) == 0)
2111                         return (1);
2112         }
2113         return (0);
2114 }
2115
2116 static Elf_Auxinfo *
2117 procstat_getauxv32_sysctl(pid_t pid, unsigned int *cntp)
2118 {
2119         Elf_Auxinfo *auxv;
2120         Elf32_Auxinfo *auxv32;
2121         void *ptr;
2122         size_t len;
2123         unsigned int i, count;
2124         int name[4];
2125
2126         name[0] = CTL_KERN;
2127         name[1] = KERN_PROC;
2128         name[2] = KERN_PROC_AUXV;
2129         name[3] = pid;
2130         len = PROC_AUXV_MAX * sizeof(Elf32_Auxinfo);
2131         auxv = NULL;
2132         auxv32 = malloc(len);
2133         if (auxv32 == NULL) {
2134                 warn("malloc(%zu)", len);
2135                 goto out;
2136         }
2137         if (sysctl(name, 4, auxv32, &len, NULL, 0) == -1) {
2138                 if (errno != ESRCH && errno != EPERM)
2139                         warn("sysctl: kern.proc.auxv: %d: %d", pid, errno);
2140                 goto out;
2141         }
2142         count = len / sizeof(Elf_Auxinfo);
2143         auxv = malloc(count  * sizeof(Elf_Auxinfo));
2144         if (auxv == NULL) {
2145                 warn("malloc(%zu)", count * sizeof(Elf_Auxinfo));
2146                 goto out;
2147         }
2148         for (i = 0; i < count; i++) {
2149                 /*
2150                  * XXX: We expect that values for a_type on a 32-bit platform
2151                  * are directly mapped to values on 64-bit one, which is not
2152                  * necessarily true.
2153                  */
2154                 auxv[i].a_type = auxv32[i].a_type;
2155                 ptr = &auxv32[i].a_un;
2156                 auxv[i].a_un.a_val = *((uint32_t *)ptr);
2157         }
2158         *cntp = count;
2159 out:
2160         free(auxv32);
2161         return (auxv);
2162 }
2163 #endif /* __ELF_WORD_SIZE == 64 */
2164
2165 static Elf_Auxinfo *
2166 procstat_getauxv_sysctl(pid_t pid, unsigned int *cntp)
2167 {
2168         Elf_Auxinfo *auxv;
2169         int name[4];
2170         size_t len;
2171
2172 #if __ELF_WORD_SIZE == 64
2173         if (is_elf32_sysctl(pid))
2174                 return (procstat_getauxv32_sysctl(pid, cntp));
2175 #endif
2176         name[0] = CTL_KERN;
2177         name[1] = KERN_PROC;
2178         name[2] = KERN_PROC_AUXV;
2179         name[3] = pid;
2180         len = PROC_AUXV_MAX * sizeof(Elf_Auxinfo);
2181         auxv = malloc(len);
2182         if (auxv == NULL) {
2183                 warn("malloc(%zu)", len);
2184                 return (NULL);
2185         }
2186         if (sysctl(name, 4, auxv, &len, NULL, 0) == -1) {
2187                 if (errno != ESRCH && errno != EPERM)
2188                         warn("sysctl: kern.proc.auxv: %d: %d", pid, errno);
2189                 free(auxv);
2190                 return (NULL);
2191         }
2192         *cntp = len / sizeof(Elf_Auxinfo);
2193         return (auxv);
2194 }
2195
2196 static Elf_Auxinfo *
2197 procstat_getauxv_core(struct procstat_core *core, unsigned int *cntp)
2198 {
2199         Elf_Auxinfo *auxv;
2200         size_t len;
2201
2202         auxv = procstat_core_get(core, PSC_TYPE_AUXV, NULL, &len);
2203         if (auxv == NULL)
2204                 return (NULL);
2205         *cntp = len / sizeof(Elf_Auxinfo);
2206         return (auxv);
2207 }
2208
2209 Elf_Auxinfo *
2210 procstat_getauxv(struct procstat *procstat, struct kinfo_proc *kp,
2211     unsigned int *cntp)
2212 {
2213         switch(procstat->type) {
2214         case PROCSTAT_KVM:
2215                 warnx("kvm method is not supported");
2216                 return (NULL);
2217         case PROCSTAT_SYSCTL:
2218                 return (procstat_getauxv_sysctl(kp->ki_pid, cntp));
2219         case PROCSTAT_CORE:
2220                 return (procstat_getauxv_core(procstat->core, cntp));
2221         default:
2222                 warnx("unknown access method: %d", procstat->type);
2223                 return (NULL);
2224         }
2225 }
2226
2227 void
2228 procstat_freeauxv(struct procstat *procstat __unused, Elf_Auxinfo *auxv)
2229 {
2230
2231         free(auxv);
2232 }
2233
2234 static struct kinfo_kstack *
2235 procstat_getkstack_sysctl(pid_t pid, int *cntp)
2236 {
2237         struct kinfo_kstack *kkstp;
2238         int error, name[4];
2239         size_t len;
2240
2241         name[0] = CTL_KERN;
2242         name[1] = KERN_PROC;
2243         name[2] = KERN_PROC_KSTACK;
2244         name[3] = pid;
2245
2246         len = 0;
2247         error = sysctl(name, 4, NULL, &len, NULL, 0);
2248         if (error < 0 && errno != ESRCH && errno != EPERM && errno != ENOENT) {
2249                 warn("sysctl: kern.proc.kstack: %d", pid);
2250                 return (NULL);
2251         }
2252         if (error == -1 && errno == ENOENT) {
2253                 warnx("sysctl: kern.proc.kstack unavailable"
2254                     " (options DDB or options STACK required in kernel)");
2255                 return (NULL);
2256         }
2257         if (error == -1)
2258                 return (NULL);
2259         kkstp = malloc(len);
2260         if (kkstp == NULL) {
2261                 warn("malloc(%zu)", len);
2262                 return (NULL);
2263         }
2264         if (sysctl(name, 4, kkstp, &len, NULL, 0) == -1) {
2265                 warn("sysctl: kern.proc.pid: %d", pid);
2266                 free(kkstp);
2267                 return (NULL);
2268         }
2269         *cntp = len / sizeof(*kkstp);
2270
2271         return (kkstp);
2272 }
2273
2274 struct kinfo_kstack *
2275 procstat_getkstack(struct procstat *procstat, struct kinfo_proc *kp,
2276     unsigned int *cntp)
2277 {
2278         switch(procstat->type) {
2279         case PROCSTAT_KVM:
2280                 warnx("kvm method is not supported");
2281                 return (NULL);
2282         case PROCSTAT_SYSCTL:
2283                 return (procstat_getkstack_sysctl(kp->ki_pid, cntp));
2284         case PROCSTAT_CORE:
2285                 warnx("core method is not supported");
2286                 return (NULL);
2287         default:
2288                 warnx("unknown access method: %d", procstat->type);
2289                 return (NULL);
2290         }
2291 }
2292
2293 void
2294 procstat_freekstack(struct procstat *procstat __unused,
2295     struct kinfo_kstack *kkstp)
2296 {
2297
2298         free(kkstp);
2299 }