xref: /titanic_51/usr/src/cmd/mdb/common/modules/specfs/specfs.c (revision 791a814c934fcd4deb13b26c1f116ff283272a0d)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 #pragma ident	"%Z%%M%	%I%	%E% SMI"
27 
28 #include <mdb/mdb_modapi.h>
29 #include <sys/types.h>
30 #include <sys/sysmacros.h>
31 #include <sys/time.h>
32 #include <sys/vnode.h>
33 #include <sys/fs/snode.h>
34 
35 typedef struct snode_walk_data {
36 	int sw_stablesz;
37 	uintptr_t sw_stable;
38 } snode_walk_data_t;
39 
40 int
41 snode_walk_init(mdb_walk_state_t *wsp)
42 {
43 	int stablesz;
44 	GElf_Sym sym;
45 	uintptr_t stable;
46 	uintptr_t sp;
47 	snode_walk_data_t *sw;
48 
49 	if (mdb_readvar(&stablesz, "stablesz") == -1) {
50 		mdb_warn("failed to read 'stablesz'");
51 		return (WALK_ERR);
52 	}
53 
54 	if (stablesz == 0)
55 		return (WALK_DONE);
56 
57 	if (mdb_lookup_by_name("stable", &sym) == -1) {
58 		mdb_warn("failed to read 'stable'");
59 		return (WALK_ERR);
60 	}
61 
62 	stable = (uintptr_t)sym.st_value;
63 
64 	if (mdb_vread(&sp, sizeof (sp), stable) == -1) {
65 		mdb_warn("failed to read stable entry at %p", stable);
66 		return (WALK_DONE);
67 	}
68 
69 	sw = mdb_alloc(sizeof (snode_walk_data_t), UM_SLEEP);
70 	sw->sw_stablesz = stablesz;
71 	sw->sw_stable = stable;
72 
73 	wsp->walk_addr = sp;
74 	wsp->walk_data = sw;
75 
76 	return (WALK_NEXT);
77 }
78 
79 int
80 snode_walk_step(mdb_walk_state_t *wsp)
81 {
82 	uintptr_t addr = wsp->walk_addr;
83 	snode_walk_data_t *sw = wsp->walk_data;
84 	struct snode *sp;
85 	struct snode snode;
86 
87 	while (addr == NULL) {
88 		if (--sw->sw_stablesz == 0)
89 			return (WALK_DONE);
90 
91 		sw->sw_stable += sizeof (struct snode *);
92 
93 		if (mdb_vread(&sp, sizeof (sp), sw->sw_stable) == -1) {
94 			mdb_warn("failed to read stable entry at %p",
95 			    sw->sw_stable);
96 			return (WALK_DONE);
97 		}
98 		addr = (uintptr_t)sp;
99 	}
100 
101 	if (mdb_vread(&snode, sizeof (snode), addr) == -1) {
102 		mdb_warn("failed to read snode at %p", addr);
103 		return (WALK_DONE);
104 	}
105 
106 	wsp->walk_addr = (uintptr_t)snode.s_next;
107 
108 	return (wsp->walk_callback(addr, &snode, wsp->walk_cbdata));
109 }
110 
111 void
112 snode_walk_fini(mdb_walk_state_t *wsp)
113 {
114 	mdb_free(wsp->walk_data, sizeof (snode_walk_data_t));
115 }
116 
117 typedef struct snode_cbdata {
118 	int sd_major;
119 	int sd_minor;
120 	int sd_verbose;
121 } snode_cbdata_t;
122 
123 static int
124 snode_cb(uintptr_t addr, const struct snode *snode, snode_cbdata_t *sd)
125 {
126 	static const mdb_bitmask_t s_flag_masks[] = {
127 		{ "UPD",	SUPD,		SUPD		},
128 		{ "ACC",	SACC,		SACC		},
129 		{ "CHG",	SCHG,		SCHG		},
130 		{ "PRIV",	SPRIV,		SPRIV		},
131 		{ "LOFFSET",	SLOFFSET,	SLOFFSET	},
132 		{ "LOCKED",	SLOCKED,	SLOCKED		},
133 		{ "WANT",	SWANT,		SWANT		},
134 		{ "CLONE",	SCLONE,		SCLONE		},
135 		{ "NEEDCLOSE",	SNEEDCLOSE,	SNEEDCLOSE	},
136 		{ "DIPSET",	SDIPSET,	SDIPSET		},
137 		{ "SIZEVALID",	SSIZEVALID,	SSIZEVALID	},
138 		{ "MUXED",	SMUXED,		SMUXED		},
139 		{ "SELFCLONE",	SSELFCLONE,	SSELFCLONE	},
140 		{ "NOFLUSH",	SNOFLUSH,	SNOFLUSH	},
141 		{ "CLOSING",	SCLOSING,	SCLOSING	},
142 		{ NULL,		0,		0		}
143 	};
144 
145 	int major = getmajor(snode->s_dev);
146 	int minor = getminor(snode->s_dev);
147 
148 	if (sd->sd_major != -1 && sd->sd_major != major)
149 		return (WALK_NEXT);
150 
151 	if (sd->sd_minor != -1 && sd->sd_minor != minor)
152 		return (WALK_NEXT);
153 
154 	if (sd->sd_verbose) {
155 		mdb_printf("%0?p %?p %6d %16lx <%b>\n",
156 		    addr, snode->s_vnode, snode->s_count, snode->s_dev,
157 		    snode->s_flag, s_flag_masks);
158 	} else {
159 		mdb_printf("%p\n", addr);
160 	}
161 
162 	return (WALK_NEXT);
163 }
164 
165 /*ARGSUSED*/
166 int
167 snode(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
168 {
169 	snode_cbdata_t sd;
170 	struct snode snode;
171 	uintptr_t major = 0, dev = 0;
172 
173 	sd.sd_major = -1;
174 	sd.sd_minor = -1;
175 	sd.sd_verbose = !(flags & DCMD_PIPE_OUT);
176 
177 	if (mdb_getopts(argc, argv,
178 	    'm', MDB_OPT_UINTPTR, &major,
179 	    'd', MDB_OPT_UINTPTR, &dev, NULL) != argc)
180 		return (DCMD_USAGE);
181 
182 	if (dev != 0) {
183 		sd.sd_major = getmajor(dev);
184 		sd.sd_minor = getminor(dev);
185 	}
186 
187 	if (major != 0)
188 		sd.sd_major = major;
189 
190 	if (DCMD_HDRSPEC(flags) && !(flags & DCMD_PIPE_OUT)) {
191 		mdb_printf("%<u>%?s %?s %6s %16s %-15s%</u>\n",
192 		    "ADDR", "VNODE", "COUNT", "DEV", "FLAG");
193 	}
194 
195 	if (!(flags & DCMD_ADDRSPEC)) {
196 		if (mdb_walk("snode", (mdb_walk_cb_t)snode_cb, &sd) == -1) {
197 			mdb_warn("can't walk snodes");
198 			return (DCMD_ERR);
199 		}
200 		return (DCMD_OK);
201 	}
202 
203 	if (mdb_vread(&snode, sizeof (snode), addr) == -1) {
204 		mdb_warn("failed to read snode structure at %p", addr);
205 		return (DCMD_ERR);
206 	}
207 
208 	snode_cb(addr, &snode, &sd);
209 
210 	return (DCMD_OK);
211 }
212 
213 /*ARGSUSED3*/
214 int
215 major2snode(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
216 {
217 	snode_cbdata_t sd;
218 
219 	if (!(flags & DCMD_ADDRSPEC) || argc != 0)
220 		return (DCMD_USAGE);
221 
222 	sd.sd_major = addr;
223 	sd.sd_minor = -1;
224 	sd.sd_verbose = 0;
225 
226 	if (mdb_pwalk("snode", (mdb_walk_cb_t)snode_cb, &sd, 0) != 0)
227 		return (DCMD_ERR);
228 
229 	return (DCMD_OK);
230 }
231 
232 /*ARGSUSED3*/
233 int
234 dev2snode(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
235 {
236 	snode_cbdata_t sd;
237 
238 	if (!(flags & DCMD_ADDRSPEC) || argc != 0)
239 		return (DCMD_USAGE);
240 
241 	sd.sd_major = getmajor(addr);
242 	sd.sd_minor = getminor(addr);
243 	sd.sd_verbose = 0;
244 
245 	if (mdb_pwalk("snode", (mdb_walk_cb_t)snode_cb, &sd, 0) != 0)
246 		return (DCMD_ERR);
247 
248 	return (DCMD_OK);
249 }
250 
251 void
252 snode_help(void)
253 {
254 	mdb_printf("Options:\n"
255 	    "   -d device  filter snodes of the specified dev_t\n"
256 	    "   -m major   filter snodes of the specified major number\n");
257 }
258 
259 /*
260  * MDB module linkage
261  */
262 static const mdb_dcmd_t dcmds[] = {
263 	{ "dev2snode", ":", "given a dev_t, return the snode", dev2snode },
264 	{ "major2snode", ":", "given a major number, return the snode(s)",
265 	    major2snode },
266 	{ "snode", "?[-d device] [-m major]",
267 		"filter and display snode structures", snode, snode_help },
268 	{ NULL }
269 };
270 
271 static const mdb_walker_t walkers[] = {
272 	{ "snode", "walk global snode lists",
273 		snode_walk_init, snode_walk_step, snode_walk_fini },
274 	{ NULL }
275 };
276 
277 static const mdb_modinfo_t modinfo = { MDB_API_VERSION, dcmds, walkers };
278 
279 const mdb_modinfo_t *
280 _mdb_init(void)
281 {
282 	return (&modinfo);
283 }
284