1 /* 2 * Kernel Debugger Architecture Independent Support Functions 3 * 4 * This file is subject to the terms and conditions of the GNU General Public 5 * License. See the file "COPYING" in the main directory of this archive 6 * for more details. 7 * 8 * Copyright (c) 1999-2004 Silicon Graphics, Inc. All Rights Reserved. 9 * Copyright (c) 2009 Wind River Systems, Inc. All Rights Reserved. 10 * 03/02/13 added new 2.5 kallsyms <xavier.bru@bull.net> 11 */ 12 13 #include <linux/types.h> 14 #include <linux/sched.h> 15 #include <linux/mm.h> 16 #include <linux/kallsyms.h> 17 #include <linux/stddef.h> 18 #include <linux/vmalloc.h> 19 #include <linux/ptrace.h> 20 #include <linux/highmem.h> 21 #include <linux/hardirq.h> 22 #include <linux/delay.h> 23 #include <linux/uaccess.h> 24 #include <linux/kdb.h> 25 #include <linux/slab.h> 26 #include <linux/ctype.h> 27 #include "kdb_private.h" 28 29 /* 30 * kdbgetsymval - Return the address of the given symbol. 31 * 32 * Parameters: 33 * symname Character string containing symbol name 34 * symtab Structure to receive results 35 * Returns: 36 * 0 Symbol not found, symtab zero filled 37 * 1 Symbol mapped to module/symbol/section, data in symtab 38 */ kdbgetsymval(const char * symname,kdb_symtab_t * symtab)39 int kdbgetsymval(const char *symname, kdb_symtab_t *symtab) 40 { 41 kdb_dbg_printf(AR, "symname=%s, symtab=%px\n", symname, symtab); 42 memset(symtab, 0, sizeof(*symtab)); 43 symtab->sym_start = kallsyms_lookup_name(symname); 44 if (symtab->sym_start) { 45 kdb_dbg_printf(AR, "returns 1, symtab->sym_start=0x%lx\n", 46 symtab->sym_start); 47 return 1; 48 } 49 kdb_dbg_printf(AR, "returns 0\n"); 50 return 0; 51 } 52 EXPORT_SYMBOL(kdbgetsymval); 53 54 /** 55 * kdbnearsym() - Return the name of the symbol with the nearest address 56 * less than @addr. 57 * @addr: Address to check for near symbol 58 * @symtab: Structure to receive results 59 * 60 * WARNING: This function may return a pointer to a single statically 61 * allocated buffer (namebuf). kdb's unusual calling context (single 62 * threaded, all other CPUs halted) provides us sufficient locking for 63 * this to be safe. The only constraint imposed by the static buffer is 64 * that the caller must consume any previous reply prior to another call 65 * to lookup a new symbol. 66 * 67 * Note that, strictly speaking, some architectures may re-enter the kdb 68 * trap if the system turns out to be very badly damaged and this breaks 69 * the single-threaded assumption above. In these circumstances successful 70 * continuation and exit from the inner trap is unlikely to work and any 71 * user attempting this receives a prominent warning before being allowed 72 * to progress. In these circumstances we remain memory safe because 73 * namebuf[KSYM_NAME_LEN-1] will never change from '\0' although we do 74 * tolerate the possibility of garbled symbol display from the outer kdb 75 * trap. 76 * 77 * Return: 78 * * 0 - No sections contain this address, symtab zero filled 79 * * 1 - Address mapped to module/symbol/section, data in symtab 80 */ kdbnearsym(unsigned long addr,kdb_symtab_t * symtab)81 int kdbnearsym(unsigned long addr, kdb_symtab_t *symtab) 82 { 83 int ret = 0; 84 unsigned long symbolsize = 0; 85 unsigned long offset = 0; 86 static char namebuf[KSYM_NAME_LEN]; 87 88 kdb_dbg_printf(AR, "addr=0x%lx, symtab=%px\n", addr, symtab); 89 memset(symtab, 0, sizeof(*symtab)); 90 91 if (addr < 4096) 92 goto out; 93 94 symtab->sym_name = kallsyms_lookup(addr, &symbolsize , &offset, 95 (char **)(&symtab->mod_name), namebuf); 96 if (offset > 8*1024*1024) { 97 symtab->sym_name = NULL; 98 addr = offset = symbolsize = 0; 99 } 100 symtab->sym_start = addr - offset; 101 symtab->sym_end = symtab->sym_start + symbolsize; 102 ret = symtab->sym_name != NULL && *(symtab->sym_name) != '\0'; 103 104 if (symtab->mod_name == NULL) 105 symtab->mod_name = "kernel"; 106 kdb_dbg_printf(AR, "returns %d symtab->sym_start=0x%lx, symtab->mod_name=%px, symtab->sym_name=%px (%s)\n", 107 ret, symtab->sym_start, symtab->mod_name, symtab->sym_name, symtab->sym_name); 108 out: 109 return ret; 110 } 111 112 static char ks_namebuf[KSYM_NAME_LEN+1], ks_namebuf_prev[KSYM_NAME_LEN+1]; 113 114 /* 115 * kallsyms_symbol_complete 116 * 117 * Parameters: 118 * prefix_name prefix of a symbol name to lookup 119 * max_len maximum length that can be returned 120 * Returns: 121 * Number of symbols which match the given prefix. 122 * Notes: 123 * prefix_name is changed to contain the longest unique prefix that 124 * starts with this prefix (tab completion). 125 */ kallsyms_symbol_complete(char * prefix_name,int max_len)126 int kallsyms_symbol_complete(char *prefix_name, int max_len) 127 { 128 loff_t pos = 0; 129 int prefix_len = strlen(prefix_name), prev_len = 0; 130 int i, number = 0; 131 const char *name; 132 133 while ((name = kdb_walk_kallsyms(&pos))) { 134 if (strncmp(name, prefix_name, prefix_len) == 0) { 135 strscpy(ks_namebuf, name, sizeof(ks_namebuf)); 136 /* Work out the longest name that matches the prefix */ 137 if (++number == 1) { 138 prev_len = min_t(int, max_len-1, 139 strlen(ks_namebuf)); 140 memcpy(ks_namebuf_prev, ks_namebuf, prev_len); 141 ks_namebuf_prev[prev_len] = '\0'; 142 continue; 143 } 144 for (i = 0; i < prev_len; i++) { 145 if (ks_namebuf[i] != ks_namebuf_prev[i]) { 146 prev_len = i; 147 ks_namebuf_prev[i] = '\0'; 148 break; 149 } 150 } 151 } 152 } 153 if (prev_len > prefix_len) 154 memcpy(prefix_name, ks_namebuf_prev, prev_len+1); 155 return number; 156 } 157 158 /* 159 * kallsyms_symbol_next 160 * 161 * Parameters: 162 * prefix_name prefix of a symbol name to lookup 163 * flag 0 means search from the head, 1 means continue search. 164 * buf_size maximum length that can be written to prefix_name 165 * buffer 166 * Returns: 167 * 1 if a symbol matches the given prefix. 168 * 0 if no string found 169 */ kallsyms_symbol_next(char * prefix_name,int flag,int buf_size)170 int kallsyms_symbol_next(char *prefix_name, int flag, int buf_size) 171 { 172 int prefix_len = strlen(prefix_name); 173 static loff_t pos; 174 const char *name; 175 176 if (!flag) 177 pos = 0; 178 179 while ((name = kdb_walk_kallsyms(&pos))) { 180 if (!strncmp(name, prefix_name, prefix_len)) 181 return strscpy(prefix_name, name, buf_size); 182 } 183 return 0; 184 } 185 186 /* 187 * kdb_symbol_print - Standard method for printing a symbol name and offset. 188 * Inputs: 189 * addr Address to be printed. 190 * symtab Address of symbol data, if NULL this routine does its 191 * own lookup. 192 * punc Punctuation for string, bit field. 193 * Remarks: 194 * The string and its punctuation is only printed if the address 195 * is inside the kernel, except that the value is always printed 196 * when requested. 197 */ kdb_symbol_print(unsigned long addr,const kdb_symtab_t * symtab_p,unsigned int punc)198 void kdb_symbol_print(unsigned long addr, const kdb_symtab_t *symtab_p, 199 unsigned int punc) 200 { 201 kdb_symtab_t symtab, *symtab_p2; 202 if (symtab_p) { 203 symtab_p2 = (kdb_symtab_t *)symtab_p; 204 } else { 205 symtab_p2 = &symtab; 206 kdbnearsym(addr, symtab_p2); 207 } 208 if (!(symtab_p2->sym_name || (punc & KDB_SP_VALUE))) 209 return; 210 if (punc & KDB_SP_SPACEB) 211 kdb_printf(" "); 212 if (punc & KDB_SP_VALUE) 213 kdb_printf(kdb_machreg_fmt0, addr); 214 if (symtab_p2->sym_name) { 215 if (punc & KDB_SP_VALUE) 216 kdb_printf(" "); 217 if (punc & KDB_SP_PAREN) 218 kdb_printf("("); 219 if (strcmp(symtab_p2->mod_name, "kernel")) 220 kdb_printf("[%s]", symtab_p2->mod_name); 221 kdb_printf("%s", symtab_p2->sym_name); 222 if (addr != symtab_p2->sym_start) 223 kdb_printf("+0x%lx", addr - symtab_p2->sym_start); 224 if (punc & KDB_SP_SYMSIZE) 225 kdb_printf("/0x%lx", 226 symtab_p2->sym_end - symtab_p2->sym_start); 227 if (punc & KDB_SP_PAREN) 228 kdb_printf(")"); 229 } 230 if (punc & KDB_SP_SPACEA) 231 kdb_printf(" "); 232 if (punc & KDB_SP_NEWLINE) 233 kdb_printf("\n"); 234 } 235 236 /* 237 * kdb_strdup - kdb equivalent of strdup, for disasm code. 238 * Inputs: 239 * str The string to duplicate. 240 * type Flags to kmalloc for the new string. 241 * Returns: 242 * Address of the new string, NULL if storage could not be allocated. 243 * Remarks: 244 * This is not in lib/string.c because it uses kmalloc which is not 245 * available when string.o is used in boot loaders. 246 */ kdb_strdup(const char * str,gfp_t type)247 char *kdb_strdup(const char *str, gfp_t type) 248 { 249 int n = strlen(str)+1; 250 char *s = kmalloc(n, type); 251 if (!s) 252 return NULL; 253 return strcpy(s, str); 254 } 255 256 /* 257 * kdb_getarea_size - Read an area of data. The kdb equivalent of 258 * copy_from_user, with kdb messages for invalid addresses. 259 * Inputs: 260 * res Pointer to the area to receive the result. 261 * addr Address of the area to copy. 262 * size Size of the area. 263 * Returns: 264 * 0 for success, < 0 for error. 265 */ kdb_getarea_size(void * res,unsigned long addr,size_t size)266 int kdb_getarea_size(void *res, unsigned long addr, size_t size) 267 { 268 int ret = copy_from_kernel_nofault((char *)res, (char *)addr, size); 269 if (ret) { 270 if (!KDB_STATE(SUPPRESS)) { 271 kdb_func_printf("Bad address 0x%lx\n", addr); 272 KDB_STATE_SET(SUPPRESS); 273 } 274 ret = KDB_BADADDR; 275 } else { 276 KDB_STATE_CLEAR(SUPPRESS); 277 } 278 return ret; 279 } 280 281 /* 282 * kdb_putarea_size - Write an area of data. The kdb equivalent of 283 * copy_to_user, with kdb messages for invalid addresses. 284 * Inputs: 285 * addr Address of the area to write to. 286 * res Pointer to the area holding the data. 287 * size Size of the area. 288 * Returns: 289 * 0 for success, < 0 for error. 290 */ kdb_putarea_size(unsigned long addr,void * res,size_t size)291 int kdb_putarea_size(unsigned long addr, void *res, size_t size) 292 { 293 int ret = copy_to_kernel_nofault((char *)addr, (char *)res, size); 294 if (ret) { 295 if (!KDB_STATE(SUPPRESS)) { 296 kdb_func_printf("Bad address 0x%lx\n", addr); 297 KDB_STATE_SET(SUPPRESS); 298 } 299 ret = KDB_BADADDR; 300 } else { 301 KDB_STATE_CLEAR(SUPPRESS); 302 } 303 return ret; 304 } 305 306 /* 307 * kdb_getphys - Read data from a physical address. Validate the 308 * address is in range, use kmap_atomic() to get data 309 * similar to kdb_getarea() - but for phys addresses 310 * Inputs: 311 * res Pointer to the word to receive the result 312 * addr Physical address of the area to copy 313 * size Size of the area 314 * Returns: 315 * 0 for success, < 0 for error. 316 */ kdb_getphys(void * res,unsigned long addr,size_t size)317 static int kdb_getphys(void *res, unsigned long addr, size_t size) 318 { 319 unsigned long pfn; 320 void *vaddr; 321 struct page *page; 322 323 pfn = (addr >> PAGE_SHIFT); 324 if (!pfn_valid(pfn)) 325 return 1; 326 page = pfn_to_page(pfn); 327 vaddr = kmap_atomic(page); 328 memcpy(res, vaddr + (addr & (PAGE_SIZE - 1)), size); 329 kunmap_atomic(vaddr); 330 331 return 0; 332 } 333 334 /* 335 * kdb_getphysword 336 * Inputs: 337 * word Pointer to the word to receive the result. 338 * addr Address of the area to copy. 339 * size Size of the area. 340 * Returns: 341 * 0 for success, < 0 for error. 342 */ kdb_getphysword(unsigned long * word,unsigned long addr,size_t size)343 int kdb_getphysword(unsigned long *word, unsigned long addr, size_t size) 344 { 345 int diag; 346 __u8 w1; 347 __u16 w2; 348 __u32 w4; 349 __u64 w8; 350 *word = 0; /* Default value if addr or size is invalid */ 351 352 switch (size) { 353 case 1: 354 diag = kdb_getphys(&w1, addr, sizeof(w1)); 355 if (!diag) 356 *word = w1; 357 break; 358 case 2: 359 diag = kdb_getphys(&w2, addr, sizeof(w2)); 360 if (!diag) 361 *word = w2; 362 break; 363 case 4: 364 diag = kdb_getphys(&w4, addr, sizeof(w4)); 365 if (!diag) 366 *word = w4; 367 break; 368 case 8: 369 if (size <= sizeof(*word)) { 370 diag = kdb_getphys(&w8, addr, sizeof(w8)); 371 if (!diag) 372 *word = w8; 373 break; 374 } 375 fallthrough; 376 default: 377 diag = KDB_BADWIDTH; 378 kdb_func_printf("bad width %zu\n", size); 379 } 380 return diag; 381 } 382 383 /* 384 * kdb_getword - Read a binary value. Unlike kdb_getarea, this treats 385 * data as numbers. 386 * Inputs: 387 * word Pointer to the word to receive the result. 388 * addr Address of the area to copy. 389 * size Size of the area. 390 * Returns: 391 * 0 for success, < 0 for error. 392 */ kdb_getword(unsigned long * word,unsigned long addr,size_t size)393 int kdb_getword(unsigned long *word, unsigned long addr, size_t size) 394 { 395 int diag; 396 __u8 w1; 397 __u16 w2; 398 __u32 w4; 399 __u64 w8; 400 *word = 0; /* Default value if addr or size is invalid */ 401 switch (size) { 402 case 1: 403 diag = kdb_getarea(w1, addr); 404 if (!diag) 405 *word = w1; 406 break; 407 case 2: 408 diag = kdb_getarea(w2, addr); 409 if (!diag) 410 *word = w2; 411 break; 412 case 4: 413 diag = kdb_getarea(w4, addr); 414 if (!diag) 415 *word = w4; 416 break; 417 case 8: 418 if (size <= sizeof(*word)) { 419 diag = kdb_getarea(w8, addr); 420 if (!diag) 421 *word = w8; 422 break; 423 } 424 fallthrough; 425 default: 426 diag = KDB_BADWIDTH; 427 kdb_func_printf("bad width %zu\n", size); 428 } 429 return diag; 430 } 431 432 /* 433 * kdb_putword - Write a binary value. Unlike kdb_putarea, this 434 * treats data as numbers. 435 * Inputs: 436 * addr Address of the area to write to.. 437 * word The value to set. 438 * size Size of the area. 439 * Returns: 440 * 0 for success, < 0 for error. 441 */ kdb_putword(unsigned long addr,unsigned long word,size_t size)442 int kdb_putword(unsigned long addr, unsigned long word, size_t size) 443 { 444 int diag; 445 __u8 w1; 446 __u16 w2; 447 __u32 w4; 448 __u64 w8; 449 switch (size) { 450 case 1: 451 w1 = word; 452 diag = kdb_putarea(addr, w1); 453 break; 454 case 2: 455 w2 = word; 456 diag = kdb_putarea(addr, w2); 457 break; 458 case 4: 459 w4 = word; 460 diag = kdb_putarea(addr, w4); 461 break; 462 case 8: 463 if (size <= sizeof(word)) { 464 w8 = word; 465 diag = kdb_putarea(addr, w8); 466 break; 467 } 468 fallthrough; 469 default: 470 diag = KDB_BADWIDTH; 471 kdb_func_printf("bad width %zu\n", size); 472 } 473 return diag; 474 } 475 476 477 478 /* 479 * kdb_task_state_char - Return the character that represents the task state. 480 * Inputs: 481 * p struct task for the process 482 * Returns: 483 * One character to represent the task state. 484 */ kdb_task_state_char(const struct task_struct * p)485 char kdb_task_state_char (const struct task_struct *p) 486 { 487 unsigned long tmp; 488 char state; 489 int cpu; 490 491 if (!p || 492 copy_from_kernel_nofault(&tmp, (char *)p, sizeof(unsigned long))) 493 return 'E'; 494 495 state = task_state_to_char((struct task_struct *) p); 496 497 if (is_idle_task(p)) { 498 /* Idle task. Is it really idle, apart from the kdb 499 * interrupt? */ 500 cpu = kdb_process_cpu(p); 501 if (!kdb_task_has_cpu(p) || kgdb_info[cpu].irq_depth == 1) { 502 if (cpu != kdb_initial_cpu) 503 state = '-'; /* idle task */ 504 } 505 } else if (!p->mm && strchr("IMS", state)) { 506 state = tolower(state); /* sleeping system daemon */ 507 } 508 return state; 509 } 510 511 /* 512 * kdb_task_state - Return true if a process has the desired state 513 * given by the mask. 514 * Inputs: 515 * p struct task for the process 516 * mask set of characters used to select processes; both NULL 517 * and the empty string mean adopt a default filter, which 518 * is to suppress sleeping system daemons and the idle tasks 519 * Returns: 520 * True if the process matches at least one criteria defined by the mask. 521 */ kdb_task_state(const struct task_struct * p,const char * mask)522 bool kdb_task_state(const struct task_struct *p, const char *mask) 523 { 524 char state = kdb_task_state_char(p); 525 526 /* If there is no mask, then we will filter code that runs when the 527 * scheduler is idling and any system daemons that are currently 528 * sleeping. 529 */ 530 if (!mask || mask[0] == '\0') 531 return !strchr("-ims", state); 532 533 /* A is a special case that matches all states */ 534 if (strchr(mask, 'A')) 535 return true; 536 537 return strchr(mask, state); 538 } 539 540 /* Maintain a small stack of kdb_flags to allow recursion without disturbing 541 * the global kdb state. 542 */ 543 544 static int kdb_flags_stack[4], kdb_flags_index; 545 kdb_save_flags(void)546 void kdb_save_flags(void) 547 { 548 BUG_ON(kdb_flags_index >= ARRAY_SIZE(kdb_flags_stack)); 549 kdb_flags_stack[kdb_flags_index++] = kdb_flags; 550 } 551 kdb_restore_flags(void)552 void kdb_restore_flags(void) 553 { 554 BUG_ON(kdb_flags_index <= 0); 555 kdb_flags = kdb_flags_stack[--kdb_flags_index]; 556 } 557