usr.sbin/pstat/pstat.c

   1 /*-
   2  * Copyright (c) 1980, 1991, 1993, 1994
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. Neither the name of the University nor the names of its contributors
  14  *    may be used to endorse or promote products derived from this software
  15  *    without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  *
  29  * @(#) Copyright (c) 1980, 1991, 1993, 1994 The Regents of the University of California.  All rights reserved.
  30  * @(#)pstat.c  8.16 (Berkeley) 5/9/95
  31  * $FreeBSD: src/usr.sbin/pstat/pstat.c,v 1.49.2.5 2002/07/12 09:12:49 des Exp $
  32  */
  33
  34 #include <sys/user.h>
  35 #include <sys/kinfo.h>
  36 #include <sys/param.h>
  37 #include <sys/time.h>
  38 #include <sys/vnode.h>
  39 #include <sys/ucred.h>
  40 #include <sys/file.h>
  41 #include <vfs/ufs/quota.h>
  42 #include <vfs/ufs/inode.h>
  43 #include <sys/mount.h>
  44 #include <sys/uio.h>
  45 #include <sys/namei.h>
  46 #include <sys/stat.h>
  47 #include <nfs/rpcv2.h>
  48 #include <nfs/nfsproto.h>
  49 #include <nfs/nfs.h>
  50 #include <nfs/nfsnode.h>
  51 #include <sys/ioctl.h>
  52 #include <sys/ioctl_compat.h>   /* XXX NTTYDISC is too well hidden */
  53 #include <sys/tty.h>
  54 #include <sys/conf.h>
  55 #include <sys/blist.h>
  56
  57 #include <sys/sysctl.h>
  58
  59 #include <err.h>
  60 #include <fcntl.h>
  61 #include <kvm.h>
  62 #include <limits.h>
  63 #include <nlist.h>
  64 #include <stdio.h>
  65 #include <stdlib.h>
  66 #include <string.h>
  67 #include <unistd.h>
  68 #include <libutil.h>
  69
  70 #ifdef USE_KCORE
  71 #  define KCORE_KINFO_WRAPPER
  72 #  include <kcore.h>
  73 #else
  74 #  include <kinfo.h>
  75 #endif
  76
  77 /*
  78  * Backoff to DECIMAL mode if humanize_number does not have FRACTIONAL mode.
  79  */
  80 #ifndef HN_FRACTIONAL
  81 #define HN_FRACTIONAL   HN_DECIMAL
  82 #endif
  83
  84 enum {
  85         NL_MOUNTLIST,
  86         NL_NUMVNODES,
  87         NL_RC_TTY,
  88         NL_NRC_TTY,
  89         NL_CY_TTY,
  90         NL_NCY_TTY,
  91         NL_SI_TTY,
  92         NL_SI_NPORTS,
  93 };
  94
  95 const size_t NL_LAST_MANDATORY = NL_NUMVNODES;
  96
  97 struct nlist nl[] = {
  98         { "_mountlist", 0, 0, 0, 0 },   /* address of head of mount list. */
  99         { "_numvnodes", 0, 0, 0, 0 },
 100         { "_rc_tty", 0, 0, 0, 0 },
 101         { "_nrc_tty", 0, 0, 0, 0 },
 102         { "_cy_tty", 0, 0, 0, 0 },
 103         { "_ncy_tty", 0, 0, 0, 0 },
 104         { "_si__tty", 0, 0, 0, 0 },
 105         { "_si_Nports", 0, 0, 0, 0 },
 106         { "", 0, 0, 0, 0 }
 107 };
 108
 109 int     usenumflag;
 110 int     totalflag;
 111 int     swapflag;
 112 int     humanflag;
 113 long    pagesize;
 114 long    blocksize;
 115 char    *nlistf = NULL;
 116 char    *memf   = NULL;
 117 kvm_t   *kd;
 118
 119 const char      *usagestr;
 120
 121 struct {
 122         int m_flag;
 123         const char *m_name;
 124 } mnt_flags[] = {
 125         { MNT_RDONLY, "rdonly" },
 126         { MNT_SYNCHRONOUS, "sync" },
 127         { MNT_NOEXEC, "noexec" },
 128         { MNT_NOSUID, "nosuid" },
 129         { MNT_NODEV, "nodev" },
 130         { MNT_ASYNC, "async" },
 131         { MNT_SUIDDIR, "suiddir" },
 132         { MNT_SOFTDEP, "softdep" },
 133         { MNT_NOSYMFOLLOW, "nosymfollow" },
 134         { MNT_NOATIME, "noatime" },
 135         { MNT_NOCLUSTERR, "noclusterread" },
 136         { MNT_NOCLUSTERW, "noclusterwrite" },
 137         { MNT_EXRDONLY, "exrdonly" },
 138         { MNT_EXPORTED, "exported" },
 139         { MNT_DEFEXPORTED, "defexported" },
 140         { MNT_EXPORTANON, "exportanon" },
 141         { MNT_EXKERB, "exkerb" },
 142         { MNT_EXPUBLIC, "public" },
 143         { MNT_LOCAL, "local" },
 144         { MNT_QUOTA, "quota" },
 145         { MNT_ROOTFS, "rootfs" },
 146         { MNT_USER, "user" },
 147         { MNT_IGNORE, "ignore" },
 148         { MNT_UPDATE, "update" },
 149         { MNT_DELEXPORT, "delexport" },
 150         { MNT_RELOAD, "reload" },
 151         { MNT_FORCE, "force" },
 152         { 0, NULL }
 153 };
 154
 155
 156 #define SVAR(var) __STRING(var) /* to force expansion */
 157 #define KGET(idx, var)                                                  \
 158         KGET1(idx, &var, sizeof(var), SVAR(var))
 159 #define KGET1(idx, p, s, msg)                                           \
 160         KGET2(nl[idx].n_value, p, s, msg)
 161 #define KGET2(addr, p, s, msg)                                          \
 162         if (kvm_read(kd, (u_long)(addr), p, s) != s)                    \
 163                 warnx("cannot read %s: %s", msg, kvm_geterr(kd))
 164 #define KGETN(idx, var)                                                 \
 165         KGET1N(idx, &var, sizeof(var), SVAR(var))
 166 #define KGET1N(idx, p, s, msg)                                          \
 167         KGET2N(nl[idx].n_value, p, s, msg)
 168 #define KGET2N(addr, p, s, msg)                                         \
 169         ((kvm_read(kd, (u_long)(addr), p, s) == s) ? 1 : 0)
 170 #define KGETRET(addr, p, s, msg)                                        \
 171         if (kvm_read(kd, (u_long)(addr), p, s) != s) {                  \
 172                 warnx("cannot read %s: %s", msg, kvm_geterr(kd));       \
 173                 return (0);                                             \
 174         }
 175
 176 void    filemode(void);
 177 int     getfiles(char **, int *);
 178 struct mount *
 179         getmnt(struct mount *);
 180 struct e_vnode *
 181         kinfo_vnodes(int *);
 182 struct e_vnode *
 183         loadvnodes(int *);
 184 void    mount_print(struct mount *);
 185 void    nfs_header(void);
 186 int     nfs_print(struct vnode *);
 187 void    swapmode(void);
 188 void    ttymode(void);
 189 void    ttyprt(struct tty *, int);
 190 void    ttytype(struct tty *, const char *, int, int, int);
 191 void    ufs_header(void);
 192 int     ufs_print(struct vnode *);
 193 static void usage(void);
 194 void    vnode_header(void);
 195 void    vnode_print(struct vnode *, struct vnode *);
 196 void    vnodemode(void);
 197
 198 static void Output(const char *name, int hlen,
 199                         struct kvm_swap *kswap, int flags);
 200
 201 int
 202 main(int argc, char **argv)
 203 {
 204         int ch, ret;
 205         int fileflag, ttyflag, vnodeflag;
 206         char buf[_POSIX2_LINE_MAX];
 207         const char *opts;
 208
 209         fileflag = swapflag = ttyflag = vnodeflag = 0;
 210
 211         /* We will behave like good old swapinfo if thus invoked */
 212         opts = strrchr(argv[0],'/');
 213         if (opts)
 214                 opts++;
 215         else
 216                 opts = argv[0];
 217         if (!strcmp(opts,"swapinfo")) {
 218                 swapflag = 1;
 219                 opts = "ghkmM:N:";
 220                 usagestr = "swapinfo [-ghkm] [-M core] [-N system]";
 221         } else {
 222                 opts = "TM:N:fhiknstv";
 223                 usagestr = "pstat [-Tfhknst] [-M core] [-N system]";
 224         }
 225
 226         while ((ch = getopt(argc, argv, opts)) != -1) {
 227                 switch (ch) {
 228                 case 'f':
 229                         fileflag = 1;
 230                         break;
 231                 case 'g':
 232                         if (setenv("BLOCKSIZE", "1G", 1) == -1)
 233                                 warn("setenv: cannot set BLOCKSIZE=1K");
 234                         break;
 235                 case 'k':
 236                         if (setenv("BLOCKSIZE", "1K", 1) == -1)
 237                                 warn("setenv: cannot set BLOCKSIZE=1K");
 238                         break;
 239                 case 'm':
 240                         if (setenv("BLOCKSIZE", "1M", 1) == -1)
 241                                 warn("setenv: cannot set BLOCKSIZE=1K");
 242                         break;
 243                 case 'h':
 244                         humanflag = 1;
 245                         break;
 246                 case 'M':
 247                         memf = optarg;
 248                         break;
 249                 case 'N':
 250                         nlistf = optarg;
 251                         break;
 252                 case 'n':
 253                         usenumflag = 1;
 254                         break;
 255                 case 's':
 256                         ++swapflag;
 257                         break;
 258                 case 'T':
 259                         totalflag = 1;
 260                         break;
 261                 case 't':
 262                         ttyflag = 1;
 263                         break;
 264                 case 'v':
 265                 case 'i':               /* Backward compatibility. */
 266                         errx(1, "vnode mode not supported");
 267 #if 0
 268                         vnodeflag = 1;
 269                         break;
 270 #endif
 271                 default:
 272                         usage();
 273                 }
 274         }
 275         argc -= optind;
 276         argv += optind;
 277
 278         /*
 279          * Discard setgid privileges if not the running kernel so that bad
 280          * guys can't print interesting stuff from kernel memory.
 281          */
 282         if (nlistf != NULL || memf != NULL)
 283                 setgid(getgid());
 284
 285         if ((kd = kvm_openfiles(nlistf, memf, NULL, O_RDONLY, buf)) == NULL)
 286                 errx(1, "kvm_openfiles: %s", buf);
 287 #ifdef USE_KCORE
 288         if (kcore_wrapper_open(nlistf, memf, buf))
 289                 errx(1, "kcore_open: %s", buf);
 290 #endif
 291         if ((ret = kvm_nlist(kd, nl)) != 0) {
 292                 size_t i;
 293                 int quit = 0;
 294
 295                 if (ret == -1)
 296                         errx(1, "kvm_nlist: %s", kvm_geterr(kd));
 297                 for (i = 0; i < NL_LAST_MANDATORY; i++) {
 298                         if (!nl[i].n_value) {
 299                                 quit = 1;
 300                                 warnx("undefined symbol: %s", nl[i].n_name);
 301                         }
 302                 }
 303                 if (quit)
 304                         exit(1);
 305         }
 306         if (!(fileflag | vnodeflag | ttyflag | swapflag | totalflag))
 307                 usage();
 308         if (fileflag || totalflag)
 309                 filemode();
 310         if (vnodeflag)
 311                 vnodemode();
 312         if (ttyflag)
 313                 ttymode();
 314         if (swapflag || totalflag)
 315                 swapmode();
 316         exit (0);
 317 }
 318
 319 static void
 320 usage(void)
 321 {
 322         fprintf(stderr, "usage: %s\n", usagestr);
 323         exit (1);
 324 }
 325
 326 struct e_vnode {
 327         struct vnode *avnode;
 328         struct vnode vnode;
 329 };
 330
 331 void
 332 vnodemode(void)
 333 {
 334         struct e_vnode *e_vnodebase, *endvnode, *evp;
 335         struct vnode *vp;
 336         struct mount *maddr, *mp = NULL;
 337         int numvnodes;
 338
 339         e_vnodebase = loadvnodes(&numvnodes);
 340         if (totalflag) {
 341                 printf("%7d vnodes\n", numvnodes);
 342                 return;
 343         }
 344         endvnode = e_vnodebase + numvnodes;
 345         printf("%d active vnodes\n", numvnodes);
 346
 347
 348 #define ST      mp->mnt_stat
 349         maddr = NULL;
 350         for (evp = e_vnodebase; evp < endvnode; evp++) {
 351                 vp = &evp->vnode;
 352                 if (vp->v_mount != maddr) {
 353                         /*
 354                          * New filesystem
 355                          */
 356                         if ((mp = getmnt(vp->v_mount)) == NULL)
 357                                 continue;
 358                         maddr = vp->v_mount;
 359                         mount_print(mp);
 360                         vnode_header();
 361                         if (!strcmp(ST.f_fstypename, "ufs") ||
 362                             !strcmp(ST.f_fstypename, "mfs"))
 363                                 ufs_header();
 364                         else if (!strcmp(ST.f_fstypename, "nfs"))
 365                                 nfs_header();
 366                         printf("\n");
 367                 }
 368                 vnode_print(evp->avnode, vp);
 369                 if (!strcmp(ST.f_fstypename, "ufs") ||
 370                     !strcmp(ST.f_fstypename, "mfs"))
 371                         ufs_print(vp);
 372                 else if (!strcmp(ST.f_fstypename, "nfs"))
 373                         nfs_print(vp);
 374                 printf("\n");
 375         }
 376         free(e_vnodebase);
 377 }
 378
 379 void
 380 vnode_header(void)
 381 {
 382         printf("ADDR     TYP VFLAG  USE HOLD");
 383 }
 384
 385 void
 386 vnode_print(struct vnode *avnode, struct vnode *vp)
 387 {
 388         const char *type;
 389         char flags[32];
 390         char *fp = flags;
 391         int flag;
 392         int refs;
 393
 394         /*
 395          * set type
 396          */
 397         switch (vp->v_type) {
 398         case VNON:
 399                 type = "non"; break;
 400         case VREG:
 401                 type = "reg"; break;
 402         case VDIR:
 403                 type = "dir"; break;
 404         case VBLK:
 405                 type = "blk"; break;
 406         case VCHR:
 407                 type = "chr"; break;
 408         case VLNK:
 409                 type = "lnk"; break;
 410         case VSOCK:
 411                 type = "soc"; break;
 412         case VFIFO:
 413                 type = "fif"; break;
 414         case VBAD:
 415                 type = "bad"; break;
 416         default:
 417                 type = "unk"; break;
 418         }
 419         /*
 420          * gather flags
 421          */
 422         flag = vp->v_flag;
 423         if (flag & VROOT)
 424                 *fp++ = 'R';
 425         if (flag & VTEXT)
 426                 *fp++ = 'T';
 427         if (flag & VSYSTEM)
 428                 *fp++ = 'S';
 429         if (flag & VISTTY)
 430                 *fp++ = 't';
 431 #ifdef VXLOCK
 432         if (flag & VXLOCK)
 433                 *fp++ = 'L';
 434         if (flag & VXWANT)
 435                 *fp++ = 'W';
 436 #endif
 437         if (flag & VOBJBUF)
 438                 *fp++ = 'V';
 439         if (flag & (VAGE0 | VAGE1))
 440                 *fp++ = 'a';
 441 #ifdef VDOOMED
 442         if (flag & VDOOMED)
 443                 *fp++ = 'D';
 444 #endif
 445         if (flag & VONWORKLST)
 446                 *fp++ = 'O';
 447 #ifdef VRECLAIMED
 448         if (flag & VINACTIVE)
 449                 *fp++ = 'I';
 450         if (flag & VRECLAIMED)
 451                 *fp++ = 'X';
 452 #endif
 453
 454         if (flag == 0)
 455                 *fp++ = '-';
 456         *fp = '\0';
 457
 458         /*
 459          * Convert SYSREF ref counts into something more
 460          * human readable for display.
 461          */
 462         refs = vp->v_refcnt;
 463         printf("%8lx %s %5s %08x %4d",
 464             (u_long)(void *)avnode, type, flags, refs, vp->v_auxrefs);
 465 }
 466
 467 void
 468 ufs_header(void)
 469 {
 470         printf(" FILEID IFLAG RDEV|SZ");
 471 }
 472
 473 int
 474 ufs_print(struct vnode *vp)
 475 {
 476         int flag;
 477         struct inode inode, *ip = &inode;
 478         char flagbuf[16], *flags = flagbuf;
 479         char *name;
 480         mode_t type;
 481
 482         KGETRET(VTOI(vp), &inode, sizeof(struct inode), "vnode's inode");
 483         flag = ip->i_flag;
 484         if (flag & IN_ACCESS)
 485                 *flags++ = 'A';
 486         if (flag & IN_CHANGE)
 487                 *flags++ = 'C';
 488         if (flag & IN_UPDATE)
 489                 *flags++ = 'U';
 490         if (flag & IN_MODIFIED)
 491                 *flags++ = 'M';
 492         if (flag & IN_RENAME)
 493                 *flags++ = 'R';
 494         if (flag & IN_SHLOCK)
 495                 *flags++ = 'S';
 496         if (flag & IN_EXLOCK)
 497                 *flags++ = 'E';
 498         if (flag & IN_HASHED)
 499                 *flags++ = 'H';
 500         if (flag & IN_LAZYMOD)
 501                 *flags++ = 'L';
 502         if (flag == 0)
 503                 *flags++ = '-';
 504         *flags = '\0';
 505
 506         printf(" %6ju %5s", (uintmax_t)ip->i_number, flagbuf);
 507         type = ip->i_mode & S_IFMT;
 508         if (S_ISCHR(ip->i_mode) || S_ISBLK(ip->i_mode))
 509                 if (usenumflag || ((name = devname(ip->i_rdev, type)) == NULL))
 510                         printf("   %2d,%-2d",
 511                             major(ip->i_rdev), minor(ip->i_rdev));
 512                 else
 513                         printf(" %7s", name);
 514         else
 515                 printf(" %7ju", (uintmax_t)ip->i_size);
 516         return (0);
 517 }
 518
 519 void
 520 nfs_header(void)
 521 {
 522         printf(" FILEID NFLAG RDEV|SZ");
 523 }
 524
 525 int
 526 nfs_print(struct vnode *vp)
 527 {
 528         struct nfsnode nfsnode, *np = &nfsnode;
 529         char flagbuf[16], *flags = flagbuf;
 530         int flag;
 531         char *name;
 532         mode_t type;
 533
 534         KGETRET(VTONFS(vp), &nfsnode, sizeof(nfsnode), "vnode's nfsnode");
 535         flag = np->n_flag;
 536         if (flag & NFLUSHWANT)
 537                 *flags++ = 'W';
 538         if (flag & NFLUSHINPROG)
 539                 *flags++ = 'P';
 540         if (flag & NLMODIFIED)
 541                 *flags++ = 'M';
 542         if (flag & NRMODIFIED)
 543                 *flags++ = 'R';
 544         if (flag & NWRITEERR)
 545                 *flags++ = 'E';
 546         if (flag & NQNFSEVICTED)
 547                 *flags++ = 'G';
 548         if (flag & NACC)
 549                 *flags++ = 'A';
 550         if (flag & NUPD)
 551                 *flags++ = 'U';
 552         if (flag & NCHG)
 553                 *flags++ = 'C';
 554         if (flag & NLOCKED)
 555                 *flags++ = 'L';
 556         if (flag & NWANTED)
 557                 *flags++ = 'w';
 558         if (flag == 0)
 559                 *flags++ = '-';
 560         *flags = '\0';
 561
 562 #define VT      np->n_vattr
 563         printf(" %6ju %5s", (uintmax_t)VT.va_fileid, flagbuf);
 564         type = VT.va_mode & S_IFMT;
 565         if (S_ISCHR(VT.va_mode) || S_ISBLK(VT.va_mode))
 566                 if (usenumflag || ((name = devname((VT.va_rmajor << 8) | VT.va_rminor, type)) == NULL))
 567                         printf("   %2d,%-2d",
 568                             VT.va_rmajor, VT.va_rminor);
 569                 else
 570                         printf(" %7s", name);
 571         else
 572                 printf(" %7ju", (uintmax_t)np->n_size);
 573         return (0);
 574 }
 575
 576 /*
 577  * Given a pointer to a mount structure in kernel space,
 578  * read it in and return a usable pointer to it.
 579  */
 580 struct mount *
 581 getmnt(struct mount *maddr)
 582 {
 583         static struct mtab {
 584                 struct mtab *next;
 585                 struct mount *maddr;
 586                 struct mount mount;
 587         } *mhead = NULL;
 588         struct mtab *mt;
 589
 590         for (mt = mhead; mt != NULL; mt = mt->next)
 591                 if (maddr == mt->maddr)
 592                         return (&mt->mount);
 593         if ((mt = malloc(sizeof(struct mtab))) == NULL)
 594                 errx(1, "malloc");
 595         KGETRET(maddr, &mt->mount, sizeof(struct mount), "mount table");
 596         mt->maddr = maddr;
 597         mt->next = mhead;
 598         mhead = mt;
 599         return (&mt->mount);
 600 }
 601
 602 void
 603 mount_print(struct mount *mp)
 604 {
 605         int flags;
 606
 607 #define ST      mp->mnt_stat
 608         printf("*** MOUNT %s %s on %s", ST.f_fstypename,
 609             ST.f_mntfromname, ST.f_mntonname);
 610         if ((flags = mp->mnt_flag)) {
 611                 int i;
 612                 const char *sep = " (";
 613
 614                 for (i = 0; mnt_flags[i].m_flag; i++) {
 615                         if (flags & mnt_flags[i].m_flag) {
 616                                 printf("%s%s", sep, mnt_flags[i].m_name);
 617                                 flags &= ~mnt_flags[i].m_flag;
 618                                 sep = ",";
 619                         }
 620                 }
 621                 if (flags)
 622                         printf("%sunknown_flags:%x", sep, flags);
 623                 printf(")");
 624         }
 625         printf("\n");
 626 #undef ST
 627 }
 628
 629 struct e_vnode *
 630 loadvnodes(int *avnodes)
 631 {
 632         int mib[2];
 633         size_t copysize;
 634         struct e_vnode *vnodebase;
 635
 636         if (memf != NULL) {
 637                 /*
 638                  * do it by hand
 639                  */
 640                 return (kinfo_vnodes(avnodes));
 641         }
 642         mib[0] = CTL_KERN;
 643         mib[1] = KERN_VNODE;
 644         if (sysctl(mib, 2, NULL, &copysize, NULL, 0) == -1)
 645                 err(1, "sysctl: KERN_VNODE");
 646         if ((vnodebase = malloc(copysize)) == NULL)
 647                 errx(1, "malloc");
 648         if (sysctl(mib, 2, vnodebase, &copysize, NULL, 0) == -1)
 649                 err(1, "sysctl: KERN_VNODE");
 650         if (copysize % sizeof(struct e_vnode))
 651                 errx(1, "vnode size mismatch");
 652         *avnodes = copysize / sizeof(struct e_vnode);
 653
 654         return (vnodebase);
 655 }
 656
 657 /*
 658  * simulate what a running kernel does in in kinfo_vnode
 659  */
 660 struct e_vnode *
 661 kinfo_vnodes(int *avnodes)
 662 {
 663         struct mntlist mountlist;
 664         struct mount *mp, mounth, *mp_next;
 665         struct vnode *vp, vnode, *vp_next;
 666         char *vbuf, *evbuf, *bp;
 667         int num, numvnodes;
 668
 669 #define VPTRSZ  sizeof(struct vnode *)
 670 #define VNODESZ sizeof(struct vnode)
 671
 672         KGET(NL_NUMVNODES, numvnodes);
 673         if ((vbuf = malloc((numvnodes + 20) * (VPTRSZ + VNODESZ))) == NULL)
 674                 errx(1, "malloc");
 675         bp = vbuf;
 676         evbuf = vbuf + (numvnodes + 20) * (VPTRSZ + VNODESZ);
 677         KGET(NL_MOUNTLIST, mountlist);
 678         for (num = 0, mp = TAILQ_FIRST(&mountlist); ; mp = mp_next) {
 679                 KGET2(mp, &mounth, sizeof(mounth), "mount entry");
 680                 mp_next = TAILQ_NEXT(&mounth, mnt_list);
 681                 for (vp = TAILQ_FIRST(&mounth.mnt_nvnodelist);
 682                     vp != NULL; vp = vp_next) {
 683                         KGET2(vp, &vnode, sizeof(vnode), "vnode");
 684                         vp_next = TAILQ_NEXT(&vnode, v_nmntvnodes);
 685                         if ((bp + VPTRSZ + VNODESZ) > evbuf)
 686                                 /* XXX - should realloc */
 687                                 errx(1, "no more room for vnodes");
 688                         memmove(bp, &vp, VPTRSZ);
 689                         bp += VPTRSZ;
 690                         memmove(bp, &vnode, VNODESZ);
 691                         bp += VNODESZ;
 692                         num++;
 693                 }
 694                 if (mp == TAILQ_LAST(&mountlist, mntlist))
 695                         break;
 696         }
 697         *avnodes = num;
 698         return ((struct e_vnode *)vbuf);
 699 }
 700
 701 char hdr[] =
 702 "  LINE RAW CAN OUT IHIWT ILOWT OHWT LWT     COL STATE  SESS      PGID DISC\n";
 703 int ttyspace = 128;
 704
 705 void
 706 ttymode(void)
 707 {
 708         struct tty *tty;
 709         struct tty ttyb[1000];
 710         int error;
 711         size_t len, i;
 712
 713         printf("%s", hdr);
 714         len = sizeof(ttyb);
 715         error = sysctlbyname("kern.ttys", &ttyb, &len, 0, 0);
 716         if (!error) {
 717                 len /= sizeof(ttyb[0]);
 718                 for (i = 0; i < len; i++) {
 719                         ttyprt(&ttyb[i], 0);
 720                 }
 721         }
 722         if ((tty = malloc(ttyspace * sizeof(*tty))) == NULL)
 723                 errx(1, "malloc");
 724         if (nl[NL_NRC_TTY].n_type != 0)
 725                 ttytype(tty, "rc", NL_RC_TTY, NL_NRC_TTY, 0);
 726         if (nl[NL_NCY_TTY].n_type != 0)
 727                 ttytype(tty, "cy", NL_CY_TTY, NL_NCY_TTY, 0);
 728         if (nl[NL_SI_NPORTS].n_type != 0)
 729                 ttytype(tty, "si", NL_SI_TTY, NL_SI_NPORTS, 1);
 730         free(tty);
 731 }
 732
 733 void
 734 ttytype(struct tty *tty, const char *name, int type, int number, int indir)
 735 {
 736         struct tty *tp;
 737         int ntty;
 738         struct tty **ttyaddr;
 739
 740         if (tty == NULL)
 741                 return;
 742         KGET(number, ntty);
 743         printf("%d %s %s\n", ntty, name, (ntty == 1) ? "line" : "lines");
 744         if (ntty > ttyspace) {
 745                 ttyspace = ntty;
 746                 if ((tty = realloc(tty, ttyspace * sizeof(*tty))) == NULL)
 747                         errx(1, "realloc");
 748         }
 749         if (indir) {
 750                 KGET(type, ttyaddr);
 751                 KGET2(ttyaddr, tty, (ssize_t)(ntty * sizeof(struct tty)),
 752                       "tty structs");
 753         } else {
 754                 KGET1(type, tty, (ssize_t)(ntty * sizeof(struct tty)),
 755                       "tty structs");
 756         }
 757         printf("%s", hdr);
 758         for (tp = tty; tp < &tty[ntty]; tp++)
 759                 ttyprt(tp, tp - tty);
 760 }
 761
 762 struct {
 763         int flag;
 764         char val;
 765 } ttystates[] = {
 766 #ifdef TS_WOPEN
 767         { TS_WOPEN,     'W'},
 768 #endif
 769         { TS_ISOPEN,    'O'},
 770         { TS_CARR_ON,   'C'},
 771 #ifdef TS_CONNECTED
 772         { TS_CONNECTED, 'c'},
 773 #endif
 774         { TS_TIMEOUT,   'T'},
 775         { TS_FLUSH,     'F'},
 776         { TS_BUSY,      'B'},
 777 #ifdef TS_ASLEEP
 778         { TS_ASLEEP,    'A'},
 779 #endif
 780 #ifdef TS_SO_OLOWAT
 781         { TS_SO_OLOWAT, 'A'},
 782 #endif
 783 #ifdef TS_SO_OCOMPLETE
 784         { TS_SO_OCOMPLETE, 'a'},
 785 #endif
 786         { TS_XCLUDE,    'X'},
 787         { TS_TTSTOP,    'S'},
 788 #ifdef TS_CAR_OFLOW
 789         { TS_CAR_OFLOW, 'm'},
 790 #endif
 791 #ifdef TS_CTS_OFLOW
 792         { TS_CTS_OFLOW, 'o'},
 793 #endif
 794 #ifdef TS_DSR_OFLOW
 795         { TS_DSR_OFLOW, 'd'},
 796 #endif
 797         { TS_TBLOCK,    'K'},
 798         { TS_ASYNC,     'Y'},
 799         { TS_BKSL,      'D'},
 800         { TS_ERASE,     'E'},
 801         { TS_LNCH,      'L'},
 802         { TS_TYPEN,     'P'},
 803         { TS_CNTTB,     'N'},
 804 #ifdef TS_CAN_BYPASS_L_RINT
 805         { TS_CAN_BYPASS_L_RINT, 'l'},
 806 #endif
 807 #ifdef TS_SNOOP
 808         { TS_SNOOP,     's'},
 809 #endif
 810 #ifdef TS_ZOMBIE
 811         { TS_ZOMBIE,    'Z'},
 812 #endif
 813         { 0,           '\0'},
 814 };
 815
 816 void
 817 ttyprt(struct tty *tp, int line)
 818 {
 819         int i, j;
 820         pid_t pgid;
 821         char *name, state[20];
 822         dev_t dev;
 823
 824         dev = (uintptr_t)tp->t_dev & 0xffff; /* XXX t_dev is really dev_t */
 825
 826         if (usenumflag || dev == 0 || (name = devname(dev, S_IFCHR)) == NULL)
 827                 printf("%7d ", line);
 828         else
 829                 printf("%7s ", name);
 830         printf("%2d %3d ", tp->t_rawq.c_cc, tp->t_canq.c_cc);
 831         printf("%3d %5d %5d %4d %3d %7d ", tp->t_outq.c_cc,
 832                 tp->t_ihiwat, tp->t_ilowat, tp->t_ohiwat, tp->t_olowat,
 833                 tp->t_column);
 834         for (i = j = 0; ttystates[i].flag; i++)
 835                 if (tp->t_state&ttystates[i].flag)
 836                         state[j++] = ttystates[i].val;
 837         if (j == 0)
 838                 state[j++] = '-';
 839         state[j] = '\0';
 840         printf("%-6s %8lx", state, (u_long)(void *)tp->t_session);
 841         pgid = 0;
 842         if (tp->t_pgrp != NULL)
 843                 KGET2(&tp->t_pgrp->pg_id, &pgid, sizeof(pid_t), "pgid");
 844         printf("%6d ", pgid);
 845         switch (tp->t_line) {
 846         case TTYDISC:
 847                 printf("term\n");
 848                 break;
 849         case NTTYDISC:
 850                 printf("ntty\n");
 851                 break;
 852         case SLIPDISC:
 853                 printf("slip\n");
 854                 break;
 855         case PPPDISC:
 856                 printf("ppp\n");
 857                 break;
 858         default:
 859                 printf("%d\n", tp->t_line);
 860                 break;
 861         }
 862 }
 863
 864 void
 865 filemode(void)
 866 {
 867         struct kinfo_file *fp, *ofp;
 868         size_t len;
 869         char flagbuf[16], *fbp;
 870         int maxfile, nfile;
 871         static const char *dtypes[] = { "???", "inode", "socket" };
 872
 873         if (kinfo_get_maxfiles(&maxfile))
 874                 err(1, "kinfo_get_maxfiles");
 875         if (totalflag) {
 876                 if (kinfo_get_openfiles(&nfile))
 877                         err(1, "kinfo_get_openfiles");
 878                 printf("%3d/%3d files\n", nfile, maxfile);
 879                 return;
 880         }
 881         if (kinfo_get_files(&fp, &len))
 882                 err(1, "kinfo_get_files");
 883         ofp = fp;
 884
 885         printf("%zu/%d open files\n", len, maxfile);
 886         printf("   LOC   TYPE    FLG     CNT  MSG    DATA    OFFSET\n");
 887         for (; len-- > 0; fp++) {
 888                 if ((unsigned)fp->f_type > DTYPE_SOCKET)
 889                         continue;
 890                 printf("%p ", fp->f_file);
 891                 printf("%-8.8s", dtypes[fp->f_type]);
 892                 fbp = flagbuf;
 893                 if (fp->f_flag & FREAD)
 894                         *fbp++ = 'R';
 895                 if (fp->f_flag & FWRITE)
 896                         *fbp++ = 'W';
 897                 if (fp->f_flag & FAPPEND)
 898                         *fbp++ = 'A';
 899 #ifdef FSHLOCK  /* currently gone */
 900                 if (fp->f_flag & FSHLOCK)
 901                         *fbp++ = 'S';
 902                 if (fp->f_flag & FEXLOCK)
 903                         *fbp++ = 'X';
 904 #endif
 905                 if (fp->f_flag & FASYNC)
 906                         *fbp++ = 'I';
 907                 *fbp = '\0';
 908                 printf("%6s  %3d", flagbuf, fp->f_count);
 909                 printf("  %3d", fp->f_msgcount);
 910                 printf("  %8lx", (u_long)(void *)fp->f_data);
 911                 if (fp->f_offset < 0)
 912                         printf("  %jx\n", (uintmax_t)fp->f_offset);
 913                 else
 914                         printf("  %jd\n", (intmax_t)fp->f_offset);
 915         }
 916         free(ofp);
 917 }
 918
 919 /*
 920  * swapmode is based on a program called swapinfo written
 921  * by Kevin Lahey <kml@rokkaku.atl.ga.us>.
 922  */
 923 void
 924 swapmode(void)
 925 {
 926         struct kvm_swap kswap[16];
 927         int i;
 928         int n;
 929         const char *header;
 930         int hlen;
 931
 932         pagesize = getpagesize();
 933         n = kvm_getswapinfo(
 934             kd,
 935             kswap,
 936             sizeof(kswap)/sizeof(kswap[0]),
 937             ((swapflag > 1) ? SWIF_DUMP_TREE : 0) | SWIF_DEV_PREFIX
 938         );
 939
 940 #define CONVERT(v)      ((long)((quad_t)(v) * pagesize / blocksize))
 941 #define CONVERTB(v)     ((long)((quad_t)(v) * pagesize))
 942
 943         if (humanflag) {
 944                 hlen = 9;
 945                 header = "   Blocks";
 946         } else {
 947                 header = getbsize(&hlen, &blocksize);
 948         }
 949
 950         if (totalflag == 0) {
 951                 printf("%-15s %*s %8s %8s %8s  %s\n",
 952                     "Device", hlen, header,
 953                     "Used", "Avail", "Capacity", "Type");
 954
 955                 for (i = 0; i < n; ++i) {
 956                         Output(kswap[i].ksw_devname, hlen, &kswap[i], 1);
 957                 }
 958         }
 959
 960         if (totalflag) {
 961                 if (humanflag) {
 962                         char buf1[6];
 963                         char buf2[6];
 964                         humanize_number(buf1, sizeof(buf1),
 965                                         CONVERTB(kswap[n].ksw_used),
 966                                         "",
 967                                         HN_AUTOSCALE, HN_NOSPACE |
 968                                                       HN_FRACTIONAL);
 969                         humanize_number(buf2, sizeof(buf2),
 970                                         CONVERTB(kswap[n].ksw_total),
 971                                         "",
 972                                         HN_AUTOSCALE, HN_NOSPACE |
 973                                                       HN_FRACTIONAL);
 974                         printf("%s/%s swap space\n", buf1, buf2);
 975                 } else {
 976                         blocksize = 1024 * 1024;
 977                         printf("%ldM/%ldM swap space\n",
 978                                CONVERT(kswap[n].ksw_used),
 979                                CONVERT(kswap[n].ksw_total));
 980                 }
 981         } else if (n > 1) {
 982                 Output("Total", hlen, &kswap[n], 0);
 983         }
 984 }
 985
 986 static
 987 void
 988 Output(const char *name, int hlen, struct kvm_swap *kswap, int flags)
 989 {
 990         char buf1[32];
 991         char buf2[32];
 992         char buf3[32];
 993
 994         if (humanflag) {
 995                 humanize_number(buf1, 6,
 996                                 CONVERTB(kswap->ksw_total),
 997                                 "",
 998                                 HN_AUTOSCALE,
 999                                 HN_NOSPACE | HN_FRACTIONAL);
1000                 humanize_number(buf2, 6,
1001                                 CONVERTB(kswap->ksw_used),
1002                                 "",
1003                                 HN_AUTOSCALE,
1004                                 HN_NOSPACE | HN_FRACTIONAL);
1005                 humanize_number(buf3, 6,
1006                                 CONVERTB(kswap->ksw_total -
1007                                          kswap->ksw_used),
1008                                 "",
1009                                 HN_AUTOSCALE,
1010                                 HN_NOSPACE | HN_FRACTIONAL);
1011         } else {
1012                 snprintf(buf1, sizeof(buf1), "%*ld",
1013                          hlen,
1014                          CONVERT(kswap->ksw_total));
1015                 snprintf(buf2, sizeof(buf2), "%8ld",
1016                          CONVERT(kswap->ksw_used));
1017                 snprintf(buf3, sizeof(buf2), "%8ld",
1018                          CONVERT(kswap->ksw_total -
1019                                  kswap->ksw_used));
1020         }
1021         printf("%-15s %*s ", name, hlen, buf1);
1022         printf("%8s %8s %5.0f%%",
1023                buf2,
1024                buf3,
1025                (double)kswap->ksw_used * 100.0 / (double)kswap->ksw_total);
1026         if (flags) {
1027                 printf("    %s",
1028                        ((kswap->ksw_flags & SW_SEQUENTIAL) ?
1029                         "Sequential" : "Interleaved"));
1030         }
1031         printf("\n");
1032 }