pstat.c revision 1.69
1 /* $NetBSD: pstat.c,v 1.69 2002/02/22 05:43:20 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.69 2002/02/22 05:43:20 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 goto out; 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 364 out: 365 free(e_vnodebase); 366 } 367 368 void 369 vnode_header() 370 { 371 372 (void)printf("%-*s TYP VFLAG USE HOLD TAG NPAGE", 373 PTRSTRWIDTH, "ADDR"); 374 } 375 376 int 377 vnode_print(avnode, vp) 378 struct vnode *avnode; 379 struct vnode *vp; 380 { 381 char *type, flags[16]; 382 char *fp = flags; 383 int flag, ovflw; 384 385 /* 386 * set type 387 */ 388 switch (vp->v_type) { 389 case VNON: 390 type = "non"; break; 391 case VREG: 392 type = "reg"; break; 393 case VDIR: 394 type = "dir"; break; 395 case VBLK: 396 type = "blk"; break; 397 case VCHR: 398 type = "chr"; break; 399 case VLNK: 400 type = "lnk"; break; 401 case VSOCK: 402 type = "soc"; break; 403 case VFIFO: 404 type = "fif"; break; 405 case VBAD: 406 type = "bad"; break; 407 default: 408 type = "unk"; break; 409 } 410 /* 411 * gather flags 412 */ 413 flag = vp->v_flag; 414 if (flag & VROOT) 415 *fp++ = 'R'; 416 if (flag & VTEXT) 417 *fp++ = 'T'; 418 if (flag & VSYSTEM) 419 *fp++ = 'S'; 420 if (flag & VISTTY) 421 *fp++ = 'I'; 422 if (flag & VEXECMAP) 423 *fp++ = 'E'; 424 if (flag & VXLOCK) 425 *fp++ = 'L'; 426 if (flag & VXWANT) 427 *fp++ = 'W'; 428 if (flag & VBWAIT) 429 *fp++ = 'B'; 430 if (flag & VALIASED) 431 *fp++ = 'A'; 432 if (flag & VDIROP) 433 *fp++ = 'D'; 434 if (flag & VLAYER) 435 *fp++ = 'Y'; 436 if (flag & VONWORKLST) 437 *fp++ = 'O'; 438 if (flag == 0) 439 *fp++ = '-'; 440 *fp = '\0'; 441 442 ovflw = 0; 443 PRWORD(ovflw, "%*lx", PTRSTRWIDTH, 0, (long)avnode); 444 PRWORD(ovflw, " %*s", 4, 1, type); 445 PRWORD(ovflw, " %*s", 6, 1, flags); 446 PRWORD(ovflw, " %*ld", 5, 1, (long)vp->v_usecount); 447 PRWORD(ovflw, " %*ld", 5, 1, (long)vp->v_holdcnt); 448 PRWORD(ovflw, " %*d", 4, 1, vp->v_tag); 449 PRWORD(ovflw, " %*d", 6, 1, vp->v_uobj.uo_npages); 450 return (ovflw); 451 } 452 453 void 454 ufs_getflags(vp, ip, flags) 455 struct vnode *vp; 456 struct inode *ip; 457 char *flags; 458 { 459 int flag; 460 461 /* 462 * XXX need to to locking state. 463 */ 464 465 flag = ip->i_flag; 466 if (flag & IN_ACCESS) 467 *flags++ = 'A'; 468 if (flag & IN_CHANGE) 469 *flags++ = 'C'; 470 if (flag & IN_UPDATE) 471 *flags++ = 'U'; 472 if (flag & IN_MODIFIED) 473 *flags++ = 'M'; 474 if (flag & IN_ACCESSED) 475 *flags++ = 'a'; 476 if (flag & IN_RENAME) 477 *flags++ = 'R'; 478 if (flag & IN_SHLOCK) 479 *flags++ = 'S'; 480 if (flag & IN_EXLOCK) 481 *flags++ = 'E'; 482 if (flag & IN_CLEANING) 483 *flags++ = 'c'; 484 if (flag & IN_ADIROP) 485 *flags++ = 'a'; 486 if (flag & IN_SPACECOUNTED) 487 *flags++ = 's'; 488 if (flag == 0) 489 *flags++ = '-'; 490 *flags = '\0'; 491 } 492 493 void 494 ufs_header() 495 { 496 497 (void)printf(" FILEID IFLAG RDEV|SZ"); 498 } 499 500 int 501 ufs_print(vp, ovflw) 502 struct vnode *vp; 503 int ovflw; 504 { 505 struct inode inode, *ip = &inode; 506 char buf[16], *name; 507 mode_t type; 508 509 KGETRET(VTOI(vp), &inode, sizeof(struct inode), "vnode's inode"); 510 ufs_getflags(vp, ip, buf); 511 PRWORD(ovflw, " %*d", 7, 1, ip->i_number); 512 PRWORD(ovflw, " %*s", 6, 1, buf); 513 type = ip->i_ffs_mode & S_IFMT; 514 if (S_ISCHR(ip->i_ffs_mode) || S_ISBLK(ip->i_ffs_mode)) { 515 if (usenumflag || 516 (name = devname(ip->i_ffs_rdev, type)) == NULL) { 517 snprintf(buf, sizeof(buf), "%d,%d", 518 major(ip->i_ffs_rdev), minor(ip->i_ffs_rdev)); 519 name = buf; 520 } 521 PRWORD(ovflw, " %*s", 8, 1, name); 522 } else 523 PRWORD(ovflw, " %*lld", 8, 1, (long long)ip->i_ffs_size); 524 return (0); 525 } 526 527 int 528 ext2fs_print(vp, ovflw) 529 struct vnode *vp; 530 int ovflw; 531 { 532 struct inode inode, *ip = &inode; 533 char buf[16], *name; 534 mode_t type; 535 536 KGETRET(VTOI(vp), &inode, sizeof(struct inode), "vnode's inode"); 537 ufs_getflags(vp, ip, buf); 538 PRWORD(ovflw, " %*d", 7, 1, ip->i_number); 539 PRWORD(ovflw, " %*s", 6, 1, buf); 540 type = ip->i_e2fs_mode & S_IFMT; 541 if (S_ISCHR(ip->i_e2fs_mode) || S_ISBLK(ip->i_e2fs_mode)) { 542 if (usenumflag || 543 (name = devname(ip->i_e2fs_rdev, type)) == NULL) { 544 snprintf(buf, sizeof(buf), "%d,%d", 545 major(ip->i_e2fs_rdev), minor(ip->i_e2fs_rdev)); 546 name = buf; 547 } 548 PRWORD(ovflw, " %*s", 8, 1, name); 549 } else 550 PRWORD(ovflw, " %*u", 8, 1, (u_int)ip->i_e2fs_size); 551 return (0); 552 } 553 554 void 555 nfs_header() 556 { 557 558 (void)printf(" FILEID NFLAG RDEV|SZ"); 559 } 560 561 int 562 nfs_print(vp, ovflw) 563 struct vnode *vp; 564 int ovflw; 565 { 566 struct nfsnode nfsnode, *np = &nfsnode; 567 char buf[16], *flags = buf; 568 int flag; 569 struct vattr va; 570 char *name; 571 mode_t type; 572 573 KGETRET(VTONFS(vp), &nfsnode, sizeof(nfsnode), "vnode's nfsnode"); 574 flag = np->n_flag; 575 if (flag & NFLUSHWANT) 576 *flags++ = 'W'; 577 if (flag & NFLUSHINPROG) 578 *flags++ = 'P'; 579 if (flag & NMODIFIED) 580 *flags++ = 'M'; 581 if (flag & NWRITEERR) 582 *flags++ = 'E'; 583 if (flag & NQNFSNONCACHE) 584 *flags++ = 'X'; 585 if (flag & NQNFSWRITE) 586 *flags++ = 'O'; 587 if (flag & NQNFSEVICTED) 588 *flags++ = 'G'; 589 if (flag & NACC) 590 *flags++ = 'A'; 591 if (flag & NUPD) 592 *flags++ = 'U'; 593 if (flag & NCHG) 594 *flags++ = 'C'; 595 if (flag == 0) 596 *flags++ = '-'; 597 *flags = '\0'; 598 599 KGETRET(np->n_vattr, &va, sizeof(va), "vnode attr"); 600 PRWORD(ovflw, " %*ld", 7, 1, (long)va.va_fileid); 601 PRWORD(ovflw, " %*s", 6, 1, buf); 602 switch (va.va_type) { 603 case VCHR: 604 type = S_IFCHR; 605 goto device; 606 607 case VBLK: 608 type = S_IFBLK; 609 device: 610 if (usenumflag || (name = devname(va.va_rdev, type)) == NULL) { 611 (void)snprintf(buf, sizeof(buf), "%d,%d", 612 major(va.va_rdev), minor(va.va_rdev)); 613 name = buf; 614 } 615 PRWORD(ovflw, " %*s", 8, 1, name); 616 break; 617 default: 618 PRWORD(ovflw, " %*lld", 8, 1, (long long)np->n_size); 619 break; 620 } 621 return (0); 622 } 623 624 void 625 layer_header() 626 { 627 628 (void)printf(" %*s", PTRSTRWIDTH, "LOWER"); 629 } 630 631 int 632 layer_print(vp, ovflw) 633 struct vnode *vp; 634 int ovflw; 635 { 636 struct layer_node lnode, *lp = &lnode; 637 638 KGETRET(VTOLAYER(vp), &lnode, sizeof(lnode), "layer vnode"); 639 640 PRWORD(ovflw, " %*lx", PTRSTRWIDTH + 1, 1, (long)lp->layer_lowervp); 641 return (0); 642 } 643 644 void 645 union_header() 646 { 647 648 (void)printf(" %*s %*s", PTRSTRWIDTH, "UPPER", PTRSTRWIDTH, "LOWER"); 649 } 650 651 int 652 union_print(vp, ovflw) 653 struct vnode *vp; 654 int ovflw; 655 { 656 struct union_node unode, *up = &unode; 657 658 KGETRET(VTOUNION(vp), &unode, sizeof(unode), "vnode's unode"); 659 660 PRWORD(ovflw, " %*lx", PTRSTRWIDTH + 1, 1, (long)up->un_uppervp); 661 PRWORD(ovflw, " %*lx", PTRSTRWIDTH + 1, 1, (long)up->un_lowervp); 662 return (0); 663 } 664 665 /* 666 * Given a pointer to a mount structure in kernel space, 667 * read it in and return a usable pointer to it. 668 */ 669 struct mount * 670 getmnt(maddr) 671 struct mount *maddr; 672 { 673 static struct mtab { 674 struct mtab *next; 675 struct mount *maddr; 676 struct mount mount; 677 } *mhead = NULL; 678 struct mtab *mt; 679 680 for (mt = mhead; mt != NULL; mt = mt->next) 681 if (maddr == mt->maddr) 682 return (&mt->mount); 683 if ((mt = malloc(sizeof(struct mtab))) == NULL) 684 err(1, "malloc"); 685 KGETRET(maddr, &mt->mount, sizeof(struct mount), "mount table"); 686 mt->maddr = maddr; 687 mt->next = mhead; 688 mhead = mt; 689 return (&mt->mount); 690 } 691 692 void 693 mount_print(mp) 694 struct mount *mp; 695 { 696 int flags; 697 698 (void)printf("*** MOUNT %s %s on %s", ST.f_fstypename, 699 ST.f_mntfromname, ST.f_mntonname); 700 if ((flags = mp->mnt_flag) != 0) { 701 int i; 702 const char *sep = " ("; 703 704 for (i = 0; mnt_flags[i].m_flag; i++) { 705 if (flags & mnt_flags[i].m_flag) { 706 (void)printf("%s%s", sep, mnt_flags[i].m_name); 707 flags &= ~mnt_flags[i].m_flag; 708 sep = ","; 709 } 710 } 711 if (flags) 712 (void)printf("%sunknown_flags:%x", sep, flags); 713 (void)printf(")"); 714 } 715 (void)printf("\n"); 716 } 717 718 char * 719 loadvnodes(avnodes) 720 int *avnodes; 721 { 722 int mib[2]; 723 size_t copysize; 724 char *vnodebase; 725 726 if (memf != NULL) { 727 /* 728 * do it by hand 729 */ 730 return (kinfo_vnodes(avnodes)); 731 } 732 mib[0] = CTL_KERN; 733 mib[1] = KERN_VNODE; 734 if (sysctl(mib, 2, NULL, ©size, NULL, 0) == -1) 735 err(1, "sysctl: KERN_VNODE"); 736 if ((vnodebase = malloc(copysize)) == NULL) 737 err(1, "malloc"); 738 if (sysctl(mib, 2, vnodebase, ©size, NULL, 0) == -1) 739 err(1, "sysctl: KERN_VNODE"); 740 if (copysize % (VPTRSZ + VNODESZ)) 741 errx(1, "vnode size mismatch"); 742 *avnodes = copysize / (VPTRSZ + VNODESZ); 743 744 return (vnodebase); 745 } 746 747 /* 748 * simulate what a running kernel does in in kinfo_vnode 749 */ 750 char * 751 kinfo_vnodes(avnodes) 752 int *avnodes; 753 { 754 struct mntlist mountlist; 755 struct mount *mp, mount; 756 struct vnode *vp, vnode; 757 char *beg, *bp, *ep; 758 int numvnodes; 759 760 KGET(V_NUMV, numvnodes); 761 if ((bp = malloc((numvnodes + 20) * (VPTRSZ + VNODESZ))) == NULL) 762 err(1, "malloc"); 763 beg = bp; 764 ep = bp + (numvnodes + 20) * (VPTRSZ + VNODESZ); 765 KGET(V_MOUNTLIST, mountlist); 766 for (mp = mountlist.cqh_first;; 767 mp = mount.mnt_list.cqe_next) { 768 KGET2(mp, &mount, sizeof(mount), "mount entry"); 769 for (vp = mount.mnt_vnodelist.lh_first; 770 vp != NULL; vp = vnode.v_mntvnodes.le_next) { 771 KGET2(vp, &vnode, sizeof(vnode), "vnode"); 772 if (bp + VPTRSZ + VNODESZ > ep) 773 /* XXX - should realloc */ 774 errx(1, "no more room for vnodes"); 775 memmove(bp, &vp, VPTRSZ); 776 bp += VPTRSZ; 777 memmove(bp, &vnode, VNODESZ); 778 bp += VNODESZ; 779 } 780 if (mp == mountlist.cqh_last) 781 break; 782 } 783 *avnodes = (bp - beg) / (VPTRSZ + VNODESZ); 784 return (beg); 785 } 786 787 const char hdr[] = 788 " LINE RAW CAN OUT HWT LWT COL STATE SESS PGID DISC\n"; 789 int ttyspace = 128; 790 791 void 792 ttymode() 793 { 794 int ntty; 795 struct ttylist_head tty_head; 796 struct tty *tp, tty; 797 798 KGET(TTY_NTTY, ntty); 799 (void)printf("%d terminal device%s\n", ntty, ntty == 1 ? "" : "s"); 800 KGET(TTY_TTYLIST, tty_head); 801 (void)printf(hdr); 802 for (tp = tty_head.tqh_first; tp; tp = tty.tty_link.tqe_next) { 803 KGET2(tp, &tty, sizeof tty, "tty struct"); 804 ttyprt(&tty); 805 } 806 } 807 808 struct { 809 int flag; 810 char val; 811 } ttystates[] = { 812 { TS_ISOPEN, 'O'}, 813 { TS_DIALOUT, '>'}, 814 { TS_CARR_ON, 'C'}, 815 { TS_TIMEOUT, 'T'}, 816 { TS_FLUSH, 'F'}, 817 { TS_BUSY, 'B'}, 818 { TS_ASLEEP, 'A'}, 819 { TS_XCLUDE, 'X'}, 820 { TS_TTSTOP, 'S'}, 821 { TS_TBLOCK, 'K'}, 822 { TS_ASYNC, 'Y'}, 823 { TS_BKSL, 'D'}, 824 { TS_ERASE, 'E'}, 825 { TS_LNCH, 'L'}, 826 { TS_TYPEN, 'P'}, 827 { TS_CNTTB, 'N'}, 828 { 0, '\0'}, 829 }; 830 831 void 832 ttyprt(tp) 833 struct tty *tp; 834 { 835 int i, j; 836 pid_t pgid; 837 char *name, state[20], buffer; 838 struct linesw t_linesw; 839 840 if (usenumflag || (name = devname(tp->t_dev, S_IFCHR)) == NULL) 841 (void)printf("0x%3x:%1x ", major(tp->t_dev), minor(tp->t_dev)); 842 else 843 (void)printf("%-7s ", name); 844 (void)printf("%2d %3d ", tp->t_rawq.c_cc, tp->t_canq.c_cc); 845 (void)printf("%3d %4d %3d %7d ", tp->t_outq.c_cc, 846 tp->t_hiwat, tp->t_lowat, tp->t_column); 847 for (i = j = 0; ttystates[i].flag; i++) 848 if (tp->t_state&ttystates[i].flag) 849 state[j++] = ttystates[i].val; 850 if (tp->t_wopen) 851 state[j++] = 'W'; 852 if (j == 0) 853 state[j++] = '-'; 854 state[j] = '\0'; 855 (void)printf("%-6s %8lX", state, (u_long)tp->t_session); 856 pgid = 0; 857 if (tp->t_pgrp != NULL) 858 KGET2(&tp->t_pgrp->pg_id, &pgid, sizeof(pid_t), "pgid"); 859 (void)printf("%6d ", pgid); 860 KGET2(tp->t_linesw, &t_linesw, sizeof(t_linesw), 861 "line discipline switch table"); 862 name = t_linesw.l_name; 863 for (;;) { 864 KGET2(name, &buffer, sizeof(buffer), "line discipline name"); 865 if (buffer == '\0') 866 break; 867 (void)putchar(buffer); 868 name++; 869 } 870 (void)putchar('\n'); 871 } 872 873 void 874 filemode() 875 { 876 struct file *fp; 877 struct file *addr; 878 char *buf, flagbuf[16], *fbp; 879 int len, maxfile, nfile; 880 static char *dtypes[] = { "???", "inode", "socket" }; 881 882 KGET(FNL_MAXFILE, maxfile); 883 if (totalflag) { 884 KGET(FNL_NFILE, nfile); 885 (void)printf("%3d/%3d files\n", nfile, maxfile); 886 return; 887 } 888 if (getfiles(&buf, &len) == -1) 889 return; 890 /* 891 * Getfiles returns in malloc'd memory a pointer to the first file 892 * structure, and then an array of file structs (whose addresses are 893 * derivable from the previous entry). 894 */ 895 addr = ((struct filelist *)buf)->lh_first; 896 fp = (struct file *)(buf + sizeof(struct filelist)); 897 nfile = (len - sizeof(struct filelist)) / sizeof(struct file); 898 899 (void)printf("%d/%d open files\n", nfile, maxfile); 900 (void)printf(" LOC TYPE FLG CNT MSG DATA OFFSET\n"); 901 for (; (char *)fp < buf + len; addr = fp->f_list.le_next, fp++) { 902 if ((unsigned)fp->f_type > DTYPE_SOCKET) 903 continue; 904 (void)printf("%lx ", (long)addr); 905 (void)printf("%-8.8s", dtypes[fp->f_type]); 906 fbp = flagbuf; 907 if (fp->f_flag & FREAD) 908 *fbp++ = 'R'; 909 if (fp->f_flag & FWRITE) 910 *fbp++ = 'W'; 911 if (fp->f_flag & FAPPEND) 912 *fbp++ = 'A'; 913 #ifdef FSHLOCK /* currently gone */ 914 if (fp->f_flag & FSHLOCK) 915 *fbp++ = 'S'; 916 if (fp->f_flag & FEXLOCK) 917 *fbp++ = 'X'; 918 #endif 919 if (fp->f_flag & FASYNC) 920 *fbp++ = 'I'; 921 *fbp = '\0'; 922 (void)printf("%6s %3d", flagbuf, fp->f_count); 923 (void)printf(" %3d", fp->f_msgcount); 924 (void)printf(" %8.1lx", (long)fp->f_data); 925 if (fp->f_offset < 0) 926 (void)printf(" %llx\n", (long long)fp->f_offset); 927 else 928 (void)printf(" %lld\n", (long long)fp->f_offset); 929 } 930 free(buf); 931 } 932 933 int 934 getfiles(abuf, alen) 935 char **abuf; 936 int *alen; 937 { 938 size_t len; 939 int mib[2]; 940 char *buf; 941 942 /* 943 * XXX 944 * Add emulation of KINFO_FILE here. 945 */ 946 if (memf != NULL) 947 errx(1, "files on dead kernel, not implemented"); 948 949 mib[0] = CTL_KERN; 950 mib[1] = KERN_FILE; 951 if (sysctl(mib, 2, NULL, &len, NULL, 0) == -1) { 952 warn("sysctl: KERN_FILE"); 953 return (-1); 954 } 955 if ((buf = malloc(len)) == NULL) 956 err(1, "malloc"); 957 if (sysctl(mib, 2, buf, &len, NULL, 0) == -1) { 958 warn("sysctl: KERN_FILE"); 959 return (-1); 960 } 961 *abuf = buf; 962 *alen = len; 963 return (0); 964 } 965 966 void 967 usage() 968 { 969 970 (void)fprintf(stderr, 971 "usage: %s [-T|-f|-s|-t|-v] [-kn] [-M core] [-N system]\n", 972 getprogname()); 973 exit(1); 974 } 975
Indexes created Wed Sep 24 15:09:51 GMT 2025