xref: /dragonfly/test/debug/ncptrace.c (revision d9d30518) 
1 /*
2  * NCPTRACE.C
3  *
4  * cc -I/usr/src/sys ncptrace.c -o /usr/local/bin/ncptrace -lkvm
5  *
6  * ncptrace
7  * ncptrace [path]
8  *
9  * Trace and dump the kernel namecache hierarchy.  If a path is specified
10  * the trace begins there, otherwise the trace begins at the root.
11  *
12  *
13  * Copyright (c) 2004 The DragonFly Project.  All rights reserved.
14  *
15  * This code is derived from software contributed to The DragonFly Project
16  * by Matthew Dillon <dillon@backplane.com>
17  *
18  * Redistribution and use in source and binary forms, with or without
19  * modification, are permitted provided that the following conditions
20  * are met:
21  *
22  * 1. Redistributions of source code must retain the above copyright
23  *    notice, this list of conditions and the following disclaimer.
24  * 2. Redistributions in binary form must reproduce the above copyright
25  *    notice, this list of conditions and the following disclaimer in
26  *    the documentation and/or other materials provided with the
27  *    distribution.
28  * 3. Neither the name of The DragonFly Project nor the names of its
29  *    contributors may be used to endorse or promote products derived
30  *    from this software without specific, prior written permission.
31  *
32  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
33  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
34  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
35  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
36  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
37  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
38  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
39  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
40  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
41  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
42  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
43  * SUCH DAMAGE.
44  *
45  * $DragonFly: src/test/debug/ncptrace.c,v 1.7 2007/05/06 20:45:01 dillon Exp $
46  */
47 
48 #define _KERNEL_STRUCTURES
49 #include <sys/param.h>
50 #include <sys/user.h>
51 #include <sys/malloc.h>
52 #include <sys/signalvar.h>
53 #include <sys/vnode.h>
54 #include <sys/namecache.h>
55 #include <sys/mount.h>
56 
57 #include <vm/vm.h>
58 #include <vm/vm_page.h>
59 #include <vm/vm_kern.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     { "_rootnch" },
73     { "_mountlist" },
74     { NULL }
75 };
76 
77 static char *getncppath(kvm_t *kd, struct nchandle *nch, char *buf, int bytes);
78 static int printvfc(kvm_t *kd, struct vfsconf *vfc);
79 static void kkread(kvm_t *kd, u_long addr, void *buf, size_t nbytes);
80 static void dumpncp(kvm_t *kd, int isnull, int tab, struct namecache *,
81 			const char *);
82 
83 static long num_unres;
84 static long num_leafs;
85 static long num_neg;
86 static long num_cache;
87 
88 int
89 main(int ac, char **av)
90 {
91     struct nchandle nch;
92     struct mount mntinfo;
93     struct mount *mntptr;
94     struct mntlist list;
95     kvm_t *kd;
96     const char *corefile = NULL;
97     const char *sysfile = NULL;
98     const char *path;
99     int ch;
100     int i;
101     int n;
102     int isnull;
103     char mntpath[1024];
104 
105     while ((ch = getopt(ac, av, "M:N:")) != -1) {
106 	switch(ch) {
107 	case 'M':
108 	    corefile = optarg;
109 	    break;
110 	case 'N':
111 	    sysfile = optarg;
112 	    break;
113 	default:
114 	    fprintf(stderr, "%s [-M core] [-N system]\n", av[0]);
115 	    exit(1);
116 	}
117     }
118     ac -= optind;
119     av += optind;
120 
121     if ((kd = kvm_open(sysfile, corefile, NULL, O_RDONLY, "kvm:")) == NULL) {
122 	perror("kvm_open");
123 	exit(1);
124     }
125     if (kvm_nlist(kd, Nl) != 0) {
126 	perror("kvm_nlist");
127 	exit(1);
128     }
129     kkread(kd, Nl[0].n_value, &nch, sizeof(nch));
130     kkread(kd, Nl[1].n_value, &list, sizeof(list));
131 
132     mntptr = TAILQ_FIRST(&list);
133     while (mntptr) {
134 	kkread(kd, (long)mntptr, &mntinfo, sizeof(mntinfo));
135 	printf("MOUNT %p ", mntptr);
136 	if (mntinfo.mnt_vfc) {
137 	    isnull = printvfc(kd, mntinfo.mnt_vfc);
138 	    printf(" ");
139 	} else {
140 	    isnull = 0;
141 	}
142 	mntpath[sizeof(mntpath)-1] = 0;
143 	path = getncppath(kd, &mntinfo.mnt_ncmounton,
144 			  mntpath, sizeof(mntpath) - 1);
145 	printf("ON %s\n", path);
146 	if (ac == 0) {
147 	    dumpncp(kd, isnull, 0, mntinfo.mnt_ncmountpt.ncp, NULL);
148 	} else {
149 	    n = strlen(path);
150 	    for (i = 0; i < ac; ++i) {
151 		if (strncmp(path, av[i], n) == 0) {
152 		    dumpncp(kd, isnull, 0,
153 			    mntinfo.mnt_ncmountpt.ncp, av[i] + n);
154 		}
155 	    }
156 	}
157 	mntptr = TAILQ_NEXT(&mntinfo, mnt_list);
158     }
159 
160     printf("numunres = %ld\n", num_unres);
161     printf("numleafs = %ld\n", num_leafs);
162     printf("numcache = %ld\n", num_cache);
163     printf("numneg   = %ld\n", num_neg);
164 }
165 
166 static void
167 dumpncp(kvm_t *kd, int isnull, int tab,
168 	struct namecache *ncptr, const char *path)
169 {
170     struct namecache ncp;
171     struct namecache *ncscan;
172     const char *ptr;
173     int haschildren;
174     char name[256];
175 
176     kkread(kd, (u_long)ncptr, &ncp, sizeof(ncp));
177     if (ncp.nc_nlen < sizeof(name)) {
178 	kkread(kd, (u_long)ncp.nc_name, name, ncp.nc_nlen);
179 	name[ncp.nc_nlen] = 0;
180     } else {
181 	name[0] = 0;
182     }
183 
184     if (isnull == 0) {
185 	if (ncp.nc_parent) {
186 	    if ((ncp.nc_flag & NCF_UNRESOLVED) && ncp.nc_list.tqh_first == NULL)
187 		++num_unres;
188 	    if (ncp.nc_list.tqh_first == NULL)
189 		++num_leafs;
190 	    ++num_cache;
191 	}
192 	if ((ncp.nc_flag & NCF_UNRESOLVED) == 0 && ncp.nc_vp == NULL)
193 	    ++num_neg;
194     }
195 
196     if (tab == 0) {
197 	strcpy(name, "FSROOT");
198 	if (path && *path == '/')
199 	    ++path;
200     } else if (name[0] == 0) {
201 	strcpy(name, "?");
202 	if (path)
203 	    return;
204     } else if (path) {
205 	if ((ptr = strchr(path, '/')) == NULL)
206 	    ptr = path + strlen(path);
207 	if (strlen(name) != ptr - path ||
208 	    bcmp(name, path, ptr - path) != 0
209 	) {
210 	    return;
211 	}
212 	path = ptr;
213 	if (*path == '/')
214 	    ++path;
215     }
216     if (path && *path == 0)
217 	path = NULL;
218 
219     if (ncp.nc_list.tqh_first)
220 	haschildren = 1;
221     else
222 	haschildren = 0;
223 
224     if (path)
225 	printf("ELM ");
226     else
227 	printf("%*.*s%s ", tab, tab, "", name);
228     printf("[ncp=%p par=%p %04x vp=%p",
229 	    ncptr, ncp.nc_parent, ncp.nc_flag, ncp.nc_vp);
230     if (ncp.nc_timeout)
231 	printf(" timo=%d", ncp.nc_timeout);
232     if (ncp.nc_refs)
233 	printf(" refs=%d", ncp.nc_refs);
234     if (ncp.nc_generation)
235 	printf(" gen=%d", ncp.nc_generation);
236     if ((ncp.nc_flag & NCF_UNRESOLVED) == 0 && ncp.nc_error)
237 	printf(" error=%d", ncp.nc_error);
238     if (ncp.nc_flag & NCF_ISMOUNTPT)
239 	printf(" MAYBEMOUNT");
240     if (ncp.nc_lock.lk_count & ~LKC_SHARED) {
241 	printf(" LOCKSTATUS(%016lx,td=%p)",
242 	       ncp.nc_lock.lk_count, ncp.nc_lock.lk_lockholder);
243     }
244     printf("]");
245 
246     if (path) {
247 	printf(" %s\n", name);
248     } else {
249 	printf("%s\n", haschildren ? " {" : "");
250     }
251     for (ncscan = ncp.nc_list.tqh_first; ncscan; ncscan = ncp.nc_entry.tqe_next) {
252 	kkread(kd, (u_long)ncscan, &ncp, sizeof(ncp));
253 	dumpncp(kd, isnull, (path ? (tab ? tab : 4) : tab + 4), ncscan, path);
254     }
255     if (haschildren && path == NULL)
256 	printf("%*.*s}\n", tab, tab, "");
257 }
258 
259 static
260 char *
261 getncppath(kvm_t *kd, struct nchandle *nch, char *base, int bytes)
262 {
263     struct mount mntinfo;
264     struct namecache ncp;
265     struct namecache *ncpptr;
266 
267     ncpptr = nch->ncp;
268     while (ncpptr) {
269 	kkread(kd, (long)ncpptr, &ncp, sizeof(ncp));
270 	if (ncp.nc_nlen >= bytes)
271 	    break;
272 	kkread(kd, (long)ncp.nc_name, base + bytes - ncp.nc_nlen, ncp.nc_nlen);
273 	bytes -= ncp.nc_nlen;
274 	if (ncp.nc_parent) {
275 	    base[--bytes] = '/';
276 	}
277 	ncpptr = ncp.nc_parent;
278     }
279     if (nch->mount) {
280 	kkread(kd, (long)nch->mount, &mntinfo, sizeof(mntinfo));
281 	if (mntinfo.mnt_ncmounton.mount)
282 	    return(getncppath(kd, &mntinfo.mnt_ncmounton, base, bytes));
283     } else if (base[bytes] == 0) {
284 	base[--bytes] = '/';
285     }
286     return(base + bytes);
287 }
288 
289 static
290 int
291 printvfc(kvm_t *kd, struct vfsconf *vfc)
292 {
293     struct vfsconf vfcinfo;
294 
295     kkread(kd, (long)vfc, &vfcinfo, sizeof(vfcinfo));
296     printf("%s [type %d]", vfcinfo.vfc_name, vfcinfo.vfc_typenum);
297 
298     return (strcmp(vfcinfo.vfc_name, "null") == 0);
299 }
300 
301 static void
302 kkread(kvm_t *kd, u_long addr, void *buf, size_t nbytes)
303 {
304     if (kvm_read(kd, addr, buf, nbytes) != nbytes) {
305         perror("kvm_read");
306         exit(1);
307     }
308 }
309 
310