procmap.c revision 1.43
1/* $OpenBSD: procmap.c,v 1.43 2013/03/20 14:53:35 deraadt 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#include <uvm/uvm_amap.h> 47 48#include <ufs/ufs/quota.h> 49#include <ufs/ufs/inode.h> 50#undef doff_t 51#undef IN_ACCESS 52#undef i_size 53#undef i_devvp 54#include <isofs/cd9660/iso.h> 55#include <isofs/cd9660/cd9660_node.h> 56 57#include <kvm.h> 58#include <fcntl.h> 59#include <errno.h> 60#include <err.h> 61#include <stdlib.h> 62#include <stddef.h> 63#include <unistd.h> 64#include <stdio.h> 65#include <limits.h> 66#include <string.h> 67 68/* 69 * stolen (and munged) from #include <uvm/uvm_object.h> 70 */ 71#define UVM_OBJ_IS_VNODE(uobj) ((uobj)->pgops == uvm_vnodeops) 72#define UVM_OBJ_IS_AOBJ(uobj) ((uobj)->pgops == aobj_pager) 73#define UVM_OBJ_IS_DEVICE(uobj) ((uobj)->pgops == uvm_deviceops) 74 75#define PRINT_VMSPACE 0x00000001 76#define PRINT_VM_MAP 0x00000002 77#define PRINT_VM_MAP_HEADER 0x00000004 78#define PRINT_VM_MAP_ENTRY 0x00000008 79#define DUMP_NAMEI_CACHE 0x00000010 80 81struct cache_entry { 82 LIST_ENTRY(cache_entry) ce_next; 83 struct vnode *ce_vp, *ce_pvp; 84 u_long ce_cid, ce_pcid; 85 unsigned int ce_nlen; 86 char ce_name[256]; 87}; 88 89LIST_HEAD(cache_head, cache_entry) lcache; 90void *uvm_vnodeops, *uvm_deviceops, *aobj_pager; 91u_long kernel_map_addr; 92int debug, verbose; 93int print_all, print_map, print_maps, print_solaris, print_ddb, print_amap; 94int rwx = VM_PROT_READ | VM_PROT_WRITE | VM_PROT_EXECUTE; 95rlim_t maxssiz; 96 97struct sum { 98 unsigned long s_am_nslots; 99 unsigned long s_am_maxslots; 100 unsigned long s_am_nusedslots; 101}; 102 103struct kbit { 104 /* 105 * size of data chunk 106 */ 107 size_t k_size; 108 109 /* 110 * something for printf() and something for kvm_read() 111 */ 112 union { 113 void *k_addr_p; 114 u_long k_addr_ul; 115 } k_addr; 116 117 /* 118 * where we actually put the "stuff" 119 */ 120 union { 121 char data[1]; 122 struct vmspace vmspace; 123 struct vm_map vm_map; 124 struct vm_map_entry vm_map_entry; 125 struct vnode vnode; 126 struct uvm_object uvm_object; 127 struct mount mount; 128 struct namecache namecache; 129 struct inode inode; 130 struct iso_node iso_node; 131 struct uvm_device uvm_device; 132 struct vm_amap vm_amap; 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 156struct 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 { NULL } 168}; 169 170void load_symbols(kvm_t *); 171void process_map(kvm_t *, pid_t, struct kinfo_proc *, struct sum *); 172struct vm_map_entry *load_vm_map_entries(kvm_t *, struct vm_map_entry *, 173 struct vm_map_entry *); 174void unload_vm_map_entries(struct vm_map_entry *); 175size_t dump_vm_map_entry(kvm_t *, struct kbit *, struct vm_map_entry *, 176 struct sum *); 177char *findname(kvm_t *, struct kbit *, struct vm_map_entry *, struct kbit *, 178 struct kbit *, struct kbit *); 179int search_cache(kvm_t *, struct kbit *, char **, char *, size_t); 180#if 0 181void load_name_cache(kvm_t *); 182void cache_enter(struct namecache *); 183#endif 184static void __dead usage(void); 185static pid_t strtopid(const char *); 186void print_sum(struct sum *, struct sum *); 187 188/* 189 * uvm_map address tree implementation. 190 */ 191static int no_impl(void *, void *); 192static int 193no_impl(void *p, void *q) 194{ 195 errx(1, "uvm_map address comparison not implemented"); 196 return 0; 197} 198 199RB_GENERATE(uvm_map_addr, vm_map_entry, daddrs.addr_entry, no_impl); 200 201int 202main(int argc, char *argv[]) 203{ 204 char errbuf[_POSIX2_LINE_MAX], *kmem = NULL, *kernel = NULL; 205 struct kinfo_proc *kproc; 206 struct sum total_sum; 207 int many, ch, rc; 208 kvm_t *kd; 209 pid_t pid = -1; 210 gid_t gid; 211 212 while ((ch = getopt(argc, argv, "AaD:dlmM:N:p:Prsvx")) != -1) { 213 switch (ch) { 214 case 'A': 215 print_amap = 1; 216 break; 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", ch); 253 /*NOTREACHED*/ 254 default: 255 usage(); 256 } 257 } 258 259 if (getuid() && pid == -1) 260 errx(1, "only root may look at the kernel"); 261 262 /* 263 * Discard setgid privileges if not the running kernel so that bad 264 * guys can't print interesting stuff from kernel memory. 265 */ 266 gid = getgid(); 267 if (kernel != NULL || kmem != NULL) 268 if (setresgid(gid, gid, gid) == -1) 269 err(1, "setresgid"); 270 271 argc -= optind; 272 argv += optind; 273 274 /* more than one "process" to dump? */ 275 many = (argc > 1 - (pid == -1 ? 0 : 1)) ? 1 : 0; 276 277 /* apply default */ 278 if (print_all + print_map + print_maps + print_solaris + 279 print_ddb == 0) 280 print_solaris = 1; 281 282 /* start by opening libkvm */ 283 kd = kvm_openfiles(kernel, kmem, NULL, O_RDONLY, errbuf); 284 285 if (kernel == NULL && kmem == NULL) 286 if (setresgid(gid, gid, gid) == -1) 287 err(1, "setresgid"); 288 289 if (kd == NULL) 290 errx(1, "%s", errbuf); 291 292 /* get "bootstrap" addresses from kernel */ 293 load_symbols(kd); 294 295 memset(&total_sum, 0, sizeof(total_sum)); 296 297 do { 298 struct sum sum; 299 300 memset(&sum, 0, sizeof(sum)); 301 302 if (pid == -1) { 303 if (argc == 0) 304 pid = getppid(); 305 else { 306 pid = strtopid(argv[0]); 307 argv++; 308 argc--; 309 } 310 } 311 312 /* find the process id */ 313 if (pid == 0) 314 kproc = NULL; 315 else { 316 kproc = kvm_getprocs(kd, KERN_PROC_PID, pid, 317 sizeof(struct kinfo_proc), &rc); 318 if (kproc == NULL || rc == 0) { 319 errno = ESRCH; 320 warn("%d", pid); 321 pid = -1; 322 continue; 323 } 324 } 325 326 /* dump it */ 327 if (many) { 328 if (kproc) 329 printf("process %d:\n", pid); 330 else 331 printf("kernel:\n"); 332 } 333 334 process_map(kd, pid, kproc, &sum); 335 if (print_amap) 336 print_sum(&sum, &total_sum); 337 pid = -1; 338 } while (argc > 0); 339 340 if (print_amap) 341 print_sum(&total_sum, NULL); 342 343 /* done. go away. */ 344 rc = kvm_close(kd); 345 if (rc == -1) 346 err(1, "kvm_close"); 347 348 return (0); 349} 350 351void 352print_sum(struct sum *sum, struct sum *total_sum) 353{ 354 const char *t = total_sum == NULL ? "total " : ""; 355 printf("%samap allocated slots: %lu\n", t, sum->s_am_maxslots); 356 printf("%samap mapped slots: %lu\n", t, sum->s_am_nslots); 357 printf("%samap used slots: %lu\n", t, sum->s_am_nusedslots); 358 359 if (total_sum) { 360 total_sum->s_am_maxslots += sum->s_am_maxslots; 361 total_sum->s_am_nslots += sum->s_am_nslots; 362 total_sum->s_am_nusedslots += sum->s_am_nusedslots; 363 } 364} 365 366void 367process_map(kvm_t *kd, pid_t pid, struct kinfo_proc *proc, struct sum *sum) 368{ 369 struct kbit kbit[3], *vmspace, *vm_map; 370 struct vm_map_entry *vm_map_entry; 371 size_t total = 0; 372 char *thing; 373 uid_t uid; 374 int vmmap_flags; 375 376 if ((uid = getuid())) { 377 if (pid == 0) { 378 warnx("kernel map is restricted"); 379 return; 380 } 381 if (uid != proc->p_uid) { 382 warnx("other users' process maps are restricted"); 383 return; 384 } 385 } 386 387 vmspace = &kbit[0]; 388 vm_map = &kbit[1]; 389 390 A(vmspace) = 0; 391 A(vm_map) = 0; 392 393 if (pid > 0) { 394 A(vmspace) = (u_long)proc->p_vmspace; 395 S(vmspace) = sizeof(struct vmspace); 396 KDEREF(kd, vmspace); 397 thing = "proc->p_vmspace.vm_map"; 398 } else { 399 A(vmspace) = 0; 400 S(vmspace) = 0; 401 thing = "kernel_map"; 402 } 403 404 if (pid > 0 && (debug & PRINT_VMSPACE)) { 405 printf("proc->p_vmspace %p = {", P(vmspace)); 406 printf(" vm_refcnt = %d,", D(vmspace, vmspace)->vm_refcnt); 407 printf(" vm_shm = %p,\n", D(vmspace, vmspace)->vm_shm); 408 printf(" vm_rssize = %d,", D(vmspace, vmspace)->vm_rssize); 409 printf(" vm_swrss = %d,", D(vmspace, vmspace)->vm_swrss); 410 printf(" vm_tsize = %d,", D(vmspace, vmspace)->vm_tsize); 411 printf(" vm_dsize = %d,\n", D(vmspace, vmspace)->vm_dsize); 412 printf(" vm_ssize = %d,", D(vmspace, vmspace)->vm_ssize); 413 printf(" vm_taddr = %p,", D(vmspace, vmspace)->vm_taddr); 414 printf(" vm_daddr = %p,\n", D(vmspace, vmspace)->vm_daddr); 415 printf(" vm_maxsaddr = %p,", 416 D(vmspace, vmspace)->vm_maxsaddr); 417 printf(" vm_minsaddr = %p }\n", 418 D(vmspace, vmspace)->vm_minsaddr); 419 } 420 421 S(vm_map) = sizeof(struct vm_map); 422 if (pid > 0) { 423 A(vm_map) = A(vmspace); 424 memcpy(D(vm_map, vm_map), &D(vmspace, vmspace)->vm_map, 425 S(vm_map)); 426 } else { 427 A(vm_map) = kernel_map_addr; 428 KDEREF(kd, vm_map); 429 } 430 if (debug & PRINT_VM_MAP) { 431 printf("%s %p = {", thing, P(vm_map)); 432 433 printf(" pmap = %p,\n", D(vm_map, vm_map)->pmap); 434 printf(" lock = <struct lock>\n"); 435 printf(" size = %lx,", D(vm_map, vm_map)->size); 436 printf(" ref_count = %d,", D(vm_map, vm_map)->ref_count); 437 printf(" ref_lock = <struct simplelock>,\n"); 438 printf(" min_offset-max_offset = 0x%lx-0x%lx\n", 439 D(vm_map, vm_map)->min_offset, 440 D(vm_map, vm_map)->max_offset); 441 printf(" b_start-b_end = 0x%lx-0x%lx\n", 442 D(vm_map, vm_map)->b_start, 443 D(vm_map, vm_map)->b_end); 444 printf(" s_start-s_end = 0x%lx-0x%lx\n", 445 D(vm_map, vm_map)->s_start, 446 D(vm_map, vm_map)->s_end); 447 vmmap_flags = D(vm_map, vm_map)->flags; 448 printf(" flags = %x <%s%s%s%s%s%s >,\n", 449 vmmap_flags, 450 vmmap_flags & VM_MAP_PAGEABLE ? " PAGEABLE" : "", 451 vmmap_flags & VM_MAP_INTRSAFE ? " INTRSAFE" : "", 452 vmmap_flags & VM_MAP_WIREFUTURE ? " WIREFUTURE" : "", 453 vmmap_flags & VM_MAP_BUSY ? " BUSY" : "", 454 vmmap_flags & VM_MAP_WANTLOCK ? " WANTLOCK" : "", 455#if VM_MAP_TOPDOWN > 0 456 vmmap_flags & VM_MAP_TOPDOWN ? " TOPDOWN" : 457#endif 458 ""); 459 printf(" timestamp = %u }\n", D(vm_map, vm_map)->timestamp); 460 } 461 if (print_ddb) { 462 printf("MAP %p: [0x%lx->0x%lx]\n", P(vm_map), 463 D(vm_map, vm_map)->min_offset, 464 D(vm_map, vm_map)->max_offset); 465 printf("\tsz=%ld, ref=%d, version=%d, flags=0x%x\n", 466 D(vm_map, vm_map)->size, 467 D(vm_map, vm_map)->ref_count, 468 D(vm_map, vm_map)->timestamp, 469 D(vm_map, vm_map)->flags); 470 printf("\tpmap=%p(resident=<unknown>)\n", 471 D(vm_map, vm_map)->pmap); 472 } 473 474 /* headers */ 475#ifdef DISABLED_HEADERS 476 if (print_map) 477 printf("%-*s %-*s rwx RWX CPY NCP I W A\n", 478 (int)sizeof(long) * 2 + 2, "Start", 479 (int)sizeof(long) * 2 + 2, "End"); 480 if (print_maps) 481 printf("%-*s %-*s rwxp %-*s Dev Inode File\n", 482 (int)sizeof(long) * 2 + 0, "Start", 483 (int)sizeof(long) * 2 + 0, "End", 484 (int)sizeof(long) * 2 + 0, "Offset"); 485 if (print_solaris) 486 printf("%-*s %*s Protection File\n", 487 (int)sizeof(long) * 2 + 0, "Start", 488 (int)sizeof(int) * 2 - 1, "Size "); 489#endif 490 if (print_all) 491 printf("%-*s %-*s %*s %-*s rwxpc RWX I/W/A Dev %*s - File\n", 492 (int)sizeof(long) * 2, "Start", 493 (int)sizeof(long) * 2, "End", 494 (int)sizeof(int) * 2, "Size ", 495 (int)sizeof(long) * 2, "Offset", 496 (int)sizeof(int) * 2, "Inode"); 497 498 /* these are the "sub entries" */ 499 RB_ROOT(&D(vm_map, vm_map)->addr) = 500 load_vm_map_entries(kd, RB_ROOT(&D(vm_map, vm_map)->addr), NULL); 501 RB_FOREACH(vm_map_entry, uvm_map_addr, &D(vm_map, vm_map)->addr) 502 total += dump_vm_map_entry(kd, vmspace, vm_map_entry, sum); 503 unload_vm_map_entries(RB_ROOT(&D(vm_map, vm_map)->addr)); 504 505 if (print_solaris) 506 printf("%-*s %8luK\n", 507 (int)sizeof(void *) * 2 - 2, " total", 508 (unsigned long)total); 509 if (print_all) 510 printf("%-*s %9luk\n", 511 (int)sizeof(void *) * 4 - 1, " total", 512 (unsigned long)total); 513} 514 515void 516load_symbols(kvm_t *kd) 517{ 518 int rc, i; 519 520 rc = kvm_nlist(kd, &nl[0]); 521 if (rc == -1) 522 errx(1, "%s == %d", kvm_geterr(kd), rc); 523 for (i = 0; i < sizeof(nl)/sizeof(nl[0]); i++) 524 if (nl[i].n_value == 0 && nl[i].n_name) 525 printf("%s not found\n", nl[i].n_name); 526 527 uvm_vnodeops = (void*)nl[NL_UVM_VNODEOPS].n_value; 528 uvm_deviceops = (void*)nl[NL_UVM_DEVICEOPS].n_value; 529 aobj_pager = (void*)nl[NL_AOBJ_PAGER].n_value; 530 531 _KDEREF(kd, nl[NL_MAXSSIZ].n_value, &maxssiz, 532 sizeof(maxssiz)); 533 _KDEREF(kd, nl[NL_KERNEL_MAP].n_value, &kernel_map_addr, 534 sizeof(kernel_map_addr)); 535} 536 537/* 538 * Recreate the addr tree of vm_map in local memory. 539 */ 540struct vm_map_entry * 541load_vm_map_entries(kvm_t *kd, struct vm_map_entry *kptr, 542 struct vm_map_entry *parent) 543{ 544 static struct kbit map_ent; 545 struct vm_map_entry *result; 546 547 if (kptr == NULL) 548 return NULL; 549 550 A(&map_ent) = (u_long)kptr; 551 S(&map_ent) = sizeof(struct vm_map_entry); 552 KDEREF(kd, &map_ent); 553 554 result = malloc(sizeof(*result)); 555 if (result == NULL) 556 err(1, "malloc"); 557 memcpy(result, D(&map_ent, vm_map_entry), sizeof(struct vm_map_entry)); 558 559 /* 560 * Recurse to download rest of the tree. 561 */ 562 RB_LEFT(result, daddrs.addr_entry) = load_vm_map_entries(kd, 563 RB_LEFT(result, daddrs.addr_entry), result); 564 RB_RIGHT(result, daddrs.addr_entry) = load_vm_map_entries(kd, 565 RB_RIGHT(result, daddrs.addr_entry), result); 566 RB_PARENT(result, daddrs.addr_entry) = parent; 567 return result; 568} 569 570/* 571 * Release the addr tree of vm_map. 572 */ 573void 574unload_vm_map_entries(struct vm_map_entry *ent) 575{ 576 if (ent == NULL) 577 return; 578 579 unload_vm_map_entries(RB_LEFT(ent, daddrs.addr_entry)); 580 unload_vm_map_entries(RB_RIGHT(ent, daddrs.addr_entry)); 581 free(ent); 582} 583 584size_t 585dump_vm_map_entry(kvm_t *kd, struct kbit *vmspace, 586 struct vm_map_entry *vme, struct sum *sum) 587{ 588 struct kbit kbit[4], *uvm_obj, *vp, *vfs, *amap; 589 ino_t inode = 0; 590 dev_t dev = 0; 591 size_t sz = 0; 592 char *name; 593 594 uvm_obj = &kbit[0]; 595 vp = &kbit[1]; 596 vfs = &kbit[2]; 597 amap = &kbit[3]; 598 599 A(uvm_obj) = 0; 600 A(vp) = 0; 601 A(vfs) = 0; 602 603 if (debug & PRINT_VM_MAP_ENTRY) { 604 printf("%s = {", "vm_map_entry"); 605 printf(" start = %lx,", vme->start); 606 printf(" end = %lx,", vme->end); 607 printf(" object.uvm_obj/sub_map = %p,\n", vme->object.uvm_obj); 608 printf(" offset = %lx,", (unsigned long)vme->offset); 609 printf(" etype = %x <%s%s%s%s%s >,", vme->etype, 610 vme->etype & UVM_ET_OBJ ? " OBJ" : "", 611 vme->etype & UVM_ET_SUBMAP ? " SUBMAP" : "", 612 vme->etype & UVM_ET_COPYONWRITE ? " COW" : "", 613 vme->etype & UVM_ET_NEEDSCOPY ? " NEEDSCOPY" : "", 614 vme->etype & UVM_ET_HOLE ? " HOLE" : ""); 615 printf(" protection = %x,\n", vme->protection); 616 printf(" max_protection = %x,", vme->max_protection); 617 printf(" inheritance = %d,", vme->inheritance); 618 printf(" wired_count = %d,\n", vme->wired_count); 619 printf(" aref = <struct vm_aref>,"); 620 printf(" advice = %d,", vme->advice); 621 printf(" flags = %x <%s%s > }\n", vme->flags, 622 vme->flags & UVM_MAP_STATIC ? " STATIC" : "", 623 vme->flags & UVM_MAP_KMEM ? " KMEM" : ""); 624 } 625 626 A(vp) = 0; 627 A(uvm_obj) = 0; 628 629 if (vme->object.uvm_obj != NULL) { 630 P(uvm_obj) = vme->object.uvm_obj; 631 S(uvm_obj) = sizeof(struct uvm_object); 632 KDEREF(kd, uvm_obj); 633 if (UVM_ET_ISOBJ(vme) && 634 UVM_OBJ_IS_VNODE(D(uvm_obj, uvm_object))) { 635 P(vp) = P(uvm_obj); 636 S(vp) = sizeof(struct vnode); 637 KDEREF(kd, vp); 638 } 639 } 640 641 if (vme->aref.ar_amap != NULL) { 642 P(amap) = vme->aref.ar_amap; 643 S(amap) = sizeof(struct vm_amap); 644 KDEREF(kd, amap); 645 } 646 647 A(vfs) = 0; 648 649 if (P(vp) != NULL && D(vp, vnode)->v_mount != NULL) { 650 P(vfs) = D(vp, vnode)->v_mount; 651 S(vfs) = sizeof(struct mount); 652 KDEREF(kd, vfs); 653 D(vp, vnode)->v_mount = D(vfs, mount); 654 } 655 656 /* 657 * dig out the device number and inode number from certain 658 * file system types. 659 */ 660#define V_DATA_IS(vp, type, d, i) do { \ 661 struct kbit data; \ 662 P(&data) = D(vp, vnode)->v_data; \ 663 S(&data) = sizeof(*D(&data, type)); \ 664 KDEREF(kd, &data); \ 665 dev = D(&data, type)->d; \ 666 inode = D(&data, type)->i; \ 667} while (0/*CONSTCOND*/) 668 669 if (A(vp) && 670 D(vp, vnode)->v_type == VREG && 671 D(vp, vnode)->v_data != NULL) { 672 switch (D(vp, vnode)->v_tag) { 673 case VT_UFS: 674 case VT_EXT2FS: 675 V_DATA_IS(vp, inode, i_dev, i_number); 676 break; 677 case VT_ISOFS: 678 V_DATA_IS(vp, iso_node, i_dev, i_number); 679 break; 680 case VT_NON: 681 case VT_NFS: 682 case VT_MFS: 683 case VT_MSDOSFS: 684 case VT_PROCFS: 685 default: 686 break; 687 } 688 } 689 690 name = findname(kd, vmspace, vme, vp, vfs, uvm_obj); 691 692 if (print_map) { 693 printf("0x%lx 0x%lx %c%c%c %c%c%c %s %s %d %d %d", 694 vme->start, vme->end, 695 (vme->protection & VM_PROT_READ) ? 'r' : '-', 696 (vme->protection & VM_PROT_WRITE) ? 'w' : '-', 697 (vme->protection & VM_PROT_EXECUTE) ? 'x' : '-', 698 (vme->max_protection & VM_PROT_READ) ? 'r' : '-', 699 (vme->max_protection & VM_PROT_WRITE) ? 'w' : '-', 700 (vme->max_protection & VM_PROT_EXECUTE) ? 'x' : '-', 701 (vme->etype & UVM_ET_COPYONWRITE) ? "COW" : "NCOW", 702 (vme->etype & UVM_ET_NEEDSCOPY) ? "NC" : "NNC", 703 vme->inheritance, vme->wired_count, 704 vme->advice); 705 if (verbose) { 706 if (inode) 707 printf(" %d,%d %u", 708 major(dev), minor(dev), inode); 709 if (name[0]) 710 printf(" %s", name); 711 } 712 printf("\n"); 713 } 714 715 if (print_maps) 716 printf("%0*lx-%0*lx %c%c%c%c %0*lx %02x:%02x %u %s\n", 717 (int)sizeof(void *) * 2, vme->start, 718 (int)sizeof(void *) * 2, vme->end, 719 (vme->protection & VM_PROT_READ) ? 'r' : '-', 720 (vme->protection & VM_PROT_WRITE) ? 'w' : '-', 721 (vme->protection & VM_PROT_EXECUTE) ? 'x' : '-', 722 (vme->etype & UVM_ET_COPYONWRITE) ? 'p' : 's', 723 (int)sizeof(void *) * 2, 724 (unsigned long)vme->offset, 725 major(dev), minor(dev), inode, inode ? name : ""); 726 727 if (print_ddb) { 728 printf(" - <lost address>: 0x%lx->0x%lx: " 729 "obj=%p/0x%lx, amap=%p/%d\n", 730 vme->start, vme->end, 731 vme->object.uvm_obj, (unsigned long)vme->offset, 732 vme->aref.ar_amap, vme->aref.ar_pageoff); 733 printf("\tsubmap=%c, cow=%c, nc=%c, prot(max)=%d/%d, inh=%d, " 734 "wc=%d, adv=%d\n", 735 (vme->etype & UVM_ET_SUBMAP) ? 'T' : 'F', 736 (vme->etype & UVM_ET_COPYONWRITE) ? 'T' : 'F', 737 (vme->etype & UVM_ET_NEEDSCOPY) ? 'T' : 'F', 738 vme->protection, vme->max_protection, 739 vme->inheritance, vme->wired_count, vme->advice); 740 if (inode && verbose) 741 printf("\t(dev=%d,%d ino=%u [%s] [%p])\n", 742 major(dev), minor(dev), inode, inode ? name : "", P(vp)); 743 else if (name[0] == ' ' && verbose) 744 printf("\t(%s)\n", &name[2]); 745 } 746 747 if (print_solaris) { 748 char prot[30]; 749 750 prot[0] = '\0'; 751 prot[1] = '\0'; 752 if (vme->protection & VM_PROT_READ) 753 strlcat(prot, "/read", sizeof(prot)); 754 if (vme->protection & VM_PROT_WRITE) 755 strlcat(prot, "/write", sizeof(prot)); 756 if (vme->protection & VM_PROT_EXECUTE) 757 strlcat(prot, "/exec", sizeof(prot)); 758 759 sz = (size_t)((vme->end - vme->start) / 1024); 760 printf("%0*lX %6luK %-15s %s\n", 761 (int)sizeof(void *) * 2, (unsigned long)vme->start, 762 (unsigned long)sz, &prot[1], name); 763 } 764 765 if (print_all) { 766 sz = (size_t)((vme->end - vme->start) / 1024); 767 printf("%0*lx-%0*lx %7luk %0*lx %c%c%c%c%c (%c%c%c) %d/%d/%d %02d:%02d %7u - %s", 768 (int)sizeof(void *) * 2, vme->start, (int)sizeof(void *) * 2, 769 vme->end - (vme->start != vme->end ? 1 : 0), (unsigned long)sz, 770 (int)sizeof(void *) * 2, (unsigned long)vme->offset, 771 (vme->protection & VM_PROT_READ) ? 'r' : '-', 772 (vme->protection & VM_PROT_WRITE) ? 'w' : '-', 773 (vme->protection & VM_PROT_EXECUTE) ? 'x' : '-', 774 (vme->etype & UVM_ET_COPYONWRITE) ? 'p' : 's', 775 (vme->etype & UVM_ET_NEEDSCOPY) ? '+' : '-', 776 (vme->max_protection & VM_PROT_READ) ? 'r' : '-', 777 (vme->max_protection & VM_PROT_WRITE) ? 'w' : '-', 778 (vme->max_protection & VM_PROT_EXECUTE) ? 'x' : '-', 779 vme->inheritance, vme->wired_count, vme->advice, 780 major(dev), minor(dev), inode, name); 781 if (A(vp)) 782 printf(" [%p]", P(vp)); 783 printf("\n"); 784 } 785 786 if (print_amap && vme->aref.ar_amap) { 787 printf(" amap - ref: %d fl: 0x%x maxsl: %d nsl: %d nuse: %d\n", 788 D(amap, vm_amap)->am_ref, 789 D(amap, vm_amap)->am_flags, 790 D(amap, vm_amap)->am_maxslot, 791 D(amap, vm_amap)->am_nslot, 792 D(amap, vm_amap)->am_nused); 793 if (sum) { 794 sum->s_am_nslots += D(amap, vm_amap)->am_nslot; 795 sum->s_am_maxslots += D(amap, vm_amap)->am_maxslot; 796 sum->s_am_nusedslots += D(amap, vm_amap)->am_nused; 797 } 798 } 799 800 /* no access allowed, don't count space */ 801 if ((vme->protection & rwx) == 0) 802 sz = 0; 803 804 return (sz); 805} 806 807char * 808findname(kvm_t *kd, struct kbit *vmspace, 809 struct vm_map_entry *vme, struct kbit *vp, 810 struct kbit *vfs, struct kbit *uvm_obj) 811{ 812 static char buf[1024], *name; 813 size_t l; 814 815 if (UVM_ET_ISOBJ(vme)) { 816 if (A(vfs)) { 817 l = strlen(D(vfs, mount)->mnt_stat.f_mntonname); 818 switch (search_cache(kd, vp, &name, buf, sizeof(buf))) { 819 case 0: /* found something */ 820 if (name - (1 + 11 + l) < buf) 821 break; 822 name--; 823 *name = '/'; 824 /*FALLTHROUGH*/ 825 case 2: /* found nothing */ 826 name -= 11; 827 memcpy(name, " -unknown- ", (size_t)11); 828 name -= l; 829 memcpy(name, 830 D(vfs, mount)->mnt_stat.f_mntonname, l); 831 break; 832 case 1: /* all is well */ 833 if (name - (1 + l) < buf) 834 break; 835 name--; 836 *name = '/'; 837 if (l != 1) { 838 name -= l; 839 memcpy(name, 840 D(vfs, mount)->mnt_stat.f_mntonname, l); 841 } 842 break; 843 } 844 } else if (UVM_OBJ_IS_DEVICE(D(uvm_obj, uvm_object))) { 845 struct kbit kdev; 846 dev_t dev; 847 848 P(&kdev) = P(uvm_obj); 849 S(&kdev) = sizeof(struct uvm_device); 850 KDEREF(kd, &kdev); 851 dev = D(&kdev, uvm_device)->u_device; 852 name = devname(dev, S_IFCHR); 853 if (name != NULL) 854 snprintf(buf, sizeof(buf), "/dev/%s", name); 855 else 856 snprintf(buf, sizeof(buf), " [ device %d,%d ]", 857 major(dev), minor(dev)); 858 name = buf; 859 } else if (UVM_OBJ_IS_AOBJ(D(uvm_obj, uvm_object))) 860 name = " [ uvm_aobj ]"; 861 else if (UVM_OBJ_IS_VNODE(D(uvm_obj, uvm_object))) 862 name = " [ ?VNODE? ]"; 863 else { 864 snprintf(buf, sizeof(buf), " [ unknown (%p) ]", 865 D(uvm_obj, uvm_object)->pgops); 866 name = buf; 867 } 868 } else if (D(vmspace, vmspace)->vm_maxsaddr <= (caddr_t)vme->start && 869 (D(vmspace, vmspace)->vm_maxsaddr + (size_t)maxssiz) >= 870 (caddr_t)vme->end) { 871 name = " [ stack ]"; 872 } else if (D(vmspace, vmspace)->vm_daddr <= (caddr_t)vme->start && 873 D(vmspace, vmspace)->vm_daddr + BRKSIZ >= (caddr_t)vme->end) { 874 name = " [ heap ]"; 875 } else if (UVM_ET_ISHOLE(vme)) 876 name = " [ hole ]"; 877 else 878 name = " [ anon ]"; 879 880 return (name); 881} 882 883int 884search_cache(kvm_t *kd, struct kbit *vp, char **name, char *buf, size_t blen) 885{ 886 struct cache_entry *ce; 887 struct kbit svp; 888 char *o, *e; 889 u_long cid; 890 891#if 0 892 if (nchashtbl == NULL) 893 load_name_cache(kd); 894#endif 895 896 P(&svp) = P(vp); 897 S(&svp) = sizeof(struct vnode); 898 cid = D(vp, vnode)->v_id; 899 900 e = &buf[blen - 1]; 901 o = e; 902 do { 903 LIST_FOREACH(ce, &lcache, ce_next) 904 if (ce->ce_vp == P(&svp) && ce->ce_cid == cid) 905 break; 906 if (ce && ce->ce_vp == P(&svp) && ce->ce_cid == cid) { 907 if (o != e) 908 *(--o) = '/'; 909 if (o - ce->ce_nlen <= buf) 910 break; 911 o -= ce->ce_nlen; 912 memcpy(o, ce->ce_name, ce->ce_nlen); 913 P(&svp) = ce->ce_pvp; 914 cid = ce->ce_pcid; 915 } else 916 break; 917 } while (1/*CONSTCOND*/); 918 *e = '\0'; 919 *name = o; 920 921 if (e == o) 922 return (2); 923 924 KDEREF(kd, &svp); 925 return (D(&svp, vnode)->v_flag & VROOT); 926} 927 928#if 0 929void 930load_name_cache(kvm_t *kd) 931{ 932 struct namecache _ncp, *ncp, *oncp; 933 struct nchashhead _ncpp, *ncpp; 934 u_long nchash; 935 int i; 936 937 LIST_INIT(&lcache); 938 939 _KDEREF(kd, nchash_addr, &nchash, sizeof(nchash)); 940 nchashtbl = calloc(sizeof(nchashtbl), (int)nchash); 941 if (nchashtbl == NULL) 942 err(1, "load_name_cache"); 943 _KDEREF(kd, nchashtbl_addr, nchashtbl, 944 sizeof(nchashtbl) * (int)nchash); 945 946 ncpp = &_ncpp; 947 948 for (i = 0; i < nchash; i++) { 949 ncpp = &nchashtbl[i]; 950 oncp = NULL; 951 LIST_FOREACH(ncp, ncpp, nc_hash) { 952 if (ncp == oncp || 953 ncp == (void*)0xdeadbeef) 954 break; 955 oncp = ncp; 956 _KDEREF(kd, (u_long)ncp, &_ncp, sizeof(*ncp)); 957 ncp = &_ncp; 958 if (ncp->nc_nlen > 0) { 959 if (ncp->nc_nlen > 2 || 960 ncp->nc_name[0] != '.' || 961 (ncp->nc_name[1] != '.' && 962 ncp->nc_nlen != 1)) 963 cache_enter(ncp); 964 } 965 } 966 } 967} 968 969void 970cache_enter(struct namecache *ncp) 971{ 972 struct cache_entry *ce; 973 974 if (debug & DUMP_NAMEI_CACHE) 975 printf("ncp->nc_vp %10p, ncp->nc_dvp %10p, ncp->nc_nlen " 976 "%3d [%.*s] (nc_dvpid=%lu, nc_vpid=%lu)\n", 977 ncp->nc_vp, ncp->nc_dvp, 978 ncp->nc_nlen, ncp->nc_nlen, ncp->nc_name, 979 ncp->nc_dvpid, ncp->nc_vpid); 980 981 ce = malloc(sizeof(struct cache_entry)); 982 if (ce == NULL) 983 err(1, "cache_enter"); 984 985 ce->ce_vp = ncp->nc_vp; 986 ce->ce_pvp = ncp->nc_dvp; 987 ce->ce_cid = ncp->nc_vpid; 988 ce->ce_pcid = ncp->nc_dvpid; 989 /* safe since nc_nlen is maximum NCHNAMLEN */ 990 ce->ce_nlen = (unsigned int)ncp->nc_nlen; 991 strlcpy(ce->ce_name, ncp->nc_name, sizeof(ce->ce_name)); 992 993 LIST_INSERT_HEAD(&lcache, ce, ce_next); 994} 995#endif 996 997static void __dead 998usage(void) 999{ 1000 extern char *__progname; 1001 fprintf(stderr, "usage: %s [-AadlmPsv] [-D number] " 1002 "[-M core] [-N system] [-p pid] [pid ...]\n", 1003 __progname); 1004 exit(1); 1005} 1006 1007static pid_t 1008strtopid(const char *str) 1009{ 1010 pid_t pid; 1011 1012 errno = 0; 1013 pid = (pid_t)strtonum(str, 0, INT_MAX, NULL); 1014 if (errno != 0) 1015 usage(); 1016 return (pid); 1017} 1018