pmap.c revision 1.55
1 /* $NetBSD: pmap.c,v 1.55 2020/03/22 14:41:32 ad Exp $ */ 2 3 /* 4 * Copyright (c) 2002, 2003, 2020 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.55 2020/03/22 14:41:32 ad 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 vnode *, 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_rssmax = %d,", D(vmspace, vmspace)->vm_rssmax); 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 printf(" vm_aslr_delta_mmap = %#zx }\n", 133 D(vmspace, vmspace)->vm_aslr_delta_mmap); 134 } 135 136 if (debug & PRINT_VM_MAP) { 137 printf("%*s%s %p = {", indent(2), "", mname, P(vm_map)); 138 printf(" pmap = %p,\n", D(vm_map, vm_map)->pmap); 139 printf("%*s lock = <struct lock>,", indent(2), ""); 140 printf(" header = <struct vm_map_entry>,"); 141 printf(" nentries = %d,\n", D(vm_map, vm_map)->nentries); 142 printf("%*s size = %#"PRIxVSIZE",", indent(2), "", 143 D(vm_map, vm_map)->size); 144 printf(" ref_count = %d,", D(vm_map, vm_map)->ref_count); 145 printf("%*s hint = %p,", indent(2), "", 146 D(vm_map, vm_map)->hint); 147 printf("%*s first_free = %p,", indent(2), "", 148 D(vm_map, vm_map)->first_free); 149 printf(" flags = %#x <%s%s%s%s%s >,\n", D(vm_map, vm_map)->flags, 150 D(vm_map, vm_map)->flags & VM_MAP_PAGEABLE ? " PAGEABLE" : "", 151 D(vm_map, vm_map)->flags & VM_MAP_WIREFUTURE ? " WIREFUTURE" : "", 152 #ifdef VM_MAP_DYING 153 D(vm_map, vm_map)->flags & VM_MAP_DYING ? " DYING" : 154 #endif 155 "", 156 #ifdef VM_MAP_TOPDOWN 157 D(vm_map, vm_map)->flags & VM_MAP_TOPDOWN ? " TOPDOWN" : 158 #endif 159 "", 160 #ifdef VM_MAP_WANTVA 161 D(vm_map, vm_map)->flags & VM_MAP_WANTVA ? " WANTVA" : 162 #endif 163 ""); 164 printf("%*s timestamp = %u }\n", indent(2), "", 165 D(vm_map, vm_map)->timestamp); 166 } 167 if (print_ddb) { 168 const char *name = mapname(P(vm_map)); 169 170 printf("%*s%s %p: [%#"PRIxVADDR"->%#"PRIxVADDR"]\n", indent(2), "", 171 recurse < 2 ? "MAP" : "SUBMAP", P(vm_map), 172 vm_map_min(D(vm_map, vm_map)), 173 vm_map_max(D(vm_map, vm_map))); 174 printf("\t%*s#ent=%d, sz=%"PRIxVSIZE", ref=%d, version=%d, flags=%#x\n", 175 indent(2), "", D(vm_map, vm_map)->nentries, 176 D(vm_map, vm_map)->size, D(vm_map, vm_map)->ref_count, 177 D(vm_map, vm_map)->timestamp, D(vm_map, vm_map)->flags); 178 printf("\t%*spmap=%p(resident=<unknown>)\n", indent(2), "", 179 D(vm_map, vm_map)->pmap); 180 if (verbose && name != NULL) 181 printf("\t%*s([ %s ])\n", indent(2), "", name); 182 } 183 184 dump_vm_map_entry(kd, proc, vmspace, header, 1); 185 186 /* 187 * we're not recursing into a submap, so print headers 188 */ 189 if (recurse < 2) { 190 /* headers */ 191 #ifdef DISABLED_HEADERS 192 if (print_map) 193 printf("%-*s %-*s rwx RWX CPY NCP I W A\n", 194 (int)sizeof(long) * 2 + 2, "Start", 195 (int)sizeof(long) * 2 + 2, "End"); 196 if (print_maps) 197 printf("%-*s %-*s rwxp %-*s Dev Inode File\n", 198 (int)sizeof(long) * 2 + 0, "Start", 199 (int)sizeof(long) * 2 + 0, "End", 200 (int)sizeof(long) * 2 + 0, "Offset"); 201 if (print_solaris) 202 printf("%-*s %*s Protection File\n", 203 (int)sizeof(long) * 2 + 0, "Start", 204 (int)sizeof(int) * 2 - 1, "Size "); 205 #endif 206 if (print_all) 207 printf("%-*s %-*s %*s %-*s rwxpc RWX I/W/A Dev %*s" 208 " - File\n", 209 (int)sizeof(long) * 2, "Start", 210 (int)sizeof(long) * 2, "End", 211 (int)sizeof(int) * 2, "Size ", 212 (int)sizeof(long) * 2, "Offset", 213 (int)sizeof(int) * 2, "Inode"); 214 } 215 216 /* these are the "sub entries" */ 217 total = 0; 218 next = D(header, vm_map_entry)->next; 219 last = P(header); 220 end = 0; 221 222 while (next != 0 && next != last) { 223 addr = (u_long)next; 224 A(vm_map_entry) = addr; 225 S(vm_map_entry) = sizeof(struct vm_map_entry); 226 KDEREF(kd, vm_map_entry); 227 next = D(vm_map_entry, vm_map_entry)->next; 228 229 if (end == 0) 230 end = D(vm_map_entry, vm_map_entry)->start; 231 else if (verbose > 1 && 232 end != D(vm_map_entry, vm_map_entry)->start) 233 printf("%*s[%lu pages / %luK]\n", indent(2), "", 234 (D(vm_map_entry, vm_map_entry)->start - end) / 235 page_size, 236 (D(vm_map_entry, vm_map_entry)->start - end) / 237 1024); 238 total += dump_vm_map_entry(kd, proc, vmspace, vm_map_entry, 0); 239 240 end = D(vm_map_entry, vm_map_entry)->end; 241 } 242 243 /* 244 * we're not recursing into a submap, so print totals 245 */ 246 if (recurse < 2) { 247 if (print_solaris) 248 printf("%-*s %8luK\n", 249 (int)sizeof(void *) * 2 - 2, " total", 250 (unsigned long)total); 251 if (print_all) 252 printf("%-*s %9luk\n", 253 (int)sizeof(void *) * 4 - 1, " total", 254 (unsigned long)total); 255 } 256 } 257 258 size_t 259 dump_vm_map_entry(kvm_t *kd, struct kinfo_proc2 *proc, struct kbit *vmspace, 260 struct kbit *vm_map_entry, int ishead) 261 { 262 struct kbit kbit[3]; 263 struct kbit *uvm_obj, *vp, *vfs; 264 struct vm_map_entry *vme; 265 size_t sz; 266 char *name; 267 dev_t dev; 268 ino_t inode; 269 270 if (S(vm_map_entry) == (size_t)-1) { 271 heapfound = 1; 272 S(vm_map_entry) = sizeof(struct vm_map_entry); 273 KDEREF(kd, vm_map_entry); 274 } 275 276 uvm_obj = &kbit[0]; 277 vp = &kbit[1]; 278 vfs = &kbit[2]; 279 280 A(uvm_obj) = 0; 281 A(vp) = 0; 282 A(vfs) = 0; 283 284 vme = D(vm_map_entry, vm_map_entry); 285 286 if ((ishead && (debug & PRINT_VM_MAP_HEADER)) || 287 (!ishead && (debug & PRINT_VM_MAP_ENTRY))) { 288 printf("%*s%s %p = {", indent(2), "", 289 ishead ? "vm_map.header" : "vm_map_entry", 290 P(vm_map_entry)); 291 printf(" prev = %p,", vme->prev); 292 printf(" next = %p,\n", vme->next); 293 printf("%*s start = %#"PRIxVADDR",", indent(2), "", vme->start); 294 printf(" end = %#"PRIxVADDR",", vme->end); 295 printf(" object.uvm_obj/sub_map = %p,\n", vme->object.uvm_obj); 296 printf("%*s offset = %" PRIx64 ",", indent(2), "", 297 vme->offset); 298 printf(" etype = %#x <%s%s%s%s >,", vme->etype, 299 UVM_ET_ISOBJ(vme) ? " OBJ" : "", 300 UVM_ET_ISSUBMAP(vme) ? " SUBMAP" : "", 301 UVM_ET_ISCOPYONWRITE(vme) ? " COW" : "", 302 UVM_ET_ISNEEDSCOPY(vme) ? " NEEDSCOPY" : ""); 303 printf(" protection = %#x,\n", vme->protection); 304 printf("%*s max_protection = %#x,", indent(2), "", 305 vme->max_protection); 306 printf(" inheritance = %d,", vme->inheritance); 307 printf(" wired_count = %d,\n", vme->wired_count); 308 printf("%*s aref = { ar_pageoff = %#x, ar_amap = %p },", 309 indent(2), "", vme->aref.ar_pageoff, vme->aref.ar_amap); 310 printf(" advice = %d,\n", vme->advice); 311 printf("%*s flags = %#x <%s%s%s > }\n", indent(2), "", 312 vme->flags, 313 vme->flags & UVM_MAP_KERNEL ? " KERNEL" : "", 314 vme->flags & UVM_MAP_STATIC ? " STATIC" : "", 315 vme->flags & UVM_MAP_NOMERGE ? " NOMERGE" : ""); 316 } 317 318 if ((debug & PRINT_VM_AMAP) && (vme->aref.ar_amap != NULL)) { 319 struct kbit akbit, *amap; 320 321 amap = &akbit; 322 P(amap) = vme->aref.ar_amap; 323 S(amap) = sizeof(struct vm_amap); 324 KDEREF(kd, amap); 325 dump_amap(kd, amap); 326 } 327 328 if (ishead) 329 return (0); 330 331 A(vp) = 0; 332 A(uvm_obj) = 0; 333 334 if (vme->object.uvm_obj != NULL) { 335 P(uvm_obj) = vme->object.uvm_obj; 336 S(uvm_obj) = sizeof(struct uvm_object); 337 KDEREF(kd, uvm_obj); 338 if (UVM_ET_ISOBJ(vme) && 339 UVM_OBJ_IS_VNODE(D(uvm_obj, uvm_object))) { 340 P(vp) = P(uvm_obj); 341 S(vp) = sizeof(struct vnode); 342 KDEREF(kd, vp); 343 } 344 } 345 346 A(vfs) = 0; 347 348 if (P(vp) != NULL && D(vp, vnode)->v_mount != NULL) { 349 P(vfs) = D(vp, vnode)->v_mount; 350 S(vfs) = sizeof(struct mount); 351 KDEREF(kd, vfs); 352 D(vp, vnode)->v_mount = D(vfs, mount); 353 } 354 355 /* 356 * dig out the device number and inode number from certain 357 * file system types. 358 */ 359 #define V_DATA_IS(vp, type, d, i) do { \ 360 struct kbit data; \ 361 P(&data) = D(vp, vnode)->v_data; \ 362 S(&data) = sizeof(*D(&data, type)); \ 363 KDEREF(kd, &data); \ 364 dev = D(&data, type)->d; \ 365 inode = D(&data, type)->i; \ 366 } while (0/*CONSTCOND*/) 367 368 dev = 0; 369 inode = 0; 370 371 if (A(vp) && 372 D(vp, vnode)->v_type == VREG && 373 D(vp, vnode)->v_data != NULL) { 374 switch (D(vp, vnode)->v_tag) { 375 case VT_UFS: 376 case VT_LFS: 377 case VT_EXT2FS: 378 V_DATA_IS(vp, inode, i_dev, i_number); 379 break; 380 case VT_ISOFS: 381 V_DATA_IS(vp, iso_node, i_dev, i_number); 382 break; 383 default: 384 break; 385 } 386 } 387 388 name = findname(kd, vmspace, vm_map_entry, vp, vfs, uvm_obj); 389 390 if (print_map) { 391 printf("%*s%#"PRIxVADDR" %#"PRIxVADDR" %c%c%c %c%c%c %s %s %d %d %d", 392 indent(2), "", 393 vme->start, vme->end, 394 (vme->protection & VM_PROT_READ) ? 'r' : '-', 395 (vme->protection & VM_PROT_WRITE) ? 'w' : '-', 396 (vme->protection & VM_PROT_EXECUTE) ? 'x' : '-', 397 (vme->max_protection & VM_PROT_READ) ? 'r' : '-', 398 (vme->max_protection & VM_PROT_WRITE) ? 'w' : '-', 399 (vme->max_protection & VM_PROT_EXECUTE) ? 'x' : '-', 400 UVM_ET_ISCOPYONWRITE(vme) ? "COW" : "NCOW", 401 UVM_ET_ISNEEDSCOPY(vme) ? "NC" : "NNC", 402 vme->inheritance, vme->wired_count, 403 vme->advice); 404 if (verbose) { 405 if (inode) 406 printf(" %llu,%llu %llu", 407 (unsigned long long)major(dev), 408 (unsigned long long)minor(dev), 409 (unsigned long long)inode); 410 if (name[0]) 411 printf(" %s", name); 412 } 413 printf("\n"); 414 } 415 416 if (print_maps) { 417 printf("%*s%0*"PRIxVADDR"-%0*"PRIxVADDR" %c%c%c%c %0*" PRIx64 " %02llx:%02llx %llu %s\n", 418 indent(2), "", 419 (int)sizeof(void *) * 2, vme->start, 420 (int)sizeof(void *) * 2, vme->end, 421 (vme->protection & VM_PROT_READ) ? 'r' : '-', 422 (vme->protection & VM_PROT_WRITE) ? 'w' : '-', 423 (vme->protection & VM_PROT_EXECUTE) ? 'x' : '-', 424 UVM_ET_ISCOPYONWRITE(vme) ? 'p' : 's', 425 (int)sizeof(void *) * 2, 426 vme->offset, 427 (unsigned long long)major(dev), 428 (unsigned long long)minor(dev), 429 (unsigned long long)inode, 430 (name[0] != ' ') || verbose ? name : ""); 431 } 432 433 if (print_ddb) { 434 printf("%*s - %p: %#"PRIxVADDR"->%#"PRIxVADDR": obj=%p/%#" PRIx64 ", amap=%p/%d\n", 435 indent(2), "", 436 P(vm_map_entry), vme->start, vme->end, 437 vme->object.uvm_obj, vme->offset, 438 vme->aref.ar_amap, vme->aref.ar_pageoff); 439 printf("\t%*ssubmap=%c, cow=%c, nc=%c, prot(max)=%d/%d, inh=%d, " 440 "wc=%d, adv=%d\n", 441 indent(2), "", 442 UVM_ET_ISSUBMAP(vme) ? 'T' : 'F', 443 UVM_ET_ISCOPYONWRITE(vme) ? 'T' : 'F', 444 UVM_ET_ISNEEDSCOPY(vme) ? 'T' : 'F', 445 vme->protection, vme->max_protection, 446 vme->inheritance, vme->wired_count, vme->advice); 447 if (verbose) { 448 printf("\t%*s", indent(2), ""); 449 if (inode) 450 printf("(dev=%llu,%llu ino=%llu [%s] [%p])\n", 451 (unsigned long long)major(dev), 452 (unsigned long long)minor(dev), 453 (unsigned long long)inode, name, P(vp)); 454 else if (name[0] == ' ') 455 printf("(%s)\n", &name[2]); 456 else 457 printf("(%s)\n", name); 458 } 459 } 460 461 sz = 0; 462 if (print_solaris) { 463 char prot[30]; 464 465 prot[0] = '\0'; 466 prot[1] = '\0'; 467 if (vme->protection & VM_PROT_READ) 468 strlcat(prot, "/read", sizeof(prot)); 469 if (vme->protection & VM_PROT_WRITE) 470 strlcat(prot, "/write", sizeof(prot)); 471 if (vme->protection & VM_PROT_EXECUTE) 472 strlcat(prot, "/exec", sizeof(prot)); 473 474 sz = (size_t)((vme->end - vme->start) / 1024); 475 printf("%*s%0*lX %6luK %-15s %s\n", 476 indent(2), "", 477 (int)sizeof(void *) * 2, 478 (unsigned long)vme->start, 479 (unsigned long)sz, 480 &prot[1], 481 name); 482 } 483 484 if (print_all) { 485 sz = (size_t)((vme->end - vme->start) / 1024); 486 printf(A(vp) ? 487 "%*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" : 488 "%*s%0*"PRIxVADDR"-%0*"PRIxVADDR" %7luk %0*" PRIx64 " %c%c%c%c%c (%c%c%c) %d/%d/%d %02llu:%02llu %7llu - %s\n", 489 indent(2), "", 490 (int)sizeof(void *) * 2, 491 vme->start, 492 (int)sizeof(void *) * 2, 493 vme->end - (vme->start != vme->end ? 1 : 0), 494 (unsigned long)sz, 495 (int)sizeof(void *) * 2, 496 vme->offset, 497 (vme->protection & VM_PROT_READ) ? 'r' : '-', 498 (vme->protection & VM_PROT_WRITE) ? 'w' : '-', 499 (vme->protection & VM_PROT_EXECUTE) ? 'x' : '-', 500 UVM_ET_ISCOPYONWRITE(vme) ? 'p' : 's', 501 UVM_ET_ISNEEDSCOPY(vme) ? '+' : '-', 502 (vme->max_protection & VM_PROT_READ) ? 'r' : '-', 503 (vme->max_protection & VM_PROT_WRITE) ? 'w' : '-', 504 (vme->max_protection & VM_PROT_EXECUTE) ? 'x' : '-', 505 vme->inheritance, 506 vme->wired_count, 507 vme->advice, 508 (unsigned long long)major(dev), 509 (unsigned long long)minor(dev), 510 (unsigned long long)inode, 511 name, P(vp)); 512 } 513 514 /* no access allowed, don't count space */ 515 if ((vme->protection & rwx) == 0) 516 sz = 0; 517 518 if (recurse && UVM_ET_ISSUBMAP(vme)) { 519 struct kbit mkbit, *submap; 520 521 recurse++; 522 submap = &mkbit; 523 P(submap) = vme->object.sub_map; 524 S(submap) = sizeof(*vme->object.sub_map); 525 KDEREF(kd, submap); 526 dump_vm_map(kd, proc, vmspace, submap, "submap"); 527 recurse--; 528 } 529 530 return (sz); 531 } 532 533 void 534 dump_amap(kvm_t *kd, struct kbit *amap) 535 { 536 struct vm_anon **am_anon; 537 int *am_slots; 538 int *am_bckptr; 539 int *am_ppref; 540 size_t l; 541 int i, r, e; 542 543 if (S(amap) == (size_t)-1) { 544 heapfound = 1; 545 S(amap) = sizeof(struct vm_amap); 546 KDEREF(kd, amap); 547 } 548 549 printf("%*s amap %p = { am_ref = %d, " 550 "am_flags = %#x,\n" 551 "%*s am_maxslot = %d, am_nslot = %d, am_nused = %d, " 552 "am_slots = %p,\n" 553 "%*s am_bckptr = %p, am_anon = %p, am_ppref = %p }\n", 554 indent(2), "", 555 P(amap), 556 D(amap, amap)->am_ref, 557 D(amap, amap)->am_flags, 558 indent(2), "", 559 D(amap, amap)->am_maxslot, 560 D(amap, amap)->am_nslot, 561 D(amap, amap)->am_nused, 562 D(amap, amap)->am_slots, 563 indent(2), "", 564 D(amap, amap)->am_bckptr, 565 D(amap, amap)->am_anon, 566 D(amap, amap)->am_ppref); 567 568 if (!(debug & DUMP_VM_AMAP_DATA)) 569 return; 570 571 /* 572 * Assume that sizeof(struct vm_anon *) >= sizeof(size_t) and 573 * allocate that amount of space. 574 */ 575 am_anon = ecalloc(D(amap, amap)->am_maxslot, sizeof(*am_anon)); 576 l = D(amap, amap)->am_maxslot * sizeof(*am_anon); 577 _KDEREF(kd, (u_long)D(amap, amap)->am_anon, am_anon, l); 578 579 l = D(amap, amap)->am_maxslot * sizeof(*am_bckptr); 580 am_bckptr = ecalloc(D(amap, amap)->am_maxslot, sizeof(*am_bckptr)); 581 _KDEREF(kd, (u_long)D(amap, amap)->am_bckptr, am_bckptr, l); 582 583 l = D(amap, amap)->am_maxslot * sizeof(*am_slots); 584 am_slots = ecalloc(D(amap, amap)->am_maxslot, sizeof(*am_slots)); 585 _KDEREF(kd, (u_long)D(amap, amap)->am_slots, am_slots, l); 586 587 if (D(amap, amap)->am_ppref != NULL && 588 D(amap, amap)->am_ppref != PPREF_NONE) { 589 am_ppref = ecalloc( 590 D(amap, amap)->am_maxslot, sizeof(*am_ppref)); 591 l = D(amap, amap)->am_maxslot * sizeof(*am_ppref); 592 _KDEREF(kd, (u_long)D(amap, amap)->am_ppref, am_ppref, l); 593 } else { 594 am_ppref = NULL; 595 } 596 597 printf(" page# %9s %8s", "am_bckptr", "am_slots"); 598 if (am_ppref) 599 printf(" %8s ", "am_ppref"); 600 printf(" %10s\n", "am_anon"); 601 602 l = r = 0; 603 e = verbose > 1 ? D(amap, amap)->am_maxslot : D(amap, amap)->am_nslot; 604 for (i = 0; i < e; i++) { 605 printf(" %4lx", (unsigned long)i); 606 607 if (am_anon[i] || verbose > 1) 608 printf(" %8x", am_bckptr[i]); 609 else 610 printf(" %8s", "-"); 611 612 if (i < D(amap, amap)->am_nused || verbose > 1) 613 printf(" %8x", am_slots[i]); 614 else 615 printf(" %8s", "-"); 616 617 if (am_ppref) { 618 if (l == 0 || r || verbose > 1) 619 printf(" %8d", am_ppref[i]); 620 else 621 printf(" %8s", "-"); 622 r = 0; 623 if (l == 0) { 624 if (am_ppref[i] > 0) { 625 r = am_ppref[i] - 1; 626 l = 1; 627 } else { 628 r = -am_ppref[i] - 1; 629 l = am_ppref[i + 1]; 630 } 631 printf(" (%4ld @ %4ld)", (long)l, (long)r); 632 r = (l > 1) ? 1 : 0; 633 } 634 else 635 printf(" "); 636 l--; 637 } 638 639 dump_vm_anon(kd, am_anon, i); 640 } 641 642 free(am_anon); 643 free(am_bckptr); 644 free(am_slots); 645 if (am_ppref) 646 free(am_ppref); 647 } 648 649 static void 650 dump_vm_anon(kvm_t *kd, struct vm_anon **alist, int i) 651 { 652 653 printf(" %10p", alist[i]); 654 655 if (debug & PRINT_VM_ANON) { 656 struct kbit kbit, *anon = &kbit; 657 658 A(anon) = (u_long)alist[i]; 659 S(anon) = sizeof(struct vm_anon); 660 if (A(anon) == 0) { 661 printf(" = { }\n"); 662 return; 663 } 664 else 665 KDEREF(kd, anon); 666 667 printf(" = { an_ref = %"PRIuPTR", an_page = %p, an_swslot = %d }", 668 D(anon, anon)->an_ref, D(anon, anon)->an_page, 669 D(anon, anon)->an_swslot); 670 } 671 672 printf("\n"); 673 } 674 675 static char* 676 findname(kvm_t *kd, struct kbit *vmspace, 677 struct kbit *vm_map_entry, struct kbit *vp, 678 struct kbit *vfs, struct kbit *uvm_obj) 679 { 680 static char buf[1024], *name; 681 struct vm_map_entry *vme; 682 size_t l; 683 int rv; 684 685 vme = D(vm_map_entry, vm_map_entry); 686 687 if (UVM_ET_ISOBJ(vme)) { 688 if (A(vfs)) { 689 l = (unsigned)strlen(D(vfs, mount)->mnt_stat.f_mntonname); 690 rv = search_cache(kd, P(vp), &name, buf, sizeof(buf)); 691 switch (rv) { 692 case 0: /* found something */ 693 name--; 694 *name = '/'; 695 /*FALLTHROUGH*/ 696 case 2: /* found nothing */ 697 name -= 5; 698 memcpy(name, " -?- ", (size_t)5); 699 name -= l; 700 memcpy(name, 701 D(vfs, mount)->mnt_stat.f_mntonname, l); 702 break; 703 case 1: /* all is well */ 704 name--; 705 *name = '/'; 706 if (l != 1) { 707 name -= l; 708 memcpy(name, 709 D(vfs, mount)->mnt_stat.f_mntonname, l); 710 } 711 break; 712 } 713 } 714 else if (UVM_OBJ_IS_DEVICE(D(uvm_obj, uvm_object))) { 715 struct kbit kdev; 716 dev_t dev; 717 718 P(&kdev) = P(uvm_obj); 719 S(&kdev) = sizeof(struct uvm_device); 720 KDEREF(kd, &kdev); 721 dev = D(&kdev, uvm_device)->u_device; 722 name = devname(dev, S_IFCHR); 723 if (name != NULL) 724 snprintf(buf, sizeof(buf), "/dev/%s", name); 725 else 726 snprintf(buf, sizeof(buf), " [ device %llu,%llu ]", 727 (unsigned long long)major(dev), 728 (unsigned long long)minor(dev)); 729 name = buf; 730 } 731 else if (UVM_OBJ_IS_AOBJ(D(uvm_obj, uvm_object))) { 732 snprintf(buf, sizeof(buf), " [ uvm_aobj ]"); 733 name = buf; 734 } 735 else if (UVM_OBJ_IS_UBCPAGER(D(uvm_obj, uvm_object))) { 736 snprintf(buf, sizeof(buf), " [ ubc_pager ]"); 737 name = buf; 738 } 739 else if (UVM_OBJ_IS_VNODE(D(uvm_obj, uvm_object))) { 740 snprintf(buf, sizeof(buf), " [ ?VNODE? ]"); 741 name = buf; 742 } 743 else { 744 snprintf(buf, sizeof(buf), " [ ?? %p ?? ]", 745 D(uvm_obj, uvm_object)->pgops); 746 name = buf; 747 } 748 } 749 750 else if ((char *)D(vmspace, vmspace)->vm_maxsaddr <= 751 (char *)vme->start && 752 ((char *)D(vmspace, vmspace)->vm_maxsaddr + (size_t)maxssiz) >= 753 (char *)vme->end) { 754 snprintf(buf, sizeof(buf), " [ stack ]"); 755 name = buf; 756 } 757 758 else if (!heapfound && 759 (vme->protection & rwx) == rwx && 760 vme->start >= (u_long)D(vmspace, vmspace)->vm_daddr) { 761 heapfound = 1; 762 snprintf(buf, sizeof(buf), " [ heap ]"); 763 name = buf; 764 } 765 766 else if (UVM_ET_ISSUBMAP(vme)) { 767 const char *sub = mapname(vme->object.sub_map); 768 snprintf(buf, sizeof(buf), " [ %s ]", sub ? sub : "(submap)"); 769 name = buf; 770 } 771 772 else { 773 snprintf(buf, sizeof(buf), " [ anon ]"); 774 name = buf; 775 } 776 777 return (name); 778 } 779 780 static int 781 search_cache(kvm_t *kd, struct vnode *vp, char **name, char *buf, size_t blen) 782 { 783 char *o, *e; 784 struct namecache nc; 785 struct vnode_impl vi; 786 u_long vip, ncp, ncp2; 787 788 vip = (u_long)vp; 789 e = &buf[blen - 1]; 790 o = e; 791 ncp2 = 0; 792 do { 793 /* Pull down vnode_impl for vnode. */ 794 _KDEREF(kd, vip, &vi, sizeof(vi)); 795 796 /* From that, get first cached name for vnode. */ 797 ncp = (u_long)vi.vi_nc_list.tqh_first; 798 if (ncp != 0 && ncp != ncp2) { 799 /* Pull down the cache entry. */ 800 _KDEREF(kd, ncp, &nc, sizeof(nc)); 801 /* Done if own parent or at the root. */ 802 if ((u_long)nc.nc_dvp == vip || 803 (vi.vi_vnode.v_vflag & VV_ROOT) != 0) 804 break; 805 /* Otherwise pull first NCHNAMLEN chars of name. */ 806 if (o != e) 807 *(--o) = '/'; 808 o -= MIN((size_t)nc.nc_nlen, NCHNAMLEN); 809 memcpy(o, nc.nc_name, (unsigned)nc.nc_nlen); 810 vip = (u_long)nc.nc_dvp; 811 ncp2 = ncp; 812 } else 813 break; 814 } while (1/*CONSTCOND*/); 815 *e = '\0'; 816 *name = o; 817 818 if (e == o) 819 return (2); 820 821 return (vi.vi_vnode.v_vflag & VV_ROOT); 822 } 823
Indexes created Tue Sep 23 21:09:50 GMT 2025