test/debug/vmpageinfo.c

   1 /*
   2  * VMPAGEINFO.C
   3  *
   4  * cc -I/usr/src/sys vmpageinfo.c -o /usr/local/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  * $DragonFly: src/test/debug/vmpageinfo.c,v 1.2 2006/05/23 01:00:05 dillon Exp $
  44  */
  45
  46 #define _KERNEL_STRUCTURES_
  47 #include <sys/param.h>
  48 #include <sys/user.h>
  49 #include <sys/malloc.h>
  50 #include <sys/signalvar.h>
  51 #include <sys/vnode.h>
  52 #include <sys/namecache.h>
  53 #include <sys/slaballoc.h>
  54
  55 #include <vm/vm.h>
  56 #include <vm/vm_page.h>
  57 #include <vm/vm_kern.h>
  58 #include <vm/vm_page.h>
  59 #include <vm/vm_object.h>
  60 #include <vm/swap_pager.h>
  61 #include <vm/vnode_pager.h>
  62
  63 #include <stdio.h>
  64 #include <stdlib.h>
  65 #include <string.h>
  66 #include <fcntl.h>
  67 #include <kvm.h>
  68 #include <nlist.h>
  69 #include <getopt.h>
  70
  71 struct nlist Nl[] = {
  72 #if 0
  73     { "_vm_page_buckets" },
  74     { "_vm_page_hash_mask" },
  75 #endif
  76     { "_vm_page_array" },
  77     { "_vm_page_array_size" },
  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 int vm_page_array_size;
  89
  90 void checkpage(kvm_t *kd, vm_page_t mptr, vm_page_t m, struct vm_object *obj);
  91 static void kkread_vmpage(kvm_t *kd, u_long addr, vm_page_t m);
  92 static void kkread(kvm_t *kd, u_long addr, void *buf, size_t nbytes);
  93 static int kkread_err(kvm_t *kd, u_long addr, void *buf, size_t nbytes);
  94
  95 #if 0
  96 static void addsltrack(vm_page_t m);
  97 #endif
  98 static void dumpsltrack(kvm_t *kd);
  99
 100 int
 101 main(int ac, char **av)
 102 {
 103     const char *corefile = NULL;
 104     const char *sysfile = NULL;
 105     struct vm_page m;
 106     struct vm_object obj;
 107     kvm_t *kd;
 108     int ch;
 109 #if 0
 110     vm_page_t mptr;
 111     int hv;
 112 #endif
 113     int i;
 114     const char *qstr;
 115     const char *ostr;
 116
 117     while ((ch = getopt(ac, av, "M:N:dv")) != -1) {
 118         switch(ch) {
 119         case 'd':
 120             ++debugopt;
 121             break;
 122         case 'v':
 123             ++verboseopt;
 124             break;
 125         case 'M':
 126             corefile = optarg;
 127             break;
 128         case 'N':
 129             sysfile = optarg;
 130             break;
 131         default:
 132             fprintf(stderr, "%s [-M core] [-N system]\n", av[0]);
 133             exit(1);
 134         }
 135     }
 136     ac -= optind;
 137     av += optind;
 138
 139     if ((kd = kvm_open(sysfile, corefile, NULL, O_RDONLY, "kvm:")) == NULL) {
 140         perror("kvm_open");
 141         exit(1);
 142     }
 143     if (kvm_nlist(kd, Nl) != 0) {
 144         perror("kvm_nlist");
 145         exit(1);
 146     }
 147
 148 #if 0
 149     kkread(kd, Nl[0].n_value, &vm_page_buckets, sizeof(vm_page_buckets));
 150     kkread(kd, Nl[1].n_value, &vm_page_hash_mask, sizeof(vm_page_hash_mask));
 151 #endif
 152     kkread(kd, Nl[0].n_value, &vm_page_array, sizeof(vm_page_array));
 153     kkread(kd, Nl[1].n_value, &vm_page_array_size, sizeof(vm_page_array_size));
 154
 155     /*
 156      * Scan the vm_page_array validating all pages with associated objects
 157      */
 158     for (i = 0; i < vm_page_array_size; ++i) {
 159         if (debugopt) {
 160             printf("page %d\r", i);
 161             fflush(stdout);
 162         }
 163         kkread_vmpage(kd, (u_long)&vm_page_array[i], &m);
 164         if (m.object) {
 165             kkread(kd, (u_long)m.object, &obj, sizeof(obj));
 166             checkpage(kd, &vm_page_array[i], &m, &obj);
 167         }
 168         if (verboseopt) {
 169             if (m.queue >= PQ_HOLD) {
 170                 qstr = "HOLD";
 171             } else if (m.queue >= PQ_CACHE) {
 172                 qstr = "CACHE";
 173             } else if (m.queue >= PQ_ACTIVE) {
 174                 qstr = "ACTIVE";
 175             } else if (m.queue >= PQ_INACTIVE) {
 176                 qstr = "INACTIVE";
 177             } else if (m.queue >= PQ_FREE) {
 178                 qstr = "FREE";
 179             } else {
 180                 qstr = "NONE";
 181             }
 182             printf("page %p obj %p/%-8ju(%016jx) val=%02x dty=%02x hold=%d "
 183                    "wire=%-2d act=%-3d busy=%d %8s",
 184                 &vm_page_array[i],
 185                 m.object,
 186                 (intmax_t)m.pindex,
 187                 (intmax_t)m.pindex * PAGE_SIZE,
 188                 m.valid,
 189                 m.dirty,
 190                 m.hold_count,
 191                 m.wire_count,
 192                 m.act_count,
 193                 m.busy,
 194                 qstr
 195             );
 196             if (m.object) {
 197                 switch(obj.type) {
 198                 case OBJT_DEFAULT:
 199                     ostr = "default";
 200                     break;
 201                 case OBJT_SWAP:
 202                     ostr = "swap";
 203                     break;
 204                 case OBJT_VNODE:
 205                     ostr = "vnode";
 206                     break;
 207                 case OBJT_DEVICE:
 208                     ostr = "device";
 209                     break;
 210                 case OBJT_PHYS:
 211                     ostr = "phys";
 212                     break;
 213                 case OBJT_DEAD:
 214                     ostr = "dead";
 215                     break;
 216                 default:
 217                     ostr = "unknown";
 218                     break;
 219                 }
 220             } else {
 221                 ostr = "-";
 222             }
 223             printf(" %-7s", ostr);
 224             if (m.flags & PG_BUSY)
 225                 printf(" BUSY");
 226             if (m.flags & PG_WANTED)
 227                 printf(" WANTED");
 228             if (m.flags & PG_WINATCFLS)
 229                 printf(" WINATCFLS");
 230             if (m.flags & PG_FICTITIOUS)
 231                 printf(" FICTITIOUS");
 232             if (m.flags & PG_WRITEABLE)
 233                 printf(" WRITEABLE");
 234             if (m.flags & PG_MAPPED)
 235                 printf(" MAPPED");
 236             if (m.flags & PG_NEED_COMMIT)
 237                 printf(" NEED_COMMIT");
 238             if (m.flags & PG_REFERENCED)
 239                 printf(" REFERENCED");
 240             if (m.flags & PG_CLEANCHK)
 241                 printf(" CLEANCHK");
 242             if (m.flags & PG_SWAPINPROG)
 243                 printf(" SWAPINPROG");
 244             if (m.flags & PG_NOSYNC)
 245                 printf(" NOSYNC");
 246             if (m.flags & PG_UNMANAGED)
 247                 printf(" UNMANAGED");
 248             if (m.flags & PG_MARKER)
 249                 printf(" MARKER");
 250             if (m.flags & PG_RAM)
 251                 printf(" RAM");
 252             if (m.flags & PG_SWAPPED)
 253                 printf(" SWAPPED");
 254 #if 0
 255             if (m.flags & PG_SLAB)
 256                 printf(" SLAB");
 257 #endif
 258             printf("\n");
 259 #if 0
 260             if (m.flags & PG_SLAB)
 261                 addsltrack(&m);
 262 #endif
 263         }
 264     }
 265     if (debugopt || verboseopt)
 266         printf("\n");
 267
 268 #if 0
 269     /*
 270      * Scan the vm_page_buckets array validating all pages found
 271      */
 272     for (i = 0; i <= vm_page_hash_mask; ++i) {
 273         if (debugopt) {
 274             printf("index %d\r", i);
 275             fflush(stdout);
 276         }
 277         kkread(kd, (u_long)&vm_page_buckets[i], &mptr, sizeof(mptr));
 278         while (mptr) {
 279             kkread(kd, (u_long)mptr, &m, sizeof(m));
 280             if (m.object) {
 281                 kkread(kd, (u_long)m.object, &obj, sizeof(obj));
 282                 hv = ((uintptr_t)m.object + m.pindex) ^ obj.hash_rand;
 283                 hv &= vm_page_hash_mask;
 284                 if (i != hv)
 285                     printf("vm_page_buckets[%d] ((struct vm_page *)%p)"
 286                         " should be in bucket %d\n", i, mptr, hv);
 287                 checkpage(kd, mptr, &m, &obj);
 288             } else {
 289                 printf("vm_page_buckets[%d] ((struct vm_page *)%p)"
 290                         " has no object\n", i, mptr);
 291             }
 292             mptr = m.hnext;
 293         }
 294     }
 295 #endif
 296     if (debugopt)
 297         printf("\n");
 298     dumpsltrack(kd);
 299     return(0);
 300 }
 301
 302 /*
 303  * A page with an object.
 304  */
 305 void
 306 checkpage(kvm_t *kd, vm_page_t mptr, vm_page_t m, struct vm_object *obj)
 307 {
 308 #if 0
 309     struct vm_page scan;
 310     vm_page_t scanptr;
 311     int hv;
 312
 313     hv = ((uintptr_t)m->object + m->pindex) ^ obj->hash_rand;
 314     hv &= vm_page_hash_mask;
 315     kkread(kd, (u_long)&vm_page_buckets[hv], &scanptr, sizeof(scanptr));
 316     while (scanptr) {
 317         if (scanptr == mptr)
 318             break;
 319         kkread(kd, (u_long)scanptr, &scan, sizeof(scan));
 320         scanptr = scan.hnext;
 321     }
 322     if (scanptr) {
 323         if (debugopt > 1)
 324             printf("good checkpage %p bucket %d\n", mptr, hv);
 325     } else {
 326         printf("vm_page_buckets[%d] ((struct vm_page *)%p)"
 327                 " page not found in bucket list\n", hv, mptr);
 328     }
 329 #endif
 330 }
 331
 332 /*
 333  * Acclerate the reading of VM pages
 334  */
 335 static void
 336 kkread_vmpage(kvm_t *kd, u_long addr, vm_page_t m)
 337 {
 338     static struct vm_page vpcache[1024];
 339     static u_long vpbeg;
 340     static u_long vpend;
 341
 342     if (addr < vpbeg || addr >= vpend) {
 343         vpbeg = addr;
 344         vpend = addr + 1024 * sizeof(*m);
 345         if (vpend > (u_long)(uintptr_t)vm_page_array +
 346                     vm_page_array_size * sizeof(*m)) {
 347             vpend = (u_long)(uintptr_t)vm_page_array +
 348                     vm_page_array_size * sizeof(*m);
 349         }
 350         kkread(kd, vpbeg, vpcache, vpend - vpbeg);
 351     }
 352     *m = vpcache[(addr - vpbeg) / sizeof(*m)];
 353 }
 354
 355 static void
 356 kkread(kvm_t *kd, u_long addr, void *buf, size_t nbytes)
 357 {
 358     if (kvm_read(kd, addr, buf, nbytes) != nbytes) {
 359         perror("kvm_read");
 360         exit(1);
 361     }
 362 }
 363
 364 static int
 365 kkread_err(kvm_t *kd, u_long addr, void *buf, size_t nbytes)
 366 {
 367     if (kvm_read(kd, addr, buf, nbytes) != nbytes) {
 368         return 1;
 369     }
 370     return 0;
 371 }
 372
 373 struct SLTrack {
 374         struct SLTrack *next;
 375         u_long addr;
 376 };
 377
 378 #define SLHSIZE 1024
 379 #define SLHMASK (SLHSIZE - 1)
 380
 381 struct SLTrack *SLHash[SLHSIZE];
 382
 383 #if 0
 384 static
 385 void
 386 addsltrack(vm_page_t m)
 387 {
 388         struct SLTrack *slt;
 389         u_long addr = (m->pindex * PAGE_SIZE) & ~131071L;
 390         int i;
 391
 392         if (m->wire_count == 0 || (m->flags & PG_MAPPED) == 0 ||
 393             m->object == NULL)
 394                 return;
 395
 396         i = (addr / 131072) & SLHMASK;
 397         for (slt = SLHash[i]; slt; slt = slt->next) {
 398                 if (slt->addr == addr)
 399                         break;
 400         }
 401         if (slt == NULL) {
 402                 slt = malloc(sizeof(*slt));
 403                 slt->addr = addr;
 404                 slt->next = SLHash[i];
 405                 SLHash[i] = slt;
 406         }
 407 }
 408 #endif
 409
 410 static
 411 void
 412 dumpsltrack(kvm_t *kd)
 413 {
 414         struct SLTrack *slt;
 415         int i;
 416         long total_zones = 0;
 417         long full_zones = 0;
 418
 419         for (i = 0; i < SLHSIZE; ++i) {
 420                 for (slt = SLHash[i]; slt; slt = slt->next) {
 421                         SLZone z;
 422
 423                         if (kkread_err(kd, slt->addr, &z, sizeof(z))) {
 424                                 printf("SLZone 0x%016lx not mapped\n",
 425                                         slt->addr);
 426                                 continue;
 427                         }
 428                         printf("SLZone 0x%016lx { mag=%08x cpu=%-2d NFree=%-3d "
 429                                "chunksz=%-5d }\n",
 430                                slt->addr,
 431                                z.z_Magic,
 432                                z.z_Cpu,
 433                                z.z_NFree,
 434                                z.z_ChunkSize
 435                         );
 436                         ++total_zones;
 437                         if (z.z_NFree == 0)
 438                                 ++full_zones;
 439                 }
 440         }
 441         printf("FullZones/TotalZones: %ld/%ld\n", full_zones, total_zones);
 442 }