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