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