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