xref: /titanic_41/usr/src/cmd/mdb/common/modules/genunix/kgrep.c (revision 9ea7ddd89362f3fb046cc70bba7ee58c21bc5674)
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 2006 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 /*
27  * Copyright 2011 Joyent, Inc.  All rights reserved.
28  */
29 
30 /*
31  * Generic memory walker, used by both the genunix and libumem dmods.
32  */
33 
34 #include <mdb/mdb_modapi.h>
35 #include <sys/sysmacros.h>
36 
37 #include "kgrep.h"
38 
39 #define	KGREP_FULL_MASK		(~(uintmax_t)0)
40 
41 typedef struct kgrep_data {
42 	uintmax_t kg_pattern;
43 	uintmax_t kg_mask;		/* fancy only */
44 	uintmax_t kg_dist;		/* fancy only */
45 	uintptr_t kg_minaddr;		/* fancy only */
46 	uintptr_t kg_maxaddr;		/* fancy only */
47 	void *kg_page;
48 	size_t kg_pagesize;
49 	char kg_cbtype;
50 	char kg_seen;
51 } kgrep_data_t;
52 
53 #define	KG_BASE		0
54 #define	KG_VERBOSE	1
55 #define	KG_PIPE		2
56 
57 static void
kgrep_cb(uintptr_t addr,uintmax_t * val,int type)58 kgrep_cb(uintptr_t addr, uintmax_t *val, int type)
59 {
60 	switch (type) {
61 	case KG_BASE:
62 	default:
63 		mdb_printf("%p\n", addr);
64 		break;
65 	case KG_VERBOSE:
66 		mdb_printf("%p:\t%llx\n", addr, *val);
67 		break;
68 	case KG_PIPE:
69 		mdb_printf("%#lr\n", addr);
70 		break;
71 	}
72 }
73 
74 static int
kgrep_range_basic(uintptr_t base,uintptr_t lim,void * kg_arg)75 kgrep_range_basic(uintptr_t base, uintptr_t lim, void *kg_arg)
76 {
77 	kgrep_data_t *kg = kg_arg;
78 	size_t pagesize = kg->kg_pagesize;
79 	uintptr_t pattern = kg->kg_pattern;
80 	uintptr_t *page = kg->kg_page;
81 	uintptr_t *page_end = &page[pagesize / sizeof (uintptr_t)];
82 	uintptr_t *pos;
83 
84 	uintptr_t addr, offset;
85 	int seen = 0;
86 
87 	/*
88 	 * page-align everything, to simplify the loop
89 	 */
90 	base = P2ALIGN(base, pagesize);
91 	lim = P2ROUNDUP(lim, pagesize);
92 
93 	for (addr = base; addr < lim; addr += pagesize) {
94 		if (mdb_vread(page, pagesize, addr) == -1)
95 			continue;
96 		seen = 1;
97 
98 		for (pos = page; pos < page_end; pos++) {
99 			if (*pos != pattern)
100 				continue;
101 
102 			offset = (caddr_t)pos - (caddr_t)page;
103 			kgrep_cb(addr + offset, NULL, kg->kg_cbtype);
104 		}
105 	}
106 	if (seen)
107 		kg->kg_seen = 1;
108 
109 	return (WALK_NEXT);
110 }
111 
112 /*
113  * Full-service template -- instantiated for each supported size.  We support
114  * the following options:
115  *
116  *	addr in [minaddr, maxaddr), and
117  *		value in [pattern, pattern + dist) OR
118  *		mask matching: (value & mask) == (pattern & mask)
119  */
120 #define	KGREP_FANCY_TEMPLATE(kgrep_range_fancybits, uintbits_t)		\
121 static int								\
122 kgrep_range_fancybits(uintptr_t base, uintptr_t lim, void *kg_arg)	\
123 {									\
124 	kgrep_data_t *kg = kg_arg;					\
125 									\
126 	uintbits_t pattern = kg->kg_pattern;				\
127 	uintbits_t dist = kg->kg_dist;					\
128 	uintbits_t mask = kg->kg_mask;					\
129 	uintptr_t minaddr = kg->kg_minaddr;				\
130 	uintptr_t maxaddr = kg->kg_maxaddr;				\
131 	size_t pagesize = kg->kg_pagesize;				\
132 	uintbits_t *page = (uintbits_t *)kg->kg_page;			\
133 	uintbits_t *page_end;						\
134 	uintbits_t *pos;						\
135 	uintbits_t cur;							\
136 	uintmax_t out;							\
137 									\
138 	uintptr_t addr, size, offset;					\
139 	int seen = 0;							\
140 									\
141 	base = P2ROUNDUP(MAX(base, minaddr), sizeof (uintbits_t));	\
142 									\
143 	if (maxaddr != 0 && lim > maxaddr)				\
144 		lim = maxaddr;						\
145 									\
146 	for (addr = base; addr < lim; addr += size) {			\
147 		/* P2END(...) computes the next page boundry */		\
148 		size = MIN(lim, P2END(addr, pagesize)) - addr;		\
149 									\
150 		if (mdb_vread(page, size, addr) == -1)			\
151 			continue;					\
152 									\
153 		seen = 1;						\
154 									\
155 		page_end = &page[size / sizeof (uintbits_t)];		\
156 		for (pos = page; pos < page_end; pos++) {		\
157 			cur = *pos;					\
158 									\
159 			/*						\
160 			 * Due to C's (surprising) integral promotion	\
161 			 * rules for unsigned types smaller than an	\
162 			 * int, we need to explicitly cast the result	\
163 			 * of cur minus pattern, below.			\
164 			 */						\
165 			if (((cur ^ pattern) & mask) != 0 &&		\
166 			    (uintbits_t)(cur - pattern) >= dist)	\
167 				continue;				\
168 									\
169 			out = cur;					\
170 			offset = (caddr_t)pos - (caddr_t)page;		\
171 			kgrep_cb(addr + offset, &out, kg->kg_cbtype);	\
172 		}							\
173 	}								\
174 	if (seen)							\
175 		kg->kg_seen = 1;					\
176 									\
177 	return (WALK_NEXT);						\
178 }
179 
KGREP_FANCY_TEMPLATE(kgrep_range_fancy8,uint8_t)180 KGREP_FANCY_TEMPLATE(kgrep_range_fancy8, uint8_t)
181 KGREP_FANCY_TEMPLATE(kgrep_range_fancy16, uint16_t)
182 KGREP_FANCY_TEMPLATE(kgrep_range_fancy32, uint32_t)
183 KGREP_FANCY_TEMPLATE(kgrep_range_fancy64, uint64_t)
184 
185 #undef KGREP_FANCY_TEMPLATE
186 
187 void
188 kgrep_help(void)
189 {
190 	mdb_printf(
191 "\n"
192 "Search the entire virtual address space for a particular pattern,\n"
193 "%<u>addr%</u>.  By default, a pointer-sized search for an exact match is\n"
194 "done.\n\n");
195 	mdb_dec_indent(2);
196 	mdb_printf("%<b>OPTIONS%</b>\n");
197 	mdb_inc_indent(2);
198 	mdb_printf(
199 "  -v    Report the value matched at each address\n"
200 "  -a minaddr\n"
201 "        Restrict the search to addresses >= minaddr\n"
202 "  -A maxaddr\n"
203 "        Restrict the search to addresses < maxaddr\n"
204 "  -d dist\n"
205 "        Search for values in [addr, addr + dist)\n"
206 "  -m mask\n"
207 "        Search for values where (value & mask) == addr\n"
208 "  -M invmask\n"
209 "        Search for values where (value & ~invmask) == addr\n"
210 "  -s size\n"
211 "        Instead of pointer-sized values, search for size-byte values.\n"
212 "        size must be 1, 2, 4, or 8.\n");
213 }
214 
215 /*ARGSUSED*/
216 int
kgrep(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)217 kgrep(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
218 {
219 	uintmax_t pattern = mdb_get_dot();
220 	uintmax_t mask = KGREP_FULL_MASK;
221 	uintmax_t invmask = 0;
222 	uintmax_t dist = 0;
223 	uintptr_t size = sizeof (uintptr_t);
224 	uintptr_t minaddr = 0;
225 	uintptr_t maxaddr = 0;
226 	size_t pagesize = kgrep_subr_pagesize();
227 	int verbose = 0;
228 	int ret;
229 	int args = 0;
230 
231 	kgrep_cb_func *func;
232 	kgrep_data_t kg;
233 
234 	uintmax_t size_mask;
235 
236 	if (mdb_getopts(argc, argv,
237 	    'a', MDB_OPT_UINTPTR, &minaddr,
238 	    'A', MDB_OPT_UINTPTR, &maxaddr,
239 	    'd', MDB_OPT_UINT64, &dist,
240 	    'm', MDB_OPT_UINT64, &mask,
241 	    'M', MDB_OPT_UINT64, &invmask,
242 	    's', MDB_OPT_UINTPTR, &size,
243 	    'v', MDB_OPT_SETBITS, B_TRUE, &verbose, NULL) != argc)
244 		return (DCMD_USAGE);
245 
246 	if (invmask != 0)
247 		args++;
248 	if (mask != KGREP_FULL_MASK)
249 		args++;
250 	if (dist != 0)
251 		args++;
252 
253 	if (args > 1) {
254 		mdb_warn("only one of -d, -m and -M may be specified\n");
255 		return (DCMD_USAGE);
256 	}
257 
258 	if (!(flags & DCMD_ADDRSPEC))
259 		return (DCMD_USAGE);
260 
261 	if (invmask != 0)
262 		mask = ~invmask;
263 
264 	if (pattern & ~mask)
265 		mdb_warn("warning: pattern does not match mask\n");
266 
267 	if (size > sizeof (uintmax_t)) {
268 		mdb_warn("sizes greater than %d not supported\n",
269 		    sizeof (uintmax_t));
270 		return (DCMD_ERR);
271 	}
272 
273 	if (size == 0 || (size & (size - 1)) != 0) {
274 		mdb_warn("size must be a power of 2\n");
275 		return (DCMD_ERR);
276 	}
277 
278 	if (size == sizeof (uintmax_t))
279 		size_mask = KGREP_FULL_MASK;
280 	else
281 		size_mask = (1ULL << (size * NBBY)) - 1ULL;
282 
283 	if (pattern & ~size_mask)
284 		mdb_warn("warning: pattern %llx overflows requested size "
285 		    "%d (max: %llx)\n",
286 		    pattern, size, size_mask);
287 
288 	if (dist > 0 &&
289 	    ((dist & ~size_mask) || size_mask + 1 - dist < pattern)) {
290 		mdb_warn("pattern %llx + distance %llx overflows size\n"
291 		    "%d (max: %llx)\n", pattern, dist, size, size_mask);
292 		return (DCMD_ERR);
293 	}
294 
295 	/*
296 	 * All arguments have now been validated.
297 	 */
298 
299 	(void) memset(&kg, '\0', sizeof (kg));
300 	kg.kg_page = mdb_alloc(pagesize, UM_SLEEP | UM_GC);
301 	kg.kg_pagesize = pagesize;
302 	kg.kg_pattern = pattern;
303 	kg.kg_mask = mask;
304 	kg.kg_dist = dist;
305 	kg.kg_minaddr = minaddr;
306 	kg.kg_maxaddr = maxaddr;
307 
308 	if (flags & DCMD_PIPE_OUT) {
309 		verbose = 0;
310 		kg.kg_cbtype = KG_PIPE;
311 	} else if (verbose) {
312 		kg.kg_cbtype = KG_VERBOSE;
313 	} else {
314 		kg.kg_cbtype = KG_BASE;
315 	}
316 
317 	/*
318 	 * kgrep_range_basic handles the common case (no arguments)
319 	 * with dispatch.
320 	 */
321 	if (size == sizeof (uintptr_t) && !verbose && mask == KGREP_FULL_MASK &&
322 	    dist == 0 && minaddr == 0 && maxaddr == 0)
323 		func = kgrep_range_basic;
324 	else {
325 		switch (size) {
326 		case 1:
327 			func = kgrep_range_fancy8;
328 			break;
329 		case 2:
330 			func = kgrep_range_fancy16;
331 			break;
332 		case 4:
333 			func = kgrep_range_fancy32;
334 			break;
335 		case 8:
336 			func = kgrep_range_fancy64;
337 			break;
338 		default:
339 			mdb_warn("can't happen: non-recognized kgrep size\n");
340 			return (DCMD_ERR);
341 		}
342 	}
343 
344 	/*
345 	 * Invoke the target, which should invoke func(start, end, &kg) for
346 	 * every range [start, end) of vaddrs which might have backing.
347 	 * Both start and end must be multiples of kgrep_subr_pagesize().
348 	 */
349 	ret = kgrep_subr(func, &kg);
350 
351 	if (ret == DCMD_OK && !kg.kg_seen)
352 		mdb_warn("warning: nothing searched\n");
353 
354 	return (ret);
355 }
356