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 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 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 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 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