debug utilities - adjust vmpageinfo, add zallocinfo
[dragonfly.git] / 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
54 #include <vm/vm.h>
55 #include <vm/vm_page.h>
56 #include <vm/vm_kern.h>
57 #include <vm/vm_page.h>
58 #include <vm/vm_object.h>
59 #include <vm/swap_pager.h>
60 #include <vm/vnode_pager.h>
61
62 #include <stdio.h>
63 #include <stdlib.h>
64 #include <string.h>
65 #include <fcntl.h>
66 #include <kvm.h>
67 #include <nlist.h>
68 #include <getopt.h>
69
70 struct nlist Nl[] = {
71 #if 0
72     { "_vm_page_buckets" },
73     { "_vm_page_hash_mask" },
74 #endif
75     { "_vm_page_array" },
76     { "_vm_page_array_size" },
77     { NULL }
78 };
79
80 int debugopt;
81 int verboseopt;
82 #if 0
83 struct vm_page **vm_page_buckets;
84 int vm_page_hash_mask;
85 #endif
86 struct vm_page *vm_page_array;
87 int vm_page_array_size;
88
89 void checkpage(kvm_t *kd, vm_page_t mptr, vm_page_t m, struct vm_object *obj);
90 void kkread(kvm_t *kd, u_long addr, void *buf, size_t nbytes);
91
92 int
93 main(int ac, char **av)
94 {
95     const char *corefile = NULL;
96     const char *sysfile = NULL;
97     vm_page_t mptr;
98     struct vm_page m;
99     struct vm_object obj;
100     kvm_t *kd;
101     int ch;
102     int hv;
103     int i;
104     const char *qstr;
105     const char *ostr;
106
107     while ((ch = getopt(ac, av, "M:N:dv")) != -1) {
108         switch(ch) {
109         case 'd':
110             ++debugopt;
111             break;
112         case 'v':
113             ++verboseopt;
114             break;
115         case 'M':
116             corefile = optarg;
117             break;
118         case 'N':
119             sysfile = optarg;
120             break;
121         default:
122             fprintf(stderr, "%s [-M core] [-N system]\n", av[0]);
123             exit(1);
124         }
125     }
126     ac -= optind;
127     av += optind;
128
129     if ((kd = kvm_open(sysfile, corefile, NULL, O_RDONLY, "kvm:")) == NULL) {
130         perror("kvm_open");
131         exit(1);
132     }
133     if (kvm_nlist(kd, Nl) != 0) {
134         perror("kvm_nlist");
135         exit(1);
136     }
137
138 #if 0
139     kkread(kd, Nl[0].n_value, &vm_page_buckets, sizeof(vm_page_buckets));
140     kkread(kd, Nl[1].n_value, &vm_page_hash_mask, sizeof(vm_page_hash_mask));
141 #endif
142     kkread(kd, Nl[0].n_value, &vm_page_array, sizeof(vm_page_array));
143     kkread(kd, Nl[1].n_value, &vm_page_array_size, sizeof(vm_page_array_size));
144
145     /*
146      * Scan the vm_page_array validating all pages with associated objects
147      */
148     for (i = 0; i < vm_page_array_size; ++i) {
149         if (debugopt) {
150             printf("page %d\r", i);
151             fflush(stdout);
152         }
153         kkread(kd, (u_long)&vm_page_array[i], &m, sizeof(m));
154         if (m.object) {
155             kkread(kd, (u_long)m.object, &obj, sizeof(obj));
156             checkpage(kd, &vm_page_array[i], &m, &obj);
157         }
158         if (verboseopt) {
159             if (m.queue >= PQ_HOLD) {
160                 qstr = "HOLD";
161             } else if (m.queue >= PQ_CACHE) {
162                 qstr = "CACHE";
163             } else if (m.queue >= PQ_ACTIVE) {
164                 qstr = "ACTIVE";
165             } else if (m.queue >= PQ_INACTIVE) {
166                 qstr = "INACTIVE";
167             } else if (m.queue >= PQ_FREE) {
168                 qstr = "FREE";
169             } else {
170                 qstr = "NONE";
171             } 
172             printf("page %p obj %p/%-8jd val=%02x dty=%02x hold=%d "
173                    "wire=%-2d act=%-3d busy=%d %8s",
174                 &vm_page_array[i],
175                 m.object,
176                 (intmax_t)m.pindex,
177                 m.valid,
178                 m.dirty,
179                 m.hold_count,
180                 m.wire_count,
181                 m.act_count,
182                 m.busy,
183                 qstr
184             );
185             switch(obj.type) {
186             case OBJT_DEFAULT:
187                 ostr = "default";
188                 break;
189             case OBJT_SWAP:
190                 ostr = "swap";
191                 break;
192             case OBJT_VNODE:
193                 ostr = "vnode";
194                 break;
195             case OBJT_DEVICE:
196                 ostr = "device";
197                 break;
198             case OBJT_PHYS:
199                 ostr = "phys";
200                 break;
201             case OBJT_DEAD:
202                 ostr = "dead";
203                 break;
204             default:
205                 ostr = "unknown";
206                 break;
207             }
208             printf(" %-7s", ostr);
209             if (m.flags & PG_BUSY)
210                 printf(" BUSY");
211             if (m.flags & PG_WANTED)
212                 printf(" WANTED");
213             if (m.flags & PG_WINATCFLS)
214                 printf(" WINATCFLS");
215             if (m.flags & PG_FICTITIOUS)
216                 printf(" FICTITIOUS");
217             if (m.flags & PG_WRITEABLE)
218                 printf(" WRITEABLE");
219             if (m.flags & PG_MAPPED)
220                 printf(" MAPPED");
221             if (m.flags & PG_ZERO)
222                 printf(" ZERO");
223             if (m.flags & PG_REFERENCED)
224                 printf(" REFERENCED");
225             if (m.flags & PG_CLEANCHK)
226                 printf(" CLEANCHK");
227             if (m.flags & PG_SWAPINPROG)
228                 printf(" SWAPINPROG");
229             if (m.flags & PG_NOSYNC)
230                 printf(" NOSYNC");
231             if (m.flags & PG_UNMANAGED)
232                 printf(" UNMANAGED");
233             if (m.flags & PG_MARKER)
234                 printf(" MARKER");
235             if (m.flags & PG_RAM)
236                 printf(" RAM");
237             if (m.flags & PG_SWAPPED)
238                 printf(" SWAPPED");
239             printf("\n");
240         }
241     }
242     if (debugopt || verboseopt)
243         printf("\n");
244
245 #if 0
246     /*
247      * Scan the vm_page_buckets array validating all pages found
248      */
249     for (i = 0; i <= vm_page_hash_mask; ++i) {
250         if (debugopt) {
251             printf("index %d\r", i);
252             fflush(stdout);
253         }
254         kkread(kd, (u_long)&vm_page_buckets[i], &mptr, sizeof(mptr));
255         while (mptr) {
256             kkread(kd, (u_long)mptr, &m, sizeof(m));
257             if (m.object) {
258                 kkread(kd, (u_long)m.object, &obj, sizeof(obj));
259                 hv = ((uintptr_t)m.object + m.pindex) ^ obj.hash_rand;
260                 hv &= vm_page_hash_mask;
261                 if (i != hv)
262                     printf("vm_page_buckets[%d] ((struct vm_page *)%p)"
263                         " should be in bucket %d\n", i, mptr, hv);
264                 checkpage(kd, mptr, &m, &obj);
265             } else {
266                 printf("vm_page_buckets[%d] ((struct vm_page *)%p)"
267                         " has no object\n", i, mptr);
268             }
269             mptr = m.hnext;
270         }
271     }
272 #endif
273     if (debugopt)
274         printf("\n");
275     return(0);
276 }
277
278 /*
279  * A page with an object.
280  */
281 void
282 checkpage(kvm_t *kd, vm_page_t mptr, vm_page_t m, struct vm_object *obj)
283 {
284 #if 0
285     struct vm_page scan;
286     vm_page_t scanptr;
287     int hv;
288
289     hv = ((uintptr_t)m->object + m->pindex) ^ obj->hash_rand;
290     hv &= vm_page_hash_mask;
291     kkread(kd, (u_long)&vm_page_buckets[hv], &scanptr, sizeof(scanptr));
292     while (scanptr) {
293         if (scanptr == mptr)
294             break;
295         kkread(kd, (u_long)scanptr, &scan, sizeof(scan));
296         scanptr = scan.hnext;
297     }
298     if (scanptr) {
299         if (debugopt > 1)
300             printf("good checkpage %p bucket %d\n", mptr, hv);
301     } else {
302         printf("vm_page_buckets[%d] ((struct vm_page *)%p)"
303                 " page not found in bucket list\n", hv, mptr);
304     }
305 #endif
306 }
307
308 void
309 kkread(kvm_t *kd, u_long addr, void *buf, size_t nbytes)
310 {
311     if (kvm_read(kd, addr, buf, nbytes) != nbytes) {
312         perror("kvm_read");
313         exit(1);
314     }
315 }
316