pmap.c revision 1.6
1 /* $NetBSD: pmap.c,v 1.6 2002/10/12 03:08:27 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.6 2002/10/12 03:08:27 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 struct vm_map *kmem_map, *mb_map, *phys_map, *exec_map, *pager_map; 108 u_long nchash_addr, nchashtbl_addr, kernel_map_addr; 109 int debug, verbose, recurse; 110 int print_all, print_map, print_maps, print_solaris, print_ddb; 111 int rwx = VM_PROT_READ | VM_PROT_WRITE | VM_PROT_EXECUTE, heapfound; 112 rlim_t maxssiz; 113 114 struct kbit { 115 /* 116 * size of data chunk 117 */ 118 size_t k_size; 119 120 /* 121 * something for printf() and something for kvm_read() 122 */ 123 union { 124 void *k_addr_p; 125 u_long k_addr_ul; 126 } k_addr; 127 128 /* 129 * where we actually put the "stuff" 130 */ 131 union { 132 char data[1]; 133 struct vmspace vmspace; 134 struct vm_map vm_map; 135 struct vm_map_entry vm_map_entry; 136 struct vnode vnode; 137 struct uvm_object uvm_object; 138 struct mount mount; 139 struct namecache namecache; 140 struct inode inode; 141 struct iso_node iso_node; 142 struct uvm_device uvm_device; 143 } k_data; 144 }; 145 146 /* the size of the object in the kernel */ 147 #define S(x) ((x)->k_size) 148 /* the address of the object in kernel, two forms */ 149 #define A(x) ((x)->k_addr.k_addr_ul) 150 #define P(x) ((x)->k_addr.k_addr_p) 151 /* the data from the kernel */ 152 #define D(x,d) (&((x)->k_data.d)) 153 154 /* suck the data from the kernel */ 155 #define _KDEREF(kd, addr, dst, sz) do { \ 156 ssize_t len; \ 157 len = kvm_read((kd), (addr), (dst), (sz)); \ 158 if (len != (sz)) \ 159 errx(1, "trying to read %lu bytes from %lx: %s", \ 160 (unsigned long)(sz), (addr), kvm_geterr(kd)); \ 161 } while (0/*CONSTCOND*/) 162 163 /* suck the data using the structure */ 164 #define KDEREF(kd, item) _KDEREF((kd), A(item), D(item, data), S(item)) 165 166 /* when recursing, output is indented */ 167 #define indent(n) ((n) * (recurse > 1 ? recurse - 1 : 0)) 168 169 struct nlist nl[] = { 170 { "_maxsmap" }, 171 #define NL_MAXSSIZ 0 172 { "_uvm_vnodeops" }, 173 #define NL_UVM_VNODEOPS 1 174 { "_uvm_deviceops" }, 175 #define NL_UVM_DEVICEOPS 2 176 { "_aobj_pager" }, 177 #define NL_AOBJ_PAGER 3 178 { "_ubc_pager" }, 179 #define NL_UBC_PAGER 4 180 { "_kernel_map" }, 181 #define NL_KERNEL_MAP 5 182 { "_nchashtbl" }, 183 #define NL_NCHASHTBL 6 184 { "_nchash" }, 185 #define NL_NCHASH 7 186 { "_kernel_text" }, 187 #define NL_KENTER 8 188 { "_kmem_map" }, 189 #define NL_KMEM_MAP 9 190 { "_mb_map" }, 191 #define NL_MB_MAP 10 192 { "_phys_map" }, 193 #define NL_PHYS_MAP 11 194 { "_exec_map" }, 195 #define NL_EXEC_MAP 12 196 { "_pager_map" }, 197 #define NL_PAGER_MAP 13 198 { NULL } 199 }; 200 201 void check(int); 202 void load_symbols(kvm_t *); 203 void process_map(kvm_t *, pid_t, struct kinfo_proc2 *); 204 void dump_vm_map(kvm_t *, struct kbit *, struct kbit *, char *); 205 size_t dump_vm_map_entry(kvm_t *, struct kbit *, struct kbit *, int); 206 char *findname(kvm_t *, struct kbit *, struct kbit *, struct kbit *, 207 struct kbit *, struct kbit *); 208 int search_cache(kvm_t *, struct kbit *, char **, char *, size_t); 209 void load_name_cache(kvm_t *); 210 void cache_enter(int, struct namecache *); 211 212 int 213 main(int argc, char *argv[]) 214 { 215 kvm_t *kd; 216 pid_t pid; 217 int many, ch, rc; 218 char errbuf[_POSIX2_LINE_MAX + 1]; 219 struct kinfo_proc2 *kproc; 220 char *kmem, *kernel; 221 222 check(STDIN_FILENO); 223 check(STDOUT_FILENO); 224 check(STDERR_FILENO); 225 226 pid = -1; 227 verbose = debug = 0; 228 print_all = print_map = print_maps = print_solaris = print_ddb = 0; 229 recurse = 0; 230 kmem = kernel = NULL; 231 232 while ((ch = getopt(argc, argv, "aD:dlmM:N:p:PRrsvx")) != -1) { 233 switch (ch) { 234 case 'a': 235 print_all = 1; 236 break; 237 case 'd': 238 print_ddb = 1; 239 break; 240 case 'D': 241 debug = atoi(optarg); 242 break; 243 case 'l': 244 print_maps = 1; 245 break; 246 case 'm': 247 print_map = 1; 248 break; 249 case 'M': 250 kmem = optarg; 251 break; 252 case 'N': 253 kernel = optarg; 254 break; 255 case 'p': 256 pid = atoi(optarg); 257 break; 258 case 'P': 259 pid = getpid(); 260 break; 261 case 'R': 262 recurse = 1; 263 break; 264 case 's': 265 print_solaris = 1; 266 break; 267 case 'v': 268 verbose = 1; 269 break; 270 case 'r': 271 case 'x': 272 errx(1, "-%c option not implemented, sorry", optopt); 273 /*NOTREACHED*/ 274 case '?': 275 default: 276 fprintf(stderr, "usage: %s [-adlmPsv] [-D number] " 277 "[-M core] [-N system] [-p pid] [pid ...]\n", 278 getprogname()); 279 exit(1); 280 } 281 } 282 argc -= optind; 283 argv += optind; 284 285 /* more than one "process" to dump? */ 286 many = (argc > 1 - (pid == -1 ? 0 : 1)) ? 1 : 0; 287 288 /* apply default */ 289 if (print_all + print_map + print_maps + print_solaris + 290 print_ddb == 0) 291 print_solaris = 1; 292 293 /* start by opening libkvm */ 294 kd = kvm_openfiles(kernel, kmem, NULL, O_RDONLY, errbuf); 295 errbuf[_POSIX2_LINE_MAX] = '\0'; 296 if (kd == NULL) 297 errx(1, "%s", errbuf); 298 299 /* get "bootstrap" addresses from kernel */ 300 load_symbols(kd); 301 302 do { 303 if (pid == -1) { 304 if (argc == 0) 305 pid = getppid(); 306 else { 307 pid = atoi(argv[0]); 308 argv++; 309 argc--; 310 } 311 } 312 313 /* find the process id */ 314 if (pid == 0) 315 kproc = NULL; 316 else { 317 kproc = kvm_getproc2(kd, KERN_PROC_PID, pid, 318 sizeof(struct kinfo_proc2), &rc); 319 if (kproc == NULL || rc == 0) { 320 errno = ESRCH; 321 warn("%d", pid); 322 pid = -1; 323 continue; 324 } 325 } 326 327 /* dump it */ 328 if (many) { 329 if (kproc) 330 printf("process %d:\n", kproc->p_pid); 331 else 332 printf("kernel:\n"); 333 } 334 335 process_map(kd, pid, kproc); 336 pid = -1; 337 } while (argc > 0); 338 339 /* done. go away. */ 340 rc = kvm_close(kd); 341 if (rc == -1) 342 err(1, "kvm_close"); 343 344 return (0); 345 } 346 347 void 348 check(int fd) 349 { 350 struct stat st; 351 int n; 352 353 if (fstat(fd, &st) == -1) { 354 (void)close(fd); 355 n = open("/dev/null", O_RDWR); 356 if (n == fd || n == -1) 357 /* we're either done or we can do no more */ 358 return; 359 /* if either of these fail, there's not much we can do */ 360 (void)dup2(n, fd); 361 (void)close(n); 362 /* XXX should we exit if it fails? */ 363 } 364 } 365 366 void 367 process_map(kvm_t *kd, pid_t pid, struct kinfo_proc2 *proc) 368 { 369 struct kbit kbit[2], *vmspace, *vm_map; 370 char *thing; 371 372 vmspace = &kbit[0]; 373 vm_map = &kbit[1]; 374 375 A(vmspace) = 0; 376 A(vm_map) = 0; 377 378 if (pid > 0) { 379 heapfound = 0; 380 A(vmspace) = (u_long)proc->p_vmspace; 381 S(vmspace) = sizeof(struct vmspace); 382 KDEREF(kd, vmspace); 383 thing = "proc->p_vmspace.vm_map"; 384 } else { 385 heapfound = 1; /* but really, do kernels have a heap? */ 386 A(vmspace) = 0; 387 S(vmspace) = 0; 388 thing = "kernel_map"; 389 } 390 391 if (pid > 0 && (debug & PRINT_VMSPACE)) { 392 printf("proc->p_vmspace %p = {", P(vmspace)); 393 printf(" vm_refcnt = %d,", D(vmspace, vmspace)->vm_refcnt); 394 printf(" vm_shm = %p,\n", D(vmspace, vmspace)->vm_shm); 395 printf(" vm_rssize = %d,", D(vmspace, vmspace)->vm_rssize); 396 printf(" vm_swrss = %d,", D(vmspace, vmspace)->vm_swrss); 397 printf(" vm_tsize = %d,", D(vmspace, vmspace)->vm_tsize); 398 printf(" vm_dsize = %d,\n", D(vmspace, vmspace)->vm_dsize); 399 printf(" vm_ssize = %d,", D(vmspace, vmspace)->vm_ssize); 400 printf(" vm_taddr = %p,", D(vmspace, vmspace)->vm_taddr); 401 printf(" vm_daddr = %p,\n", D(vmspace, vmspace)->vm_daddr); 402 printf(" vm_maxsaddr = %p,", 403 D(vmspace, vmspace)->vm_maxsaddr); 404 printf(" vm_minsaddr = %p }\n", 405 D(vmspace, vmspace)->vm_minsaddr); 406 } 407 408 S(vm_map) = sizeof(struct vm_map); 409 if (pid > 0) { 410 A(vm_map) = A(vmspace); 411 memcpy(D(vm_map, vm_map), &D(vmspace, vmspace)->vm_map, 412 S(vm_map)); 413 } else { 414 A(vm_map) = kernel_map_addr; 415 KDEREF(kd, vm_map); 416 } 417 418 dump_vm_map(kd, vmspace, vm_map, thing); 419 } 420 421 void 422 load_symbols(kvm_t *kd) 423 { 424 int rc; 425 426 rc = kvm_nlist(kd, &nl[0]); 427 if (rc != 0) 428 errx(1, "%s == %d", kvm_geterr(kd), rc); 429 430 uvm_vnodeops = (void*)nl[NL_UVM_VNODEOPS].n_value; 431 uvm_deviceops = (void*)nl[NL_UVM_DEVICEOPS].n_value; 432 aobj_pager = (void*)nl[NL_AOBJ_PAGER].n_value; 433 ubc_pager = (void*)nl[NL_UBC_PAGER].n_value; 434 435 kernel_floor = (void*)nl[NL_KENTER].n_value; 436 nchash_addr = nl[NL_NCHASH].n_value; 437 438 _KDEREF(kd, nl[NL_MAXSSIZ].n_value, &maxssiz, 439 sizeof(maxssiz)); 440 _KDEREF(kd, nl[NL_NCHASHTBL].n_value, &nchashtbl_addr, 441 sizeof(nchashtbl_addr)); 442 _KDEREF(kd, nl[NL_KERNEL_MAP].n_value, &kernel_map_addr, 443 sizeof(kernel_map_addr)); 444 445 _KDEREF(kd, nl[NL_KMEM_MAP].n_value, &kmem_map, 446 sizeof(kmem_map)); 447 _KDEREF(kd, nl[NL_MB_MAP].n_value, &mb_map, 448 sizeof(mb_map)); 449 _KDEREF(kd, nl[NL_PHYS_MAP].n_value, &phys_map, 450 sizeof(phys_map)); 451 _KDEREF(kd, nl[NL_EXEC_MAP].n_value, &exec_map, 452 sizeof(exec_map)); 453 _KDEREF(kd, nl[NL_PAGER_MAP].n_value, &pager_map, 454 sizeof(pager_map)); 455 } 456 457 void 458 dump_vm_map(kvm_t *kd, struct kbit *vmspace, struct kbit *vm_map, 459 char *name) 460 { 461 struct kbit kbit[2], *header, *vm_map_entry; 462 struct vm_map_entry *last, *next; 463 size_t total; 464 u_long addr; 465 466 header = &kbit[0]; 467 vm_map_entry = &kbit[1]; 468 A(header) = 0; 469 A(vm_map_entry) = 0; 470 471 if (debug & PRINT_VM_MAP) { 472 printf("%*s%s %p = {", indent(2), "", name, P(vm_map)); 473 printf(" pmap = %p,\n", D(vm_map, vm_map)->pmap); 474 printf("%*s lock = <struct lock>,", indent(2), ""); 475 printf(" header = <struct vm_map_entry>,"); 476 printf(" nentries = %d,\n", D(vm_map, vm_map)->nentries); 477 printf("%*s size = %lx,", indent(2), "", 478 D(vm_map, vm_map)->size); 479 printf(" ref_count = %d,", D(vm_map, vm_map)->ref_count); 480 printf(" ref_lock = <struct simplelock>,\n"); 481 printf("%*s hint = %p,", indent(2), "", 482 D(vm_map, vm_map)->hint); 483 printf(" hint_lock = <struct simplelock>,\n"); 484 printf("%*s first_free = %p,", indent(2), "", 485 D(vm_map, vm_map)->first_free); 486 printf(" flags = %x <%s%s%s%s%s%s >,\n", D(vm_map, vm_map)->flags, 487 D(vm_map, vm_map)->flags & VM_MAP_PAGEABLE ? " PAGEABLE" : "", 488 D(vm_map, vm_map)->flags & VM_MAP_INTRSAFE ? " INTRSAFE" : "", 489 D(vm_map, vm_map)->flags & VM_MAP_WIREFUTURE ? " WIREFUTURE" : "", 490 D(vm_map, vm_map)->flags & VM_MAP_BUSY ? " BUSY" : "", 491 D(vm_map, vm_map)->flags & VM_MAP_WANTLOCK ? " WANTLOCK" : "", 492 #ifdef VM_MAP_DYING 493 D(vm_map, vm_map)->flags & VM_MAP_DYING ? " DYING" : "", 494 #endif 495 #ifdef VM_MAP_TOPDOWN 496 D(vm_map, vm_map)->flags & VM_MAP_TOPDOWN ? " TOPDOWN" : 497 #endif 498 ""); 499 printf("%*s flags_lock = <struct simplelock>,", indent(2), ""); 500 printf(" timestamp = %u }\n", D(vm_map, vm_map)->timestamp); 501 } 502 if (print_ddb) { 503 char *name; 504 505 if (A(vm_map) == kernel_map_addr) 506 name = "kernel_map"; 507 else if (P(vm_map) == kmem_map) 508 name = "kmem_map"; 509 else if (P(vm_map) == mb_map) 510 name = "mb_map"; 511 else if (P(vm_map) == phys_map) 512 name = "phys_map"; 513 else if (P(vm_map) == exec_map) 514 name = "exec_map"; 515 else if (P(vm_map) == pager_map) 516 name = "pager_map"; 517 else 518 name = NULL; 519 520 printf("%*s%s %p: [0x%lx->0x%lx]\n", indent(2), "", 521 recurse < 2 ? "MAP" : "SUBMAP", P(vm_map), 522 D(vm_map, vm_map)->min_offset, 523 D(vm_map, vm_map)->max_offset); 524 printf("\t%*s#ent=%d, sz=%ld, ref=%d, version=%d, flags=0x%x\n", 525 indent(2), "", D(vm_map, vm_map)->nentries, 526 D(vm_map, vm_map)->size, D(vm_map, vm_map)->ref_count, 527 D(vm_map, vm_map)->timestamp, D(vm_map, vm_map)->flags); 528 printf("\t%*spmap=%p(resident=<unknown>)\n", indent(2), "", 529 D(vm_map, vm_map)->pmap); 530 if (verbose && name != NULL) 531 printf("\t%*s([ %s ])\n", indent(2), "", name); 532 } 533 534 A(header) = A(vm_map) + offsetof(struct vm_map, header); 535 S(header) = sizeof(struct vm_map_entry); 536 memcpy(D(header, vm_map_entry), &D(vm_map, vm_map)->header, S(header)); 537 dump_vm_map_entry(kd, vmspace, header, 1); 538 539 /* 540 * we're not recursing into a submap, so print headers 541 */ 542 if (recurse < 2) { 543 /* headers */ 544 #ifdef DISABLED_HEADERS 545 if (print_map) 546 printf("%-*s %-*s rwx RWX CPY NCP I W A\n", 547 (int)sizeof(long) * 2 + 2, "Start", 548 (int)sizeof(long) * 2 + 2, "End"); 549 if (print_maps) 550 printf("%-*s %-*s rwxp %-*s Dev Inode File\n", 551 (int)sizeof(long) * 2 + 0, "Start", 552 (int)sizeof(long) * 2 + 0, "End", 553 (int)sizeof(long) * 2 + 0, "Offset"); 554 if (print_solaris) 555 printf("%-*s %*s Protection File\n", 556 (int)sizeof(long) * 2 + 0, "Start", 557 (int)sizeof(int) * 2 - 1, "Size "); 558 #endif 559 if (print_all) 560 printf("%-*s %-*s %*s %-*s rwxpc RWX I/W/A Dev %*s" 561 " - File\n", 562 (int)sizeof(long) * 2, "Start", 563 (int)sizeof(long) * 2, "End", 564 (int)sizeof(int) * 2, "Size ", 565 (int)sizeof(long) * 2, "Offset", 566 (int)sizeof(int) * 2, "Inode"); 567 } 568 569 /* these are the "sub entries" */ 570 total = 0; 571 next = D(header, vm_map_entry)->next; 572 last = P(header); 573 574 while (next != 0 && next != last) { 575 addr = (u_long)next; 576 A(vm_map_entry) = addr; 577 S(vm_map_entry) = sizeof(struct vm_map_entry); 578 KDEREF(kd, vm_map_entry); 579 next = D(vm_map_entry, vm_map_entry)->next; 580 total += dump_vm_map_entry(kd, vmspace, vm_map_entry, 0); 581 } 582 583 /* 584 * we're not recursing into a submap, so print totals 585 */ 586 if (recurse < 2) { 587 if (print_solaris) 588 printf("%-*s %8luK\n", 589 (int)sizeof(void *) * 2 - 2, " total", 590 (unsigned long)total); 591 if (print_all) 592 printf("%-*s %9luk\n", 593 (int)sizeof(void *) * 4 - 1, " total", 594 (unsigned long)total); 595 } 596 } 597 598 size_t 599 dump_vm_map_entry(kvm_t *kd, struct kbit *vmspace, 600 struct kbit *vm_map_entry, 601 int ishead) 602 { 603 struct kbit kbit[3]; 604 struct kbit *uvm_obj, *vp, *vfs; 605 struct vm_map_entry *vme; 606 size_t sz; 607 char *name; 608 dev_t dev; 609 ino_t inode; 610 611 uvm_obj = &kbit[0]; 612 vp = &kbit[1]; 613 vfs = &kbit[2]; 614 615 A(uvm_obj) = 0; 616 A(vp) = 0; 617 A(vfs) = 0; 618 619 vme = D(vm_map_entry, vm_map_entry); 620 621 if ((ishead && (debug & PRINT_VM_MAP_HEADER)) || 622 (!ishead && (debug & PRINT_VM_MAP_ENTRY))) { 623 printf("%*s%s %p = {", indent(2), "", 624 ishead ? "vm_map.header" : "vm_map_entry", 625 P(vm_map_entry)); 626 printf(" prev = %p,", vme->prev); 627 printf(" next = %p,\n", vme->next); 628 printf("%*s start = %lx,", indent(2), "", vme->start); 629 printf(" end = %lx,", vme->end); 630 printf(" object.uvm_obj/sub_map = %p,\n", vme->object.uvm_obj); 631 printf("%*s offset = %lx,", indent(2), "", 632 (unsigned long)vme->offset); 633 printf(" etype = %x <%s%s%s%s >,", vme->etype, 634 vme->etype & UVM_ET_OBJ ? " OBJ" : "", 635 vme->etype & UVM_ET_SUBMAP ? " SUBMAP" : "", 636 vme->etype & UVM_ET_COPYONWRITE ? " COW" : "", 637 vme->etype & UVM_ET_NEEDSCOPY ? " NEEDSCOPY" : ""); 638 printf(" protection = %x,\n", vme->protection); 639 printf("%*s max_protection = %x,", indent(2), "", 640 vme->max_protection); 641 printf(" inheritance = %d,", vme->inheritance); 642 printf(" wired_count = %d,\n", vme->wired_count); 643 printf("%*s aref = { ar_pageoff = %x, ar_amap = %p },", 644 indent(2), "", vme->aref.ar_pageoff, vme->aref.ar_amap); 645 printf(" advice = %d,\n", vme->advice); 646 printf("%*s flags = %x <%s%s > }\n", indent(2), "", 647 vme->flags, 648 vme->flags & UVM_MAP_STATIC ? " STATIC" : "", 649 vme->flags & UVM_MAP_KMEM ? " KMEM" : ""); 650 } 651 652 if (ishead) 653 return (0); 654 655 A(vp) = 0; 656 A(uvm_obj) = 0; 657 658 if (vme->object.uvm_obj != NULL) { 659 P(uvm_obj) = vme->object.uvm_obj; 660 S(uvm_obj) = sizeof(struct uvm_object); 661 KDEREF(kd, uvm_obj); 662 if (UVM_ET_ISOBJ(vme) && 663 UVM_OBJ_IS_VNODE(D(uvm_obj, uvm_object))) { 664 P(vp) = P(uvm_obj); 665 S(vp) = sizeof(struct vnode); 666 KDEREF(kd, vp); 667 } 668 } 669 670 A(vfs) = NULL; 671 672 if (P(vp) != NULL && D(vp, vnode)->v_mount != NULL) { 673 P(vfs) = D(vp, vnode)->v_mount; 674 S(vfs) = sizeof(struct mount); 675 KDEREF(kd, vfs); 676 D(vp, vnode)->v_mount = D(vfs, mount); 677 } 678 679 /* 680 * dig out the device number and inode number from certain 681 * file system types. 682 */ 683 #define V_DATA_IS(vp, type, d, i) do { \ 684 struct kbit data; \ 685 P(&data) = D(vp, vnode)->v_data; \ 686 S(&data) = sizeof(*D(&data, type)); \ 687 KDEREF(kd, &data); \ 688 dev = D(&data, type)->d; \ 689 inode = D(&data, type)->i; \ 690 } while (0/*CONSTCOND*/) 691 692 dev = 0; 693 inode = 0; 694 695 if (A(vp) && 696 D(vp, vnode)->v_type == VREG && 697 D(vp, vnode)->v_data != NULL) { 698 switch (D(vp, vnode)->v_tag) { 699 case VT_UFS: 700 case VT_LFS: 701 case VT_EXT2FS: 702 V_DATA_IS(vp, inode, i_dev, i_number); 703 break; 704 case VT_ISOFS: 705 V_DATA_IS(vp, iso_node, i_dev, i_number); 706 break; 707 case VT_NON: 708 case VT_NFS: 709 case VT_MFS: 710 case VT_MSDOSFS: 711 case VT_LOFS: 712 case VT_FDESC: 713 case VT_PORTAL: 714 case VT_NULL: 715 case VT_UMAP: 716 case VT_KERNFS: 717 case VT_PROCFS: 718 case VT_AFS: 719 case VT_UNION: 720 case VT_ADOSFS: 721 case VT_CODA: 722 case VT_FILECORE: 723 case VT_NTFS: 724 case VT_VFS: 725 case VT_OVERLAY: 726 case VT_SMBFS: 727 break; 728 } 729 } 730 731 name = findname(kd, vmspace, vm_map_entry, vp, vfs, uvm_obj); 732 733 if (print_map) { 734 printf("%*s0x%lx 0x%lx %c%c%c %c%c%c %s %s %d %d %d", 735 indent(2), "", 736 vme->start, vme->end, 737 (vme->protection & VM_PROT_READ) ? 'r' : '-', 738 (vme->protection & VM_PROT_WRITE) ? 'w' : '-', 739 (vme->protection & VM_PROT_EXECUTE) ? 'x' : '-', 740 (vme->max_protection & VM_PROT_READ) ? 'r' : '-', 741 (vme->max_protection & VM_PROT_WRITE) ? 'w' : '-', 742 (vme->max_protection & VM_PROT_EXECUTE) ? 'x' : '-', 743 (vme->etype & UVM_ET_COPYONWRITE) ? "COW" : "NCOW", 744 (vme->etype & UVM_ET_NEEDSCOPY) ? "NC" : "NNC", 745 vme->inheritance, vme->wired_count, 746 vme->advice); 747 if (verbose) { 748 if (inode) 749 printf(" %d,%d %d", 750 major(dev), minor(dev), inode); 751 if (name[0]) 752 printf(" %s", name); 753 } 754 printf("\n"); 755 } 756 757 if (print_maps) { 758 printf("%*s%0*lx-%0*lx %c%c%c%c %0*lx %02x:%02x %d %s\n", 759 indent(2), "", 760 (int)sizeof(void *) * 2, vme->start, 761 (int)sizeof(void *) * 2, vme->end, 762 (vme->protection & VM_PROT_READ) ? 'r' : '-', 763 (vme->protection & VM_PROT_WRITE) ? 'w' : '-', 764 (vme->protection & VM_PROT_EXECUTE) ? 'x' : '-', 765 (vme->etype & UVM_ET_COPYONWRITE) ? 'p' : 's', 766 (int)sizeof(void *) * 2, 767 (unsigned long)vme->offset, 768 major(dev), minor(dev), inode, 769 (name[0] != ' ') || verbose ? name : ""); 770 } 771 772 if (print_ddb) { 773 printf("%*s - %p: 0x%lx->0x%lx: obj=%p/0x%lx, amap=%p/%d\n", 774 indent(2), "", 775 P(vm_map_entry), vme->start, vme->end, 776 vme->object.uvm_obj, (unsigned long)vme->offset, 777 vme->aref.ar_amap, vme->aref.ar_pageoff); 778 printf("\t%*ssubmap=%c, cow=%c, nc=%c, prot(max)=%d/%d, inh=%d, " 779 "wc=%d, adv=%d\n", 780 indent(2), "", 781 (vme->etype & UVM_ET_SUBMAP) ? 'T' : 'F', 782 (vme->etype & UVM_ET_COPYONWRITE) ? 'T' : 'F', 783 (vme->etype & UVM_ET_NEEDSCOPY) ? 'T' : 'F', 784 vme->protection, vme->max_protection, 785 vme->inheritance, vme->wired_count, vme->advice); 786 if (verbose) { 787 printf("\t%*s", indent(2), ""); 788 if (inode) 789 printf("(dev=%d,%d ino=%d [%s] [%p])\n", 790 major(dev), minor(dev), inode, 791 name, P(vp)); 792 else if (name[0] == ' ') 793 printf("(%s)\n", &name[2]); 794 else 795 printf("(%s)\n", name); 796 } 797 } 798 799 sz = 0; 800 if (print_solaris) { 801 char prot[30]; 802 803 prot[0] = '\0'; 804 prot[1] = '\0'; 805 if (vme->protection & VM_PROT_READ) 806 strcat(prot, "/read"); 807 if (vme->protection & VM_PROT_WRITE) 808 strcat(prot, "/write"); 809 if (vme->protection & VM_PROT_EXECUTE) 810 strcat(prot, "/exec"); 811 812 sz = (size_t)((vme->end - vme->start) / 1024); 813 printf("%*s%0*lX %6luK %-15s %s\n", 814 indent(2), "", 815 (int)sizeof(void *) * 2, 816 (unsigned long)vme->start, 817 (unsigned long)sz, 818 &prot[1], 819 name); 820 } 821 822 if (print_all) { 823 sz = (size_t)((vme->end - vme->start) / 1024); 824 printf(A(vp) ? 825 "%*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" : 826 "%*s%0*lx-%0*lx %7luk %0*lx %c%c%c%c%c (%c%c%c) %d/%d/%d %02d:%02d %7d - %s\n", 827 indent(2), "", 828 (int)sizeof(void *) * 2, 829 vme->start, 830 (int)sizeof(void *) * 2, 831 vme->end - (vme->start != vme->end ? 1 : 0), 832 (unsigned long)sz, 833 (int)sizeof(void *) * 2, 834 (unsigned long)vme->offset, 835 (vme->protection & VM_PROT_READ) ? 'r' : '-', 836 (vme->protection & VM_PROT_WRITE) ? 'w' : '-', 837 (vme->protection & VM_PROT_EXECUTE) ? 'x' : '-', 838 (vme->etype & UVM_ET_COPYONWRITE) ? 'p' : 's', 839 (vme->etype & UVM_ET_NEEDSCOPY) ? '+' : '-', 840 (vme->max_protection & VM_PROT_READ) ? 'r' : '-', 841 (vme->max_protection & VM_PROT_WRITE) ? 'w' : '-', 842 (vme->max_protection & VM_PROT_EXECUTE) ? 'x' : '-', 843 vme->inheritance, 844 vme->wired_count, 845 vme->advice, 846 major(dev), minor(dev), inode, 847 name, P(vp)); 848 } 849 850 /* no access allowed, don't count space */ 851 if ((vme->protection & rwx) == 0) 852 sz = 0; 853 854 if (recurse && (vme->etype & UVM_ET_SUBMAP)) { 855 struct kbit kbit, *submap; 856 857 recurse++; 858 submap = &kbit; 859 P(submap) = vme->object.sub_map; 860 S(submap) = sizeof(*vme->object.sub_map); 861 KDEREF(kd, submap); 862 dump_vm_map(kd, vmspace, submap, "submap"); 863 recurse--; 864 } 865 866 return (sz); 867 } 868 869 char* 870 findname(kvm_t *kd, struct kbit *vmspace, 871 struct kbit *vm_map_entry, struct kbit *vp, 872 struct kbit *vfs, struct kbit *uvm_obj) 873 { 874 static char buf[1024], *name; 875 struct vm_map_entry *vme; 876 size_t l; 877 878 vme = D(vm_map_entry, vm_map_entry); 879 880 if (UVM_ET_ISOBJ(vme)) { 881 if (A(vfs)) { 882 l = (unsigned)strlen(D(vfs, mount)->mnt_stat.f_mntonname); 883 switch (search_cache(kd, vp, &name, buf, sizeof(buf))) { 884 case 0: /* found something */ 885 name--; 886 *name = '/'; 887 /*FALLTHROUGH*/ 888 case 2: /* found nothing */ 889 name -= 6; 890 memcpy(name, " -??- ", (size_t)6); 891 name -= l; 892 memcpy(name, 893 D(vfs, mount)->mnt_stat.f_mntonname, l); 894 break; 895 case 1: /* all is well */ 896 name--; 897 *name = '/'; 898 if (l != 1) { 899 name -= l; 900 memcpy(name, 901 D(vfs, mount)->mnt_stat.f_mntonname, l); 902 } 903 break; 904 } 905 } 906 else if (UVM_OBJ_IS_DEVICE(D(uvm_obj, uvm_object))) { 907 struct kbit kdev; 908 dev_t dev; 909 910 P(&kdev) = P(uvm_obj); 911 S(&kdev) = sizeof(struct uvm_device); 912 KDEREF(kd, &kdev); 913 dev = D(&kdev, uvm_device)->u_device; 914 name = devname(dev, S_IFCHR); 915 if (name != NULL) 916 snprintf(buf, sizeof(buf), "/dev/%s", name); 917 else 918 snprintf(buf, sizeof(buf), " [ device %d,%d ]", 919 major(dev), minor(dev)); 920 name = buf; 921 } 922 else if (UVM_OBJ_IS_AOBJ(D(uvm_obj, uvm_object))) 923 name = " [ uvm_aobj ]"; 924 else if (UVM_OBJ_IS_UBCPAGER(D(uvm_obj, uvm_object))) 925 name = " [ ubc_pager ]"; 926 else if (UVM_OBJ_IS_VNODE(D(uvm_obj, uvm_object))) 927 name = " [ ?VNODE? ]"; 928 else { 929 snprintf(buf, sizeof(buf), " [ ?? %p ?? ]", 930 D(uvm_obj, uvm_object)->pgops); 931 name = buf; 932 } 933 } 934 935 else if (D(vmspace, vmspace)->vm_maxsaddr <= 936 (caddr_t)vme->start && 937 (D(vmspace, vmspace)->vm_maxsaddr + (size_t)maxssiz) >= 938 (caddr_t)vme->end) 939 name = " [ stack ]"; 940 941 else if ((vme->protection & rwx) == rwx && !heapfound) { 942 /* XXX this could probably be done better */ 943 heapfound = 1; 944 name = " [ heap ]"; 945 } 946 947 else 948 name = " [ anon ]"; 949 950 return (name); 951 } 952 953 int 954 search_cache(kvm_t *kd, struct kbit *vp, char **name, char *buf, size_t blen) 955 { 956 char *o, *e; 957 struct cache_entry *ce; 958 struct kbit svp; 959 u_long cid; 960 961 if (nchashtbl == NULL) 962 load_name_cache(kd); 963 964 P(&svp) = P(vp); 965 S(&svp) = sizeof(struct vnode); 966 cid = D(vp, vnode)->v_id; 967 968 e = &buf[blen - 1]; 969 o = e; 970 do { 971 LIST_FOREACH(ce, &lcache, ce_next) 972 if (ce->ce_vp == P(&svp) && ce->ce_cid == cid) 973 break; 974 if (ce && ce->ce_vp == P(&svp) && ce->ce_cid == cid) { 975 if (o != e) 976 *(--o) = '/'; 977 o -= ce->ce_nlen; 978 memcpy(o, ce->ce_name, (unsigned)ce->ce_nlen); 979 P(&svp) = ce->ce_pvp; 980 cid = ce->ce_pcid; 981 } 982 else 983 break; 984 } while (1/*CONSTCOND*/); 985 *e = '\0'; 986 *name = o; 987 988 if (e == o) 989 return (2); 990 991 KDEREF(kd, &svp); 992 return (D(&svp, vnode)->v_flag & VROOT); 993 } 994 995 void 996 load_name_cache(kvm_t *kd) 997 { 998 struct namecache _ncp, *ncp, *oncp; 999 struct nchashhead _ncpp, *ncpp; 1000 u_long nchash; 1001 int i; 1002 1003 LIST_INIT(&lcache); 1004 1005 _KDEREF(kd, nchash_addr, &nchash, sizeof(nchash)); 1006 nchashtbl = malloc(sizeof(nchashtbl) * (int)nchash); 1007 _KDEREF(kd, nchashtbl_addr, nchashtbl, 1008 sizeof(nchashtbl) * (int)nchash); 1009 1010 ncpp = &_ncpp; 1011 1012 for (i = 0; i <= nchash; i++) { 1013 ncpp = &nchashtbl[i]; 1014 oncp = NULL; 1015 LIST_FOREACH(ncp, ncpp, nc_hash) { 1016 if (ncp == oncp || 1017 (void*)ncp < kernel_floor || 1018 ncp == (void*)0xdeadbeef) 1019 break; 1020 oncp = ncp; 1021 _KDEREF(kd, (u_long)ncp, &_ncp, sizeof(*ncp)); 1022 ncp = &_ncp; 1023 if ((void*)ncp->nc_vp > kernel_floor && 1024 ncp->nc_nlen > 0) { 1025 if (ncp->nc_nlen > 2 || 1026 ncp->nc_name[0] != '.' || 1027 (ncp->nc_name[1] != '.' && 1028 ncp->nc_nlen != 1)) 1029 cache_enter(i, ncp); 1030 } 1031 } 1032 } 1033 } 1034 1035 void 1036 cache_enter(int i, struct namecache *ncp) 1037 { 1038 struct cache_entry *ce; 1039 1040 if (debug & DUMP_NAMEI_CACHE) 1041 printf("[%d] ncp->nc_vp %10p, ncp->nc_dvp %10p, " 1042 "ncp->nc_nlen %3d [%.*s] (nc_dvpid=%lu, nc_vpid=%lu)\n", 1043 i, ncp->nc_vp, ncp->nc_dvp, 1044 ncp->nc_nlen, ncp->nc_nlen, ncp->nc_name, 1045 ncp->nc_dvpid, ncp->nc_vpid); 1046 1047 ce = malloc(sizeof(struct cache_entry)); 1048 1049 ce->ce_vp = ncp->nc_vp; 1050 ce->ce_pvp = ncp->nc_dvp; 1051 ce->ce_cid = ncp->nc_vpid; 1052 ce->ce_pcid = ncp->nc_dvpid; 1053 ce->ce_nlen = ncp->nc_nlen; 1054 strncpy(ce->ce_name, ncp->nc_name, sizeof(ce->ce_name)); 1055 ce->ce_name[MIN(ce->ce_nlen, sizeof(ce->ce_name) - 1)] = '\0'; 1056 1057 LIST_INSERT_HEAD(&lcache, ce, ce_next); 1058 } 1059
Indexes created Mon Sep 22 13:09:51 GMT 2025