pmap.c revision 1.4
1 /* $NetBSD: pmap.c,v 1.4 2002/09/17 19:54:28 atatat Exp $ */ 2 3 /* 4 * Copyright (c) 2002 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Andrew Brown. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 3. All advertising materials mentioning features or use of this software 19 * must display the following acknowledgement: 20 * This product includes software developed by the NetBSD 21 * Foundation, Inc. and its contributors. 22 * 4. Neither the name of The NetBSD Foundation nor the names of its 23 * contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 27 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 28 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 29 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 30 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 36 * POSSIBILITY OF SUCH DAMAGE. 37 */ 38 39 #include <sys/cdefs.h> 40 #ifndef lint 41 __RCSID("$NetBSD: pmap.c,v 1.4 2002/09/17 19:54:28 atatat Exp $"); 42 #endif 43 44 #include <sys/types.h> 45 #include <sys/param.h> 46 #include <sys/time.h> 47 #include <sys/exec.h> 48 #include <sys/proc.h> 49 #include <sys/vnode.h> 50 #include <sys/mount.h> 51 #include <sys/uio.h> 52 #include <sys/namei.h> 53 #include <sys/sysctl.h> 54 55 #include <uvm/uvm.h> 56 #include <uvm/uvm_device.h> 57 58 #include <ufs/ufs/inode.h> 59 #undef doff_t 60 #undef IN_ACCESS 61 #include <isofs/cd9660/iso.h> 62 #include <isofs/cd9660/cd9660_node.h> 63 64 #include <kvm.h> 65 #include <fcntl.h> 66 #include <errno.h> 67 #include <err.h> 68 #include <stdlib.h> 69 #include <stddef.h> 70 #include <unistd.h> 71 #include <stdio.h> 72 #include <limits.h> 73 #include <string.h> 74 75 #ifndef __NetBSD_Version__ 76 #error go away, you fool 77 #elif (__NetBSD_Version__ < 105000000) 78 #error only works with uvm 79 #endif 80 81 /* 82 * stolen (and munged) from #include <uvm/uvm_object.h> 83 */ 84 #define UVM_OBJ_IS_VNODE(uobj) ((uobj)->pgops == uvm_vnodeops) 85 #define UVM_OBJ_IS_AOBJ(uobj) ((uobj)->pgops == aobj_pager) 86 #define UVM_OBJ_IS_DEVICE(uobj) ((uobj)->pgops == uvm_deviceops) 87 #define UVM_OBJ_IS_UBCPAGER(uobj) ((uobj)->pgops == ubc_pager) 88 89 #define PRINT_VMSPACE 0x00000001 90 #define PRINT_VM_MAP 0x00000002 91 #define PRINT_VM_MAP_HEADER 0x00000004 92 #define PRINT_VM_MAP_ENTRY 0x00000008 93 #define DUMP_NAMEI_CACHE 0x00000010 94 95 struct cache_entry { 96 LIST_ENTRY(cache_entry) ce_next; 97 struct vnode *ce_vp, *ce_pvp; 98 u_long ce_cid, ce_pcid; 99 int ce_nlen; 100 char ce_name[256]; 101 }; 102 103 LIST_HEAD(cache_head, cache_entry) lcache; 104 LIST_HEAD(nchashhead, namecache) *nchashtbl = NULL; 105 void *uvm_vnodeops, *uvm_deviceops, *aobj_pager, *ubc_pager; 106 void *kernel_floor; 107 u_long nchash_addr, nchashtbl_addr, kernel_map_addr; 108 int debug, verbose, recurse; 109 int print_all, print_map, print_maps, print_solaris, print_ddb; 110 int rwx = VM_PROT_READ | VM_PROT_WRITE | VM_PROT_EXECUTE, heapfound; 111 rlim_t maxssiz; 112 113 struct kbit { 114 /* 115 * size of data chunk 116 */ 117 size_t k_size; 118 119 /* 120 * something for printf() and something for kvm_read() 121 */ 122 union { 123 void *k_addr_p; 124 u_long k_addr_ul; 125 } k_addr; 126 127 /* 128 * where we actually put the "stuff" 129 */ 130 union { 131 char data[1]; 132 struct vmspace vmspace; 133 struct vm_map vm_map; 134 struct vm_map_entry vm_map_entry; 135 struct vnode vnode; 136 struct uvm_object uvm_object; 137 struct mount mount; 138 struct namecache namecache; 139 struct inode inode; 140 struct iso_node iso_node; 141 struct uvm_device uvm_device; 142 } k_data; 143 }; 144 145 /* the size of the object in the kernel */ 146 #define S(x) ((x)->k_size) 147 /* the address of the object in kernel, two forms */ 148 #define A(x) ((x)->k_addr.k_addr_ul) 149 #define P(x) ((x)->k_addr.k_addr_p) 150 /* the data from the kernel */ 151 #define D(x,d) (&((x)->k_data.d)) 152 153 /* suck the data from the kernel */ 154 #define _KDEREF(kd, addr, dst, sz) do { \ 155 ssize_t len; \ 156 len = kvm_read((kd), (addr), (dst), (sz)); \ 157 if (len != (sz)) \ 158 errx(1, "trying to read %lu bytes from %lx: %s", \ 159 (unsigned long)(sz), (addr), kvm_geterr(kd)); \ 160 } while (0/*CONSTCOND*/) 161 162 /* suck the data using the structure */ 163 #define KDEREF(kd, item) _KDEREF((kd), A(item), D(item, data), S(item)) 164 165 /* when recursing, output is indented */ 166 #define indent(n) ((n) * (recurse > 1 ? recurse - 1 : 0)) 167 168 struct nlist nl[] = { 169 { "_maxsmap" }, 170 #define NL_MAXSSIZ 0 171 { "_uvm_vnodeops" }, 172 #define NL_UVM_VNODEOPS 1 173 { "_uvm_deviceops" }, 174 #define NL_UVM_DEVICEOPS 2 175 { "_aobj_pager" }, 176 #define NL_AOBJ_PAGER 3 177 { "_ubc_pager" }, 178 #define NL_UBC_PAGER 4 179 { "_kernel_map" }, 180 #define NL_KERNEL_MAP 5 181 { "_nchashtbl" }, 182 #define NL_NCHASHTBL 6 183 { "_nchash" }, 184 #define NL_NCHASH 7 185 { "_kernel_text" }, 186 #define NL_KENTER 8 187 { NULL } 188 }; 189 190 void load_symbols(kvm_t *); 191 void process_map(kvm_t *, pid_t, struct kinfo_proc2 *); 192 void dump_vm_map(kvm_t *, struct kbit *, struct kbit *, char *); 193 size_t dump_vm_map_entry(kvm_t *, struct kbit *, struct kbit *, int); 194 char *findname(kvm_t *, struct kbit *, struct kbit *, struct kbit *, 195 struct kbit *, struct kbit *); 196 int search_cache(kvm_t *, struct kbit *, char **, char *, size_t); 197 void load_name_cache(kvm_t *); 198 void cache_enter(int, struct namecache *); 199 200 int 201 main(int argc, char *argv[]) 202 { 203 kvm_t *kd; 204 pid_t pid; 205 int many, ch, rc; 206 char errbuf[_POSIX2_LINE_MAX + 1]; 207 struct kinfo_proc2 *kproc; 208 char *kmem, *kernel; 209 210 pid = -1; 211 verbose = debug = 0; 212 print_all = print_map = print_maps = print_solaris = print_ddb = 0; 213 recurse = 0; 214 kmem = kernel = NULL; 215 216 while ((ch = getopt(argc, argv, "aD:dlmM:N:p:PRrsvx")) != -1) { 217 switch (ch) { 218 case 'a': 219 print_all = 1; 220 break; 221 case 'd': 222 print_ddb = 1; 223 break; 224 case 'D': 225 debug = atoi(optarg); 226 break; 227 case 'l': 228 print_maps = 1; 229 break; 230 case 'm': 231 print_map = 1; 232 break; 233 case 'M': 234 kmem = optarg; 235 break; 236 case 'N': 237 kernel = optarg; 238 break; 239 case 'p': 240 pid = atoi(optarg); 241 break; 242 case 'P': 243 pid = getpid(); 244 break; 245 case 'R': 246 recurse = 1; 247 break; 248 case 's': 249 print_solaris = 1; 250 break; 251 case 'v': 252 verbose = 1; 253 break; 254 case 'r': 255 case 'x': 256 errx(1, "-%c option not implemented, sorry", optopt); 257 /*NOTREACHED*/ 258 case '?': 259 default: 260 fprintf(stderr, "usage: %s [-adlmPsv] [-D number] " 261 "[-M core] [-N system] [-p pid] [pid ...]\n", 262 getprogname()); 263 exit(1); 264 } 265 } 266 argc -= optind; 267 argv += optind; 268 269 /* more than one "process" to dump? */ 270 many = (argc > 1 - (pid == -1 ? 0 : 1)) ? 1 : 0; 271 272 /* apply default */ 273 if (print_all + print_map + print_maps + print_solaris + 274 print_ddb == 0) 275 print_solaris = 1; 276 277 /* start by opening libkvm */ 278 kd = kvm_openfiles(kernel, kmem, NULL, O_RDONLY, errbuf); 279 errbuf[_POSIX2_LINE_MAX] = '\0'; 280 if (kd == NULL) 281 errx(1, "%s", errbuf); 282 283 /* get "bootstrap" addresses from kernel */ 284 load_symbols(kd); 285 286 do { 287 if (pid == -1) { 288 if (argc == 0) 289 pid = getppid(); 290 else { 291 pid = atoi(argv[0]); 292 argv++; 293 argc--; 294 } 295 } 296 297 /* find the process id */ 298 if (pid == 0) 299 kproc = NULL; 300 else { 301 kproc = kvm_getproc2(kd, KERN_PROC_PID, pid, 302 sizeof(struct kinfo_proc2), &rc); 303 if (kproc == NULL || rc == 0) { 304 errno = ESRCH; 305 warn("%d", pid); 306 pid = -1; 307 continue; 308 } 309 } 310 311 /* dump it */ 312 if (many) { 313 if (kproc) 314 printf("process %d:\n", kproc->p_pid); 315 else 316 printf("kernel:\n"); 317 } 318 319 process_map(kd, pid, kproc); 320 pid = -1; 321 } while (argc > 0); 322 323 /* done. go away. */ 324 rc = kvm_close(kd); 325 if (rc == -1) 326 err(1, "kvm_close"); 327 328 return (0); 329 } 330 331 void 332 process_map(kvm_t *kd, pid_t pid, struct kinfo_proc2 *proc) 333 { 334 struct kbit kbit[2], *vmspace, *vm_map; 335 char *thing; 336 337 vmspace = &kbit[0]; 338 vm_map = &kbit[1]; 339 340 A(vmspace) = 0; 341 A(vm_map) = 0; 342 343 if (pid > 0) { 344 heapfound = 0; 345 A(vmspace) = (u_long)proc->p_vmspace; 346 S(vmspace) = sizeof(struct vmspace); 347 KDEREF(kd, vmspace); 348 thing = "proc->p_vmspace.vm_map"; 349 } else { 350 heapfound = 1; /* but really, do kernels have a heap? */ 351 A(vmspace) = 0; 352 S(vmspace) = 0; 353 thing = "kernel_map"; 354 } 355 356 if (pid > 0 && (debug & PRINT_VMSPACE)) { 357 printf("proc->p_vmspace %p = {", P(vmspace)); 358 printf(" vm_refcnt = %d,", D(vmspace, vmspace)->vm_refcnt); 359 printf(" vm_shm = %p,\n", D(vmspace, vmspace)->vm_shm); 360 printf(" vm_rssize = %d,", D(vmspace, vmspace)->vm_rssize); 361 printf(" vm_swrss = %d,", D(vmspace, vmspace)->vm_swrss); 362 printf(" vm_tsize = %d,", D(vmspace, vmspace)->vm_tsize); 363 printf(" vm_dsize = %d,\n", D(vmspace, vmspace)->vm_dsize); 364 printf(" vm_ssize = %d,", D(vmspace, vmspace)->vm_ssize); 365 printf(" vm_taddr = %p,", D(vmspace, vmspace)->vm_taddr); 366 printf(" vm_daddr = %p,\n", D(vmspace, vmspace)->vm_daddr); 367 printf(" vm_maxsaddr = %p,", 368 D(vmspace, vmspace)->vm_maxsaddr); 369 printf(" vm_minsaddr = %p }\n", 370 D(vmspace, vmspace)->vm_minsaddr); 371 } 372 373 S(vm_map) = sizeof(struct vm_map); 374 if (pid > 0) { 375 A(vm_map) = A(vmspace); 376 memcpy(D(vm_map, vm_map), &D(vmspace, vmspace)->vm_map, 377 S(vm_map)); 378 } else { 379 A(vm_map) = kernel_map_addr; 380 KDEREF(kd, vm_map); 381 } 382 383 dump_vm_map(kd, vmspace, vm_map, thing); 384 } 385 386 void 387 load_symbols(kvm_t *kd) 388 { 389 int rc; 390 391 rc = kvm_nlist(kd, &nl[0]); 392 if (rc != 0) 393 errx(1, "%s == %d", kvm_geterr(kd), rc); 394 395 uvm_vnodeops = (void*)nl[NL_UVM_VNODEOPS].n_value; 396 uvm_deviceops = (void*)nl[NL_UVM_DEVICEOPS].n_value; 397 aobj_pager = (void*)nl[NL_AOBJ_PAGER].n_value; 398 ubc_pager = (void*)nl[NL_UBC_PAGER].n_value; 399 400 kernel_floor = (void*)nl[NL_KENTER].n_value; 401 nchash_addr = nl[NL_NCHASH].n_value; 402 403 _KDEREF(kd, nl[NL_MAXSSIZ].n_value, &maxssiz, 404 sizeof(maxssiz)); 405 _KDEREF(kd, nl[NL_NCHASHTBL].n_value, &nchashtbl_addr, 406 sizeof(nchashtbl_addr)); 407 _KDEREF(kd, nl[NL_KERNEL_MAP].n_value, &kernel_map_addr, 408 sizeof(kernel_map_addr)); 409 } 410 411 void 412 dump_vm_map(kvm_t *kd, struct kbit *vmspace, struct kbit *vm_map, 413 char *name) 414 { 415 struct kbit kbit[2], *header, *vm_map_entry; 416 struct vm_map_entry *last, *next; 417 size_t total; 418 u_long addr; 419 420 header = &kbit[0]; 421 vm_map_entry = &kbit[1]; 422 A(header) = 0; 423 A(vm_map_entry) = 0; 424 425 if (debug & PRINT_VM_MAP) { 426 printf("%*s%s %p = {", indent(2), "", name, P(vm_map)); 427 printf(" pmap = %p,\n", D(vm_map, vm_map)->pmap); 428 printf("%*s lock = <struct lock>,", indent(2), ""); 429 printf(" header = <struct vm_map_entry>,"); 430 printf(" nentries = %d,\n", D(vm_map, vm_map)->nentries); 431 printf("%*s size = %lx,", indent(2), "", 432 D(vm_map, vm_map)->size); 433 printf(" ref_count = %d,", D(vm_map, vm_map)->ref_count); 434 printf(" ref_lock = <struct simplelock>,\n"); 435 printf("%*s hint = %p,", indent(2), "", 436 D(vm_map, vm_map)->hint); 437 printf(" hint_lock = <struct simplelock>,\n"); 438 printf("%*s first_free = %p,", indent(2), "", 439 D(vm_map, vm_map)->first_free); 440 printf(" flags = %x <%s%s%s%s%s%s >,\n", D(vm_map, vm_map)->flags, 441 D(vm_map, vm_map)->flags & VM_MAP_PAGEABLE ? " PAGEABLE" : "", 442 D(vm_map, vm_map)->flags & VM_MAP_INTRSAFE ? " INTRSAFE" : "", 443 D(vm_map, vm_map)->flags & VM_MAP_WIREFUTURE ? " WIREFUTURE" : "", 444 D(vm_map, vm_map)->flags & VM_MAP_BUSY ? " BUSY" : "", 445 D(vm_map, vm_map)->flags & VM_MAP_WANTLOCK ? " WANTLOCK" : "", 446 #if VM_MAP_TOPDOWN > 0 447 D(vm_map, vm_map)->flags & VM_MAP_TOPDOWN ? " TOPDOWN" : 448 #endif 449 ""); 450 printf("%*s flags_lock = <struct simplelock>,", indent(2), ""); 451 printf(" timestamp = %u }\n", D(vm_map, vm_map)->timestamp); 452 } 453 if (print_ddb) { 454 printf("%*s%s %p: [0x%lx->0x%lx]\n", indent(2), "", 455 recurse < 2 ? "MAP" : "SUBMAP", P(vm_map), 456 D(vm_map, vm_map)->min_offset, 457 D(vm_map, vm_map)->max_offset); 458 printf("\t%*s#ent=%d, sz=%ld, ref=%d, version=%d, flags=0x%x\n", 459 indent(2), "", D(vm_map, vm_map)->nentries, 460 D(vm_map, vm_map)->size, D(vm_map, vm_map)->ref_count, 461 D(vm_map, vm_map)->timestamp, D(vm_map, vm_map)->flags); 462 printf("\t%*spmap=%p(resident=<unknown>)\n", indent(2), "", 463 D(vm_map, vm_map)->pmap); 464 } 465 466 A(header) = A(vm_map) + offsetof(struct vm_map, header); 467 S(header) = sizeof(struct vm_map_entry); 468 memcpy(D(header, vm_map_entry), &D(vm_map, vm_map)->header, S(header)); 469 dump_vm_map_entry(kd, vmspace, header, 1); 470 471 /* 472 * we're not recursing into a submap, so print headers 473 */ 474 if (recurse < 2) { 475 /* headers */ 476 #ifdef DISABLED_HEADERS 477 if (print_map) 478 printf("%-*s %-*s rwx RWX CPY NCP I W A\n", 479 (int)sizeof(long) * 2 + 2, "Start", 480 (int)sizeof(long) * 2 + 2, "End"); 481 if (print_maps) 482 printf("%-*s %-*s rwxp %-*s Dev Inode File\n", 483 (int)sizeof(long) * 2 + 0, "Start", 484 (int)sizeof(long) * 2 + 0, "End", 485 (int)sizeof(long) * 2 + 0, "Offset"); 486 if (print_solaris) 487 printf("%-*s %*s Protection File\n", 488 (int)sizeof(long) * 2 + 0, "Start", 489 (int)sizeof(int) * 2 - 1, "Size "); 490 #endif 491 if (print_all) 492 printf("%-*s %-*s %*s %-*s rwxpc RWX I/W/A Dev %*s" 493 " - File\n", 494 (int)sizeof(long) * 2, "Start", 495 (int)sizeof(long) * 2, "End", 496 (int)sizeof(int) * 2, "Size ", 497 (int)sizeof(long) * 2, "Offset", 498 (int)sizeof(int) * 2, "Inode"); 499 } 500 501 /* these are the "sub entries" */ 502 total = 0; 503 next = D(header, vm_map_entry)->next; 504 last = P(header); 505 506 while (next != 0 && next != last) { 507 addr = (u_long)next; 508 A(vm_map_entry) = addr; 509 S(vm_map_entry) = sizeof(struct vm_map_entry); 510 KDEREF(kd, vm_map_entry); 511 next = D(vm_map_entry, vm_map_entry)->next; 512 total += dump_vm_map_entry(kd, vmspace, vm_map_entry, 0); 513 } 514 515 /* 516 * we're not recursing into a submap, so print totals 517 */ 518 if (recurse < 2) { 519 if (print_solaris) 520 printf("%-*s %8luK\n", 521 (int)sizeof(void *) * 2 - 2, " total", 522 (unsigned long)total); 523 if (print_all) 524 printf("%-*s %9luk\n", 525 (int)sizeof(void *) * 4 - 1, " total", 526 (unsigned long)total); 527 } 528 } 529 530 size_t 531 dump_vm_map_entry(kvm_t *kd, struct kbit *vmspace, 532 struct kbit *vm_map_entry, 533 int ishead) 534 { 535 struct kbit kbit[3]; 536 struct kbit *uvm_obj, *vp, *vfs; 537 struct vm_map_entry *vme; 538 size_t sz; 539 char *name; 540 dev_t dev; 541 ino_t inode; 542 543 uvm_obj = &kbit[0]; 544 vp = &kbit[1]; 545 vfs = &kbit[2]; 546 547 A(uvm_obj) = 0; 548 A(vp) = 0; 549 A(vfs) = 0; 550 551 vme = D(vm_map_entry, vm_map_entry); 552 553 if ((ishead && (debug & PRINT_VM_MAP_HEADER)) || 554 (!ishead && (debug & PRINT_VM_MAP_ENTRY))) { 555 printf("%*s%s %p = {", indent(2), "", 556 ishead ? "vm_map.header" : "vm_map_entry", 557 P(vm_map_entry)); 558 printf(" prev = %p,", vme->prev); 559 printf(" next = %p,\n", vme->next); 560 printf("%*s start = %lx,", indent(2), "", vme->start); 561 printf(" end = %lx,", vme->end); 562 printf(" object.uvm_obj/sub_map = %p,\n", vme->object.uvm_obj); 563 printf("%*s offset = %lx,", indent(2), "", 564 (unsigned long)vme->offset); 565 printf(" etype = %x <%s%s%s%s >,", vme->etype, 566 vme->etype & UVM_ET_OBJ ? " OBJ" : "", 567 vme->etype & UVM_ET_SUBMAP ? " SUBMAP" : "", 568 vme->etype & UVM_ET_COPYONWRITE ? " COW" : "", 569 vme->etype & UVM_ET_NEEDSCOPY ? " NEEDSCOPY" : ""); 570 printf(" protection = %x,\n", vme->protection); 571 printf("%*s max_protection = %x,", indent(2), "", 572 vme->max_protection); 573 printf(" inheritance = %d,", vme->inheritance); 574 printf(" wired_count = %d,\n", vme->wired_count); 575 printf("%*s aref = <struct vm_aref>,", indent(2), ""); 576 printf(" advice = %d,", vme->advice); 577 printf(" flags = %x <%s%s > }\n", vme->flags, 578 vme->flags & UVM_MAP_STATIC ? " STATIC" : "", 579 vme->flags & UVM_MAP_KMEM ? " KMEM" : ""); 580 } 581 582 if (ishead) 583 return (0); 584 585 A(vp) = 0; 586 A(uvm_obj) = 0; 587 588 if (vme->object.uvm_obj != NULL) { 589 P(uvm_obj) = vme->object.uvm_obj; 590 S(uvm_obj) = sizeof(struct uvm_object); 591 KDEREF(kd, uvm_obj); 592 if (UVM_ET_ISOBJ(vme) && 593 UVM_OBJ_IS_VNODE(D(uvm_obj, uvm_object))) { 594 P(vp) = P(uvm_obj); 595 S(vp) = sizeof(struct vnode); 596 KDEREF(kd, vp); 597 } 598 } 599 600 A(vfs) = NULL; 601 602 if (P(vp) != NULL && D(vp, vnode)->v_mount != NULL) { 603 P(vfs) = D(vp, vnode)->v_mount; 604 S(vfs) = sizeof(struct mount); 605 KDEREF(kd, vfs); 606 D(vp, vnode)->v_mount = D(vfs, mount); 607 } 608 609 /* 610 * dig out the device number and inode number from certain 611 * file system types. 612 */ 613 #define V_DATA_IS(vp, type, d, i) do { \ 614 struct kbit data; \ 615 P(&data) = D(vp, vnode)->v_data; \ 616 S(&data) = sizeof(*D(&data, type)); \ 617 KDEREF(kd, &data); \ 618 dev = D(&data, type)->d; \ 619 inode = D(&data, type)->i; \ 620 } while (0/*CONSTCOND*/) 621 622 dev = 0; 623 inode = 0; 624 625 if (A(vp) && 626 D(vp, vnode)->v_type == VREG && 627 D(vp, vnode)->v_data != NULL) { 628 switch (D(vp, vnode)->v_tag) { 629 case VT_UFS: 630 case VT_LFS: 631 case VT_EXT2FS: 632 V_DATA_IS(vp, inode, i_dev, i_number); 633 break; 634 case VT_ISOFS: 635 V_DATA_IS(vp, iso_node, i_dev, i_number); 636 break; 637 case VT_NON: 638 case VT_NFS: 639 case VT_MFS: 640 case VT_MSDOSFS: 641 case VT_LOFS: 642 case VT_FDESC: 643 case VT_PORTAL: 644 case VT_NULL: 645 case VT_UMAP: 646 case VT_KERNFS: 647 case VT_PROCFS: 648 case VT_AFS: 649 case VT_UNION: 650 case VT_ADOSFS: 651 case VT_CODA: 652 case VT_FILECORE: 653 case VT_NTFS: 654 case VT_VFS: 655 case VT_OVERLAY: 656 case VT_SMBFS: 657 break; 658 } 659 } 660 661 name = findname(kd, vmspace, vm_map_entry, vp, vfs, uvm_obj); 662 663 if (print_map) { 664 printf("%*s0x%lx 0x%lx %c%c%c %c%c%c %s %s %d %d %d", 665 indent(2), "", 666 vme->start, vme->end, 667 (vme->protection & VM_PROT_READ) ? 'r' : '-', 668 (vme->protection & VM_PROT_WRITE) ? 'w' : '-', 669 (vme->protection & VM_PROT_EXECUTE) ? 'x' : '-', 670 (vme->max_protection & VM_PROT_READ) ? 'r' : '-', 671 (vme->max_protection & VM_PROT_WRITE) ? 'w' : '-', 672 (vme->max_protection & VM_PROT_EXECUTE) ? 'x' : '-', 673 (vme->etype & UVM_ET_COPYONWRITE) ? "COW" : "NCOW", 674 (vme->etype & UVM_ET_NEEDSCOPY) ? "NC" : "NNC", 675 vme->inheritance, vme->wired_count, 676 vme->advice); 677 if (verbose) { 678 if (inode) 679 printf(" %d,%d %d", 680 major(dev), minor(dev), inode); 681 if (name[0]) 682 printf(" %s", name); 683 } 684 printf("\n"); 685 } 686 687 if (print_maps) { 688 printf("%*s%0*lx-%0*lx %c%c%c%c %0*lx %02x:%02x %d %s\n", 689 indent(2), "", 690 (int)sizeof(void *) * 2, vme->start, 691 (int)sizeof(void *) * 2, vme->end, 692 (vme->protection & VM_PROT_READ) ? 'r' : '-', 693 (vme->protection & VM_PROT_WRITE) ? 'w' : '-', 694 (vme->protection & VM_PROT_EXECUTE) ? 'x' : '-', 695 (vme->etype & UVM_ET_COPYONWRITE) ? 'p' : 's', 696 (int)sizeof(void *) * 2, 697 (unsigned long)vme->offset, 698 major(dev), minor(dev), inode, 699 (name[0] != ' ') || verbose ? name : ""); 700 } 701 702 if (print_ddb) { 703 printf("%*s - %p: 0x%lx->0x%lx: obj=%p/0x%lx, amap=%p/%d\n", 704 indent(2), "", 705 P(vm_map_entry), vme->start, vme->end, 706 vme->object.uvm_obj, (unsigned long)vme->offset, 707 vme->aref.ar_amap, vme->aref.ar_pageoff); 708 printf("\t%*ssubmap=%c, cow=%c, nc=%c, prot(max)=%d/%d, inh=%d, " 709 "wc=%d, adv=%d\n", 710 indent(2), "", 711 (vme->etype & UVM_ET_SUBMAP) ? 'T' : 'F', 712 (vme->etype & UVM_ET_COPYONWRITE) ? 'T' : 'F', 713 (vme->etype & UVM_ET_NEEDSCOPY) ? 'T' : 'F', 714 vme->protection, vme->max_protection, 715 vme->inheritance, vme->wired_count, vme->advice); 716 if (verbose) { 717 printf("\t%*s", indent(2), ""); 718 if (inode) 719 printf("(dev=%d,%d ino=%d [%s] [%p])\n", 720 major(dev), minor(dev), inode, 721 name, P(vp)); 722 else if (name[0] == ' ') 723 printf("(%s)\n", &name[2]); 724 else 725 printf("(%s)\n", name); 726 } 727 } 728 729 sz = 0; 730 if (print_solaris) { 731 char prot[30]; 732 733 prot[0] = '\0'; 734 prot[1] = '\0'; 735 if (vme->protection & VM_PROT_READ) 736 strcat(prot, "/read"); 737 if (vme->protection & VM_PROT_WRITE) 738 strcat(prot, "/write"); 739 if (vme->protection & VM_PROT_EXECUTE) 740 strcat(prot, "/exec"); 741 742 sz = (size_t)((vme->end - vme->start) / 1024); 743 printf("%*s%0*lX %6luK %-15s %s\n", 744 indent(2), "", 745 (int)sizeof(void *) * 2, 746 (unsigned long)vme->start, 747 (unsigned long)sz, 748 &prot[1], 749 name); 750 } 751 752 if (print_all) { 753 sz = (size_t)((vme->end - vme->start) / 1024); 754 printf(A(vp) ? 755 "%*s%0*lx-%0*lx %7luk %0*lx %c%c%c%c%c (%c%c%c) %d/%d/%d %02d:%02d %7d - %s [%p]\n" : 756 "%*s%0*lx-%0*lx %7luk %0*lx %c%c%c%c%c (%c%c%c) %d/%d/%d %02d:%02d %7d - %s\n", 757 indent(2), "", 758 (int)sizeof(void *) * 2, 759 vme->start, 760 (int)sizeof(void *) * 2, 761 vme->end - (vme->start != vme->end ? 1 : 0), 762 (unsigned long)sz, 763 (int)sizeof(void *) * 2, 764 (unsigned long)vme->offset, 765 (vme->protection & VM_PROT_READ) ? 'r' : '-', 766 (vme->protection & VM_PROT_WRITE) ? 'w' : '-', 767 (vme->protection & VM_PROT_EXECUTE) ? 'x' : '-', 768 (vme->etype & UVM_ET_COPYONWRITE) ? 'p' : 's', 769 (vme->etype & UVM_ET_NEEDSCOPY) ? '+' : '-', 770 (vme->max_protection & VM_PROT_READ) ? 'r' : '-', 771 (vme->max_protection & VM_PROT_WRITE) ? 'w' : '-', 772 (vme->max_protection & VM_PROT_EXECUTE) ? 'x' : '-', 773 vme->inheritance, 774 vme->wired_count, 775 vme->advice, 776 major(dev), minor(dev), inode, 777 name, P(vp)); 778 } 779 780 /* no access allowed, don't count space */ 781 if ((vme->protection & rwx) == 0) 782 sz = 0; 783 784 if (recurse && (vme->etype & UVM_ET_SUBMAP)) { 785 struct kbit kbit, *submap; 786 787 recurse++; 788 submap = &kbit; 789 P(submap) = vme->object.sub_map; 790 S(submap) = sizeof(*vme->object.sub_map); 791 KDEREF(kd, submap); 792 dump_vm_map(kd, vmspace, submap, "submap"); 793 recurse--; 794 } 795 796 return (sz); 797 } 798 799 char* 800 findname(kvm_t *kd, struct kbit *vmspace, 801 struct kbit *vm_map_entry, struct kbit *vp, 802 struct kbit *vfs, struct kbit *uvm_obj) 803 { 804 static char buf[1024], *name; 805 struct vm_map_entry *vme; 806 size_t l; 807 808 vme = D(vm_map_entry, vm_map_entry); 809 810 if (UVM_ET_ISOBJ(vme)) { 811 if (A(vfs)) { 812 l = (unsigned)strlen(D(vfs, mount)->mnt_stat.f_mntonname); 813 switch (search_cache(kd, vp, &name, buf, sizeof(buf))) { 814 case 0: /* found something */ 815 name--; 816 *name = '/'; 817 /*FALLTHROUGH*/ 818 case 2: /* found nothing */ 819 name -= 6; 820 memcpy(name, " -??- ", (size_t)6); 821 name -= l; 822 memcpy(name, 823 D(vfs, mount)->mnt_stat.f_mntonname, l); 824 break; 825 case 1: /* all is well */ 826 name--; 827 *name = '/'; 828 if (l != 1) { 829 name -= l; 830 memcpy(name, 831 D(vfs, mount)->mnt_stat.f_mntonname, l); 832 } 833 break; 834 } 835 } 836 else if (UVM_OBJ_IS_DEVICE(D(uvm_obj, uvm_object))) { 837 struct kbit kdev; 838 dev_t dev; 839 840 P(&kdev) = P(uvm_obj); 841 S(&kdev) = sizeof(struct uvm_device); 842 KDEREF(kd, &kdev); 843 dev = D(&kdev, uvm_device)->u_device; 844 name = devname(dev, S_IFCHR); 845 if (name != NULL) 846 snprintf(buf, sizeof(buf), "/dev/%s", name); 847 else 848 snprintf(buf, sizeof(buf), " [ device %d,%d ]", 849 major(dev), minor(dev)); 850 name = buf; 851 } 852 else if (UVM_OBJ_IS_AOBJ(D(uvm_obj, uvm_object))) 853 name = " [ uvm_aobj ]"; 854 else if (UVM_OBJ_IS_UBCPAGER(D(uvm_obj, uvm_object))) 855 name = " [ ubc_pager ]"; 856 else if (UVM_OBJ_IS_VNODE(D(uvm_obj, uvm_object))) 857 name = " [ ?VNODE? ]"; 858 else { 859 snprintf(buf, sizeof(buf), " [ ?? %p ?? ]", 860 D(uvm_obj, uvm_object)->pgops); 861 name = buf; 862 } 863 } 864 865 else if (D(vmspace, vmspace)->vm_maxsaddr <= 866 (caddr_t)vme->start && 867 (D(vmspace, vmspace)->vm_maxsaddr + (size_t)maxssiz) >= 868 (caddr_t)vme->end) 869 name = " [ stack ]"; 870 871 else if ((vme->protection & rwx) == rwx && !heapfound) { 872 /* XXX this could probably be done better */ 873 heapfound = 1; 874 name = " [ heap ]"; 875 } 876 877 else 878 name = " [ anon ]"; 879 880 return (name); 881 } 882 883 int 884 search_cache(kvm_t *kd, struct kbit *vp, char **name, char *buf, size_t blen) 885 { 886 char *o, *e; 887 struct cache_entry *ce; 888 struct kbit svp; 889 u_long cid; 890 891 if (nchashtbl == NULL) 892 load_name_cache(kd); 893 894 P(&svp) = P(vp); 895 S(&svp) = sizeof(struct vnode); 896 cid = D(vp, vnode)->v_id; 897 898 e = &buf[blen - 1]; 899 o = e; 900 do { 901 LIST_FOREACH(ce, &lcache, ce_next) 902 if (ce->ce_vp == P(&svp) && ce->ce_cid == cid) 903 break; 904 if (ce && ce->ce_vp == P(&svp) && ce->ce_cid == cid) { 905 if (o != e) 906 *(--o) = '/'; 907 o -= ce->ce_nlen; 908 memcpy(o, ce->ce_name, (unsigned)ce->ce_nlen); 909 P(&svp) = ce->ce_pvp; 910 cid = ce->ce_pcid; 911 } 912 else 913 break; 914 } while (1/*CONSTCOND*/); 915 *e = '\0'; 916 *name = o; 917 918 if (e == o) 919 return (2); 920 921 KDEREF(kd, &svp); 922 return (D(&svp, vnode)->v_flag & VROOT); 923 } 924 925 void 926 load_name_cache(kvm_t *kd) 927 { 928 struct namecache _ncp, *ncp, *oncp; 929 struct nchashhead _ncpp, *ncpp; 930 u_long nchash; 931 int i; 932 933 LIST_INIT(&lcache); 934 935 _KDEREF(kd, nchash_addr, &nchash, sizeof(nchash)); 936 nchashtbl = malloc(sizeof(nchashtbl) * (int)nchash); 937 _KDEREF(kd, nchashtbl_addr, nchashtbl, 938 sizeof(nchashtbl) * (int)nchash); 939 940 ncpp = &_ncpp; 941 942 for (i = 0; i <= nchash; i++) { 943 ncpp = &nchashtbl[i]; 944 oncp = NULL; 945 LIST_FOREACH(ncp, ncpp, nc_hash) { 946 if (ncp == oncp || 947 (void*)ncp < kernel_floor || 948 ncp == (void*)0xdeadbeef) 949 break; 950 oncp = ncp; 951 _KDEREF(kd, (u_long)ncp, &_ncp, sizeof(*ncp)); 952 ncp = &_ncp; 953 if ((void*)ncp->nc_vp > kernel_floor && 954 ncp->nc_nlen > 0) { 955 if (ncp->nc_nlen > 2 || 956 ncp->nc_name[0] != '.' || 957 (ncp->nc_name[1] != '.' && 958 ncp->nc_nlen != 1)) 959 cache_enter(i, ncp); 960 } 961 } 962 } 963 } 964 965 void 966 cache_enter(int i, struct namecache *ncp) 967 { 968 struct cache_entry *ce; 969 970 if (debug & DUMP_NAMEI_CACHE) 971 printf("[%d] ncp->nc_vp %10p, ncp->nc_dvp %10p, " 972 "ncp->nc_nlen %3d [%.*s] (nc_dvpid=%lu, nc_vpid=%lu)\n", 973 i, ncp->nc_vp, ncp->nc_dvp, 974 ncp->nc_nlen, ncp->nc_nlen, ncp->nc_name, 975 ncp->nc_dvpid, ncp->nc_vpid); 976 977 ce = malloc(sizeof(struct cache_entry)); 978 979 ce->ce_vp = ncp->nc_vp; 980 ce->ce_pvp = ncp->nc_dvp; 981 ce->ce_cid = ncp->nc_vpid; 982 ce->ce_pcid = ncp->nc_dvpid; 983 ce->ce_nlen = ncp->nc_nlen; 984 strncpy(ce->ce_name, ncp->nc_name, sizeof(ce->ce_name)); 985 ce->ce_name[MIN(ce->ce_nlen, sizeof(ce->ce_name) - 1)] = '\0'; 986 987 LIST_INSERT_HEAD(&lcache, ce, ce_next); 988 } 989
Indexes created Tue Sep 23 07:09:52 GMT 2025