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