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