test/debug/vmpageinfo.c

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