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_ZERO)
 239                 printf(" ZERO");
 240             if (m.flags & PG_REFERENCED)
 241                 printf(" REFERENCED");
 242             if (m.flags & PG_CLEANCHK)
 243                 printf(" CLEANCHK");
 244             if (m.flags & PG_SWAPINPROG)
 245                 printf(" SWAPINPROG");
 246             if (m.flags & PG_NOSYNC)
 247                 printf(" NOSYNC");
 248             if (m.flags & PG_UNMANAGED)
 249                 printf(" UNMANAGED");
 250             if (m.flags & PG_MARKER)
 251                 printf(" MARKER");
 252             if (m.flags & PG_RAM)
 253                 printf(" RAM");
 254             if (m.flags & PG_SWAPPED)
 255                 printf(" SWAPPED");
 256 #if 0
 257             if (m.flags & PG_SLAB)
 258                 printf(" SLAB");
 259 #endif
 260             printf("\n");
 261 #if 0
 262             if (m.flags & PG_SLAB)
 263                 addsltrack(&m);
 264 #endif
 265         }
 266     }
 267     if (debugopt || verboseopt)
 268         printf("\n");
 269
 270 #if 0
 271     /*
 272      * Scan the vm_page_buckets array validating all pages found
 273      */
 274     for (i = 0; i <= vm_page_hash_mask; ++i) {
 275         if (debugopt) {
 276             printf("index %d\r", i);
 277             fflush(stdout);
 278         }
 279         kkread(kd, (u_long)&vm_page_buckets[i], &mptr, sizeof(mptr));
 280         while (mptr) {
 281             kkread(kd, (u_long)mptr, &m, sizeof(m));
 282             if (m.object) {
 283                 kkread(kd, (u_long)m.object, &obj, sizeof(obj));
 284                 hv = ((uintptr_t)m.object + m.pindex) ^ obj.hash_rand;
 285                 hv &= vm_page_hash_mask;
 286                 if (i != hv)
 287                     printf("vm_page_buckets[%d] ((struct vm_page *)%p)"
 288                         " should be in bucket %d\n", i, mptr, hv);
 289                 checkpage(kd, mptr, &m, &obj);
 290             } else {
 291                 printf("vm_page_buckets[%d] ((struct vm_page *)%p)"
 292                         " has no object\n", i, mptr);
 293             }
 294             mptr = m.hnext;
 295         }
 296     }
 297 #endif
 298     if (debugopt)
 299         printf("\n");
 300     dumpsltrack(kd);
 301     return(0);
 302 }
 303
 304 /*
 305  * A page with an object.
 306  */
 307 void
 308 checkpage(kvm_t *kd, vm_page_t mptr, vm_page_t m, struct vm_object *obj)
 309 {
 310 #if 0
 311     struct vm_page scan;
 312     vm_page_t scanptr;
 313     int hv;
 314
 315     hv = ((uintptr_t)m->object + m->pindex) ^ obj->hash_rand;
 316     hv &= vm_page_hash_mask;
 317     kkread(kd, (u_long)&vm_page_buckets[hv], &scanptr, sizeof(scanptr));
 318     while (scanptr) {
 319         if (scanptr == mptr)
 320             break;
 321         kkread(kd, (u_long)scanptr, &scan, sizeof(scan));
 322         scanptr = scan.hnext;
 323     }
 324     if (scanptr) {
 325         if (debugopt > 1)
 326             printf("good checkpage %p bucket %d\n", mptr, hv);
 327     } else {
 328         printf("vm_page_buckets[%d] ((struct vm_page *)%p)"
 329                 " page not found in bucket list\n", hv, mptr);
 330     }
 331 #endif
 332 }
 333
 334 /*
 335  * Acclerate the reading of VM pages
 336  */
 337 static void
 338 kkread_vmpage(kvm_t *kd, u_long addr, vm_page_t m)
 339 {
 340     static struct vm_page vpcache[1024];
 341     static u_long vpbeg;
 342     static u_long vpend;
 343
 344     if (addr < vpbeg || addr >= vpend) {
 345         vpbeg = addr;
 346         vpend = addr + 1024 * sizeof(*m);
 347         if (vpend > (u_long)(uintptr_t)vm_page_array +
 348                     vm_page_array_size * sizeof(*m)) {
 349             vpend = (u_long)(uintptr_t)vm_page_array +
 350                     vm_page_array_size * sizeof(*m);
 351         }
 352         kkread(kd, vpbeg, vpcache, vpend - vpbeg);
 353     }
 354     *m = vpcache[(addr - vpbeg) / sizeof(*m)];
 355 }
 356
 357 static void
 358 kkread(kvm_t *kd, u_long addr, void *buf, size_t nbytes)
 359 {
 360     if (kvm_read(kd, addr, buf, nbytes) != nbytes) {
 361         perror("kvm_read");
 362         exit(1);
 363     }
 364 }
 365
 366 static int
 367 kkread_err(kvm_t *kd, u_long addr, void *buf, size_t nbytes)
 368 {
 369     if (kvm_read(kd, addr, buf, nbytes) != nbytes) {
 370         return 1;
 371     }
 372     return 0;
 373 }
 374
 375 struct SLTrack {
 376         struct SLTrack *next;
 377         u_long addr;
 378 };
 379
 380 #define SLHSIZE 1024
 381 #define SLHMASK (SLHSIZE - 1)
 382
 383 struct SLTrack *SLHash[SLHSIZE];
 384
 385 #if 0
 386 static
 387 void
 388 addsltrack(vm_page_t m)
 389 {
 390         struct SLTrack *slt;
 391         u_long addr = (m->pindex * PAGE_SIZE) & ~131071L;
 392         int i;
 393
 394         if (m->wire_count == 0 || (m->flags & PG_MAPPED) == 0 ||
 395             m->object == NULL)
 396                 return;
 397
 398         i = (addr / 131072) & SLHMASK;
 399         for (slt = SLHash[i]; slt; slt = slt->next) {
 400                 if (slt->addr == addr)
 401                         break;
 402         }
 403         if (slt == NULL) {
 404                 slt = malloc(sizeof(*slt));
 405                 slt->addr = addr;
 406                 slt->next = SLHash[i];
 407                 SLHash[i] = slt;
 408         }
 409 }
 410 #endif
 411
 412 static
 413 void
 414 dumpsltrack(kvm_t *kd)
 415 {
 416         struct SLTrack *slt;
 417         int i;
 418         long total_zones = 0;
 419         long full_zones = 0;
 420
 421         for (i = 0; i < SLHSIZE; ++i) {
 422                 for (slt = SLHash[i]; slt; slt = slt->next) {
 423                         SLZone z;
 424
 425                         if (kkread_err(kd, slt->addr, &z, sizeof(z))) {
 426                                 printf("SLZone 0x%016lx not mapped\n",
 427                                         slt->addr);
 428                                 continue;
 429                         }
 430                         printf("SLZone 0x%016lx { mag=%08x cpu=%-2d NFree=%-3d "
 431                                "chunksz=%-5d }\n",
 432                                slt->addr,
 433                                z.z_Magic,
 434                                z.z_Cpu,
 435                                z.z_NFree,
 436                                z.z_ChunkSize
 437                         );
 438                         ++total_zones;
 439                         if (z.z_NFree == 0)
 440                                 ++full_zones;
 441                 }
 442         }
 443         printf("FullZones/TotalZones: %ld/%ld\n", full_zones, total_zones);
 444 }