1 /*- 2 * SPDX-License-Identifier: BSD-3-Clause 3 * 4 * Copyright (c) 1980, 1991, 1993, 1994 5 * The Regents of the University of California. All rights reserved. 6 * Copyright (c) 2002 Networks Associates Technologies, Inc. 7 * All rights reserved. 8 * 9 * Portions of this software were developed for the FreeBSD Project by 10 * ThinkSec AS and NAI Labs, the Security Research Division of Network 11 * Associates, Inc. under DARPA/SPAWAR contract N66001-01-C-8035 12 * ("CBOSS"), as part of the DARPA CHATS research program. 13 * 14 * Redistribution and use in source and binary forms, with or without 15 * modification, are permitted provided that the following conditions 16 * are met: 17 * 1. Redistributions of source code must retain the above copyright 18 * notice, this list of conditions and the following disclaimer. 19 * 2. Redistributions in binary form must reproduce the above copyright 20 * notice, this list of conditions and the following disclaimer in the 21 * documentation and/or other materials provided with the distribution. 22 * 3. Neither the name of the University nor the names of its contributors 23 * may be used to endorse or promote products derived from this software 24 * without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 27 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 28 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 29 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 30 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 31 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 32 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 33 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 34 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 35 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 36 * SUCH DAMAGE. 37 */ 38 39 #include <sys/param.h> 40 #include <sys/time.h> 41 #include <sys/file.h> 42 #include <sys/stat.h> 43 #include <sys/stdint.h> 44 #include <sys/ioctl.h> 45 #include <sys/tty.h> 46 #include <sys/blist.h> 47 48 #include <sys/sysctl.h> 49 #include <vm/vm_param.h> 50 51 #include <err.h> 52 #include <errno.h> 53 #include <fcntl.h> 54 #include <kvm.h> 55 #include <libutil.h> 56 #include <limits.h> 57 #include <nlist.h> 58 #include <stdio.h> 59 #include <stdlib.h> 60 #include <string.h> 61 #include <unistd.h> 62 63 enum { 64 NL_CONSTTY, 65 NL_MAXFILES, 66 NL_NFILES, 67 NL_TTY_LIST, 68 NL_MARKER 69 }; 70 71 static struct { 72 int order; 73 const char *name; 74 } namelist[] = { 75 { NL_CONSTTY, "_constty" }, 76 { NL_MAXFILES, "_maxfiles" }, 77 { NL_NFILES, "_openfiles" }, 78 { NL_TTY_LIST, "_tty_list" }, 79 { NL_MARKER, "" }, 80 }; 81 #define NNAMES (sizeof(namelist) / sizeof(*namelist)) 82 static struct nlist nl[NNAMES]; 83 84 #define SIZEHDR "Size" 85 86 static int humanflag; 87 static int usenumflag; 88 static int totalflag; 89 static int swapflag; 90 static char *nlistf; 91 static char *memf; 92 static kvm_t *kd; 93 94 static const char *usagestr; 95 96 static void filemode(void); 97 static int getfiles(struct xfile **, size_t *); 98 static void swapmode(void); 99 static void ttymode(void); 100 static void ttyprt(struct xtty *); 101 static void usage(void); 102 103 int 104 main(int argc, char *argv[]) 105 { 106 int ch, quit, ret; 107 int fileflag, ttyflag; 108 unsigned int i; 109 char buf[_POSIX2_LINE_MAX]; 110 const char *opts; 111 112 fileflag = swapflag = ttyflag = 0; 113 114 /* We will behave like good old swapinfo if thus invoked */ 115 opts = strrchr(argv[0], '/'); 116 if (opts) 117 opts++; 118 else 119 opts = argv[0]; 120 if (!strcmp(opts, "swapinfo")) { 121 swapflag = 1; 122 opts = "ghkmM:N:"; 123 usagestr = "swapinfo [-ghkm] [-M core [-N system]]"; 124 } else { 125 opts = "TM:N:fghkmnst"; 126 usagestr = "pstat [-Tfghkmnst] [-M core [-N system]]"; 127 } 128 129 while ((ch = getopt(argc, argv, opts)) != -1) 130 switch (ch) { 131 case 'f': 132 fileflag = 1; 133 break; 134 case 'g': 135 setenv("BLOCKSIZE", "1G", 1); 136 break; 137 case 'h': 138 humanflag = 1; 139 break; 140 case 'k': 141 setenv("BLOCKSIZE", "1K", 1); 142 break; 143 case 'm': 144 setenv("BLOCKSIZE", "1M", 1); 145 break; 146 case 'M': 147 memf = optarg; 148 break; 149 case 'N': 150 nlistf = optarg; 151 break; 152 case 'n': 153 usenumflag = 1; 154 break; 155 case 's': 156 ++swapflag; 157 break; 158 case 'T': 159 totalflag = 1; 160 break; 161 case 't': 162 ttyflag = 1; 163 break; 164 default: 165 usage(); 166 } 167 168 /* 169 * Initialize symbol names list. 170 */ 171 for (i = 0; i < NNAMES; i++) 172 nl[namelist[i].order].n_name = strdup(namelist[i].name); 173 174 if (memf != NULL) { 175 kd = kvm_openfiles(nlistf, memf, NULL, O_RDONLY, buf); 176 if (kd == NULL) 177 errx(1, "kvm_openfiles: %s", buf); 178 if ((ret = kvm_nlist(kd, nl)) != 0) { 179 if (ret == -1) 180 errx(1, "kvm_nlist: %s", kvm_geterr(kd)); 181 quit = 0; 182 for (i = 0; nl[i].n_name[0] != '\0'; ++i) 183 if (nl[i].n_value == 0) { 184 quit = 1; 185 warnx("undefined symbol: %s", 186 nl[i].n_name); 187 } 188 if (quit) 189 exit(1); 190 } 191 } 192 if (!(fileflag | ttyflag | swapflag | totalflag)) 193 usage(); 194 if (fileflag || totalflag) 195 filemode(); 196 if (ttyflag) 197 ttymode(); 198 if (swapflag || totalflag) 199 swapmode(); 200 exit (0); 201 } 202 203 static void 204 usage(void) 205 { 206 fprintf(stderr, "usage: %s\n", usagestr); 207 exit (1); 208 } 209 210 static const char fhdr32[] = 211 " LOC TYPE FLG CNT MSG DATA OFFSET\n"; 212 /* c0000000 ------ RWAI 123 123 c0000000 1000000000000000 */ 213 214 static const char fhdr64[] = 215 " LOC TYPE FLG CNT MSG DATA OFFSET\n"; 216 /* c000000000000000 ------ RWAI 123 123 c000000000000000 1000000000000000 */ 217 218 static const char hdr[] = 219 " LINE INQ CAN LIN LOW OUTQ USE LOW COL SESS PGID STATE\n"; 220 221 static void 222 ttymode_kvm(void) 223 { 224 TAILQ_HEAD(, tty) tl; 225 struct tty *tp, tty; 226 struct xtty xt; 227 228 (void)printf("%s", hdr); 229 bzero(&xt, sizeof xt); 230 xt.xt_size = sizeof xt; 231 if (kvm_read(kd, nl[NL_TTY_LIST].n_value, &tl, sizeof tl) != sizeof tl) 232 errx(1, "kvm_read(): %s", kvm_geterr(kd)); 233 tp = TAILQ_FIRST(&tl); 234 while (tp != NULL) { 235 if (kvm_read(kd, (u_long)tp, &tty, sizeof tty) != sizeof tty) 236 errx(1, "kvm_read(): %s", kvm_geterr(kd)); 237 xt.xt_insize = tty.t_inq.ti_nblocks * TTYINQ_DATASIZE; 238 xt.xt_incc = tty.t_inq.ti_linestart - tty.t_inq.ti_begin; 239 xt.xt_inlc = tty.t_inq.ti_end - tty.t_inq.ti_linestart; 240 xt.xt_inlow = tty.t_inlow; 241 xt.xt_outsize = tty.t_outq.to_nblocks * TTYOUTQ_DATASIZE; 242 xt.xt_outcc = tty.t_outq.to_end - tty.t_outq.to_begin; 243 xt.xt_outlow = tty.t_outlow; 244 xt.xt_column = tty.t_column; 245 /* xt.xt_pgid = ... */ 246 /* xt.xt_sid = ... */ 247 xt.xt_flags = tty.t_flags; 248 xt.xt_dev = (uint32_t)NODEV; 249 ttyprt(&xt); 250 tp = TAILQ_NEXT(&tty, t_list); 251 } 252 } 253 254 static void 255 ttymode_sysctl(void) 256 { 257 struct xtty *xttys; 258 size_t len; 259 unsigned int i, n; 260 261 (void)printf("%s", hdr); 262 if ((xttys = malloc(len = sizeof(*xttys))) == NULL) 263 err(1, "malloc()"); 264 while (sysctlbyname("kern.ttys", xttys, &len, 0, 0) == -1) { 265 if (errno != ENOMEM) 266 err(1, "sysctlbyname()"); 267 len *= 2; 268 if ((xttys = realloc(xttys, len)) == NULL) 269 err(1, "realloc()"); 270 } 271 n = len / sizeof(*xttys); 272 for (i = 0; i < n; i++) 273 ttyprt(&xttys[i]); 274 } 275 276 static void 277 ttymode(void) 278 { 279 280 if (kd != NULL) 281 ttymode_kvm(); 282 else 283 ttymode_sysctl(); 284 } 285 286 static struct { 287 int flag; 288 char val; 289 } ttystates[] = { 290 #if 0 291 { TF_NOPREFIX, 'N' }, 292 #endif 293 { TF_INITLOCK, 'I' }, 294 { TF_CALLOUT, 'C' }, 295 296 /* Keep these together -> 'Oi' and 'Oo'. */ 297 { TF_OPENED, 'O' }, 298 { TF_OPENED_IN, 'i' }, 299 { TF_OPENED_OUT, 'o' }, 300 { TF_OPENED_CONS, 'c' }, 301 302 { TF_GONE, 'G' }, 303 { TF_OPENCLOSE, 'B' }, 304 { TF_ASYNC, 'Y' }, 305 { TF_LITERAL, 'L' }, 306 307 /* Keep these together -> 'Hi' and 'Ho'. */ 308 { TF_HIWAT, 'H' }, 309 { TF_HIWAT_IN, 'i' }, 310 { TF_HIWAT_OUT, 'o' }, 311 312 { TF_STOPPED, 'S' }, 313 { TF_EXCLUDE, 'X' }, 314 { TF_BYPASS, 'l' }, 315 { TF_ZOMBIE, 'Z' }, 316 { TF_HOOK, 's' }, 317 318 /* Keep these together -> 'bi' and 'bo'. */ 319 { TF_BUSY, 'b' }, 320 { TF_BUSY_IN, 'i' }, 321 { TF_BUSY_OUT, 'o' }, 322 323 { 0, '\0'}, 324 }; 325 326 static void 327 ttyprt(struct xtty *xt) 328 { 329 int i, j; 330 const char *name; 331 332 if (xt->xt_size != sizeof *xt) 333 errx(1, "struct xtty size mismatch"); 334 if (usenumflag || xt->xt_dev == 0 || 335 (name = devname(xt->xt_dev, S_IFCHR)) == NULL) 336 printf("%#10jx ", (uintmax_t)xt->xt_dev); 337 else 338 printf("%10s ", name); 339 printf("%5zu %4zu %4zu %4zu %5zu %4zu %4zu %5u %5d %5d ", 340 xt->xt_insize, xt->xt_incc, xt->xt_inlc, 341 (xt->xt_insize - xt->xt_inlow), xt->xt_outsize, 342 xt->xt_outcc, (xt->xt_outsize - xt->xt_outlow), 343 MIN(xt->xt_column, 99999), xt->xt_sid, xt->xt_pgid); 344 for (i = j = 0; ttystates[i].flag; i++) 345 if (xt->xt_flags & ttystates[i].flag) { 346 putchar(ttystates[i].val); 347 j++; 348 } 349 if (j == 0) 350 putchar('-'); 351 putchar('\n'); 352 } 353 354 static void 355 filemode(void) 356 { 357 struct xfile *fp, *buf; 358 char flagbuf[16], *fbp; 359 int maxf, openf; 360 size_t len; 361 static char const * const dtypes[] = { "???", "inode", "socket", 362 "pipe", "fifo", "kqueue", "crypto" }; 363 int i; 364 int wid; 365 366 if (kd != NULL) { 367 if (kvm_read(kd, nl[NL_MAXFILES].n_value, 368 &maxf, sizeof maxf) != sizeof maxf || 369 kvm_read(kd, nl[NL_NFILES].n_value, 370 &openf, sizeof openf) != sizeof openf) 371 errx(1, "kvm_read(): %s", kvm_geterr(kd)); 372 } else { 373 len = sizeof(int); 374 if (sysctlbyname("kern.maxfiles", &maxf, &len, 0, 0) == -1 || 375 sysctlbyname("kern.openfiles", &openf, &len, 0, 0) == -1) 376 err(1, "sysctlbyname()"); 377 } 378 379 if (totalflag) { 380 (void)printf("%3d/%3d files\n", openf, maxf); 381 return; 382 } 383 if (getfiles(&buf, &len) == -1) 384 return; 385 openf = len / sizeof *fp; 386 387 (void)printf("%d/%d open files\n", openf, maxf); 388 printf(sizeof(uintptr_t) == 4 ? fhdr32 : fhdr64); 389 wid = (int)sizeof(uintptr_t) * 2; 390 for (fp = (struct xfile *)buf, i = 0; i < openf; ++fp, ++i) { 391 if ((size_t)fp->xf_type >= sizeof(dtypes) / sizeof(dtypes[0])) 392 continue; 393 (void)printf("%*jx", wid, (uintmax_t)(uintptr_t)fp->xf_file); 394 (void)printf(" %-6.6s", dtypes[fp->xf_type]); 395 fbp = flagbuf; 396 if (fp->xf_flag & FREAD) 397 *fbp++ = 'R'; 398 if (fp->xf_flag & FWRITE) 399 *fbp++ = 'W'; 400 if (fp->xf_flag & FAPPEND) 401 *fbp++ = 'A'; 402 if (fp->xf_flag & FASYNC) 403 *fbp++ = 'I'; 404 *fbp = '\0'; 405 (void)printf(" %4s %3d", flagbuf, fp->xf_count); 406 (void)printf(" %3d", fp->xf_msgcount); 407 (void)printf(" %*jx", wid, (uintmax_t)(uintptr_t)fp->xf_data); 408 (void)printf(" %*jx\n", (int)sizeof(fp->xf_offset) * 2, 409 (uintmax_t)fp->xf_offset); 410 } 411 free(buf); 412 } 413 414 static int 415 getfiles(struct xfile **abuf, size_t *alen) 416 { 417 struct xfile *buf; 418 size_t len; 419 int mib[2]; 420 421 /* 422 * XXX 423 * Add emulation of KINFO_FILE here. 424 */ 425 if (kd != NULL) 426 errx(1, "files on dead kernel, not implemented"); 427 428 mib[0] = CTL_KERN; 429 mib[1] = KERN_FILE; 430 if (sysctl(mib, 2, NULL, &len, NULL, 0) == -1) { 431 warn("sysctl: KERN_FILE"); 432 return (-1); 433 } 434 if ((buf = malloc(len)) == NULL) 435 errx(1, "malloc"); 436 if (sysctl(mib, 2, buf, &len, NULL, 0) == -1) { 437 warn("sysctl: KERN_FILE"); 438 return (-1); 439 } 440 *abuf = buf; 441 *alen = len; 442 return (0); 443 } 444 445 /* 446 * swapmode is based on a program called swapinfo written 447 * by Kevin Lahey <kml@rokkaku.atl.ga.us>. 448 */ 449 450 #define CONVERT(v) ((int64_t)(v) * pagesize / blocksize) 451 #define CONVERT_BLOCKS(v) ((int64_t)(v) * pagesize) 452 static struct kvm_swap swtot; 453 static int nswdev; 454 455 static void 456 print_swap_header(void) 457 { 458 int hlen; 459 long blocksize; 460 const char *header; 461 462 if (humanflag) { 463 header = SIZEHDR; 464 hlen = 8; /* as the hardcoded field width of values */ 465 } else { 466 header = getbsize(&hlen, &blocksize); 467 } 468 if (totalflag == 0) 469 (void)printf("%-15s %*s %8s %8s %8s\n", 470 "Device", hlen, header, 471 "Used", "Avail", "Capacity"); 472 } 473 474 static void 475 print_swap_line(const char *swdevname, intmax_t nblks, intmax_t bused, 476 intmax_t bavail, float bpercent) 477 { 478 char usedbuf[5]; 479 char availbuf[5]; 480 char sizebuf[5]; 481 int hlen, pagesize; 482 long blocksize; 483 484 pagesize = getpagesize(); 485 getbsize(&hlen, &blocksize); 486 487 printf("%-15s ", swdevname); 488 if (humanflag) { 489 humanize_number(sizebuf, sizeof(sizebuf), 490 CONVERT_BLOCKS(nblks), "", 491 HN_AUTOSCALE, HN_B | HN_NOSPACE | HN_DECIMAL); 492 humanize_number(usedbuf, sizeof(usedbuf), 493 CONVERT_BLOCKS(bused), "", 494 HN_AUTOSCALE, HN_B | HN_NOSPACE | HN_DECIMAL); 495 humanize_number(availbuf, sizeof(availbuf), 496 CONVERT_BLOCKS(bavail), "", 497 HN_AUTOSCALE, HN_B | HN_NOSPACE | HN_DECIMAL); 498 printf("%8s %8s %8s %5.0f%%\n", sizebuf, 499 usedbuf, availbuf, bpercent); 500 } else { 501 printf("%*jd %8jd %8jd %5.0f%%\n", hlen, 502 (intmax_t)CONVERT(nblks), 503 (intmax_t)CONVERT(bused), 504 (intmax_t)CONVERT(bavail), bpercent); 505 } 506 } 507 508 static void 509 print_swap(struct kvm_swap *ksw) 510 { 511 512 swtot.ksw_total += ksw->ksw_total; 513 swtot.ksw_used += ksw->ksw_used; 514 ++nswdev; 515 if (totalflag == 0) 516 print_swap_line(ksw->ksw_devname, ksw->ksw_total, 517 ksw->ksw_used, ksw->ksw_total - ksw->ksw_used, 518 (ksw->ksw_used * 100.0) / ksw->ksw_total); 519 } 520 521 static void 522 print_swap_total(void) 523 { 524 int hlen, pagesize; 525 long blocksize; 526 527 pagesize = getpagesize(); 528 getbsize(&hlen, &blocksize); 529 if (totalflag) { 530 blocksize = 1024 * 1024; 531 (void)printf("%jdM/%jdM swap space\n", 532 CONVERT(swtot.ksw_used), CONVERT(swtot.ksw_total)); 533 } else if (nswdev > 1) { 534 print_swap_line("Total", swtot.ksw_total, swtot.ksw_used, 535 swtot.ksw_total - swtot.ksw_used, 536 (swtot.ksw_used * 100.0) / swtot.ksw_total); 537 } 538 } 539 540 static void 541 swapmode_kvm(void) 542 { 543 struct kvm_swap kswap[16]; 544 int i, n; 545 546 n = kvm_getswapinfo(kd, kswap, sizeof kswap / sizeof kswap[0], 547 SWIF_DEV_PREFIX); 548 549 print_swap_header(); 550 for (i = 0; i < n; ++i) 551 print_swap(&kswap[i]); 552 print_swap_total(); 553 } 554 555 static void 556 swapmode_sysctl(void) 557 { 558 struct kvm_swap ksw; 559 struct xswdev xsw; 560 size_t mibsize, size; 561 int mib[16], n; 562 563 print_swap_header(); 564 mibsize = sizeof mib / sizeof mib[0]; 565 if (sysctlnametomib("vm.swap_info", mib, &mibsize) == -1) 566 err(1, "sysctlnametomib()"); 567 for (n = 0; ; ++n) { 568 mib[mibsize] = n; 569 size = sizeof xsw; 570 if (sysctl(mib, mibsize + 1, &xsw, &size, NULL, 0) == -1) 571 break; 572 if (xsw.xsw_version != XSWDEV_VERSION) 573 errx(1, "xswdev version mismatch"); 574 if (xsw.xsw_dev == NODEV) 575 snprintf(ksw.ksw_devname, sizeof ksw.ksw_devname, 576 "<NFSfile>"); 577 else 578 snprintf(ksw.ksw_devname, sizeof ksw.ksw_devname, 579 "/dev/%s", devname(xsw.xsw_dev, S_IFCHR)); 580 ksw.ksw_used = xsw.xsw_used; 581 ksw.ksw_total = xsw.xsw_nblks; 582 ksw.ksw_flags = xsw.xsw_flags; 583 print_swap(&ksw); 584 } 585 if (errno != ENOENT) 586 err(1, "sysctl()"); 587 print_swap_total(); 588 } 589 590 static void 591 swapmode(void) 592 { 593 if (kd != NULL) 594 swapmode_kvm(); 595 else 596 swapmode_sysctl(); 597 } 598