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