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