1 /* $NetBSD: pmap.c,v 1.52 2015/12/14 03:15:10 christos Exp $ */ 2 3 /* 4 * Copyright (c) 2002, 2003 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Andrew Brown. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 #include <sys/cdefs.h> 33 #ifndef lint 34 __RCSID("$NetBSD: pmap.c,v 1.52 2015/12/14 03:15:10 christos Exp $"); 35 #endif 36 37 #include <string.h> 38 #include <util.h> 39 40 #include "pmap.h" 41 #include "main.h" 42 43 static void dump_vm_anon(kvm_t *, struct vm_anon **, int); 44 static char *findname(kvm_t *, struct kbit *, struct kbit *, struct kbit *, 45 struct kbit *, struct kbit *); 46 static int search_cache(kvm_t *, struct kbit *, char **, char *, size_t); 47 48 /* when recursing, output is indented */ 49 #define indent(n) ((n) * (recurse > 1 ? recurse - 1 : 0)) 50 #define rwx (VM_PROT_READ | VM_PROT_WRITE | VM_PROT_EXECUTE) 51 52 int heapfound; 53 54 void 55 process_map(kvm_t *kd, struct kinfo_proc2 *proc, 56 struct kbit *vmspace, const char *thing) 57 { 58 struct kbit kbit, *vm_map = &kbit; 59 60 if (proc) { 61 heapfound = 0; 62 A(vmspace) = (u_long)proc->p_vmspace; 63 S(vmspace) = sizeof(struct vmspace); 64 thing = "proc->p_vmspace.vm_map"; 65 } else if (S(vmspace) == (size_t)-1) { 66 heapfound = 0; 67 /* A(vmspace) set by caller */ 68 S(vmspace) = sizeof(struct vmspace); 69 /* object identified by caller */ 70 } else { 71 heapfound = 1; /* but really, do kernels have a heap? */ 72 A(vmspace) = 0; 73 S(vmspace) = 0; 74 thing = "kernel_map"; 75 } 76 77 S(vm_map) = sizeof(struct vm_map); 78 79 if (S(vmspace) != 0) { 80 KDEREF(kd, vmspace); 81 A(vm_map) = A(vmspace) + offsetof(struct vmspace, vm_map); 82 memcpy(D(vm_map, vm_map), &D(vmspace, vmspace)->vm_map, 83 S(vm_map)); 84 } else { 85 memset(vmspace, 0, sizeof(*vmspace)); 86 A(vm_map) = kernel_map_addr; 87 KDEREF(kd, vm_map); 88 } 89 90 dump_vm_map(kd, proc, vmspace, vm_map, thing); 91 } 92 93 void 94 dump_vm_map(kvm_t *kd, struct kinfo_proc2 *proc, 95 struct kbit *vmspace, struct kbit *vm_map, const char *mname) 96 { 97 struct kbit kbit[2], *header, *vm_map_entry; 98 struct vm_map_entry *last, *next; 99 size_t total; 100 u_long addr, end; 101 102 if (S(vm_map) == (size_t)-1) { 103 heapfound = 1; 104 S(vm_map) = sizeof(struct vm_map); 105 KDEREF(kd, vm_map); 106 } 107 108 header = &kbit[0]; 109 vm_map_entry = &kbit[1]; 110 A(header) = 0; 111 A(vm_map_entry) = 0; 112 113 A(header) = A(vm_map) + offsetof(struct vm_map, header); 114 S(header) = sizeof(struct vm_map_entry); 115 memcpy(D(header, vm_map_entry), &D(vm_map, vm_map)->header, S(header)); 116 117 if (S(vmspace) != 0 && (debug & PRINT_VMSPACE)) { 118 printf("proc->p_vmspace %p = {", P(vmspace)); 119 printf(" vm_refcnt = %d,", D(vmspace, vmspace)->vm_refcnt); 120 printf(" vm_shm = %p,\n", D(vmspace, vmspace)->vm_shm); 121 printf(" vm_rssize = %d,", D(vmspace, vmspace)->vm_rssize); 122 printf(" vm_swrss = %d,", D(vmspace, vmspace)->vm_swrss); 123 printf(" vm_tsize = %d,", D(vmspace, vmspace)->vm_tsize); 124 printf(" vm_dsize = %d,\n", D(vmspace, vmspace)->vm_dsize); 125 printf(" vm_ssize = %d,", D(vmspace, vmspace)->vm_ssize); 126 printf(" vm_taddr = %p,", D(vmspace, vmspace)->vm_taddr); 127 printf(" vm_daddr = %p,\n", D(vmspace, vmspace)->vm_daddr); 128 printf(" vm_maxsaddr = %p,", 129 D(vmspace, vmspace)->vm_maxsaddr); 130 printf(" vm_minsaddr = %p }\n", 131 D(vmspace, vmspace)->vm_minsaddr); 132 } 133 134 if (debug & PRINT_VM_MAP) { 135 printf("%*s%s %p = {", indent(2), "", mname, P(vm_map)); 136 printf(" pmap = %p,\n", D(vm_map, vm_map)->pmap); 137 printf("%*s lock = <struct lock>,", indent(2), ""); 138 printf(" header = <struct vm_map_entry>,"); 139 printf(" nentries = %d,\n", D(vm_map, vm_map)->nentries); 140 printf("%*s size = %#"PRIxVSIZE",", indent(2), "", 141 D(vm_map, vm_map)->size); 142 printf(" ref_count = %d,", D(vm_map, vm_map)->ref_count); 143 printf("%*s hint = %p,", indent(2), "", 144 D(vm_map, vm_map)->hint); 145 printf("%*s first_free = %p,", indent(2), "", 146 D(vm_map, vm_map)->first_free); 147 printf(" flags = %x <%s%s%s%s >,\n", D(vm_map, vm_map)->flags, 148 D(vm_map, vm_map)->flags & VM_MAP_PAGEABLE ? " PAGEABLE" : "", 149 D(vm_map, vm_map)->flags & VM_MAP_WIREFUTURE ? " WIREFUTURE" : "", 150 #ifdef VM_MAP_DYING 151 D(vm_map, vm_map)->flags & VM_MAP_DYING ? " DYING" : 152 #endif 153 "", 154 #ifdef VM_MAP_TOPDOWN 155 D(vm_map, vm_map)->flags & VM_MAP_TOPDOWN ? " TOPDOWN" : 156 #endif 157 ""); 158 printf("%*s timestamp = %u }\n", indent(2), "", 159 D(vm_map, vm_map)->timestamp); 160 } 161 if (print_ddb) { 162 const char *name = mapname(P(vm_map)); 163 164 printf("%*s%s %p: [%#"PRIxVADDR"->%#"PRIxVADDR"]\n", indent(2), "", 165 recurse < 2 ? "MAP" : "SUBMAP", P(vm_map), 166 vm_map_min(D(vm_map, vm_map)), 167 vm_map_max(D(vm_map, vm_map))); 168 printf("\t%*s#ent=%d, sz=%"PRIxVSIZE", ref=%d, version=%d, flags=0x%x\n", 169 indent(2), "", D(vm_map, vm_map)->nentries, 170 D(vm_map, vm_map)->size, D(vm_map, vm_map)->ref_count, 171 D(vm_map, vm_map)->timestamp, D(vm_map, vm_map)->flags); 172 printf("\t%*spmap=%p(resident=<unknown>)\n", indent(2), "", 173 D(vm_map, vm_map)->pmap); 174 if (verbose && name != NULL) 175 printf("\t%*s([ %s ])\n", indent(2), "", name); 176 } 177 178 dump_vm_map_entry(kd, proc, vmspace, header, 1); 179 180 /* 181 * we're not recursing into a submap, so print headers 182 */ 183 if (recurse < 2) { 184 /* headers */ 185 #ifdef DISABLED_HEADERS 186 if (print_map) 187 printf("%-*s %-*s rwx RWX CPY NCP I W A\n", 188 (int)sizeof(long) * 2 + 2, "Start", 189 (int)sizeof(long) * 2 + 2, "End"); 190 if (print_maps) 191 printf("%-*s %-*s rwxp %-*s Dev Inode File\n", 192 (int)sizeof(long) * 2 + 0, "Start", 193 (int)sizeof(long) * 2 + 0, "End", 194 (int)sizeof(long) * 2 + 0, "Offset"); 195 if (print_solaris) 196 printf("%-*s %*s Protection File\n", 197 (int)sizeof(long) * 2 + 0, "Start", 198 (int)sizeof(int) * 2 - 1, "Size "); 199 #endif 200 if (print_all) 201 printf("%-*s %-*s %*s %-*s rwxpc RWX I/W/A Dev %*s" 202 " - File\n", 203 (int)sizeof(long) * 2, "Start", 204 (int)sizeof(long) * 2, "End", 205 (int)sizeof(int) * 2, "Size ", 206 (int)sizeof(long) * 2, "Offset", 207 (int)sizeof(int) * 2, "Inode"); 208 } 209 210 /* these are the "sub entries" */ 211 total = 0; 212 next = D(header, vm_map_entry)->next; 213 last = P(header); 214 end = 0; 215 216 while (next != 0 && next != last) { 217 addr = (u_long)next; 218 A(vm_map_entry) = addr; 219 S(vm_map_entry) = sizeof(struct vm_map_entry); 220 KDEREF(kd, vm_map_entry); 221 next = D(vm_map_entry, vm_map_entry)->next; 222 223 if (end == 0) 224 end = D(vm_map_entry, vm_map_entry)->start; 225 else if (verbose > 1 && 226 end != D(vm_map_entry, vm_map_entry)->start) 227 printf("%*s[%lu pages / %luK]\n", indent(2), "", 228 (D(vm_map_entry, vm_map_entry)->start - end) / 229 page_size, 230 (D(vm_map_entry, vm_map_entry)->start - end) / 231 1024); 232 total += dump_vm_map_entry(kd, proc, vmspace, vm_map_entry, 0); 233 234 end = D(vm_map_entry, vm_map_entry)->end; 235 } 236 237 /* 238 * we're not recursing into a submap, so print totals 239 */ 240 if (recurse < 2) { 241 if (print_solaris) 242 printf("%-*s %8luK\n", 243 (int)sizeof(void *) * 2 - 2, " total", 244 (unsigned long)total); 245 if (print_all) 246 printf("%-*s %9luk\n", 247 (int)sizeof(void *) * 4 - 1, " total", 248 (unsigned long)total); 249 } 250 } 251 252 size_t 253 dump_vm_map_entry(kvm_t *kd, struct kinfo_proc2 *proc, struct kbit *vmspace, 254 struct kbit *vm_map_entry, int ishead) 255 { 256 struct kbit kbit[3]; 257 struct kbit *uvm_obj, *vp, *vfs; 258 struct vm_map_entry *vme; 259 size_t sz; 260 char *name; 261 dev_t dev; 262 ino_t inode; 263 264 if (S(vm_map_entry) == (size_t)-1) { 265 heapfound = 1; 266 S(vm_map_entry) = sizeof(struct vm_map_entry); 267 KDEREF(kd, vm_map_entry); 268 } 269 270 uvm_obj = &kbit[0]; 271 vp = &kbit[1]; 272 vfs = &kbit[2]; 273 274 A(uvm_obj) = 0; 275 A(vp) = 0; 276 A(vfs) = 0; 277 278 vme = D(vm_map_entry, vm_map_entry); 279 280 if ((ishead && (debug & PRINT_VM_MAP_HEADER)) || 281 (!ishead && (debug & PRINT_VM_MAP_ENTRY))) { 282 printf("%*s%s %p = {", indent(2), "", 283 ishead ? "vm_map.header" : "vm_map_entry", 284 P(vm_map_entry)); 285 printf(" prev = %p,", vme->prev); 286 printf(" next = %p,\n", vme->next); 287 printf("%*s start = %#"PRIxVADDR",", indent(2), "", vme->start); 288 printf(" end = %#"PRIxVADDR",", vme->end); 289 printf(" object.uvm_obj/sub_map = %p,\n", vme->object.uvm_obj); 290 printf("%*s offset = %" PRIx64 ",", indent(2), "", 291 vme->offset); 292 printf(" etype = %x <%s%s%s%s >,", vme->etype, 293 UVM_ET_ISOBJ(vme) ? " OBJ" : "", 294 UVM_ET_ISSUBMAP(vme) ? " SUBMAP" : "", 295 UVM_ET_ISCOPYONWRITE(vme) ? " COW" : "", 296 UVM_ET_ISNEEDSCOPY(vme) ? " NEEDSCOPY" : ""); 297 printf(" protection = %x,\n", vme->protection); 298 printf("%*s max_protection = %x,", indent(2), "", 299 vme->max_protection); 300 printf(" inheritance = %d,", vme->inheritance); 301 printf(" wired_count = %d,\n", vme->wired_count); 302 printf("%*s aref = { ar_pageoff = %x, ar_amap = %p },", 303 indent(2), "", vme->aref.ar_pageoff, vme->aref.ar_amap); 304 printf(" advice = %d,\n", vme->advice); 305 printf("%*s flags = %x <%s%s%s > }\n", indent(2), "", 306 vme->flags, 307 vme->flags & UVM_MAP_KERNEL ? " KERNEL" : "", 308 vme->flags & UVM_MAP_STATIC ? " STATIC" : "", 309 vme->flags & UVM_MAP_NOMERGE ? " NOMERGE" : ""); 310 } 311 312 if ((debug & PRINT_VM_AMAP) && (vme->aref.ar_amap != NULL)) { 313 struct kbit akbit, *amap; 314 315 amap = &akbit; 316 P(amap) = vme->aref.ar_amap; 317 S(amap) = sizeof(struct vm_amap); 318 KDEREF(kd, amap); 319 dump_amap(kd, amap); 320 } 321 322 if (ishead) 323 return (0); 324 325 A(vp) = 0; 326 A(uvm_obj) = 0; 327 328 if (vme->object.uvm_obj != NULL) { 329 P(uvm_obj) = vme->object.uvm_obj; 330 S(uvm_obj) = sizeof(struct uvm_object); 331 KDEREF(kd, uvm_obj); 332 if (UVM_ET_ISOBJ(vme) && 333 UVM_OBJ_IS_VNODE(D(uvm_obj, uvm_object))) { 334 P(vp) = P(uvm_obj); 335 S(vp) = sizeof(struct vnode); 336 KDEREF(kd, vp); 337 } 338 } 339 340 A(vfs) = 0; 341 342 if (P(vp) != NULL && D(vp, vnode)->v_mount != NULL) { 343 P(vfs) = D(vp, vnode)->v_mount; 344 S(vfs) = sizeof(struct mount); 345 KDEREF(kd, vfs); 346 D(vp, vnode)->v_mount = D(vfs, mount); 347 } 348 349 /* 350 * dig out the device number and inode number from certain 351 * file system types. 352 */ 353 #define V_DATA_IS(vp, type, d, i) do { \ 354 struct kbit data; \ 355 P(&data) = D(vp, vnode)->v_data; \ 356 S(&data) = sizeof(*D(&data, type)); \ 357 KDEREF(kd, &data); \ 358 dev = D(&data, type)->d; \ 359 inode = D(&data, type)->i; \ 360 } while (0/*CONSTCOND*/) 361 362 dev = 0; 363 inode = 0; 364 365 if (A(vp) && 366 D(vp, vnode)->v_type == VREG && 367 D(vp, vnode)->v_data != NULL) { 368 switch (D(vp, vnode)->v_tag) { 369 case VT_UFS: 370 case VT_LFS: 371 case VT_EXT2FS: 372 V_DATA_IS(vp, inode, i_dev, i_number); 373 break; 374 case VT_ISOFS: 375 V_DATA_IS(vp, iso_node, i_dev, i_number); 376 break; 377 default: 378 break; 379 } 380 } 381 382 name = findname(kd, vmspace, vm_map_entry, vp, vfs, uvm_obj); 383 384 if (print_map) { 385 printf("%*s%#"PRIxVADDR" %#"PRIxVADDR" %c%c%c %c%c%c %s %s %d %d %d", 386 indent(2), "", 387 vme->start, vme->end, 388 (vme->protection & VM_PROT_READ) ? 'r' : '-', 389 (vme->protection & VM_PROT_WRITE) ? 'w' : '-', 390 (vme->protection & VM_PROT_EXECUTE) ? 'x' : '-', 391 (vme->max_protection & VM_PROT_READ) ? 'r' : '-', 392 (vme->max_protection & VM_PROT_WRITE) ? 'w' : '-', 393 (vme->max_protection & VM_PROT_EXECUTE) ? 'x' : '-', 394 UVM_ET_ISCOPYONWRITE(vme) ? "COW" : "NCOW", 395 UVM_ET_ISNEEDSCOPY(vme) ? "NC" : "NNC", 396 vme->inheritance, vme->wired_count, 397 vme->advice); 398 if (verbose) { 399 if (inode) 400 printf(" %llu,%llu %llu", 401 (unsigned long long)major(dev), 402 (unsigned long long)minor(dev), 403 (unsigned long long)inode); 404 if (name[0]) 405 printf(" %s", name); 406 } 407 printf("\n"); 408 } 409 410 if (print_maps) { 411 printf("%*s%0*"PRIxVADDR"-%0*"PRIxVADDR" %c%c%c%c %0*" PRIx64 " %02llx:%02llx %llu %s\n", 412 indent(2), "", 413 (int)sizeof(void *) * 2, vme->start, 414 (int)sizeof(void *) * 2, vme->end, 415 (vme->protection & VM_PROT_READ) ? 'r' : '-', 416 (vme->protection & VM_PROT_WRITE) ? 'w' : '-', 417 (vme->protection & VM_PROT_EXECUTE) ? 'x' : '-', 418 UVM_ET_ISCOPYONWRITE(vme) ? 'p' : 's', 419 (int)sizeof(void *) * 2, 420 vme->offset, 421 (unsigned long long)major(dev), 422 (unsigned long long)minor(dev), 423 (unsigned long long)inode, 424 (name[0] != ' ') || verbose ? name : ""); 425 } 426 427 if (print_ddb) { 428 printf("%*s - %p: %#"PRIxVADDR"->%#"PRIxVADDR": obj=%p/0x%" PRIx64 ", amap=%p/%d\n", 429 indent(2), "", 430 P(vm_map_entry), vme->start, vme->end, 431 vme->object.uvm_obj, vme->offset, 432 vme->aref.ar_amap, vme->aref.ar_pageoff); 433 printf("\t%*ssubmap=%c, cow=%c, nc=%c, prot(max)=%d/%d, inh=%d, " 434 "wc=%d, adv=%d\n", 435 indent(2), "", 436 UVM_ET_ISSUBMAP(vme) ? 'T' : 'F', 437 UVM_ET_ISCOPYONWRITE(vme) ? 'T' : 'F', 438 UVM_ET_ISNEEDSCOPY(vme) ? 'T' : 'F', 439 vme->protection, vme->max_protection, 440 vme->inheritance, vme->wired_count, vme->advice); 441 if (verbose) { 442 printf("\t%*s", indent(2), ""); 443 if (inode) 444 printf("(dev=%llu,%llu ino=%llu [%s] [%p])\n", 445 (unsigned long long)major(dev), 446 (unsigned long long)minor(dev), 447 (unsigned long long)inode, name, P(vp)); 448 else if (name[0] == ' ') 449 printf("(%s)\n", &name[2]); 450 else 451 printf("(%s)\n", name); 452 } 453 } 454 455 sz = 0; 456 if (print_solaris) { 457 char prot[30]; 458 459 prot[0] = '\0'; 460 prot[1] = '\0'; 461 if (vme->protection & VM_PROT_READ) 462 strlcat(prot, "/read", sizeof(prot)); 463 if (vme->protection & VM_PROT_WRITE) 464 strlcat(prot, "/write", sizeof(prot)); 465 if (vme->protection & VM_PROT_EXECUTE) 466 strlcat(prot, "/exec", sizeof(prot)); 467 468 sz = (size_t)((vme->end - vme->start) / 1024); 469 printf("%*s%0*lX %6luK %-15s %s\n", 470 indent(2), "", 471 (int)sizeof(void *) * 2, 472 (unsigned long)vme->start, 473 (unsigned long)sz, 474 &prot[1], 475 name); 476 } 477 478 if (print_all) { 479 sz = (size_t)((vme->end - vme->start) / 1024); 480 printf(A(vp) ? 481 "%*s%0*"PRIxVADDR"-%0*"PRIxVADDR" %7luk %0*" PRIx64 " %c%c%c%c%c (%c%c%c) %d/%d/%d %02llu:%02llu %7llu - %s [%p]\n" : 482 "%*s%0*"PRIxVADDR"-%0*"PRIxVADDR" %7luk %0*" PRIx64 " %c%c%c%c%c (%c%c%c) %d/%d/%d %02llu:%02llu %7llu - %s\n", 483 indent(2), "", 484 (int)sizeof(void *) * 2, 485 vme->start, 486 (int)sizeof(void *) * 2, 487 vme->end - (vme->start != vme->end ? 1 : 0), 488 (unsigned long)sz, 489 (int)sizeof(void *) * 2, 490 vme->offset, 491 (vme->protection & VM_PROT_READ) ? 'r' : '-', 492 (vme->protection & VM_PROT_WRITE) ? 'w' : '-', 493 (vme->protection & VM_PROT_EXECUTE) ? 'x' : '-', 494 UVM_ET_ISCOPYONWRITE(vme) ? 'p' : 's', 495 UVM_ET_ISNEEDSCOPY(vme) ? '+' : '-', 496 (vme->max_protection & VM_PROT_READ) ? 'r' : '-', 497 (vme->max_protection & VM_PROT_WRITE) ? 'w' : '-', 498 (vme->max_protection & VM_PROT_EXECUTE) ? 'x' : '-', 499 vme->inheritance, 500 vme->wired_count, 501 vme->advice, 502 (unsigned long long)major(dev), 503 (unsigned long long)minor(dev), 504 (unsigned long long)inode, 505 name, P(vp)); 506 } 507 508 /* no access allowed, don't count space */ 509 if ((vme->protection & rwx) == 0) 510 sz = 0; 511 512 if (recurse && UVM_ET_ISSUBMAP(vme)) { 513 struct kbit mkbit, *submap; 514 515 recurse++; 516 submap = &mkbit; 517 P(submap) = vme->object.sub_map; 518 S(submap) = sizeof(*vme->object.sub_map); 519 KDEREF(kd, submap); 520 dump_vm_map(kd, proc, vmspace, submap, "submap"); 521 recurse--; 522 } 523 524 return (sz); 525 } 526 527 void 528 dump_amap(kvm_t *kd, struct kbit *amap) 529 { 530 struct vm_anon **am_anon; 531 int *am_slots; 532 int *am_bckptr; 533 int *am_ppref; 534 size_t l; 535 int i, r, e; 536 537 if (S(amap) == (size_t)-1) { 538 heapfound = 1; 539 S(amap) = sizeof(struct vm_amap); 540 KDEREF(kd, amap); 541 } 542 543 printf("%*s amap %p = { am_ref = %d, " 544 "am_flags = %x,\n" 545 "%*s am_maxslot = %d, am_nslot = %d, am_nused = %d, " 546 "am_slots = %p,\n" 547 "%*s am_bckptr = %p, am_anon = %p, am_ppref = %p }\n", 548 indent(2), "", 549 P(amap), 550 D(amap, amap)->am_ref, 551 D(amap, amap)->am_flags, 552 indent(2), "", 553 D(amap, amap)->am_maxslot, 554 D(amap, amap)->am_nslot, 555 D(amap, amap)->am_nused, 556 D(amap, amap)->am_slots, 557 indent(2), "", 558 D(amap, amap)->am_bckptr, 559 D(amap, amap)->am_anon, 560 D(amap, amap)->am_ppref); 561 562 if (!(debug & DUMP_VM_AMAP_DATA)) 563 return; 564 565 /* 566 * Assume that sizeof(struct vm_anon *) >= sizeof(size_t) and 567 * allocate that amount of space. 568 */ 569 am_anon = ecalloc(D(amap, amap)->am_maxslot, sizeof(*am_anon)); 570 l = D(amap, amap)->am_maxslot * sizeof(*am_anon); 571 _KDEREF(kd, (u_long)D(amap, amap)->am_anon, am_anon, l); 572 573 l = D(amap, amap)->am_maxslot * sizeof(*am_bckptr); 574 am_bckptr = ecalloc(D(amap, amap)->am_maxslot, sizeof(*am_bckptr)); 575 _KDEREF(kd, (u_long)D(amap, amap)->am_bckptr, am_bckptr, l); 576 577 l = D(amap, amap)->am_maxslot * sizeof(*am_slots); 578 am_slots = ecalloc(D(amap, amap)->am_maxslot, sizeof(*am_slots)); 579 _KDEREF(kd, (u_long)D(amap, amap)->am_slots, am_slots, l); 580 581 if (D(amap, amap)->am_ppref != NULL && 582 D(amap, amap)->am_ppref != PPREF_NONE) { 583 am_ppref = ecalloc( 584 D(amap, amap)->am_maxslot, sizeof(*am_ppref)); 585 l = D(amap, amap)->am_maxslot * sizeof(*am_ppref); 586 _KDEREF(kd, (u_long)D(amap, amap)->am_ppref, am_ppref, l); 587 } else { 588 am_ppref = NULL; 589 } 590 591 printf(" page# %9s %8s", "am_bckptr", "am_slots"); 592 if (am_ppref) 593 printf(" %8s ", "am_ppref"); 594 printf(" %10s\n", "am_anon"); 595 596 l = r = 0; 597 e = verbose > 1 ? D(amap, amap)->am_maxslot : D(amap, amap)->am_nslot; 598 for (i = 0; i < e; i++) { 599 printf(" %4lx", (unsigned long)i); 600 601 if (am_anon[i] || verbose > 1) 602 printf(" %8x", am_bckptr[i]); 603 else 604 printf(" %8s", "-"); 605 606 if (i < D(amap, amap)->am_nused || verbose > 1) 607 printf(" %8x", am_slots[i]); 608 else 609 printf(" %8s", "-"); 610 611 if (am_ppref) { 612 if (l == 0 || r || verbose > 1) 613 printf(" %8d", am_ppref[i]); 614 else 615 printf(" %8s", "-"); 616 r = 0; 617 if (l == 0) { 618 if (am_ppref[i] > 0) { 619 r = am_ppref[i] - 1; 620 l = 1; 621 } else { 622 r = -am_ppref[i] - 1; 623 l = am_ppref[i + 1]; 624 } 625 printf(" (%4ld @ %4ld)", (long)l, (long)r); 626 r = (l > 1) ? 1 : 0; 627 } 628 else 629 printf(" "); 630 l--; 631 } 632 633 dump_vm_anon(kd, am_anon, i); 634 } 635 636 free(am_anon); 637 free(am_bckptr); 638 free(am_slots); 639 if (am_ppref) 640 free(am_ppref); 641 } 642 643 static void 644 dump_vm_anon(kvm_t *kd, struct vm_anon **alist, int i) 645 { 646 647 printf(" %10p", alist[i]); 648 649 if (debug & PRINT_VM_ANON) { 650 struct kbit kbit, *anon = &kbit; 651 652 A(anon) = (u_long)alist[i]; 653 S(anon) = sizeof(struct vm_anon); 654 if (A(anon) == 0) { 655 printf(" = { }\n"); 656 return; 657 } 658 else 659 KDEREF(kd, anon); 660 661 printf(" = { an_ref = %"PRIuPTR", an_page = %p, an_swslot = %d }", 662 D(anon, anon)->an_ref, D(anon, anon)->an_page, 663 D(anon, anon)->an_swslot); 664 } 665 666 printf("\n"); 667 } 668 669 static char* 670 findname(kvm_t *kd, struct kbit *vmspace, 671 struct kbit *vm_map_entry, struct kbit *vp, 672 struct kbit *vfs, struct kbit *uvm_obj) 673 { 674 static char buf[1024], *name; 675 struct vm_map_entry *vme; 676 size_t l; 677 678 vme = D(vm_map_entry, vm_map_entry); 679 680 if (UVM_ET_ISOBJ(vme)) { 681 if (A(vfs)) { 682 l = (unsigned)strlen(D(vfs, mount)->mnt_stat.f_mntonname); 683 switch (search_cache(kd, vp, &name, buf, sizeof(buf))) { 684 case 0: /* found something */ 685 name--; 686 *name = '/'; 687 /*FALLTHROUGH*/ 688 case 2: /* found nothing */ 689 name -= 5; 690 memcpy(name, " -?- ", (size_t)5); 691 name -= l; 692 memcpy(name, 693 D(vfs, mount)->mnt_stat.f_mntonname, l); 694 break; 695 case 1: /* all is well */ 696 name--; 697 *name = '/'; 698 if (l != 1) { 699 name -= l; 700 memcpy(name, 701 D(vfs, mount)->mnt_stat.f_mntonname, l); 702 } 703 break; 704 } 705 } 706 else if (UVM_OBJ_IS_DEVICE(D(uvm_obj, uvm_object))) { 707 struct kbit kdev; 708 dev_t dev; 709 710 P(&kdev) = P(uvm_obj); 711 S(&kdev) = sizeof(struct uvm_device); 712 KDEREF(kd, &kdev); 713 dev = D(&kdev, uvm_device)->u_device; 714 name = devname(dev, S_IFCHR); 715 if (name != NULL) 716 snprintf(buf, sizeof(buf), "/dev/%s", name); 717 else 718 snprintf(buf, sizeof(buf), " [ device %llu,%llu ]", 719 (unsigned long long)major(dev), 720 (unsigned long long)minor(dev)); 721 name = buf; 722 } 723 else if (UVM_OBJ_IS_AOBJ(D(uvm_obj, uvm_object))) { 724 snprintf(buf, sizeof(buf), " [ uvm_aobj ]"); 725 name = buf; 726 } 727 else if (UVM_OBJ_IS_UBCPAGER(D(uvm_obj, uvm_object))) { 728 snprintf(buf, sizeof(buf), " [ ubc_pager ]"); 729 name = buf; 730 } 731 else if (UVM_OBJ_IS_VNODE(D(uvm_obj, uvm_object))) { 732 snprintf(buf, sizeof(buf), " [ ?VNODE? ]"); 733 name = buf; 734 } 735 else { 736 snprintf(buf, sizeof(buf), " [ ?? %p ?? ]", 737 D(uvm_obj, uvm_object)->pgops); 738 name = buf; 739 } 740 } 741 742 else if ((char *)D(vmspace, vmspace)->vm_maxsaddr <= 743 (char *)vme->start && 744 ((char *)D(vmspace, vmspace)->vm_maxsaddr + (size_t)maxssiz) >= 745 (char *)vme->end) { 746 snprintf(buf, sizeof(buf), " [ stack ]"); 747 name = buf; 748 } 749 750 else if (!heapfound && 751 (vme->protection & rwx) == rwx && 752 vme->start >= (u_long)D(vmspace, vmspace)->vm_daddr) { 753 heapfound = 1; 754 snprintf(buf, sizeof(buf), " [ heap ]"); 755 name = buf; 756 } 757 758 else if (UVM_ET_ISSUBMAP(vme)) { 759 const char *sub = mapname(vme->object.sub_map); 760 snprintf(buf, sizeof(buf), " [ %s ]", sub ? sub : "(submap)"); 761 name = buf; 762 } 763 764 else { 765 snprintf(buf, sizeof(buf), " [ anon ]"); 766 name = buf; 767 } 768 769 return (name); 770 } 771 772 static int 773 search_cache(kvm_t *kd, struct kbit *vp, char **name, char *buf, size_t blen) 774 { 775 char *o, *e; 776 struct cache_entry *ce; 777 struct kbit svp; 778 779 if (nchashtbl == NULL) 780 load_name_cache(kd); 781 782 P(&svp) = P(vp); 783 S(&svp) = sizeof(struct vnode); 784 785 e = &buf[blen - 1]; 786 o = e; 787 do { 788 LIST_FOREACH(ce, &lcache, ce_next) 789 if (ce->ce_vp == P(&svp)) 790 break; 791 if (ce && ce->ce_vp == P(&svp)) { 792 if (o != e) 793 *(--o) = '/'; 794 o -= ce->ce_nlen; 795 memcpy(o, ce->ce_name, (unsigned)ce->ce_nlen); 796 P(&svp) = ce->ce_pvp; 797 } 798 else 799 break; 800 } while (1/*CONSTCOND*/); 801 *e = '\0'; 802 *name = o; 803 804 if (e == o) 805 return (2); 806 807 KDEREF(kd, &svp); 808 return (D(&svp, vnode)->v_vflag & VV_ROOT); 809 } 810