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