1 /* 2 * VMPAGEINFO.C 3 * 4 * cc -I/usr/src/sys vmpageinfo.c -o ~/bin/vmpageinfo -lkvm 5 * 6 * vmpageinfo 7 * 8 * Validate the vm_page_buckets[] hash array against the vm_page_array 9 * 10 * 11 * Copyright (c) 2004 The DragonFly Project. All rights reserved. 12 * 13 * This code is derived from software contributed to The DragonFly Project 14 * by Matthew Dillon <dillon@backplane.com> 15 * 16 * Redistribution and use in source and binary forms, with or without 17 * modification, are permitted provided that the following conditions 18 * are met: 19 * 20 * 1. Redistributions of source code must retain the above copyright 21 * notice, this list of conditions and the following disclaimer. 22 * 2. Redistributions in binary form must reproduce the above copyright 23 * notice, this list of conditions and the following disclaimer in 24 * the documentation and/or other materials provided with the 25 * distribution. 26 * 3. Neither the name of The DragonFly Project nor the names of its 27 * contributors may be used to endorse or promote products derived 28 * from this software without specific, prior written permission. 29 * 30 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 31 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 32 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 33 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 34 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 35 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, 36 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 37 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 38 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 39 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 40 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 41 * SUCH DAMAGE. 42 */ 43 44 #define _KERNEL_STRUCTURES_ 45 #include <sys/param.h> 46 #include <sys/user.h> 47 #include <sys/buf.h> 48 #include <sys/malloc.h> 49 #include <sys/signalvar.h> 50 #include <sys/vnode.h> 51 #include <sys/namecache.h> 52 #include <sys/slaballoc.h> 53 54 #include <vm/vm.h> 55 #include <vm/vm_page.h> 56 #include <vm/vm_kern.h> 57 #include <vm/vm_object.h> 58 #include <vm/swap_pager.h> 59 #include <vm/vnode_pager.h> 60 61 #include <stdio.h> 62 #include <stdlib.h> 63 #include <string.h> 64 #include <fcntl.h> 65 #include <kvm.h> 66 #include <nlist.h> 67 #include <getopt.h> 68 69 struct nlist Nl[] = { 70 { "_vm_page_array" }, 71 { "_vm_page_array_size" }, 72 { "_kernel_object" }, 73 { "_nbuf" }, 74 { "_nswbuf_mem" }, 75 { "_nswbuf_kva" }, 76 { "_nswbuf_raw" }, 77 { "_kernbase" }, 78 { "__end" }, 79 { NULL } 80 }; 81 82 int debugopt; 83 int verboseopt; 84 #if 0 85 struct vm_page **vm_page_buckets; 86 int vm_page_hash_mask; 87 #endif 88 struct vm_page *vm_page_array; 89 struct vm_object *kernel_object_ptr; 90 int vm_page_array_size; 91 long nbuf; 92 long nswbuf_mem; 93 long nswbuf_kva; 94 long nswbuf_raw; 95 long kern_size; 96 97 void checkpage(kvm_t *kd, vm_page_t mptr, vm_page_t m, struct vm_object *obj); 98 static void kkread_vmpage(kvm_t *kd, u_long addr, vm_page_t m); 99 static void kkread(kvm_t *kd, u_long addr, void *buf, size_t nbytes); 100 static int kkread_err(kvm_t *kd, u_long addr, void *buf, size_t nbytes); 101 102 #if 0 103 static void addsltrack(vm_page_t m); 104 static void dumpsltrack(kvm_t *kd); 105 #endif 106 static int unique_object(void *ptr); 107 108 long count_free; 109 long count_wired; /* total */ 110 long count_wired_vnode; 111 long count_wired_anon; 112 long count_wired_in_pmap; 113 long count_wired_pgtable; 114 long count_wired_other; 115 long count_wired_kernel; 116 long count_wired_obj_other; 117 118 long count_anon; 119 long count_anon_in_pmap; 120 long count_vnode; 121 long count_device; 122 long count_phys; 123 long count_kernel; 124 long count_unknown; 125 long count_noobj_offqueue; 126 long count_noobj_onqueue; 127 128 int 129 main(int ac, char **av) 130 { 131 const char *corefile = NULL; 132 const char *sysfile = NULL; 133 struct vm_page m; 134 struct vm_object obj; 135 kvm_t *kd; 136 int ch; 137 #if 0 138 vm_page_t mptr; 139 int hv; 140 #endif 141 int i; 142 const char *qstr; 143 const char *ostr; 144 145 while ((ch = getopt(ac, av, "M:N:dv")) != -1) { 146 switch(ch) { 147 case 'd': 148 ++debugopt; 149 break; 150 case 'v': 151 ++verboseopt; 152 break; 153 case 'M': 154 corefile = optarg; 155 break; 156 case 'N': 157 sysfile = optarg; 158 break; 159 default: 160 fprintf(stderr, "%s [-M core] [-N system]\n", av[0]); 161 exit(1); 162 } 163 } 164 ac -= optind; 165 av += optind; 166 167 if ((kd = kvm_open(sysfile, corefile, NULL, O_RDONLY, "kvm:")) == NULL) { 168 perror("kvm_open"); 169 exit(1); 170 } 171 if (kvm_nlist(kd, Nl) != 0) { 172 perror("kvm_nlist"); 173 exit(1); 174 } 175 176 kkread(kd, Nl[0].n_value, &vm_page_array, sizeof(vm_page_array)); 177 kkread(kd, Nl[1].n_value, &vm_page_array_size, sizeof(vm_page_array_size)); 178 kernel_object_ptr = (void *)Nl[2].n_value; 179 kkread(kd, Nl[3].n_value, &nbuf, sizeof(nbuf)); 180 kkread(kd, Nl[4].n_value, &nswbuf_mem, sizeof(nswbuf_mem)); 181 kkread(kd, Nl[5].n_value, &nswbuf_kva, sizeof(nswbuf_kva)); 182 kkread(kd, Nl[6].n_value, &nswbuf_raw, sizeof(nswbuf_raw)); 183 kern_size = Nl[8].n_value - Nl[7].n_value; 184 185 /* 186 * Scan the vm_page_array validating all pages with associated objects 187 */ 188 for (i = 0; i < vm_page_array_size; ++i) { 189 if (debugopt) { 190 printf("page %d\r", i); 191 fflush(stdout); 192 } 193 kkread_vmpage(kd, (u_long)&vm_page_array[i], &m); 194 if (m.object) { 195 kkread(kd, (u_long)m.object, &obj, sizeof(obj)); 196 checkpage(kd, &vm_page_array[i], &m, &obj); 197 } 198 if (m.queue >= PQ_HOLD) { 199 qstr = "HOLD"; 200 } else if (m.queue >= PQ_CACHE) { 201 qstr = "CACHE"; 202 } else if (m.queue >= PQ_ACTIVE) { 203 qstr = "ACTIVE"; 204 } else if (m.queue >= PQ_INACTIVE) { 205 qstr = "INACTIVE"; 206 } else if (m.queue >= PQ_FREE) { 207 qstr = "FREE"; 208 ++count_free; 209 } else { 210 qstr = "NONE"; 211 } 212 if (m.wire_count) { 213 ++count_wired; 214 if (m.object == NULL) { 215 if ((m.flags & PG_MAPPED) && 216 (m.flags & PG_WRITEABLE) && 217 (m.flags & PG_UNQUEUED)) { 218 ++count_wired_pgtable; 219 } else { 220 ++count_wired_other; 221 } 222 } else if (m.object == kernel_object_ptr) { 223 ++count_wired_kernel; 224 } else { 225 switch(obj.type) { 226 case OBJT_VNODE: 227 ++count_wired_vnode; 228 break; 229 case OBJT_DEFAULT: 230 case OBJT_SWAP: 231 /* 232 if (m.md.pmap_count) 233 ++count_wired_in_pmap; 234 else 235 */ 236 ++count_wired_anon; 237 break; 238 default: 239 ++count_wired_obj_other; 240 break; 241 } 242 } 243 } else 244 #if 0 245 if (m.md.pmap_count) { 246 if (m.object && m.object != kernel_object_ptr) { 247 switch(obj.type) { 248 case OBJT_DEFAULT: 249 case OBJT_SWAP: 250 ++count_anon_in_pmap; 251 break; 252 default: 253 break; 254 } 255 } 256 } 257 #endif 258 259 if (verboseopt) { 260 printf("page %p obj %p/%-8ju(%016jx) val=%02x dty=%02x hold=%d " 261 "wire=%-2d act=%-3d busy=%d w/pmapcnt=%d/%d %8s", 262 &vm_page_array[i], 263 m.object, 264 (intmax_t)m.pindex, 265 (intmax_t)m.pindex * PAGE_SIZE, 266 m.valid, 267 m.dirty, 268 m.hold_count, 269 m.wire_count, 270 m.act_count, 271 m.busy_count, 272 0 /* m.md.writeable_count */, 273 0 /*m.md.pmap_count*/, 274 qstr 275 ); 276 } 277 278 if (m.object == kernel_object_ptr) { 279 ostr = "kernel"; 280 if (unique_object(m.object)) 281 count_kernel += obj.resident_page_count; 282 } else if (m.object) { 283 switch(obj.type) { 284 case OBJT_DEFAULT: 285 ostr = "default"; 286 if (unique_object(m.object)) 287 count_anon += obj.resident_page_count; 288 break; 289 case OBJT_SWAP: 290 ostr = "swap"; 291 if (unique_object(m.object)) 292 count_anon += obj.resident_page_count; 293 break; 294 case OBJT_VNODE: 295 ostr = "vnode"; 296 if (unique_object(m.object)) 297 count_vnode += obj.resident_page_count; 298 break; 299 case OBJT_DEVICE: 300 ostr = "device"; 301 if (unique_object(m.object)) 302 count_device += obj.resident_page_count; 303 break; 304 case OBJT_PHYS: 305 ostr = "phys"; 306 if (unique_object(m.object)) 307 count_phys += obj.resident_page_count; 308 break; 309 case OBJT_DEAD: 310 ostr = "dead"; 311 if (unique_object(m.object)) 312 count_unknown += obj.resident_page_count; 313 break; 314 default: 315 if (unique_object(m.object)) 316 count_unknown += obj.resident_page_count; 317 ostr = "unknown"; 318 break; 319 } 320 } else { 321 ostr = "-"; 322 if (m.queue == PQ_NONE) 323 ++count_noobj_offqueue; 324 else if (m.queue - m.pc != PQ_FREE) 325 ++count_noobj_onqueue; 326 } 327 328 if (verboseopt) { 329 printf(" %-7s", ostr); 330 if (m.busy_count & PBUSY_LOCKED) 331 printf(" BUSY"); 332 if (m.busy_count & PBUSY_WANTED) 333 printf(" WANTED"); 334 if (m.flags & PG_WINATCFLS) 335 printf(" WINATCFLS"); 336 if (m.flags & PG_FICTITIOUS) 337 printf(" FICTITIOUS"); 338 if (m.flags & PG_WRITEABLE) 339 printf(" WRITEABLE"); 340 if (m.flags & PG_MAPPED) 341 printf(" MAPPED"); 342 if (m.flags & PG_NEED_COMMIT) 343 printf(" NEED_COMMIT"); 344 if (m.flags & PG_REFERENCED) 345 printf(" REFERENCED"); 346 if (m.flags & PG_CLEANCHK) 347 printf(" CLEANCHK"); 348 if (m.busy_count & PBUSY_SWAPINPROG) 349 printf(" SWAPINPROG"); 350 if (m.flags & PG_NOSYNC) 351 printf(" NOSYNC"); 352 if (m.flags & PG_UNQUEUED) 353 printf(" UNQUEUED"); 354 if (m.flags & PG_MARKER) 355 printf(" MARKER"); 356 if (m.flags & PG_RAM) 357 printf(" RAM"); 358 if (m.flags & PG_SWAPPED) 359 printf(" SWAPPED"); 360 #if 0 361 if (m.flags & PG_SLAB) 362 printf(" SLAB"); 363 #endif 364 printf("\n"); 365 #if 0 366 if (m.flags & PG_SLAB) 367 addsltrack(&m); 368 #endif 369 } 370 } 371 if (debugopt || verboseopt) 372 printf("\n"); 373 printf("%8.2fM free\n", count_free * 4096.0 / 1048576.0); 374 375 printf("%8.2fM wired vnode (in buffer cache)\n", 376 count_wired_vnode * 4096.0 / 1048576.0); 377 printf("%8.2fM wired in-pmap (probably vnode pages also in buffer cache)\n", 378 count_wired_in_pmap * 4096.0 / 1048576.0); 379 printf("%8.2fM wired pgtable\n", 380 count_wired_pgtable * 4096.0 / 1048576.0); 381 printf("%8.2fM wired anon\n", 382 count_wired_anon * 4096.0 / 1048576.0); 383 printf("%8.2fM wired kernel_object\n", 384 count_wired_kernel * 4096.0 / 1048576.0); 385 386 printf("\t%8.2fM vm_page_array\n", 387 vm_page_array_size * sizeof(struct vm_page) / 1048576.0); 388 printf("\t%8.2fM buf, swbuf_mem, swbuf_kva, swbuf_raw\n", 389 (nbuf + nswbuf_mem + nswbuf_kva + nswbuf_raw) * 390 sizeof(struct buf) / 1048576.0); 391 printf("\t%8.2fM kernel binary\n", kern_size / 1048576.0); 392 printf("\t(also add in KMALLOC id kmapinfo, or loosely, vmstat -m)\n"); 393 394 printf("%8.2fM wired other (unknown object)\n", 395 count_wired_obj_other * 4096.0 / 1048576.0); 396 printf("%8.2fM wired other (no object, probably kernel)\n", 397 count_wired_other * 4096.0 / 1048576.0); 398 399 printf("%8.2fM WIRED TOTAL\n", 400 count_wired * 4096.0 / 1048576.0); 401 402 printf("\n"); 403 printf("%8.2fM anonymous (total, includes in-pmap)\n", 404 count_anon * 4096.0 / 1048576.0); 405 printf("%8.2fM anonymous memory in-pmap\n", 406 count_anon_in_pmap * 4096.0 / 1048576.0); 407 printf("%8.2fM vnode (includes wired)\n", 408 count_vnode * 4096.0 / 1048576.0); 409 printf("%8.2fM device\n", count_device * 4096.0 / 1048576.0); 410 printf("%8.2fM phys\n", count_phys * 4096.0 / 1048576.0); 411 printf("%8.2fM kernel (includes wired)\n", 412 count_kernel * 4096.0 / 1048576.0); 413 printf("%8.2fM unknown\n", count_unknown * 4096.0 / 1048576.0); 414 printf("%8.2fM no_object, off queue (includes wired w/o object)\n", 415 count_noobj_offqueue * 4096.0 / 1048576.0); 416 printf("%8.2fM no_object, on non-free queue (includes wired w/o object)\n", 417 count_noobj_onqueue * 4096.0 / 1048576.0); 418 419 #if 0 420 /* 421 * Scan the vm_page_buckets array validating all pages found 422 */ 423 for (i = 0; i <= vm_page_hash_mask; ++i) { 424 if (debugopt) { 425 printf("index %d\r", i); 426 fflush(stdout); 427 } 428 kkread(kd, (u_long)&vm_page_buckets[i], &mptr, sizeof(mptr)); 429 while (mptr) { 430 kkread(kd, (u_long)mptr, &m, sizeof(m)); 431 if (m.object) { 432 kkread(kd, (u_long)m.object, &obj, sizeof(obj)); 433 hv = ((uintptr_t)m.object + m.pindex) ^ obj.hash_rand; 434 hv &= vm_page_hash_mask; 435 if (i != hv) 436 printf("vm_page_buckets[%d] ((struct vm_page *)%p)" 437 " should be in bucket %d\n", i, mptr, hv); 438 checkpage(kd, mptr, &m, &obj); 439 } else { 440 printf("vm_page_buckets[%d] ((struct vm_page *)%p)" 441 " has no object\n", i, mptr); 442 } 443 mptr = m.hnext; 444 } 445 } 446 #endif 447 if (debugopt) 448 printf("\n"); 449 #if 0 450 dumpsltrack(kd); 451 #endif 452 return(0); 453 } 454 455 /* 456 * A page with an object. 457 */ 458 void 459 checkpage(kvm_t *kd, vm_page_t mptr, vm_page_t m, struct vm_object *obj) 460 { 461 #if 0 462 struct vm_page scan; 463 vm_page_t scanptr; 464 int hv; 465 466 hv = ((uintptr_t)m->object + m->pindex) ^ obj->hash_rand; 467 hv &= vm_page_hash_mask; 468 kkread(kd, (u_long)&vm_page_buckets[hv], &scanptr, sizeof(scanptr)); 469 while (scanptr) { 470 if (scanptr == mptr) 471 break; 472 kkread(kd, (u_long)scanptr, &scan, sizeof(scan)); 473 scanptr = scan.hnext; 474 } 475 if (scanptr) { 476 if (debugopt > 1) 477 printf("good checkpage %p bucket %d\n", mptr, hv); 478 } else { 479 printf("vm_page_buckets[%d] ((struct vm_page *)%p)" 480 " page not found in bucket list\n", hv, mptr); 481 } 482 #endif 483 } 484 485 /* 486 * Acclerate the reading of VM pages 487 */ 488 static void 489 kkread_vmpage(kvm_t *kd, u_long addr, vm_page_t m) 490 { 491 static struct vm_page vpcache[1024]; 492 static u_long vpbeg; 493 static u_long vpend; 494 495 if (addr < vpbeg || addr >= vpend) { 496 vpbeg = addr; 497 vpend = addr + 1024 * sizeof(*m); 498 if (vpend > (u_long)(uintptr_t)vm_page_array + 499 vm_page_array_size * sizeof(*m)) { 500 vpend = (u_long)(uintptr_t)vm_page_array + 501 vm_page_array_size * sizeof(*m); 502 } 503 kkread(kd, vpbeg, vpcache, vpend - vpbeg); 504 } 505 *m = vpcache[(addr - vpbeg) / sizeof(*m)]; 506 } 507 508 static void 509 kkread(kvm_t *kd, u_long addr, void *buf, size_t nbytes) 510 { 511 if (kvm_read(kd, addr, buf, nbytes) != nbytes) { 512 perror("kvm_read"); 513 exit(1); 514 } 515 } 516 517 static int 518 kkread_err(kvm_t *kd, u_long addr, void *buf, size_t nbytes) 519 { 520 if (kvm_read(kd, addr, buf, nbytes) != nbytes) { 521 return 1; 522 } 523 return 0; 524 } 525 526 struct SLTrack { 527 struct SLTrack *next; 528 u_long addr; 529 }; 530 531 #define SLHSIZE 1024 532 #define SLHMASK (SLHSIZE - 1) 533 534 struct SLTrack *SLHash[SLHSIZE]; 535 536 #if 0 537 static 538 void 539 addsltrack(vm_page_t m) 540 { 541 struct SLTrack *slt; 542 u_long addr = (m->pindex * PAGE_SIZE) & ~131071L; 543 int i; 544 545 if (m->wire_count == 0 || (m->flags & PG_MAPPED) == 0 || 546 m->object == NULL) 547 return; 548 549 i = (addr / 131072) & SLHMASK; 550 for (slt = SLHash[i]; slt; slt = slt->next) { 551 if (slt->addr == addr) 552 break; 553 } 554 if (slt == NULL) { 555 slt = malloc(sizeof(*slt)); 556 slt->addr = addr; 557 slt->next = SLHash[i]; 558 SLHash[i] = slt; 559 } 560 } 561 #endif 562 563 static 564 void 565 dumpsltrack(kvm_t *kd) 566 { 567 struct SLTrack *slt; 568 int i; 569 long total_zones = 0; 570 long full_zones = 0; 571 572 for (i = 0; i < SLHSIZE; ++i) { 573 for (slt = SLHash[i]; slt; slt = slt->next) { 574 SLZone z; 575 576 if (kkread_err(kd, slt->addr, &z, sizeof(z))) { 577 printf("SLZone 0x%016lx not mapped\n", 578 slt->addr); 579 continue; 580 } 581 printf("SLZone 0x%016lx { mag=%08x cpu=%-2d NFree=%-3d " 582 "chunksz=%-5d }\n", 583 slt->addr, 584 z.z_Magic, 585 z.z_Cpu, 586 z.z_NFree, 587 z.z_ChunkSize 588 ); 589 ++total_zones; 590 if (z.z_NFree == 0) 591 ++full_zones; 592 } 593 } 594 printf("FullZones/TotalZones: %ld/%ld\n", full_zones, total_zones); 595 } 596 597 #define HASH_SIZE (1024*1024) 598 #define HASH_MASK (HASH_SIZE - 1) 599 600 struct dup_entry { 601 struct dup_entry *next; 602 void *ptr; 603 }; 604 605 struct dup_entry *dup_hash[HASH_SIZE]; 606 607 static int 608 unique_object(void *ptr) 609 { 610 struct dup_entry *hen; 611 int hv; 612 613 hv = (intptr_t)ptr ^ ((intptr_t)ptr >> 20); 614 hv &= HASH_MASK; 615 for (hen = dup_hash[hv]; hen; hen = hen->next) { 616 if (hen->ptr == ptr) 617 return 0; 618 } 619 hen = malloc(sizeof(*hen)); 620 hen->next = dup_hash[hv]; 621 hen->ptr = ptr; 622 dup_hash[hv] = hen; 623 624 return 1; 625 } 626