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