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