usr.sbin/pstat/pstat.c

   1 /*      $NetBSD: pstat.c,v 1.115 2009/09/16 07:27:41 mlelstv Exp $      */
   2
   3 /*-
   4  * Copyright (c) 1980, 1991, 1993, 1994
   5  *      The Regents of the University of California.  All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. Neither the name of the University nor the names of its contributors
  16  *    may be used to endorse or promote products derived from this software
  17  *    without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  */
  31
  32 #include <sys/cdefs.h>
  33 #ifndef lint
  34 __COPYRIGHT("@(#) Copyright (c) 1980, 1991, 1993, 1994\
  35  The Regents of the University of California.  All rights reserved.");
  36 #endif /* not lint */
  37
  38 #ifndef lint
  39 #if 0
  40 static char sccsid[] = "@(#)pstat.c     8.16 (Berkeley) 5/9/95";
  41 #else
  42 __RCSID("$NetBSD: pstat.c,v 1.115 2009/09/16 07:27:41 mlelstv Exp $");
  43 #endif
  44 #endif /* not lint */
  45
  46 #define _KERNEL
  47 #include <sys/types.h>
  48 #undef _KERNEL
  49 #include <sys/param.h>
  50 #include <sys/time.h>
  51 #include <sys/vnode.h>
  52 #include <sys/ucred.h>
  53 #include <stdbool.h>
  54 #define _KERNEL
  55 #define NFS
  56 #include <sys/mount.h>
  57 #undef NFS
  58 #include <sys/file.h>
  59 #include <ufs/ufs/inode.h>
  60 #include <ufs/ufs/ufsmount.h>
  61 #include <sys/uio.h>
  62 #include <miscfs/genfs/layer.h>
  63 #undef _KERNEL
  64 #include <sys/stat.h>
  65 #include <nfs/nfsproto.h>
  66 #include <nfs/rpcv2.h>
  67 #include <nfs/nfs.h>
  68 #include <nfs/nfsnode.h>
  69 #include <sys/ioctl.h>
  70 #include <sys/tty.h>
  71 #include <sys/conf.h>
  72
  73 #include <sys/sysctl.h>
  74
  75 #include <err.h>
  76 #include <kvm.h>
  77 #include <limits.h>
  78 #include <nlist.h>
  79 #include <stdio.h>
  80 #include <stdlib.h>
  81 #include <string.h>
  82 #include <unistd.h>
  83
  84 #include "swapctl.h"
  85
  86 struct nlist nl[] = {
  87 #define V_MOUNTLIST     0
  88         { "_mountlist", 0, 0, 0, 0 },   /* address of head of mount list. */
  89 #define V_NUMV          1
  90         { "_numvnodes", 0, 0, 0, 0 },
  91 #define FNL_NFILE       2
  92         { "_nfiles", 0, 0, 0, 0 },
  93 #define FNL_MAXFILE     3
  94         { "_maxfiles", 0, 0, 0, 0 },
  95 #define TTY_NTTY        4
  96         { "_tty_count", 0, 0, 0, 0 },
  97 #define TTY_TTYLIST     5
  98         { "_ttylist", 0, 0, 0, 0 },
  99 #define NLMANDATORY TTY_TTYLIST /* names up to here are mandatory */
 100         { "", 0, 0, 0, 0 }
 101 };
 102
 103 int     usenumflag;
 104 int     totalflag;
 105 int     kflag;
 106 int     hflag;
 107 char    *nlistf = NULL;
 108 char    *memf   = NULL;
 109 kvm_t   *kd;
 110
 111 static const char * const dtypes[] = { DTYPE_NAMES };
 112
 113
 114 static const struct {
 115         u_int m_flag;
 116         u_int m_visible;
 117         const char *m_name;
 118 } mnt_flags[] = {
 119         __MNT_FLAGS
 120 };
 121
 122 struct flagbit_desc {
 123         u_int fd_flags;
 124         char fd_mark;
 125 };
 126
 127 #define SVAR(var) __STRING(var) /* to force expansion */
 128 #define KGET(idx, var)                                                  \
 129         KGET1(idx, &var, sizeof(var), SVAR(var))
 130 #define KGET1(idx, p, s, msg)                                           \
 131         KGET2(nl[idx].n_value, p, s, msg)
 132 #define KGET2(addr, p, s, msg) do {                                     \
 133         if (kvm_read(kd, (u_long)(addr), p, s) != s)                    \
 134                 warnx("cannot read %s: %s", msg, kvm_geterr(kd));       \
 135 } while (/* CONSTCOND */0)
 136 #define KGETRET(addr, p, s, msg) do {                                   \
 137         if (kvm_read(kd, (u_long)(addr), p, s) != s) {                  \
 138                 warnx("cannot read %s: %s", msg, kvm_geterr(kd));       \
 139                 return (0);                                             \
 140         }                                                               \
 141 } while (/* CONSTCOND */0)
 142
 143 #if 1                           /* This is copied from vmstat/vmstat.c */
 144 /*
 145  * Print single word.  `ovflow' is number of characters didn't fit
 146  * on the last word.  `fmt' is a format string to print this word.
 147  * It must contain asterisk for field width.  `width' is a width
 148  * occupied by this word.  `fixed' is a number of constant chars in
 149  * `fmt'.  `val' is a value to be printed using format string `fmt'.
 150  */
 151 #define PRWORD(ovflw, fmt, width, fixed, val) do {      \
 152         (ovflw) += printf((fmt),                        \
 153             (width) - (fixed) - (ovflw) > 0 ?           \
 154             (width) - (fixed) - (ovflw) : 0,            \
 155             (val)) - (width);                           \
 156         if ((ovflw) < 0)                                \
 157                 (ovflw) = 0;                            \
 158 } while (/* CONSTCOND */0)
 159 #endif
 160
 161 void    filemode(void);
 162 int     getfiles(char **, int *, char **);
 163 int     getflags(const struct flagbit_desc *, char *, u_int);
 164 struct mount *
 165         getmnt(struct mount *);
 166 char *  kinfo_vnodes(int *);
 167 void    layer_header(void);
 168 int     layer_print(struct vnode *, int);
 169 char *  loadvnodes(int *);
 170 int     main(int, char **);
 171 void    mount_print(struct mount *);
 172 void    nfs_header(void);
 173 int     nfs_print(struct vnode *, int);
 174 void    ttymode(void);
 175 void    ttyprt(struct tty *);
 176 void    ufs_header(void);
 177 int     ufs_print(struct vnode *, int);
 178 int     ext2fs_print(struct vnode *, int);
 179 void    usage(void);
 180 void    vnode_header(void);
 181 int     vnode_print(struct vnode *, struct vnode *);
 182 void    vnodemode(void);
 183
 184 int
 185 main(int argc, char *argv[])
 186 {
 187         int ch, i, quit, ret, use_sysctl;
 188         int fileflag, swapflag, ttyflag, vnodeflag;
 189         gid_t egid = getegid();
 190         char buf[_POSIX2_LINE_MAX];
 191
 192         setegid(getgid());
 193         fileflag = swapflag = ttyflag = vnodeflag = 0;
 194         while ((ch = getopt(argc, argv, "TM:N:fghikmnstv")) != -1)
 195                 switch (ch) {
 196                 case 'f':
 197                         fileflag = 1;
 198                         break;
 199                 case 'M':
 200                         memf = optarg;
 201                         break;
 202                 case 'N':
 203                         nlistf = optarg;
 204                         break;
 205                 case 'n':
 206                         usenumflag = 1;
 207                         break;
 208                 case 's':
 209                         swapflag = 1;
 210                         break;
 211                 case 'T':
 212                         totalflag = 1;
 213                         break;
 214                 case 't':
 215                         ttyflag = 1;
 216                         break;
 217                 case 'k':
 218                         kflag = 1;
 219                         break;
 220                 case 'g':
 221                         kflag = 3; /* 1k ^ 3 */
 222                         break;
 223                 case 'h':
 224                         hflag = 1;
 225                         break;
 226                 case 'm':
 227                         kflag = 2; /* 1k ^ 2 */
 228                         break;
 229                 case 'v':
 230                 case 'i':               /* Backward compatibility. */
 231                         vnodeflag = 1;
 232                         break;
 233                 default:
 234                         usage();
 235                 }
 236         argc -= optind;
 237         argv += optind;
 238
 239         /*
 240          * Discard setgid privileges.  If not the running kernel, we toss
 241          * them away totally so that bad guys can't print interesting stuff
 242          * from kernel memory, otherwise switch back to kmem for the
 243          * duration of the kvm_openfiles() call.
 244          */
 245         if (nlistf != NULL || memf != NULL)
 246                 (void)setgid(getgid());
 247         else
 248                 (void)setegid(egid);
 249
 250         use_sysctl = (nlistf == NULL && memf == NULL);
 251
 252         if ((kd = kvm_openfiles(nlistf, memf, NULL, O_RDONLY, buf)) == 0)
 253                 errx(1, "kvm_openfiles: %s", buf);
 254
 255         /* get rid of it now anyway */
 256         if (nlistf == NULL && memf == NULL)
 257                 (void)setgid(getgid());
 258         if ((ret = kvm_nlist(kd, nl)) != 0) {
 259                 if (ret == -1)
 260                         errx(1, "kvm_nlist: %s", kvm_geterr(kd));
 261                 for (i = quit = 0; i <= NLMANDATORY; i++)
 262                         if (!nl[i].n_value) {
 263                                 quit = 1;
 264                                 warnx("undefined symbol: %s", nl[i].n_name);
 265                         }
 266                 if (quit)
 267                         exit(1);
 268         }
 269         if (!(fileflag | vnodeflag | ttyflag | swapflag | totalflag))
 270                 usage();
 271         if (fileflag || totalflag)
 272                 filemode();
 273         if (vnodeflag || totalflag)
 274                 vnodemode();
 275         if (ttyflag)
 276                 ttymode();
 277         if (swapflag || totalflag)
 278                 if (use_sysctl)
 279                         list_swap(0, kflag, 0, totalflag, 1, hflag);
 280         exit(0);
 281 }
 282
 283 #define VPTRSZ  sizeof(struct vnode *)
 284 #define VNODESZ sizeof(struct vnode)
 285 #define PTRSTRWIDTH ((int)sizeof(void *) * 2) /* Width of resulting string
 286                                                  when pointer is printed
 287                                                  in hexadecimal. */
 288
 289 static void
 290 devprintf(char *buf, size_t buflen, dev_t dev)
 291 {
 292         (void)snprintf(buf, buflen, "%llu,%llu",
 293             (unsigned long long)major(dev),
 294             (unsigned long long)minor(dev));
 295 }
 296
 297 void
 298 vnodemode(void)
 299 {
 300         char *e_vnodebase, *endvnode, *evp;
 301         struct vnode *vp;
 302         struct mount *maddr, *mp;
 303         int numvnodes, ovflw;
 304         int (*vnode_fsprint) (struct vnode *, int); /* per-fs data printer */
 305
 306         mp = NULL;
 307         e_vnodebase = loadvnodes(&numvnodes);
 308         if (totalflag) {
 309                 (void)printf("%7d vnodes\n", numvnodes);
 310                 goto out;
 311         }
 312         endvnode = e_vnodebase + numvnodes * (VPTRSZ + VNODESZ);
 313         (void)printf("%d active vnodes\n", numvnodes);
 314
 315 #define ST      mp->mnt_stat
 316 #define FSTYPE_IS(mp, name)                                             \
 317         (strncmp((mp)->mnt_stat.f_fstypename, (name),                   \
 318         sizeof((mp)->mnt_stat.f_fstypename)) == 0)
 319         maddr = NULL;
 320         vnode_fsprint = NULL;
 321         for (evp = e_vnodebase; evp < endvnode; evp += VPTRSZ + VNODESZ) {
 322                 vp = (struct vnode *)(evp + VPTRSZ);
 323                 if (vp->v_mount != maddr) {
 324                         /*
 325                          * New filesystem
 326                          */
 327                         if ((mp = getmnt(vp->v_mount)) == NULL)
 328                                 continue;
 329                         maddr = vp->v_mount;
 330                         mount_print(mp);
 331                         vnode_header();
 332                         if (FSTYPE_IS(mp, MOUNT_FFS) ||
 333                             FSTYPE_IS(mp, MOUNT_MFS)) {
 334                                 ufs_header();
 335                                 vnode_fsprint = ufs_print;
 336                         } else if (FSTYPE_IS(mp, MOUNT_NFS)) {
 337                                 nfs_header();
 338                                 vnode_fsprint = nfs_print;
 339                         } else if (FSTYPE_IS(mp, MOUNT_EXT2FS)) {
 340                                 ufs_header();
 341                                 vnode_fsprint = ext2fs_print;
 342                         } else if (FSTYPE_IS(mp, MOUNT_NULL) ||
 343                             FSTYPE_IS(mp, MOUNT_OVERLAY) ||
 344                             FSTYPE_IS(mp, MOUNT_UMAP)) {
 345                                 layer_header();
 346                                 vnode_fsprint = layer_print;
 347                         } else
 348                                 vnode_fsprint = NULL;
 349                         (void)printf("\n");
 350                 }
 351                 ovflw = vnode_print(*(struct vnode **)evp, vp);
 352                 if (VTOI(vp) != NULL && vnode_fsprint != NULL)
 353                         (*vnode_fsprint)(vp, ovflw);
 354                 (void)printf("\n");
 355         }
 356
 357  out:
 358         if (e_vnodebase)
 359                 free(e_vnodebase);
 360 }
 361
 362 int
 363 getflags(const struct flagbit_desc *fd, char *p, u_int flags)
 364 {
 365         char *q = p;
 366
 367         if (flags == 0) {
 368                 *p++ = '-';
 369                 *p = '\0';
 370                 return (0);
 371         }
 372
 373         for (; fd->fd_flags != 0; fd++)
 374                 if ((flags & fd->fd_flags) != 0)
 375                         *p++ = fd->fd_mark;
 376         *p = '\0';
 377         return (p - q);
 378 }
 379
 380 const struct flagbit_desc vnode_flags[] = {
 381         { VV_ROOT,      'R' },
 382         { VI_TEXT,      'T' },
 383         { VV_SYSTEM,    'S' },
 384         { VV_ISTTY,     'I' },
 385         { VI_EXECMAP,   'E' },
 386         { VI_XLOCK,     'L' },
 387         { VU_DIROP,     'D' },
 388         { VI_LAYER,     'Y' },
 389         { VI_ONWORKLST, 'O' },
 390         { 0,            '\0' },
 391 };
 392
 393 void
 394 vnode_header(void)
 395 {
 396
 397         (void)printf("%-*s TYP VFLAG  USE HOLD TAG NPAGE",
 398             PTRSTRWIDTH, "ADDR");
 399 }
 400
 401 int
 402 vnode_print(struct vnode *avnode, struct vnode *vp)
 403 {
 404         const char *type;
 405         char flags[sizeof(vnode_flags) / sizeof(vnode_flags[0])];
 406         int ovflw;
 407
 408         /*
 409          * set type
 410          */
 411         switch (vp->v_type) {
 412         case VNON:
 413                 type = "non"; break;
 414         case VREG:
 415                 type = "reg"; break;
 416         case VDIR:
 417                 type = "dir"; break;
 418         case VBLK:
 419                 type = "blk"; break;
 420         case VCHR:
 421                 type = "chr"; break;
 422         case VLNK:
 423                 type = "lnk"; break;
 424         case VSOCK:
 425                 type = "soc"; break;
 426         case VFIFO:
 427                 type = "fif"; break;
 428         case VBAD:
 429                 type = "bad"; break;
 430         default:
 431                 type = "unk"; break;
 432         }
 433         /*
 434          * gather flags
 435          */
 436         (void)getflags(vnode_flags, flags,
 437             vp->v_uflag | vp->v_iflag | vp->v_vflag);
 438
 439         ovflw = 0;
 440         PRWORD(ovflw, "%*lx", PTRSTRWIDTH, 0, (long)avnode);
 441         PRWORD(ovflw, " %*s", 4, 1, type);
 442         PRWORD(ovflw, " %*s", 6, 1, flags);
 443         PRWORD(ovflw, " %*ld", 5, 1, (long)vp->v_usecount);
 444         PRWORD(ovflw, " %*ld", 5, 1, (long)vp->v_holdcnt);
 445         PRWORD(ovflw, " %*d", 4, 1, vp->v_tag);
 446         PRWORD(ovflw, " %*d", 6, 1, vp->v_uobj.uo_npages);
 447         return (ovflw);
 448 }
 449
 450 const struct flagbit_desc ufs_flags[] = {
 451         { IN_ACCESS,    'A' },
 452         { IN_CHANGE,    'C' },
 453         { IN_UPDATE,    'U' },
 454         { IN_MODIFIED,  'M' },
 455         { IN_ACCESSED,  'a' },
 456         { IN_RENAME,    'R' },
 457         { IN_SHLOCK,    'S' },
 458         { IN_EXLOCK,    'E' },
 459         { IN_CLEANING,  'c' },
 460         { IN_ADIROP,    'D' },
 461         { IN_SPACECOUNTED, 's' },
 462         { 0,            '\0' },
 463 };
 464
 465 void
 466 ufs_header(void)
 467 {
 468
 469         (void)printf(" FILEID IFLAG RDEV|SZ");
 470 }
 471
 472 int
 473 ufs_print(struct vnode *vp, int ovflw)
 474 {
 475         struct inode inode, *ip = &inode;
 476         union dinode {
 477                 struct ufs1_dinode dp1;
 478                 struct ufs2_dinode dp2;
 479         } dip;
 480         struct ufsmount ump;
 481         char flags[sizeof(ufs_flags) / sizeof(ufs_flags[0])];
 482         char dev[4 + 1 + 7 + 1]; /* 12bit marjor + 20bit minor */
 483         char *name;
 484         mode_t type;
 485         dev_t rdev;
 486
 487         KGETRET(VTOI(vp), &inode, sizeof(struct inode), "vnode's inode");
 488         KGETRET(ip->i_ump, &ump, sizeof(struct ufsmount),
 489             "vnode's mount point");
 490
 491         if (ump.um_fstype == UFS1) {
 492                 KGETRET(ip->i_din.ffs1_din, &dip, sizeof (struct ufs1_dinode),
 493                     "inode's dinode");
 494                 rdev = (uint32_t)dip.dp1.di_rdev;
 495         } else {
 496                 KGETRET(ip->i_din.ffs2_din, &dip, sizeof (struct ufs2_dinode),
 497                     "inode's UFS2 dinode");
 498                 rdev = dip.dp2.di_rdev;
 499         }
 500
 501         /*
 502          * XXX need to to locking state.
 503          */
 504
 505         (void)getflags(ufs_flags, flags, ip->i_flag);
 506         PRWORD(ovflw, " %*llu", 7, 1, (unsigned long long)ip->i_number);
 507         PRWORD(ovflw, " %*s", 6, 1, flags);
 508         type = ip->i_mode & S_IFMT;
 509         if (S_ISCHR(ip->i_mode) || S_ISBLK(ip->i_mode)) {
 510                 if (usenumflag ||
 511                     (name = devname(rdev, type)) == NULL) {
 512                         devprintf(dev, sizeof(dev), rdev);
 513                         name = dev;
 514                 }
 515                 PRWORD(ovflw, " %*s", 8, 1, name);
 516         } else
 517                 PRWORD(ovflw, " %*lld", 8, 1, (long long)ip->i_size);
 518         return 0;
 519 }
 520
 521 int
 522 ext2fs_print(struct vnode *vp, int ovflw)
 523 {
 524         struct inode inode, *ip = &inode;
 525         struct ext2fs_dinode dip;
 526         char flags[sizeof(ufs_flags) / sizeof(ufs_flags[0])];
 527         char dev[4 + 1 + 7 + 1]; /* 12bit marjor + 20bit minor */
 528         char *name;
 529         mode_t type;
 530
 531         KGETRET(VTOI(vp), &inode, sizeof(struct inode), "vnode's inode");
 532         KGETRET(ip->i_din.e2fs_din, &dip, sizeof (struct ext2fs_dinode),
 533             "inode's dinode");
 534
 535         /*
 536          * XXX need to to locking state.
 537          */
 538
 539         (void)getflags(ufs_flags, flags, ip->i_flag);
 540         PRWORD(ovflw, " %*llu", 7, 1, (unsigned long long)ip->i_number);
 541         PRWORD(ovflw, " %*s", 6, 1, flags);
 542         type = dip.e2di_mode & S_IFMT;
 543         if (S_ISCHR(dip.e2di_mode) || S_ISBLK(dip.e2di_mode)) {
 544                 if (usenumflag ||
 545                     (name = devname(dip.e2di_rdev, type)) == NULL) {
 546                         devprintf(dev, sizeof(dev), dip.e2di_rdev);
 547                         name = dev;
 548                 }
 549                 PRWORD(ovflw, " %*s", 8, 1, name);
 550         } else
 551                 PRWORD(ovflw, " %*u", 8, 1, (u_int)dip.e2di_size);
 552         return (0);
 553 }
 554
 555 const struct flagbit_desc nfs_flags[] = {
 556         { NFLUSHWANT,   'W' },
 557         { NFLUSHINPROG, 'P' },
 558         { NMODIFIED,    'M' },
 559         { NWRITEERR,    'E' },
 560         { NACC,         'A' },
 561         { NUPD,         'U' },
 562         { NCHG,         'C' },
 563         { 0,            '\0' },
 564 };
 565
 566 void
 567 nfs_header(void)
 568 {
 569
 570         (void)printf(" FILEID NFLAG RDEV|SZ");
 571 }
 572
 573 int
 574 nfs_print(struct vnode *vp, int ovflw)
 575 {
 576         struct nfsnode nfsnode, *np = &nfsnode;
 577         char flags[sizeof(nfs_flags) / sizeof(nfs_flags[0])];
 578         char dev[4 + 1 + 7 + 1]; /* 12bit marjor + 20bit minor */
 579         struct vattr va;
 580         char *name;
 581         mode_t type;
 582
 583         KGETRET(VTONFS(vp), &nfsnode, sizeof(nfsnode), "vnode's nfsnode");
 584         (void)getflags(nfs_flags, flags, np->n_flag);
 585
 586         KGETRET(np->n_vattr, &va, sizeof(va), "vnode attr");
 587         PRWORD(ovflw, " %*ld", 7, 1, (long)va.va_fileid);
 588         PRWORD(ovflw, " %*s", 6, 1, flags);
 589         switch (va.va_type) {
 590         case VCHR:
 591                 type = S_IFCHR;
 592                 goto device;
 593
 594         case VBLK:
 595                 type = S_IFBLK;
 596         device:
 597                 if (usenumflag || (name = devname(va.va_rdev, type)) == NULL) {
 598                         devprintf(dev, sizeof(dev), va.va_rdev);
 599                         name = dev;
 600                 }
 601                 PRWORD(ovflw, " %*s", 8, 1, name);
 602                 break;
 603         default:
 604                 PRWORD(ovflw, " %*lld", 8, 1, (long long)np->n_size);
 605                 break;
 606         }
 607         return (0);
 608 }
 609
 610 void
 611 layer_header(void)
 612 {
 613
 614         (void)printf(" %*s", PTRSTRWIDTH, "LOWER");
 615 }
 616
 617 int
 618 layer_print(struct vnode *vp, int ovflw)
 619 {
 620         struct layer_node lnode, *lp = &lnode;
 621
 622         KGETRET(VTOLAYER(vp), &lnode, sizeof(lnode), "layer vnode");
 623
 624         PRWORD(ovflw, " %*lx", PTRSTRWIDTH + 1, 1, (long)lp->layer_lowervp);
 625         return (0);
 626 }
 627
 628 /*
 629  * Given a pointer to a mount structure in kernel space,
 630  * read it in and return a usable pointer to it.
 631  */
 632 struct mount *
 633 getmnt(struct mount *maddr)
 634 {
 635         static struct mtab {
 636                 struct mtab *next;
 637                 struct mount *maddr;
 638                 struct mount mount;
 639         } *mhead = NULL;
 640         struct mtab *mt;
 641         struct mount mb;
 642
 643         for (mt = mhead; mt != NULL; mt = mt->next)
 644                 if (maddr == mt->maddr)
 645                         return (&mt->mount);
 646         KGETRET(maddr, &mb, sizeof(struct mount), "mount table");
 647         if ((mt = malloc(sizeof(struct mtab))) == NULL)
 648                 err(1, "malloc");
 649         mt->mount = mb;
 650         mt->maddr = maddr;
 651         mt->next = mhead;
 652         mhead = mt;
 653         return (&mt->mount);
 654 }
 655
 656 void
 657 mount_print(struct mount *mp)
 658 {
 659         int flags;
 660
 661         (void)printf("*** MOUNT %s %s on %s", ST.f_fstypename,
 662             ST.f_mntfromname, ST.f_mntonname);
 663         if ((flags = mp->mnt_flag) != 0) {
 664                 size_t i;
 665                 const char *sep = " (";
 666
 667                 for (i = 0; i < sizeof mnt_flags / sizeof mnt_flags[0]; i++) {
 668                         if (flags & mnt_flags[i].m_flag) {
 669                                 (void)printf("%s%s", sep, mnt_flags[i].m_name);
 670                                 flags &= ~mnt_flags[i].m_flag;
 671                                 sep = ",";
 672                         }
 673                 }
 674                 if (flags)
 675                         (void)printf("%sunknown_flags:%x", sep, flags);
 676                 (void)printf(")");
 677         }
 678         (void)printf("\n");
 679 }
 680
 681 char *
 682 loadvnodes(int *avnodes)
 683 {
 684         int mib[2];
 685         size_t copysize;
 686         char *vnodebase;
 687
 688         if (totalflag) {
 689                 KGET(V_NUMV, *avnodes);
 690                 return NULL;
 691         }
 692         if (memf != NULL) {
 693                 /*
 694                  * do it by hand
 695                  */
 696                 return (kinfo_vnodes(avnodes));
 697         }
 698         mib[0] = CTL_KERN;
 699         mib[1] = KERN_VNODE;
 700         if (sysctl(mib, 2, NULL, &copysize, NULL, 0) == -1)
 701                 err(1, "sysctl: KERN_VNODE");
 702         if ((vnodebase = malloc(copysize)) == NULL)
 703                 err(1, "malloc");
 704         if (sysctl(mib, 2, vnodebase, &copysize, NULL, 0) == -1)
 705                 err(1, "sysctl: KERN_VNODE");
 706         if (copysize % (VPTRSZ + VNODESZ))
 707                 errx(1, "vnode size mismatch");
 708         *avnodes = copysize / (VPTRSZ + VNODESZ);
 709
 710         return (vnodebase);
 711 }
 712
 713 /*
 714  * simulate what a running kernel does in in kinfo_vnode
 715  */
 716 char *
 717 kinfo_vnodes(int *avnodes)
 718 {
 719         struct mntlist mlist;
 720         struct mount *mp, mount;
 721         struct vnode *vp, vnode;
 722         char *beg, *bp, *ep;
 723         int numvnodes;
 724
 725         KGET(V_NUMV, numvnodes);
 726         if ((bp = malloc((numvnodes + 20) * (VPTRSZ + VNODESZ))) == NULL)
 727                 err(1, "malloc");
 728         beg = bp;
 729         ep = bp + (numvnodes + 20) * (VPTRSZ + VNODESZ);
 730         KGET(V_MOUNTLIST, mlist);
 731         for (mp = mlist.cqh_first;;
 732             mp = mount.mnt_list.cqe_next) {
 733                 KGET2(mp, &mount, sizeof(mount), "mount entry");
 734                 TAILQ_FOREACH(vp, &mount.mnt_vnodelist, v_mntvnodes) {
 735                         KGET2(vp, &vnode, sizeof(vnode), "vnode");
 736                         if (bp + VPTRSZ + VNODESZ > ep)
 737                                 /* XXX - should realloc */
 738                                 errx(1, "no more room for vnodes");
 739                         memmove(bp, &vp, VPTRSZ);
 740                         bp += VPTRSZ;
 741                         memmove(bp, &vnode, VNODESZ);
 742                         bp += VNODESZ;
 743                 }
 744                 if (mp == mlist.cqh_last)
 745                         break;
 746         }
 747         *avnodes = (bp - beg) / (VPTRSZ + VNODESZ);
 748         return (beg);
 749 }
 750
 751 void
 752 ttymode(void)
 753 {
 754         int ntty;
 755         struct ttylist_head tty_head;
 756         struct tty *tp, tty;
 757
 758         KGET(TTY_NTTY, ntty);
 759         (void)printf("%d terminal device%s\n", ntty, ntty == 1 ? "" : "s");
 760         KGET(TTY_TTYLIST, tty_head);
 761         (void)printf(
 762             "  LINE RAW CAN OUT  HWT LWT     COL STATE  %-*s  PGID DISC\n",
 763             PTRSTRWIDTH, "SESS");
 764         for (tp = tty_head.tqh_first; tp; tp = tty.tty_link.tqe_next) {
 765                 KGET2(tp, &tty, sizeof tty, "tty struct");
 766                 ttyprt(&tty);
 767         }
 768 }
 769
 770 static const struct flagbit_desc ttystates[] = {
 771         { TS_ISOPEN,    'O'},
 772         { TS_DIALOUT,   '>'},
 773         { TS_CARR_ON,   'C'},
 774         { TS_TIMEOUT,   'T'},
 775         { TS_FLUSH,     'F'},
 776         { TS_BUSY,      'B'},
 777         { TS_XCLUDE,    'X'},
 778         { TS_TTSTOP,    'S'},
 779         { TS_TBLOCK,    'K'},
 780         { TS_ASYNC,     'Y'},
 781         { TS_BKSL,      'D'},
 782         { TS_ERASE,     'E'},
 783         { TS_LNCH,      'L'},
 784         { TS_TYPEN,     'P'},
 785         { TS_CNTTB,     'N'},
 786         { 0,            '\0'},
 787 };
 788
 789 void
 790 ttyprt(struct tty *tp)
 791 {
 792         char state[sizeof(ttystates) / sizeof(ttystates[0]) + 1];
 793         char dev[2 + 3 + 1 + 5 + 1]; /* 12bit major + 20bit minor */
 794         struct linesw t_linesw;
 795         const char *name;
 796         char buffer;
 797         pid_t pgid;
 798         int n, ovflw;
 799
 800         if (usenumflag || (name = devname(tp->t_dev, S_IFCHR)) == NULL) {
 801                 devprintf(dev, sizeof(dev), tp->t_dev);
 802                 name = dev;
 803         }
 804         ovflw = 0;
 805         PRWORD(ovflw, "%-*s", 7, 0, name);
 806         PRWORD(ovflw, " %*d", 3, 1, tp->t_rawq.c_cc);
 807         PRWORD(ovflw, " %*d", 4, 1, tp->t_canq.c_cc);
 808         PRWORD(ovflw, " %*d", 4, 1, tp->t_outq.c_cc);
 809         PRWORD(ovflw, " %*d", 5, 1, tp->t_hiwat);
 810         PRWORD(ovflw, " %*d", 4, 1, tp->t_lowat);
 811         PRWORD(ovflw, " %*d", 8, 1, tp->t_column);
 812         n = getflags(ttystates, state, tp->t_state);
 813         if (tp->t_wopen) {
 814                 state[n++] = 'W';
 815                 state[n] = '\0';
 816         }
 817         PRWORD(ovflw, " %-*s", 7, 1, state);
 818         PRWORD(ovflw, " %*lX", PTRSTRWIDTH + 1, 1, (u_long)tp->t_session);
 819         pgid = 0;
 820         if (tp->t_pgrp != NULL)
 821                 KGET2(&tp->t_pgrp->pg_id, &pgid, sizeof(pid_t), "pgid");
 822         PRWORD(ovflw, " %*d", 6, 1, pgid);
 823         KGET2(tp->t_linesw, &t_linesw, sizeof(t_linesw),
 824             "line discipline switch table");
 825         name = t_linesw.l_name;
 826         (void)putchar(' ');
 827         for (;;) {
 828                 KGET2(name, &buffer, sizeof(buffer), "line discipline name");
 829                 if (buffer == '\0')
 830                         break;
 831                 (void)putchar(buffer);
 832                 name++;
 833         }
 834         (void)putchar('\n');
 835 }
 836
 837 static const struct flagbit_desc filemode_flags[] = {
 838         { FREAD,        'R' },
 839         { FWRITE,       'W' },
 840         { FAPPEND,      'A' },
 841 #ifdef FSHLOCK  /* currently gone */
 842         { FSHLOCK,      'S' },
 843         { FEXLOCK,      'X' },
 844 #endif
 845         { FASYNC,       'I' },
 846         { 0,            '\0' },
 847 };
 848
 849 void
 850 filemode(void)
 851 {
 852         struct kinfo_file *ki;
 853         char flags[sizeof(filemode_flags) / sizeof(filemode_flags[0])];
 854         char *buf, *offset;
 855         int len, maxfile, nfile, ovflw;
 856
 857         KGET(FNL_MAXFILE, maxfile);
 858         if (totalflag) {
 859                 KGET(FNL_NFILE, nfile);
 860                 (void)printf("%3d/%3d files\n", nfile, maxfile);
 861                 return;
 862         }
 863         if (getfiles(&buf, &len, &offset) == -1)
 864                 return;
 865         /*
 866          * Getfiles returns in malloc'd memory to an array of kinfo_file2
 867          * structures.
 868          */
 869         nfile = len / sizeof(struct kinfo_file);
 870
 871         (void)printf("%d/%d open files\n", nfile, maxfile);
 872         (void)printf("%*s%s%*s TYPE    FLG     CNT  MSG  %*s%s%*s IFLG OFFSET\n",
 873             (PTRSTRWIDTH - 4) / 2, "", " LOC", (PTRSTRWIDTH - 4) / 2, "",
 874             (PTRSTRWIDTH - 4) / 2, "", "DATA", (PTRSTRWIDTH - 4) / 2, "");
 875         for (ki = (struct kinfo_file *)offset; nfile--; ki++) {
 876                 if ((unsigned)ki->ki_ftype >= sizeof(dtypes) / sizeof(dtypes[0]))
 877                         continue;
 878                 ovflw = 0;
 879                 (void)getflags(filemode_flags, flags, ki->ki_flag);
 880                 PRWORD(ovflw, "%*lx", PTRSTRWIDTH, 0, (long)ki->ki_fileaddr);
 881                 PRWORD(ovflw, " %-*s", 9, 1, dtypes[ki->ki_ftype]);
 882                 PRWORD(ovflw, " %*s", 6, 1, flags);
 883                 PRWORD(ovflw, " %*d", 5, 1, ki->ki_count);
 884                 PRWORD(ovflw, " %*d", 5, 1, ki->ki_msgcount);
 885                 PRWORD(ovflw, "  %*lx", PTRSTRWIDTH + 1, 2, (long)ki->ki_fdata);
 886                 PRWORD(ovflw, " %*x", 5, 1, 0);
 887                 if ((off_t)ki->ki_foffset < 0)
 888                         PRWORD(ovflw, "  %-*lld\n", PTRSTRWIDTH + 1, 2,
 889                             (long long)ki->ki_foffset);
 890                 else
 891                         PRWORD(ovflw, "  %-*lld\n", PTRSTRWIDTH + 1, 2,
 892                             (long long)ki->ki_foffset);
 893         }
 894         free(buf);
 895 }
 896
 897 int
 898 getfiles(char **abuf, int *alen, char **aoffset)
 899 {
 900         size_t len;
 901         int mib[6];
 902         char *buf;
 903         size_t offset;
 904
 905         /*
 906          * XXX
 907          * Add emulation of KINFO_FILE here.
 908          */
 909         if (memf != NULL)
 910                 errx(1, "files on dead kernel, not implemented");
 911
 912         mib[0] = CTL_KERN;
 913         mib[1] = KERN_FILE2;
 914         mib[2] = KERN_FILE_BYFILE;
 915         mib[3] = 0;
 916         mib[4] = sizeof(struct kinfo_file);
 917         mib[5] = 0;
 918         if (sysctl(mib, 6, NULL, &len, NULL, 0) == -1) {
 919                 warn("sysctl: KERN_FILE2");
 920                 return (-1);
 921         }
 922         /* We need to align (struct kinfo_file *) in the buffer. */
 923         offset = len % sizeof(off_t);
 924         mib[5] = len / sizeof(struct kinfo_file);
 925         if ((buf = malloc(len + offset)) == NULL)
 926                 err(1, "malloc");
 927         if (sysctl(mib, 6, buf + offset, &len, NULL, 0) == -1) {
 928                 warn("sysctl: 2nd KERN_FILE2");
 929                 return (-1);
 930         }
 931         *abuf = buf;
 932         *alen = len;
 933         *aoffset = (buf + offset);
 934         return (0);
 935 }
 936
 937 void
 938 usage(void)
 939 {
 940
 941         (void)fprintf(stderr,
 942             "usage: %s [-T|-f|-s|-t|-v] [-ghkmn] [-M core] [-N system]\n",
 943             getprogname());
 944         exit(1);
 945 }