1 /* 2 * Kernel Debugger Architecture Independent Main Code 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) 2000 Stephane Eranian <eranian@hpl.hp.com> 10 * Xscale (R) modifications copyright (C) 2003 Intel Corporation. 11 * Copyright (c) 2009 Wind River Systems, Inc. All Rights Reserved. 12 */ 13 14 #include <linux/ctype.h> 15 #include <linux/string.h> 16 #include <linux/kernel.h> 17 #include <linux/reboot.h> 18 #include <linux/sched.h> 19 #include <linux/sysrq.h> 20 #include <linux/smp.h> 21 #include <linux/utsname.h> 22 #include <linux/vmalloc.h> 23 #include <linux/module.h> 24 #include <linux/mm.h> 25 #include <linux/init.h> 26 #include <linux/kallsyms.h> 27 #include <linux/kgdb.h> 28 #include <linux/kdb.h> 29 #include <linux/notifier.h> 30 #include <linux/interrupt.h> 31 #include <linux/delay.h> 32 #include <linux/nmi.h> 33 #include <linux/time.h> 34 #include <linux/ptrace.h> 35 #include <linux/sysctl.h> 36 #include <linux/cpu.h> 37 #include <linux/kdebug.h> 38 #include <linux/proc_fs.h> 39 #include <linux/uaccess.h> 40 #include <linux/slab.h> 41 #include "kdb_private.h" 42 43 #define GREP_LEN 256 44 char kdb_grep_string[GREP_LEN]; 45 int kdb_grepping_flag; 46 EXPORT_SYMBOL(kdb_grepping_flag); 47 int kdb_grep_leading; 48 int kdb_grep_trailing; 49 50 /* 51 * Kernel debugger state flags 52 */ 53 int kdb_flags; 54 atomic_t kdb_event; 55 56 /* 57 * kdb_lock protects updates to kdb_initial_cpu. Used to 58 * single thread processors through the kernel debugger. 59 */ 60 int kdb_initial_cpu = -1; /* cpu number that owns kdb */ 61 int kdb_nextline = 1; 62 int kdb_state; /* General KDB state */ 63 64 struct task_struct *kdb_current_task; 65 EXPORT_SYMBOL(kdb_current_task); 66 struct pt_regs *kdb_current_regs; 67 68 const char *kdb_diemsg; 69 static int kdb_go_count; 70 #ifdef CONFIG_KDB_CONTINUE_CATASTROPHIC 71 static unsigned int kdb_continue_catastrophic = 72 CONFIG_KDB_CONTINUE_CATASTROPHIC; 73 #else 74 static unsigned int kdb_continue_catastrophic; 75 #endif 76 77 /* kdb_commands describes the available commands. */ 78 static kdbtab_t *kdb_commands; 79 #define KDB_BASE_CMD_MAX 50 80 static int kdb_max_commands = KDB_BASE_CMD_MAX; 81 static kdbtab_t kdb_base_commands[KDB_BASE_CMD_MAX]; 82 #define for_each_kdbcmd(cmd, num) \ 83 for ((cmd) = kdb_base_commands, (num) = 0; \ 84 num < kdb_max_commands; \ 85 num++, num == KDB_BASE_CMD_MAX ? cmd = kdb_commands : cmd++) 86 87 typedef struct _kdbmsg { 88 int km_diag; /* kdb diagnostic */ 89 char *km_msg; /* Corresponding message text */ 90 } kdbmsg_t; 91 92 #define KDBMSG(msgnum, text) \ 93 { KDB_##msgnum, text } 94 95 static kdbmsg_t kdbmsgs[] = { 96 KDBMSG(NOTFOUND, "Command Not Found"), 97 KDBMSG(ARGCOUNT, "Improper argument count, see usage."), 98 KDBMSG(BADWIDTH, "Illegal value for BYTESPERWORD use 1, 2, 4 or 8, " 99 "8 is only allowed on 64 bit systems"), 100 KDBMSG(BADRADIX, "Illegal value for RADIX use 8, 10 or 16"), 101 KDBMSG(NOTENV, "Cannot find environment variable"), 102 KDBMSG(NOENVVALUE, "Environment variable should have value"), 103 KDBMSG(NOTIMP, "Command not implemented"), 104 KDBMSG(ENVFULL, "Environment full"), 105 KDBMSG(ENVBUFFULL, "Environment buffer full"), 106 KDBMSG(TOOMANYBPT, "Too many breakpoints defined"), 107 #ifdef CONFIG_CPU_XSCALE 108 KDBMSG(TOOMANYDBREGS, "More breakpoints than ibcr registers defined"), 109 #else 110 KDBMSG(TOOMANYDBREGS, "More breakpoints than db registers defined"), 111 #endif 112 KDBMSG(DUPBPT, "Duplicate breakpoint address"), 113 KDBMSG(BPTNOTFOUND, "Breakpoint not found"), 114 KDBMSG(BADMODE, "Invalid IDMODE"), 115 KDBMSG(BADINT, "Illegal numeric value"), 116 KDBMSG(INVADDRFMT, "Invalid symbolic address format"), 117 KDBMSG(BADREG, "Invalid register name"), 118 KDBMSG(BADCPUNUM, "Invalid cpu number"), 119 KDBMSG(BADLENGTH, "Invalid length field"), 120 KDBMSG(NOBP, "No Breakpoint exists"), 121 KDBMSG(BADADDR, "Invalid address"), 122 }; 123 #undef KDBMSG 124 125 static const int __nkdb_err = sizeof(kdbmsgs) / sizeof(kdbmsg_t); 126 127 128 /* 129 * Initial environment. This is all kept static and local to 130 * this file. We don't want to rely on the memory allocation 131 * mechanisms in the kernel, so we use a very limited allocate-only 132 * heap for new and altered environment variables. The entire 133 * environment is limited to a fixed number of entries (add more 134 * to __env[] if required) and a fixed amount of heap (add more to 135 * KDB_ENVBUFSIZE if required). 136 */ 137 138 static char *__env[] = { 139 #if defined(CONFIG_SMP) 140 "PROMPT=[%d]kdb> ", 141 "MOREPROMPT=[%d]more> ", 142 #else 143 "PROMPT=kdb> ", 144 "MOREPROMPT=more> ", 145 #endif 146 "RADIX=16", 147 "MDCOUNT=8", /* lines of md output */ 148 KDB_PLATFORM_ENV, 149 "DTABCOUNT=30", 150 "NOSECT=1", 151 (char *)0, 152 (char *)0, 153 (char *)0, 154 (char *)0, 155 (char *)0, 156 (char *)0, 157 (char *)0, 158 (char *)0, 159 (char *)0, 160 (char *)0, 161 (char *)0, 162 (char *)0, 163 (char *)0, 164 (char *)0, 165 (char *)0, 166 (char *)0, 167 (char *)0, 168 (char *)0, 169 (char *)0, 170 (char *)0, 171 (char *)0, 172 (char *)0, 173 (char *)0, 174 (char *)0, 175 }; 176 177 static const int __nenv = (sizeof(__env) / sizeof(char *)); 178 179 struct task_struct *kdb_curr_task(int cpu) 180 { 181 struct task_struct *p = curr_task(cpu); 182 #ifdef _TIF_MCA_INIT 183 if ((task_thread_info(p)->flags & _TIF_MCA_INIT) && KDB_TSK(cpu)) 184 p = krp->p; 185 #endif 186 return p; 187 } 188 189 /* 190 * kdbgetenv - This function will return the character string value of 191 * an environment variable. 192 * Parameters: 193 * match A character string representing an environment variable. 194 * Returns: 195 * NULL No environment variable matches 'match' 196 * char* Pointer to string value of environment variable. 197 */ 198 char *kdbgetenv(const char *match) 199 { 200 char **ep = __env; 201 int matchlen = strlen(match); 202 int i; 203 204 for (i = 0; i < __nenv; i++) { 205 char *e = *ep++; 206 207 if (!e) 208 continue; 209 210 if ((strncmp(match, e, matchlen) == 0) 211 && ((e[matchlen] == '\0') 212 || (e[matchlen] == '='))) { 213 char *cp = strchr(e, '='); 214 return cp ? ++cp : ""; 215 } 216 } 217 return NULL; 218 } 219 220 /* 221 * kdballocenv - This function is used to allocate bytes for 222 * environment entries. 223 * Parameters: 224 * match A character string representing a numeric value 225 * Outputs: 226 * *value the unsigned long representation of the env variable 'match' 227 * Returns: 228 * Zero on success, a kdb diagnostic on failure. 229 * Remarks: 230 * We use a static environment buffer (envbuffer) to hold the values 231 * of dynamically generated environment variables (see kdb_set). Buffer 232 * space once allocated is never free'd, so over time, the amount of space 233 * (currently 512 bytes) will be exhausted if env variables are changed 234 * frequently. 235 */ 236 static char *kdballocenv(size_t bytes) 237 { 238 #define KDB_ENVBUFSIZE 512 239 static char envbuffer[KDB_ENVBUFSIZE]; 240 static int envbufsize; 241 char *ep = NULL; 242 243 if ((KDB_ENVBUFSIZE - envbufsize) >= bytes) { 244 ep = &envbuffer[envbufsize]; 245 envbufsize += bytes; 246 } 247 return ep; 248 } 249 250 /* 251 * kdbgetulenv - This function will return the value of an unsigned 252 * long-valued environment variable. 253 * Parameters: 254 * match A character string representing a numeric value 255 * Outputs: 256 * *value the unsigned long represntation of the env variable 'match' 257 * Returns: 258 * Zero on success, a kdb diagnostic on failure. 259 */ 260 static int kdbgetulenv(const char *match, unsigned long *value) 261 { 262 char *ep; 263 264 ep = kdbgetenv(match); 265 if (!ep) 266 return KDB_NOTENV; 267 if (strlen(ep) == 0) 268 return KDB_NOENVVALUE; 269 270 *value = simple_strtoul(ep, NULL, 0); 271 272 return 0; 273 } 274 275 /* 276 * kdbgetintenv - This function will return the value of an 277 * integer-valued environment variable. 278 * Parameters: 279 * match A character string representing an integer-valued env variable 280 * Outputs: 281 * *value the integer representation of the environment variable 'match' 282 * Returns: 283 * Zero on success, a kdb diagnostic on failure. 284 */ 285 int kdbgetintenv(const char *match, int *value) 286 { 287 unsigned long val; 288 int diag; 289 290 diag = kdbgetulenv(match, &val); 291 if (!diag) 292 *value = (int) val; 293 return diag; 294 } 295 296 /* 297 * kdbgetularg - This function will convert a numeric string into an 298 * unsigned long value. 299 * Parameters: 300 * arg A character string representing a numeric value 301 * Outputs: 302 * *value the unsigned long represntation of arg. 303 * Returns: 304 * Zero on success, a kdb diagnostic on failure. 305 */ 306 int kdbgetularg(const char *arg, unsigned long *value) 307 { 308 char *endp; 309 unsigned long val; 310 311 val = simple_strtoul(arg, &endp, 0); 312 313 if (endp == arg) { 314 /* 315 * Also try base 16, for us folks too lazy to type the 316 * leading 0x... 317 */ 318 val = simple_strtoul(arg, &endp, 16); 319 if (endp == arg) 320 return KDB_BADINT; 321 } 322 323 *value = val; 324 325 return 0; 326 } 327 328 int kdbgetu64arg(const char *arg, u64 *value) 329 { 330 char *endp; 331 u64 val; 332 333 val = simple_strtoull(arg, &endp, 0); 334 335 if (endp == arg) { 336 337 val = simple_strtoull(arg, &endp, 16); 338 if (endp == arg) 339 return KDB_BADINT; 340 } 341 342 *value = val; 343 344 return 0; 345 } 346 347 /* 348 * kdb_set - This function implements the 'set' command. Alter an 349 * existing environment variable or create a new one. 350 */ 351 int kdb_set(int argc, const char **argv) 352 { 353 int i; 354 char *ep; 355 size_t varlen, vallen; 356 357 /* 358 * we can be invoked two ways: 359 * set var=value argv[1]="var", argv[2]="value" 360 * set var = value argv[1]="var", argv[2]="=", argv[3]="value" 361 * - if the latter, shift 'em down. 362 */ 363 if (argc == 3) { 364 argv[2] = argv[3]; 365 argc--; 366 } 367 368 if (argc != 2) 369 return KDB_ARGCOUNT; 370 371 /* 372 * Check for internal variables 373 */ 374 if (strcmp(argv[1], "KDBDEBUG") == 0) { 375 unsigned int debugflags; 376 char *cp; 377 378 debugflags = simple_strtoul(argv[2], &cp, 0); 379 if (cp == argv[2] || debugflags & ~KDB_DEBUG_FLAG_MASK) { 380 kdb_printf("kdb: illegal debug flags '%s'\n", 381 argv[2]); 382 return 0; 383 } 384 kdb_flags = (kdb_flags & 385 ~(KDB_DEBUG_FLAG_MASK << KDB_DEBUG_FLAG_SHIFT)) 386 | (debugflags << KDB_DEBUG_FLAG_SHIFT); 387 388 return 0; 389 } 390 391 /* 392 * Tokenizer squashed the '=' sign. argv[1] is variable 393 * name, argv[2] = value. 394 */ 395 varlen = strlen(argv[1]); 396 vallen = strlen(argv[2]); 397 ep = kdballocenv(varlen + vallen + 2); 398 if (ep == (char *)0) 399 return KDB_ENVBUFFULL; 400 401 sprintf(ep, "%s=%s", argv[1], argv[2]); 402 403 ep[varlen+vallen+1] = '\0'; 404 405 for (i = 0; i < __nenv; i++) { 406 if (__env[i] 407 && ((strncmp(__env[i], argv[1], varlen) == 0) 408 && ((__env[i][varlen] == '\0') 409 || (__env[i][varlen] == '=')))) { 410 __env[i] = ep; 411 return 0; 412 } 413 } 414 415 /* 416 * Wasn't existing variable. Fit into slot. 417 */ 418 for (i = 0; i < __nenv-1; i++) { 419 if (__env[i] == (char *)0) { 420 __env[i] = ep; 421 return 0; 422 } 423 } 424 425 return KDB_ENVFULL; 426 } 427 428 static int kdb_check_regs(void) 429 { 430 if (!kdb_current_regs) { 431 kdb_printf("No current kdb registers." 432 " You may need to select another task\n"); 433 return KDB_BADREG; 434 } 435 return 0; 436 } 437 438 /* 439 * kdbgetaddrarg - This function is responsible for parsing an 440 * address-expression and returning the value of the expression, 441 * symbol name, and offset to the caller. 442 * 443 * The argument may consist of a numeric value (decimal or 444 * hexidecimal), a symbol name, a register name (preceded by the 445 * percent sign), an environment variable with a numeric value 446 * (preceded by a dollar sign) or a simple arithmetic expression 447 * consisting of a symbol name, +/-, and a numeric constant value 448 * (offset). 449 * Parameters: 450 * argc - count of arguments in argv 451 * argv - argument vector 452 * *nextarg - index to next unparsed argument in argv[] 453 * regs - Register state at time of KDB entry 454 * Outputs: 455 * *value - receives the value of the address-expression 456 * *offset - receives the offset specified, if any 457 * *name - receives the symbol name, if any 458 * *nextarg - index to next unparsed argument in argv[] 459 * Returns: 460 * zero is returned on success, a kdb diagnostic code is 461 * returned on error. 462 */ 463 int kdbgetaddrarg(int argc, const char **argv, int *nextarg, 464 unsigned long *value, long *offset, 465 char **name) 466 { 467 unsigned long addr; 468 unsigned long off = 0; 469 int positive; 470 int diag; 471 int found = 0; 472 char *symname; 473 char symbol = '\0'; 474 char *cp; 475 kdb_symtab_t symtab; 476 477 /* 478 * Process arguments which follow the following syntax: 479 * 480 * symbol | numeric-address [+/- numeric-offset] 481 * %register 482 * $environment-variable 483 */ 484 485 if (*nextarg > argc) 486 return KDB_ARGCOUNT; 487 488 symname = (char *)argv[*nextarg]; 489 490 /* 491 * If there is no whitespace between the symbol 492 * or address and the '+' or '-' symbols, we 493 * remember the character and replace it with a 494 * null so the symbol/value can be properly parsed 495 */ 496 cp = strpbrk(symname, "+-"); 497 if (cp != NULL) { 498 symbol = *cp; 499 *cp++ = '\0'; 500 } 501 502 if (symname[0] == '$') { 503 diag = kdbgetulenv(&symname[1], &addr); 504 if (diag) 505 return diag; 506 } else if (symname[0] == '%') { 507 diag = kdb_check_regs(); 508 if (diag) 509 return diag; 510 /* Implement register values with % at a later time as it is 511 * arch optional. 512 */ 513 return KDB_NOTIMP; 514 } else { 515 found = kdbgetsymval(symname, &symtab); 516 if (found) { 517 addr = symtab.sym_start; 518 } else { 519 diag = kdbgetularg(argv[*nextarg], &addr); 520 if (diag) 521 return diag; 522 } 523 } 524 525 if (!found) 526 found = kdbnearsym(addr, &symtab); 527 528 (*nextarg)++; 529 530 if (name) 531 *name = symname; 532 if (value) 533 *value = addr; 534 if (offset && name && *name) 535 *offset = addr - symtab.sym_start; 536 537 if ((*nextarg > argc) 538 && (symbol == '\0')) 539 return 0; 540 541 /* 542 * check for +/- and offset 543 */ 544 545 if (symbol == '\0') { 546 if ((argv[*nextarg][0] != '+') 547 && (argv[*nextarg][0] != '-')) { 548 /* 549 * Not our argument. Return. 550 */ 551 return 0; 552 } else { 553 positive = (argv[*nextarg][0] == '+'); 554 (*nextarg)++; 555 } 556 } else 557 positive = (symbol == '+'); 558 559 /* 560 * Now there must be an offset! 561 */ 562 if ((*nextarg > argc) 563 && (symbol == '\0')) { 564 return KDB_INVADDRFMT; 565 } 566 567 if (!symbol) { 568 cp = (char *)argv[*nextarg]; 569 (*nextarg)++; 570 } 571 572 diag = kdbgetularg(cp, &off); 573 if (diag) 574 return diag; 575 576 if (!positive) 577 off = -off; 578 579 if (offset) 580 *offset += off; 581 582 if (value) 583 *value += off; 584 585 return 0; 586 } 587 588 static void kdb_cmderror(int diag) 589 { 590 int i; 591 592 if (diag >= 0) { 593 kdb_printf("no error detected (diagnostic is %d)\n", diag); 594 return; 595 } 596 597 for (i = 0; i < __nkdb_err; i++) { 598 if (kdbmsgs[i].km_diag == diag) { 599 kdb_printf("diag: %d: %s\n", diag, kdbmsgs[i].km_msg); 600 return; 601 } 602 } 603 604 kdb_printf("Unknown diag %d\n", -diag); 605 } 606 607 /* 608 * kdb_defcmd, kdb_defcmd2 - This function implements the 'defcmd' 609 * command which defines one command as a set of other commands, 610 * terminated by endefcmd. kdb_defcmd processes the initial 611 * 'defcmd' command, kdb_defcmd2 is invoked from kdb_parse for 612 * the following commands until 'endefcmd'. 613 * Inputs: 614 * argc argument count 615 * argv argument vector 616 * Returns: 617 * zero for success, a kdb diagnostic if error 618 */ 619 struct defcmd_set { 620 int count; 621 int usable; 622 char *name; 623 char *usage; 624 char *help; 625 char **command; 626 }; 627 static struct defcmd_set *defcmd_set; 628 static int defcmd_set_count; 629 static int defcmd_in_progress; 630 631 /* Forward references */ 632 static int kdb_exec_defcmd(int argc, const char **argv); 633 634 static int kdb_defcmd2(const char *cmdstr, const char *argv0) 635 { 636 struct defcmd_set *s = defcmd_set + defcmd_set_count - 1; 637 char **save_command = s->command; 638 if (strcmp(argv0, "endefcmd") == 0) { 639 defcmd_in_progress = 0; 640 if (!s->count) 641 s->usable = 0; 642 if (s->usable) 643 kdb_register(s->name, kdb_exec_defcmd, 644 s->usage, s->help, 0); 645 return 0; 646 } 647 if (!s->usable) 648 return KDB_NOTIMP; 649 s->command = kzalloc((s->count + 1) * sizeof(*(s->command)), GFP_KDB); 650 if (!s->command) { 651 kdb_printf("Could not allocate new kdb_defcmd table for %s\n", 652 cmdstr); 653 s->usable = 0; 654 return KDB_NOTIMP; 655 } 656 memcpy(s->command, save_command, s->count * sizeof(*(s->command))); 657 s->command[s->count++] = kdb_strdup(cmdstr, GFP_KDB); 658 kfree(save_command); 659 return 0; 660 } 661 662 static int kdb_defcmd(int argc, const char **argv) 663 { 664 struct defcmd_set *save_defcmd_set = defcmd_set, *s; 665 if (defcmd_in_progress) { 666 kdb_printf("kdb: nested defcmd detected, assuming missing " 667 "endefcmd\n"); 668 kdb_defcmd2("endefcmd", "endefcmd"); 669 } 670 if (argc == 0) { 671 int i; 672 for (s = defcmd_set; s < defcmd_set + defcmd_set_count; ++s) { 673 kdb_printf("defcmd %s \"%s\" \"%s\"\n", s->name, 674 s->usage, s->help); 675 for (i = 0; i < s->count; ++i) 676 kdb_printf("%s", s->command[i]); 677 kdb_printf("endefcmd\n"); 678 } 679 return 0; 680 } 681 if (argc != 3) 682 return KDB_ARGCOUNT; 683 defcmd_set = kmalloc((defcmd_set_count + 1) * sizeof(*defcmd_set), 684 GFP_KDB); 685 if (!defcmd_set) { 686 kdb_printf("Could not allocate new defcmd_set entry for %s\n", 687 argv[1]); 688 defcmd_set = save_defcmd_set; 689 return KDB_NOTIMP; 690 } 691 memcpy(defcmd_set, save_defcmd_set, 692 defcmd_set_count * sizeof(*defcmd_set)); 693 kfree(save_defcmd_set); 694 s = defcmd_set + defcmd_set_count; 695 memset(s, 0, sizeof(*s)); 696 s->usable = 1; 697 s->name = kdb_strdup(argv[1], GFP_KDB); 698 s->usage = kdb_strdup(argv[2], GFP_KDB); 699 s->help = kdb_strdup(argv[3], GFP_KDB); 700 if (s->usage[0] == '"') { 701 strcpy(s->usage, s->usage+1); 702 s->usage[strlen(s->usage)-1] = '\0'; 703 } 704 if (s->help[0] == '"') { 705 strcpy(s->help, s->help+1); 706 s->help[strlen(s->help)-1] = '\0'; 707 } 708 ++defcmd_set_count; 709 defcmd_in_progress = 1; 710 return 0; 711 } 712 713 /* 714 * kdb_exec_defcmd - Execute the set of commands associated with this 715 * defcmd name. 716 * Inputs: 717 * argc argument count 718 * argv argument vector 719 * Returns: 720 * zero for success, a kdb diagnostic if error 721 */ 722 static int kdb_exec_defcmd(int argc, const char **argv) 723 { 724 int i, ret; 725 struct defcmd_set *s; 726 if (argc != 0) 727 return KDB_ARGCOUNT; 728 for (s = defcmd_set, i = 0; i < defcmd_set_count; ++i, ++s) { 729 if (strcmp(s->name, argv[0]) == 0) 730 break; 731 } 732 if (i == defcmd_set_count) { 733 kdb_printf("kdb_exec_defcmd: could not find commands for %s\n", 734 argv[0]); 735 return KDB_NOTIMP; 736 } 737 for (i = 0; i < s->count; ++i) { 738 /* Recursive use of kdb_parse, do not use argv after 739 * this point */ 740 argv = NULL; 741 kdb_printf("[%s]kdb> %s\n", s->name, s->command[i]); 742 ret = kdb_parse(s->command[i]); 743 if (ret) 744 return ret; 745 } 746 return 0; 747 } 748 749 /* Command history */ 750 #define KDB_CMD_HISTORY_COUNT 32 751 #define CMD_BUFLEN 200 /* kdb_printf: max printline 752 * size == 256 */ 753 static unsigned int cmd_head, cmd_tail; 754 static unsigned int cmdptr; 755 static char cmd_hist[KDB_CMD_HISTORY_COUNT][CMD_BUFLEN]; 756 static char cmd_cur[CMD_BUFLEN]; 757 758 /* 759 * The "str" argument may point to something like | grep xyz 760 */ 761 static void parse_grep(const char *str) 762 { 763 int len; 764 char *cp = (char *)str, *cp2; 765 766 /* sanity check: we should have been called with the \ first */ 767 if (*cp != '|') 768 return; 769 cp++; 770 while (isspace(*cp)) 771 cp++; 772 if (strncmp(cp, "grep ", 5)) { 773 kdb_printf("invalid 'pipe', see grephelp\n"); 774 return; 775 } 776 cp += 5; 777 while (isspace(*cp)) 778 cp++; 779 cp2 = strchr(cp, '\n'); 780 if (cp2) 781 *cp2 = '\0'; /* remove the trailing newline */ 782 len = strlen(cp); 783 if (len == 0) { 784 kdb_printf("invalid 'pipe', see grephelp\n"); 785 return; 786 } 787 /* now cp points to a nonzero length search string */ 788 if (*cp == '"') { 789 /* allow it be "x y z" by removing the "'s - there must 790 be two of them */ 791 cp++; 792 cp2 = strchr(cp, '"'); 793 if (!cp2) { 794 kdb_printf("invalid quoted string, see grephelp\n"); 795 return; 796 } 797 *cp2 = '\0'; /* end the string where the 2nd " was */ 798 } 799 kdb_grep_leading = 0; 800 if (*cp == '^') { 801 kdb_grep_leading = 1; 802 cp++; 803 } 804 len = strlen(cp); 805 kdb_grep_trailing = 0; 806 if (*(cp+len-1) == '$') { 807 kdb_grep_trailing = 1; 808 *(cp+len-1) = '\0'; 809 } 810 len = strlen(cp); 811 if (!len) 812 return; 813 if (len >= GREP_LEN) { 814 kdb_printf("search string too long\n"); 815 return; 816 } 817 strcpy(kdb_grep_string, cp); 818 kdb_grepping_flag++; 819 return; 820 } 821 822 /* 823 * kdb_parse - Parse the command line, search the command table for a 824 * matching command and invoke the command function. This 825 * function may be called recursively, if it is, the second call 826 * will overwrite argv and cbuf. It is the caller's 827 * responsibility to save their argv if they recursively call 828 * kdb_parse(). 829 * Parameters: 830 * cmdstr The input command line to be parsed. 831 * regs The registers at the time kdb was entered. 832 * Returns: 833 * Zero for success, a kdb diagnostic if failure. 834 * Remarks: 835 * Limited to 20 tokens. 836 * 837 * Real rudimentary tokenization. Basically only whitespace 838 * is considered a token delimeter (but special consideration 839 * is taken of the '=' sign as used by the 'set' command). 840 * 841 * The algorithm used to tokenize the input string relies on 842 * there being at least one whitespace (or otherwise useless) 843 * character between tokens as the character immediately following 844 * the token is altered in-place to a null-byte to terminate the 845 * token string. 846 */ 847 848 #define MAXARGC 20 849 850 int kdb_parse(const char *cmdstr) 851 { 852 static char *argv[MAXARGC]; 853 static int argc; 854 static char cbuf[CMD_BUFLEN+2]; 855 char *cp; 856 char *cpp, quoted; 857 kdbtab_t *tp; 858 int i, escaped, ignore_errors = 0, check_grep; 859 860 /* 861 * First tokenize the command string. 862 */ 863 cp = (char *)cmdstr; 864 kdb_grepping_flag = check_grep = 0; 865 866 if (KDB_FLAG(CMD_INTERRUPT)) { 867 /* Previous command was interrupted, newline must not 868 * repeat the command */ 869 KDB_FLAG_CLEAR(CMD_INTERRUPT); 870 KDB_STATE_SET(PAGER); 871 argc = 0; /* no repeat */ 872 } 873 874 if (*cp != '\n' && *cp != '\0') { 875 argc = 0; 876 cpp = cbuf; 877 while (*cp) { 878 /* skip whitespace */ 879 while (isspace(*cp)) 880 cp++; 881 if ((*cp == '\0') || (*cp == '\n') || 882 (*cp == '#' && !defcmd_in_progress)) 883 break; 884 /* special case: check for | grep pattern */ 885 if (*cp == '|') { 886 check_grep++; 887 break; 888 } 889 if (cpp >= cbuf + CMD_BUFLEN) { 890 kdb_printf("kdb_parse: command buffer " 891 "overflow, command ignored\n%s\n", 892 cmdstr); 893 return KDB_NOTFOUND; 894 } 895 if (argc >= MAXARGC - 1) { 896 kdb_printf("kdb_parse: too many arguments, " 897 "command ignored\n%s\n", cmdstr); 898 return KDB_NOTFOUND; 899 } 900 argv[argc++] = cpp; 901 escaped = 0; 902 quoted = '\0'; 903 /* Copy to next unquoted and unescaped 904 * whitespace or '=' */ 905 while (*cp && *cp != '\n' && 906 (escaped || quoted || !isspace(*cp))) { 907 if (cpp >= cbuf + CMD_BUFLEN) 908 break; 909 if (escaped) { 910 escaped = 0; 911 *cpp++ = *cp++; 912 continue; 913 } 914 if (*cp == '\\') { 915 escaped = 1; 916 ++cp; 917 continue; 918 } 919 if (*cp == quoted) 920 quoted = '\0'; 921 else if (*cp == '\'' || *cp == '"') 922 quoted = *cp; 923 *cpp = *cp++; 924 if (*cpp == '=' && !quoted) 925 break; 926 ++cpp; 927 } 928 *cpp++ = '\0'; /* Squash a ws or '=' character */ 929 } 930 } 931 if (!argc) 932 return 0; 933 if (check_grep) 934 parse_grep(cp); 935 if (defcmd_in_progress) { 936 int result = kdb_defcmd2(cmdstr, argv[0]); 937 if (!defcmd_in_progress) { 938 argc = 0; /* avoid repeat on endefcmd */ 939 *(argv[0]) = '\0'; 940 } 941 return result; 942 } 943 if (argv[0][0] == '-' && argv[0][1] && 944 (argv[0][1] < '0' || argv[0][1] > '9')) { 945 ignore_errors = 1; 946 ++argv[0]; 947 } 948 949 for_each_kdbcmd(tp, i) { 950 if (tp->cmd_name) { 951 /* 952 * If this command is allowed to be abbreviated, 953 * check to see if this is it. 954 */ 955 956 if (tp->cmd_minlen 957 && (strlen(argv[0]) <= tp->cmd_minlen)) { 958 if (strncmp(argv[0], 959 tp->cmd_name, 960 tp->cmd_minlen) == 0) { 961 break; 962 } 963 } 964 965 if (strcmp(argv[0], tp->cmd_name) == 0) 966 break; 967 } 968 } 969 970 /* 971 * If we don't find a command by this name, see if the first 972 * few characters of this match any of the known commands. 973 * e.g., md1c20 should match md. 974 */ 975 if (i == kdb_max_commands) { 976 for_each_kdbcmd(tp, i) { 977 if (tp->cmd_name) { 978 if (strncmp(argv[0], 979 tp->cmd_name, 980 strlen(tp->cmd_name)) == 0) { 981 break; 982 } 983 } 984 } 985 } 986 987 if (i < kdb_max_commands) { 988 int result; 989 KDB_STATE_SET(CMD); 990 result = (*tp->cmd_func)(argc-1, (const char **)argv); 991 if (result && ignore_errors && result > KDB_CMD_GO) 992 result = 0; 993 KDB_STATE_CLEAR(CMD); 994 switch (tp->cmd_repeat) { 995 case KDB_REPEAT_NONE: 996 argc = 0; 997 if (argv[0]) 998 *(argv[0]) = '\0'; 999 break; 1000 case KDB_REPEAT_NO_ARGS: 1001 argc = 1; 1002 if (argv[1]) 1003 *(argv[1]) = '\0'; 1004 break; 1005 case KDB_REPEAT_WITH_ARGS: 1006 break; 1007 } 1008 return result; 1009 } 1010 1011 /* 1012 * If the input with which we were presented does not 1013 * map to an existing command, attempt to parse it as an 1014 * address argument and display the result. Useful for 1015 * obtaining the address of a variable, or the nearest symbol 1016 * to an address contained in a register. 1017 */ 1018 { 1019 unsigned long value; 1020 char *name = NULL; 1021 long offset; 1022 int nextarg = 0; 1023 1024 if (kdbgetaddrarg(0, (const char **)argv, &nextarg, 1025 &value, &offset, &name)) { 1026 return KDB_NOTFOUND; 1027 } 1028 1029 kdb_printf("%s = ", argv[0]); 1030 kdb_symbol_print(value, NULL, KDB_SP_DEFAULT); 1031 kdb_printf("\n"); 1032 return 0; 1033 } 1034 } 1035 1036 1037 static int handle_ctrl_cmd(char *cmd) 1038 { 1039 #define CTRL_P 16 1040 #define CTRL_N 14 1041 1042 /* initial situation */ 1043 if (cmd_head == cmd_tail) 1044 return 0; 1045 switch (*cmd) { 1046 case CTRL_P: 1047 if (cmdptr != cmd_tail) 1048 cmdptr = (cmdptr-1) % KDB_CMD_HISTORY_COUNT; 1049 strncpy(cmd_cur, cmd_hist[cmdptr], CMD_BUFLEN); 1050 return 1; 1051 case CTRL_N: 1052 if (cmdptr != cmd_head) 1053 cmdptr = (cmdptr+1) % KDB_CMD_HISTORY_COUNT; 1054 strncpy(cmd_cur, cmd_hist[cmdptr], CMD_BUFLEN); 1055 return 1; 1056 } 1057 return 0; 1058 } 1059 1060 /* 1061 * kdb_reboot - This function implements the 'reboot' command. Reboot 1062 * the system immediately, or loop for ever on failure. 1063 */ 1064 static int kdb_reboot(int argc, const char **argv) 1065 { 1066 emergency_restart(); 1067 kdb_printf("Hmm, kdb_reboot did not reboot, spinning here\n"); 1068 while (1) 1069 cpu_relax(); 1070 /* NOTREACHED */ 1071 return 0; 1072 } 1073 1074 static void kdb_dumpregs(struct pt_regs *regs) 1075 { 1076 int old_lvl = console_loglevel; 1077 console_loglevel = 15; 1078 kdb_trap_printk++; 1079 show_regs(regs); 1080 kdb_trap_printk--; 1081 kdb_printf("\n"); 1082 console_loglevel = old_lvl; 1083 } 1084 1085 void kdb_set_current_task(struct task_struct *p) 1086 { 1087 kdb_current_task = p; 1088 1089 if (kdb_task_has_cpu(p)) { 1090 kdb_current_regs = KDB_TSKREGS(kdb_process_cpu(p)); 1091 return; 1092 } 1093 kdb_current_regs = NULL; 1094 } 1095 1096 /* 1097 * kdb_local - The main code for kdb. This routine is invoked on a 1098 * specific processor, it is not global. The main kdb() routine 1099 * ensures that only one processor at a time is in this routine. 1100 * This code is called with the real reason code on the first 1101 * entry to a kdb session, thereafter it is called with reason 1102 * SWITCH, even if the user goes back to the original cpu. 1103 * Inputs: 1104 * reason The reason KDB was invoked 1105 * error The hardware-defined error code 1106 * regs The exception frame at time of fault/breakpoint. 1107 * db_result Result code from the break or debug point. 1108 * Returns: 1109 * 0 KDB was invoked for an event which it wasn't responsible 1110 * 1 KDB handled the event for which it was invoked. 1111 * KDB_CMD_GO User typed 'go'. 1112 * KDB_CMD_CPU User switched to another cpu. 1113 * KDB_CMD_SS Single step. 1114 * KDB_CMD_SSB Single step until branch. 1115 */ 1116 static int kdb_local(kdb_reason_t reason, int error, struct pt_regs *regs, 1117 kdb_dbtrap_t db_result) 1118 { 1119 char *cmdbuf; 1120 int diag; 1121 struct task_struct *kdb_current = 1122 kdb_curr_task(raw_smp_processor_id()); 1123 1124 KDB_DEBUG_STATE("kdb_local 1", reason); 1125 kdb_go_count = 0; 1126 if (reason == KDB_REASON_DEBUG) { 1127 /* special case below */ 1128 } else { 1129 kdb_printf("\nEntering kdb (current=0x%p, pid %d) ", 1130 kdb_current, kdb_current ? kdb_current->pid : 0); 1131 #if defined(CONFIG_SMP) 1132 kdb_printf("on processor %d ", raw_smp_processor_id()); 1133 #endif 1134 } 1135 1136 switch (reason) { 1137 case KDB_REASON_DEBUG: 1138 { 1139 /* 1140 * If re-entering kdb after a single step 1141 * command, don't print the message. 1142 */ 1143 switch (db_result) { 1144 case KDB_DB_BPT: 1145 kdb_printf("\nEntering kdb (0x%p, pid %d) ", 1146 kdb_current, kdb_current->pid); 1147 #if defined(CONFIG_SMP) 1148 kdb_printf("on processor %d ", raw_smp_processor_id()); 1149 #endif 1150 kdb_printf("due to Debug @ " kdb_machreg_fmt "\n", 1151 instruction_pointer(regs)); 1152 break; 1153 case KDB_DB_SSB: 1154 /* 1155 * In the midst of ssb command. Just return. 1156 */ 1157 KDB_DEBUG_STATE("kdb_local 3", reason); 1158 return KDB_CMD_SSB; /* Continue with SSB command */ 1159 1160 break; 1161 case KDB_DB_SS: 1162 break; 1163 case KDB_DB_SSBPT: 1164 KDB_DEBUG_STATE("kdb_local 4", reason); 1165 return 1; /* kdba_db_trap did the work */ 1166 default: 1167 kdb_printf("kdb: Bad result from kdba_db_trap: %d\n", 1168 db_result); 1169 break; 1170 } 1171 1172 } 1173 break; 1174 case KDB_REASON_ENTER: 1175 if (KDB_STATE(KEYBOARD)) 1176 kdb_printf("due to Keyboard Entry\n"); 1177 else 1178 kdb_printf("due to KDB_ENTER()\n"); 1179 break; 1180 case KDB_REASON_KEYBOARD: 1181 KDB_STATE_SET(KEYBOARD); 1182 kdb_printf("due to Keyboard Entry\n"); 1183 break; 1184 case KDB_REASON_ENTER_SLAVE: 1185 /* drop through, slaves only get released via cpu switch */ 1186 case KDB_REASON_SWITCH: 1187 kdb_printf("due to cpu switch\n"); 1188 break; 1189 case KDB_REASON_OOPS: 1190 kdb_printf("Oops: %s\n", kdb_diemsg); 1191 kdb_printf("due to oops @ " kdb_machreg_fmt "\n", 1192 instruction_pointer(regs)); 1193 kdb_dumpregs(regs); 1194 break; 1195 case KDB_REASON_NMI: 1196 kdb_printf("due to NonMaskable Interrupt @ " 1197 kdb_machreg_fmt "\n", 1198 instruction_pointer(regs)); 1199 kdb_dumpregs(regs); 1200 break; 1201 case KDB_REASON_SSTEP: 1202 case KDB_REASON_BREAK: 1203 kdb_printf("due to %s @ " kdb_machreg_fmt "\n", 1204 reason == KDB_REASON_BREAK ? 1205 "Breakpoint" : "SS trap", instruction_pointer(regs)); 1206 /* 1207 * Determine if this breakpoint is one that we 1208 * are interested in. 1209 */ 1210 if (db_result != KDB_DB_BPT) { 1211 kdb_printf("kdb: error return from kdba_bp_trap: %d\n", 1212 db_result); 1213 KDB_DEBUG_STATE("kdb_local 6", reason); 1214 return 0; /* Not for us, dismiss it */ 1215 } 1216 break; 1217 case KDB_REASON_RECURSE: 1218 kdb_printf("due to Recursion @ " kdb_machreg_fmt "\n", 1219 instruction_pointer(regs)); 1220 break; 1221 default: 1222 kdb_printf("kdb: unexpected reason code: %d\n", reason); 1223 KDB_DEBUG_STATE("kdb_local 8", reason); 1224 return 0; /* Not for us, dismiss it */ 1225 } 1226 1227 while (1) { 1228 /* 1229 * Initialize pager context. 1230 */ 1231 kdb_nextline = 1; 1232 KDB_STATE_CLEAR(SUPPRESS); 1233 1234 cmdbuf = cmd_cur; 1235 *cmdbuf = '\0'; 1236 *(cmd_hist[cmd_head]) = '\0'; 1237 1238 if (KDB_FLAG(ONLY_DO_DUMP)) { 1239 /* kdb is off but a catastrophic error requires a dump. 1240 * Take the dump and reboot. 1241 * Turn on logging so the kdb output appears in the log 1242 * buffer in the dump. 1243 */ 1244 const char *setargs[] = { "set", "LOGGING", "1" }; 1245 kdb_set(2, setargs); 1246 kdb_reboot(0, NULL); 1247 /*NOTREACHED*/ 1248 } 1249 1250 do_full_getstr: 1251 #if defined(CONFIG_SMP) 1252 snprintf(kdb_prompt_str, CMD_BUFLEN, kdbgetenv("PROMPT"), 1253 raw_smp_processor_id()); 1254 #else 1255 snprintf(kdb_prompt_str, CMD_BUFLEN, kdbgetenv("PROMPT")); 1256 #endif 1257 if (defcmd_in_progress) 1258 strncat(kdb_prompt_str, "[defcmd]", CMD_BUFLEN); 1259 1260 /* 1261 * Fetch command from keyboard 1262 */ 1263 cmdbuf = kdb_getstr(cmdbuf, CMD_BUFLEN, kdb_prompt_str); 1264 if (*cmdbuf != '\n') { 1265 if (*cmdbuf < 32) { 1266 if (cmdptr == cmd_head) { 1267 strncpy(cmd_hist[cmd_head], cmd_cur, 1268 CMD_BUFLEN); 1269 *(cmd_hist[cmd_head] + 1270 strlen(cmd_hist[cmd_head])-1) = '\0'; 1271 } 1272 if (!handle_ctrl_cmd(cmdbuf)) 1273 *(cmd_cur+strlen(cmd_cur)-1) = '\0'; 1274 cmdbuf = cmd_cur; 1275 goto do_full_getstr; 1276 } else { 1277 strncpy(cmd_hist[cmd_head], cmd_cur, 1278 CMD_BUFLEN); 1279 } 1280 1281 cmd_head = (cmd_head+1) % KDB_CMD_HISTORY_COUNT; 1282 if (cmd_head == cmd_tail) 1283 cmd_tail = (cmd_tail+1) % KDB_CMD_HISTORY_COUNT; 1284 } 1285 1286 cmdptr = cmd_head; 1287 diag = kdb_parse(cmdbuf); 1288 if (diag == KDB_NOTFOUND) { 1289 kdb_printf("Unknown kdb command: '%s'\n", cmdbuf); 1290 diag = 0; 1291 } 1292 if (diag == KDB_CMD_GO 1293 || diag == KDB_CMD_CPU 1294 || diag == KDB_CMD_SS 1295 || diag == KDB_CMD_SSB 1296 || diag == KDB_CMD_KGDB) 1297 break; 1298 1299 if (diag) 1300 kdb_cmderror(diag); 1301 } 1302 KDB_DEBUG_STATE("kdb_local 9", diag); 1303 return diag; 1304 } 1305 1306 1307 /* 1308 * kdb_print_state - Print the state data for the current processor 1309 * for debugging. 1310 * Inputs: 1311 * text Identifies the debug point 1312 * value Any integer value to be printed, e.g. reason code. 1313 */ 1314 void kdb_print_state(const char *text, int value) 1315 { 1316 kdb_printf("state: %s cpu %d value %d initial %d state %x\n", 1317 text, raw_smp_processor_id(), value, kdb_initial_cpu, 1318 kdb_state); 1319 } 1320 1321 /* 1322 * kdb_main_loop - After initial setup and assignment of the 1323 * controlling cpu, all cpus are in this loop. One cpu is in 1324 * control and will issue the kdb prompt, the others will spin 1325 * until 'go' or cpu switch. 1326 * 1327 * To get a consistent view of the kernel stacks for all 1328 * processes, this routine is invoked from the main kdb code via 1329 * an architecture specific routine. kdba_main_loop is 1330 * responsible for making the kernel stacks consistent for all 1331 * processes, there should be no difference between a blocked 1332 * process and a running process as far as kdb is concerned. 1333 * Inputs: 1334 * reason The reason KDB was invoked 1335 * error The hardware-defined error code 1336 * reason2 kdb's current reason code. 1337 * Initially error but can change 1338 * according to kdb state. 1339 * db_result Result code from break or debug point. 1340 * regs The exception frame at time of fault/breakpoint. 1341 * should always be valid. 1342 * Returns: 1343 * 0 KDB was invoked for an event which it wasn't responsible 1344 * 1 KDB handled the event for which it was invoked. 1345 */ 1346 int kdb_main_loop(kdb_reason_t reason, kdb_reason_t reason2, int error, 1347 kdb_dbtrap_t db_result, struct pt_regs *regs) 1348 { 1349 int result = 1; 1350 /* Stay in kdb() until 'go', 'ss[b]' or an error */ 1351 while (1) { 1352 /* 1353 * All processors except the one that is in control 1354 * will spin here. 1355 */ 1356 KDB_DEBUG_STATE("kdb_main_loop 1", reason); 1357 while (KDB_STATE(HOLD_CPU)) { 1358 /* state KDB is turned off by kdb_cpu to see if the 1359 * other cpus are still live, each cpu in this loop 1360 * turns it back on. 1361 */ 1362 if (!KDB_STATE(KDB)) 1363 KDB_STATE_SET(KDB); 1364 } 1365 1366 KDB_STATE_CLEAR(SUPPRESS); 1367 KDB_DEBUG_STATE("kdb_main_loop 2", reason); 1368 if (KDB_STATE(LEAVING)) 1369 break; /* Another cpu said 'go' */ 1370 /* Still using kdb, this processor is in control */ 1371 result = kdb_local(reason2, error, regs, db_result); 1372 KDB_DEBUG_STATE("kdb_main_loop 3", result); 1373 1374 if (result == KDB_CMD_CPU) 1375 break; 1376 1377 if (result == KDB_CMD_SS) { 1378 KDB_STATE_SET(DOING_SS); 1379 break; 1380 } 1381 1382 if (result == KDB_CMD_SSB) { 1383 KDB_STATE_SET(DOING_SS); 1384 KDB_STATE_SET(DOING_SSB); 1385 break; 1386 } 1387 1388 if (result == KDB_CMD_KGDB) { 1389 if (!KDB_STATE(DOING_KGDB)) 1390 kdb_printf("Entering please attach debugger " 1391 "or use $D#44+ or $3#33\n"); 1392 break; 1393 } 1394 if (result && result != 1 && result != KDB_CMD_GO) 1395 kdb_printf("\nUnexpected kdb_local return code %d\n", 1396 result); 1397 KDB_DEBUG_STATE("kdb_main_loop 4", reason); 1398 break; 1399 } 1400 if (KDB_STATE(DOING_SS)) 1401 KDB_STATE_CLEAR(SSBPT); 1402 1403 /* Clean up any keyboard devices before leaving */ 1404 kdb_kbd_cleanup_state(); 1405 1406 return result; 1407 } 1408 1409 /* 1410 * kdb_mdr - This function implements the guts of the 'mdr', memory 1411 * read command. 1412 * mdr <addr arg>,<byte count> 1413 * Inputs: 1414 * addr Start address 1415 * count Number of bytes 1416 * Returns: 1417 * Always 0. Any errors are detected and printed by kdb_getarea. 1418 */ 1419 static int kdb_mdr(unsigned long addr, unsigned int count) 1420 { 1421 unsigned char c; 1422 while (count--) { 1423 if (kdb_getarea(c, addr)) 1424 return 0; 1425 kdb_printf("%02x", c); 1426 addr++; 1427 } 1428 kdb_printf("\n"); 1429 return 0; 1430 } 1431 1432 /* 1433 * kdb_md - This function implements the 'md', 'md1', 'md2', 'md4', 1434 * 'md8' 'mdr' and 'mds' commands. 1435 * 1436 * md|mds [<addr arg> [<line count> [<radix>]]] 1437 * mdWcN [<addr arg> [<line count> [<radix>]]] 1438 * where W = is the width (1, 2, 4 or 8) and N is the count. 1439 * for eg., md1c20 reads 20 bytes, 1 at a time. 1440 * mdr <addr arg>,<byte count> 1441 */ 1442 static void kdb_md_line(const char *fmtstr, unsigned long addr, 1443 int symbolic, int nosect, int bytesperword, 1444 int num, int repeat, int phys) 1445 { 1446 /* print just one line of data */ 1447 kdb_symtab_t symtab; 1448 char cbuf[32]; 1449 char *c = cbuf; 1450 int i; 1451 unsigned long word; 1452 1453 memset(cbuf, '\0', sizeof(cbuf)); 1454 if (phys) 1455 kdb_printf("phys " kdb_machreg_fmt0 " ", addr); 1456 else 1457 kdb_printf(kdb_machreg_fmt0 " ", addr); 1458 1459 for (i = 0; i < num && repeat--; i++) { 1460 if (phys) { 1461 if (kdb_getphysword(&word, addr, bytesperword)) 1462 break; 1463 } else if (kdb_getword(&word, addr, bytesperword)) 1464 break; 1465 kdb_printf(fmtstr, word); 1466 if (symbolic) 1467 kdbnearsym(word, &symtab); 1468 else 1469 memset(&symtab, 0, sizeof(symtab)); 1470 if (symtab.sym_name) { 1471 kdb_symbol_print(word, &symtab, 0); 1472 if (!nosect) { 1473 kdb_printf("\n"); 1474 kdb_printf(" %s %s " 1475 kdb_machreg_fmt " " 1476 kdb_machreg_fmt " " 1477 kdb_machreg_fmt, symtab.mod_name, 1478 symtab.sec_name, symtab.sec_start, 1479 symtab.sym_start, symtab.sym_end); 1480 } 1481 addr += bytesperword; 1482 } else { 1483 union { 1484 u64 word; 1485 unsigned char c[8]; 1486 } wc; 1487 unsigned char *cp; 1488 #ifdef __BIG_ENDIAN 1489 cp = wc.c + 8 - bytesperword; 1490 #else 1491 cp = wc.c; 1492 #endif 1493 wc.word = word; 1494 #define printable_char(c) \ 1495 ({unsigned char __c = c; isascii(__c) && isprint(__c) ? __c : '.'; }) 1496 switch (bytesperword) { 1497 case 8: 1498 *c++ = printable_char(*cp++); 1499 *c++ = printable_char(*cp++); 1500 *c++ = printable_char(*cp++); 1501 *c++ = printable_char(*cp++); 1502 addr += 4; 1503 case 4: 1504 *c++ = printable_char(*cp++); 1505 *c++ = printable_char(*cp++); 1506 addr += 2; 1507 case 2: 1508 *c++ = printable_char(*cp++); 1509 addr++; 1510 case 1: 1511 *c++ = printable_char(*cp++); 1512 addr++; 1513 break; 1514 } 1515 #undef printable_char 1516 } 1517 } 1518 kdb_printf("%*s %s\n", (int)((num-i)*(2*bytesperword + 1)+1), 1519 " ", cbuf); 1520 } 1521 1522 static int kdb_md(int argc, const char **argv) 1523 { 1524 static unsigned long last_addr; 1525 static int last_radix, last_bytesperword, last_repeat; 1526 int radix = 16, mdcount = 8, bytesperword = KDB_WORD_SIZE, repeat; 1527 int nosect = 0; 1528 char fmtchar, fmtstr[64]; 1529 unsigned long addr; 1530 unsigned long word; 1531 long offset = 0; 1532 int symbolic = 0; 1533 int valid = 0; 1534 int phys = 0; 1535 1536 kdbgetintenv("MDCOUNT", &mdcount); 1537 kdbgetintenv("RADIX", &radix); 1538 kdbgetintenv("BYTESPERWORD", &bytesperword); 1539 1540 /* Assume 'md <addr>' and start with environment values */ 1541 repeat = mdcount * 16 / bytesperword; 1542 1543 if (strcmp(argv[0], "mdr") == 0) { 1544 if (argc != 2) 1545 return KDB_ARGCOUNT; 1546 valid = 1; 1547 } else if (isdigit(argv[0][2])) { 1548 bytesperword = (int)(argv[0][2] - '0'); 1549 if (bytesperword == 0) { 1550 bytesperword = last_bytesperword; 1551 if (bytesperword == 0) 1552 bytesperword = 4; 1553 } 1554 last_bytesperword = bytesperword; 1555 repeat = mdcount * 16 / bytesperword; 1556 if (!argv[0][3]) 1557 valid = 1; 1558 else if (argv[0][3] == 'c' && argv[0][4]) { 1559 char *p; 1560 repeat = simple_strtoul(argv[0] + 4, &p, 10); 1561 mdcount = ((repeat * bytesperword) + 15) / 16; 1562 valid = !*p; 1563 } 1564 last_repeat = repeat; 1565 } else if (strcmp(argv[0], "md") == 0) 1566 valid = 1; 1567 else if (strcmp(argv[0], "mds") == 0) 1568 valid = 1; 1569 else if (strcmp(argv[0], "mdp") == 0) { 1570 phys = valid = 1; 1571 } 1572 if (!valid) 1573 return KDB_NOTFOUND; 1574 1575 if (argc == 0) { 1576 if (last_addr == 0) 1577 return KDB_ARGCOUNT; 1578 addr = last_addr; 1579 radix = last_radix; 1580 bytesperword = last_bytesperword; 1581 repeat = last_repeat; 1582 mdcount = ((repeat * bytesperword) + 15) / 16; 1583 } 1584 1585 if (argc) { 1586 unsigned long val; 1587 int diag, nextarg = 1; 1588 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, 1589 &offset, NULL); 1590 if (diag) 1591 return diag; 1592 if (argc > nextarg+2) 1593 return KDB_ARGCOUNT; 1594 1595 if (argc >= nextarg) { 1596 diag = kdbgetularg(argv[nextarg], &val); 1597 if (!diag) { 1598 mdcount = (int) val; 1599 repeat = mdcount * 16 / bytesperword; 1600 } 1601 } 1602 if (argc >= nextarg+1) { 1603 diag = kdbgetularg(argv[nextarg+1], &val); 1604 if (!diag) 1605 radix = (int) val; 1606 } 1607 } 1608 1609 if (strcmp(argv[0], "mdr") == 0) 1610 return kdb_mdr(addr, mdcount); 1611 1612 switch (radix) { 1613 case 10: 1614 fmtchar = 'd'; 1615 break; 1616 case 16: 1617 fmtchar = 'x'; 1618 break; 1619 case 8: 1620 fmtchar = 'o'; 1621 break; 1622 default: 1623 return KDB_BADRADIX; 1624 } 1625 1626 last_radix = radix; 1627 1628 if (bytesperword > KDB_WORD_SIZE) 1629 return KDB_BADWIDTH; 1630 1631 switch (bytesperword) { 1632 case 8: 1633 sprintf(fmtstr, "%%16.16l%c ", fmtchar); 1634 break; 1635 case 4: 1636 sprintf(fmtstr, "%%8.8l%c ", fmtchar); 1637 break; 1638 case 2: 1639 sprintf(fmtstr, "%%4.4l%c ", fmtchar); 1640 break; 1641 case 1: 1642 sprintf(fmtstr, "%%2.2l%c ", fmtchar); 1643 break; 1644 default: 1645 return KDB_BADWIDTH; 1646 } 1647 1648 last_repeat = repeat; 1649 last_bytesperword = bytesperword; 1650 1651 if (strcmp(argv[0], "mds") == 0) { 1652 symbolic = 1; 1653 /* Do not save these changes as last_*, they are temporary mds 1654 * overrides. 1655 */ 1656 bytesperword = KDB_WORD_SIZE; 1657 repeat = mdcount; 1658 kdbgetintenv("NOSECT", &nosect); 1659 } 1660 1661 /* Round address down modulo BYTESPERWORD */ 1662 1663 addr &= ~(bytesperword-1); 1664 1665 while (repeat > 0) { 1666 unsigned long a; 1667 int n, z, num = (symbolic ? 1 : (16 / bytesperword)); 1668 1669 if (KDB_FLAG(CMD_INTERRUPT)) 1670 return 0; 1671 for (a = addr, z = 0; z < repeat; a += bytesperword, ++z) { 1672 if (phys) { 1673 if (kdb_getphysword(&word, a, bytesperword) 1674 || word) 1675 break; 1676 } else if (kdb_getword(&word, a, bytesperword) || word) 1677 break; 1678 } 1679 n = min(num, repeat); 1680 kdb_md_line(fmtstr, addr, symbolic, nosect, bytesperword, 1681 num, repeat, phys); 1682 addr += bytesperword * n; 1683 repeat -= n; 1684 z = (z + num - 1) / num; 1685 if (z > 2) { 1686 int s = num * (z-2); 1687 kdb_printf(kdb_machreg_fmt0 "-" kdb_machreg_fmt0 1688 " zero suppressed\n", 1689 addr, addr + bytesperword * s - 1); 1690 addr += bytesperword * s; 1691 repeat -= s; 1692 } 1693 } 1694 last_addr = addr; 1695 1696 return 0; 1697 } 1698 1699 /* 1700 * kdb_mm - This function implements the 'mm' command. 1701 * mm address-expression new-value 1702 * Remarks: 1703 * mm works on machine words, mmW works on bytes. 1704 */ 1705 static int kdb_mm(int argc, const char **argv) 1706 { 1707 int diag; 1708 unsigned long addr; 1709 long offset = 0; 1710 unsigned long contents; 1711 int nextarg; 1712 int width; 1713 1714 if (argv[0][2] && !isdigit(argv[0][2])) 1715 return KDB_NOTFOUND; 1716 1717 if (argc < 2) 1718 return KDB_ARGCOUNT; 1719 1720 nextarg = 1; 1721 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL); 1722 if (diag) 1723 return diag; 1724 1725 if (nextarg > argc) 1726 return KDB_ARGCOUNT; 1727 diag = kdbgetaddrarg(argc, argv, &nextarg, &contents, NULL, NULL); 1728 if (diag) 1729 return diag; 1730 1731 if (nextarg != argc + 1) 1732 return KDB_ARGCOUNT; 1733 1734 width = argv[0][2] ? (argv[0][2] - '0') : (KDB_WORD_SIZE); 1735 diag = kdb_putword(addr, contents, width); 1736 if (diag) 1737 return diag; 1738 1739 kdb_printf(kdb_machreg_fmt " = " kdb_machreg_fmt "\n", addr, contents); 1740 1741 return 0; 1742 } 1743 1744 /* 1745 * kdb_go - This function implements the 'go' command. 1746 * go [address-expression] 1747 */ 1748 static int kdb_go(int argc, const char **argv) 1749 { 1750 unsigned long addr; 1751 int diag; 1752 int nextarg; 1753 long offset; 1754 1755 if (raw_smp_processor_id() != kdb_initial_cpu) { 1756 kdb_printf("go must execute on the entry cpu, " 1757 "please use \"cpu %d\" and then execute go\n", 1758 kdb_initial_cpu); 1759 return KDB_BADCPUNUM; 1760 } 1761 if (argc == 1) { 1762 nextarg = 1; 1763 diag = kdbgetaddrarg(argc, argv, &nextarg, 1764 &addr, &offset, NULL); 1765 if (diag) 1766 return diag; 1767 } else if (argc) { 1768 return KDB_ARGCOUNT; 1769 } 1770 1771 diag = KDB_CMD_GO; 1772 if (KDB_FLAG(CATASTROPHIC)) { 1773 kdb_printf("Catastrophic error detected\n"); 1774 kdb_printf("kdb_continue_catastrophic=%d, ", 1775 kdb_continue_catastrophic); 1776 if (kdb_continue_catastrophic == 0 && kdb_go_count++ == 0) { 1777 kdb_printf("type go a second time if you really want " 1778 "to continue\n"); 1779 return 0; 1780 } 1781 if (kdb_continue_catastrophic == 2) { 1782 kdb_printf("forcing reboot\n"); 1783 kdb_reboot(0, NULL); 1784 } 1785 kdb_printf("attempting to continue\n"); 1786 } 1787 return diag; 1788 } 1789 1790 /* 1791 * kdb_rd - This function implements the 'rd' command. 1792 */ 1793 static int kdb_rd(int argc, const char **argv) 1794 { 1795 int len = kdb_check_regs(); 1796 #if DBG_MAX_REG_NUM > 0 1797 int i; 1798 char *rname; 1799 int rsize; 1800 u64 reg64; 1801 u32 reg32; 1802 u16 reg16; 1803 u8 reg8; 1804 1805 if (len) 1806 return len; 1807 1808 for (i = 0; i < DBG_MAX_REG_NUM; i++) { 1809 rsize = dbg_reg_def[i].size * 2; 1810 if (rsize > 16) 1811 rsize = 2; 1812 if (len + strlen(dbg_reg_def[i].name) + 4 + rsize > 80) { 1813 len = 0; 1814 kdb_printf("\n"); 1815 } 1816 if (len) 1817 len += kdb_printf(" "); 1818 switch(dbg_reg_def[i].size * 8) { 1819 case 8: 1820 rname = dbg_get_reg(i, ®8, kdb_current_regs); 1821 if (!rname) 1822 break; 1823 len += kdb_printf("%s: %02x", rname, reg8); 1824 break; 1825 case 16: 1826 rname = dbg_get_reg(i, ®16, kdb_current_regs); 1827 if (!rname) 1828 break; 1829 len += kdb_printf("%s: %04x", rname, reg16); 1830 break; 1831 case 32: 1832 rname = dbg_get_reg(i, ®32, kdb_current_regs); 1833 if (!rname) 1834 break; 1835 len += kdb_printf("%s: %08x", rname, reg32); 1836 break; 1837 case 64: 1838 rname = dbg_get_reg(i, ®64, kdb_current_regs); 1839 if (!rname) 1840 break; 1841 len += kdb_printf("%s: %016llx", rname, reg64); 1842 break; 1843 default: 1844 len += kdb_printf("%s: ??", dbg_reg_def[i].name); 1845 } 1846 } 1847 kdb_printf("\n"); 1848 #else 1849 if (len) 1850 return len; 1851 1852 kdb_dumpregs(kdb_current_regs); 1853 #endif 1854 return 0; 1855 } 1856 1857 /* 1858 * kdb_rm - This function implements the 'rm' (register modify) command. 1859 * rm register-name new-contents 1860 * Remarks: 1861 * Allows register modification with the same restrictions as gdb 1862 */ 1863 static int kdb_rm(int argc, const char **argv) 1864 { 1865 #if DBG_MAX_REG_NUM > 0 1866 int diag; 1867 const char *rname; 1868 int i; 1869 u64 reg64; 1870 u32 reg32; 1871 u16 reg16; 1872 u8 reg8; 1873 1874 if (argc != 2) 1875 return KDB_ARGCOUNT; 1876 /* 1877 * Allow presence or absence of leading '%' symbol. 1878 */ 1879 rname = argv[1]; 1880 if (*rname == '%') 1881 rname++; 1882 1883 diag = kdbgetu64arg(argv[2], ®64); 1884 if (diag) 1885 return diag; 1886 1887 diag = kdb_check_regs(); 1888 if (diag) 1889 return diag; 1890 1891 diag = KDB_BADREG; 1892 for (i = 0; i < DBG_MAX_REG_NUM; i++) { 1893 if (strcmp(rname, dbg_reg_def[i].name) == 0) { 1894 diag = 0; 1895 break; 1896 } 1897 } 1898 if (!diag) { 1899 switch(dbg_reg_def[i].size * 8) { 1900 case 8: 1901 reg8 = reg64; 1902 dbg_set_reg(i, ®8, kdb_current_regs); 1903 break; 1904 case 16: 1905 reg16 = reg64; 1906 dbg_set_reg(i, ®16, kdb_current_regs); 1907 break; 1908 case 32: 1909 reg32 = reg64; 1910 dbg_set_reg(i, ®32, kdb_current_regs); 1911 break; 1912 case 64: 1913 dbg_set_reg(i, ®64, kdb_current_regs); 1914 break; 1915 } 1916 } 1917 return diag; 1918 #else 1919 kdb_printf("ERROR: Register set currently not implemented\n"); 1920 return 0; 1921 #endif 1922 } 1923 1924 #if defined(CONFIG_MAGIC_SYSRQ) 1925 /* 1926 * kdb_sr - This function implements the 'sr' (SYSRQ key) command 1927 * which interfaces to the soi-disant MAGIC SYSRQ functionality. 1928 * sr <magic-sysrq-code> 1929 */ 1930 static int kdb_sr(int argc, const char **argv) 1931 { 1932 if (argc != 1) 1933 return KDB_ARGCOUNT; 1934 kdb_trap_printk++; 1935 __handle_sysrq(*argv[1], false); 1936 kdb_trap_printk--; 1937 1938 return 0; 1939 } 1940 #endif /* CONFIG_MAGIC_SYSRQ */ 1941 1942 /* 1943 * kdb_ef - This function implements the 'regs' (display exception 1944 * frame) command. This command takes an address and expects to 1945 * find an exception frame at that address, formats and prints 1946 * it. 1947 * regs address-expression 1948 * Remarks: 1949 * Not done yet. 1950 */ 1951 static int kdb_ef(int argc, const char **argv) 1952 { 1953 int diag; 1954 unsigned long addr; 1955 long offset; 1956 int nextarg; 1957 1958 if (argc != 1) 1959 return KDB_ARGCOUNT; 1960 1961 nextarg = 1; 1962 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL); 1963 if (diag) 1964 return diag; 1965 show_regs((struct pt_regs *)addr); 1966 return 0; 1967 } 1968 1969 #if defined(CONFIG_MODULES) 1970 /* 1971 * kdb_lsmod - This function implements the 'lsmod' command. Lists 1972 * currently loaded kernel modules. 1973 * Mostly taken from userland lsmod. 1974 */ 1975 static int kdb_lsmod(int argc, const char **argv) 1976 { 1977 struct module *mod; 1978 1979 if (argc != 0) 1980 return KDB_ARGCOUNT; 1981 1982 kdb_printf("Module Size modstruct Used by\n"); 1983 list_for_each_entry(mod, kdb_modules, list) { 1984 1985 kdb_printf("%-20s%8u 0x%p ", mod->name, 1986 mod->core_size, (void *)mod); 1987 #ifdef CONFIG_MODULE_UNLOAD 1988 kdb_printf("%4ld ", module_refcount(mod)); 1989 #endif 1990 if (mod->state == MODULE_STATE_GOING) 1991 kdb_printf(" (Unloading)"); 1992 else if (mod->state == MODULE_STATE_COMING) 1993 kdb_printf(" (Loading)"); 1994 else 1995 kdb_printf(" (Live)"); 1996 kdb_printf(" 0x%p", mod->module_core); 1997 1998 #ifdef CONFIG_MODULE_UNLOAD 1999 { 2000 struct module_use *use; 2001 kdb_printf(" [ "); 2002 list_for_each_entry(use, &mod->source_list, 2003 source_list) 2004 kdb_printf("%s ", use->target->name); 2005 kdb_printf("]\n"); 2006 } 2007 #endif 2008 } 2009 2010 return 0; 2011 } 2012 2013 #endif /* CONFIG_MODULES */ 2014 2015 /* 2016 * kdb_env - This function implements the 'env' command. Display the 2017 * current environment variables. 2018 */ 2019 2020 static int kdb_env(int argc, const char **argv) 2021 { 2022 int i; 2023 2024 for (i = 0; i < __nenv; i++) { 2025 if (__env[i]) 2026 kdb_printf("%s\n", __env[i]); 2027 } 2028 2029 if (KDB_DEBUG(MASK)) 2030 kdb_printf("KDBFLAGS=0x%x\n", kdb_flags); 2031 2032 return 0; 2033 } 2034 2035 #ifdef CONFIG_PRINTK 2036 /* 2037 * kdb_dmesg - This function implements the 'dmesg' command to display 2038 * the contents of the syslog buffer. 2039 * dmesg [lines] [adjust] 2040 */ 2041 static int kdb_dmesg(int argc, const char **argv) 2042 { 2043 char *syslog_data[4], *start, *end, c = '\0', *p; 2044 int diag, logging, logsize, lines = 0, adjust = 0, n; 2045 2046 if (argc > 2) 2047 return KDB_ARGCOUNT; 2048 if (argc) { 2049 char *cp; 2050 lines = simple_strtol(argv[1], &cp, 0); 2051 if (*cp) 2052 lines = 0; 2053 if (argc > 1) { 2054 adjust = simple_strtoul(argv[2], &cp, 0); 2055 if (*cp || adjust < 0) 2056 adjust = 0; 2057 } 2058 } 2059 2060 /* disable LOGGING if set */ 2061 diag = kdbgetintenv("LOGGING", &logging); 2062 if (!diag && logging) { 2063 const char *setargs[] = { "set", "LOGGING", "0" }; 2064 kdb_set(2, setargs); 2065 } 2066 2067 /* syslog_data[0,1] physical start, end+1. syslog_data[2,3] 2068 * logical start, end+1. */ 2069 kdb_syslog_data(syslog_data); 2070 if (syslog_data[2] == syslog_data[3]) 2071 return 0; 2072 logsize = syslog_data[1] - syslog_data[0]; 2073 start = syslog_data[2]; 2074 end = syslog_data[3]; 2075 #define KDB_WRAP(p) (((p - syslog_data[0]) % logsize) + syslog_data[0]) 2076 for (n = 0, p = start; p < end; ++p) { 2077 c = *KDB_WRAP(p); 2078 if (c == '\n') 2079 ++n; 2080 } 2081 if (c != '\n') 2082 ++n; 2083 if (lines < 0) { 2084 if (adjust >= n) 2085 kdb_printf("buffer only contains %d lines, nothing " 2086 "printed\n", n); 2087 else if (adjust - lines >= n) 2088 kdb_printf("buffer only contains %d lines, last %d " 2089 "lines printed\n", n, n - adjust); 2090 if (adjust) { 2091 for (; start < end && adjust; ++start) { 2092 if (*KDB_WRAP(start) == '\n') 2093 --adjust; 2094 } 2095 if (start < end) 2096 ++start; 2097 } 2098 for (p = start; p < end && lines; ++p) { 2099 if (*KDB_WRAP(p) == '\n') 2100 ++lines; 2101 } 2102 end = p; 2103 } else if (lines > 0) { 2104 int skip = n - (adjust + lines); 2105 if (adjust >= n) { 2106 kdb_printf("buffer only contains %d lines, " 2107 "nothing printed\n", n); 2108 skip = n; 2109 } else if (skip < 0) { 2110 lines += skip; 2111 skip = 0; 2112 kdb_printf("buffer only contains %d lines, first " 2113 "%d lines printed\n", n, lines); 2114 } 2115 for (; start < end && skip; ++start) { 2116 if (*KDB_WRAP(start) == '\n') 2117 --skip; 2118 } 2119 for (p = start; p < end && lines; ++p) { 2120 if (*KDB_WRAP(p) == '\n') 2121 --lines; 2122 } 2123 end = p; 2124 } 2125 /* Do a line at a time (max 200 chars) to reduce protocol overhead */ 2126 c = '\n'; 2127 while (start != end) { 2128 char buf[201]; 2129 p = buf; 2130 if (KDB_FLAG(CMD_INTERRUPT)) 2131 return 0; 2132 while (start < end && (c = *KDB_WRAP(start)) && 2133 (p - buf) < sizeof(buf)-1) { 2134 ++start; 2135 *p++ = c; 2136 if (c == '\n') 2137 break; 2138 } 2139 *p = '\0'; 2140 kdb_printf("%s", buf); 2141 } 2142 if (c != '\n') 2143 kdb_printf("\n"); 2144 2145 return 0; 2146 } 2147 #endif /* CONFIG_PRINTK */ 2148 /* 2149 * kdb_cpu - This function implements the 'cpu' command. 2150 * cpu [<cpunum>] 2151 * Returns: 2152 * KDB_CMD_CPU for success, a kdb diagnostic if error 2153 */ 2154 static void kdb_cpu_status(void) 2155 { 2156 int i, start_cpu, first_print = 1; 2157 char state, prev_state = '?'; 2158 2159 kdb_printf("Currently on cpu %d\n", raw_smp_processor_id()); 2160 kdb_printf("Available cpus: "); 2161 for (start_cpu = -1, i = 0; i < NR_CPUS; i++) { 2162 if (!cpu_online(i)) { 2163 state = 'F'; /* cpu is offline */ 2164 } else { 2165 state = ' '; /* cpu is responding to kdb */ 2166 if (kdb_task_state_char(KDB_TSK(i)) == 'I') 2167 state = 'I'; /* idle task */ 2168 } 2169 if (state != prev_state) { 2170 if (prev_state != '?') { 2171 if (!first_print) 2172 kdb_printf(", "); 2173 first_print = 0; 2174 kdb_printf("%d", start_cpu); 2175 if (start_cpu < i-1) 2176 kdb_printf("-%d", i-1); 2177 if (prev_state != ' ') 2178 kdb_printf("(%c)", prev_state); 2179 } 2180 prev_state = state; 2181 start_cpu = i; 2182 } 2183 } 2184 /* print the trailing cpus, ignoring them if they are all offline */ 2185 if (prev_state != 'F') { 2186 if (!first_print) 2187 kdb_printf(", "); 2188 kdb_printf("%d", start_cpu); 2189 if (start_cpu < i-1) 2190 kdb_printf("-%d", i-1); 2191 if (prev_state != ' ') 2192 kdb_printf("(%c)", prev_state); 2193 } 2194 kdb_printf("\n"); 2195 } 2196 2197 static int kdb_cpu(int argc, const char **argv) 2198 { 2199 unsigned long cpunum; 2200 int diag; 2201 2202 if (argc == 0) { 2203 kdb_cpu_status(); 2204 return 0; 2205 } 2206 2207 if (argc != 1) 2208 return KDB_ARGCOUNT; 2209 2210 diag = kdbgetularg(argv[1], &cpunum); 2211 if (diag) 2212 return diag; 2213 2214 /* 2215 * Validate cpunum 2216 */ 2217 if ((cpunum > NR_CPUS) || !cpu_online(cpunum)) 2218 return KDB_BADCPUNUM; 2219 2220 dbg_switch_cpu = cpunum; 2221 2222 /* 2223 * Switch to other cpu 2224 */ 2225 return KDB_CMD_CPU; 2226 } 2227 2228 /* The user may not realize that ps/bta with no parameters does not print idle 2229 * or sleeping system daemon processes, so tell them how many were suppressed. 2230 */ 2231 void kdb_ps_suppressed(void) 2232 { 2233 int idle = 0, daemon = 0; 2234 unsigned long mask_I = kdb_task_state_string("I"), 2235 mask_M = kdb_task_state_string("M"); 2236 unsigned long cpu; 2237 const struct task_struct *p, *g; 2238 for_each_online_cpu(cpu) { 2239 p = kdb_curr_task(cpu); 2240 if (kdb_task_state(p, mask_I)) 2241 ++idle; 2242 } 2243 kdb_do_each_thread(g, p) { 2244 if (kdb_task_state(p, mask_M)) 2245 ++daemon; 2246 } kdb_while_each_thread(g, p); 2247 if (idle || daemon) { 2248 if (idle) 2249 kdb_printf("%d idle process%s (state I)%s\n", 2250 idle, idle == 1 ? "" : "es", 2251 daemon ? " and " : ""); 2252 if (daemon) 2253 kdb_printf("%d sleeping system daemon (state M) " 2254 "process%s", daemon, 2255 daemon == 1 ? "" : "es"); 2256 kdb_printf(" suppressed,\nuse 'ps A' to see all.\n"); 2257 } 2258 } 2259 2260 /* 2261 * kdb_ps - This function implements the 'ps' command which shows a 2262 * list of the active processes. 2263 * ps [DRSTCZEUIMA] All processes, optionally filtered by state 2264 */ 2265 void kdb_ps1(const struct task_struct *p) 2266 { 2267 int cpu; 2268 unsigned long tmp; 2269 2270 if (!p || probe_kernel_read(&tmp, (char *)p, sizeof(unsigned long))) 2271 return; 2272 2273 cpu = kdb_process_cpu(p); 2274 kdb_printf("0x%p %8d %8d %d %4d %c 0x%p %c%s\n", 2275 (void *)p, p->pid, p->parent->pid, 2276 kdb_task_has_cpu(p), kdb_process_cpu(p), 2277 kdb_task_state_char(p), 2278 (void *)(&p->thread), 2279 p == kdb_curr_task(raw_smp_processor_id()) ? '*' : ' ', 2280 p->comm); 2281 if (kdb_task_has_cpu(p)) { 2282 if (!KDB_TSK(cpu)) { 2283 kdb_printf(" Error: no saved data for this cpu\n"); 2284 } else { 2285 if (KDB_TSK(cpu) != p) 2286 kdb_printf(" Error: does not match running " 2287 "process table (0x%p)\n", KDB_TSK(cpu)); 2288 } 2289 } 2290 } 2291 2292 static int kdb_ps(int argc, const char **argv) 2293 { 2294 struct task_struct *g, *p; 2295 unsigned long mask, cpu; 2296 2297 if (argc == 0) 2298 kdb_ps_suppressed(); 2299 kdb_printf("%-*s Pid Parent [*] cpu State %-*s Command\n", 2300 (int)(2*sizeof(void *))+2, "Task Addr", 2301 (int)(2*sizeof(void *))+2, "Thread"); 2302 mask = kdb_task_state_string(argc ? argv[1] : NULL); 2303 /* Run the active tasks first */ 2304 for_each_online_cpu(cpu) { 2305 if (KDB_FLAG(CMD_INTERRUPT)) 2306 return 0; 2307 p = kdb_curr_task(cpu); 2308 if (kdb_task_state(p, mask)) 2309 kdb_ps1(p); 2310 } 2311 kdb_printf("\n"); 2312 /* Now the real tasks */ 2313 kdb_do_each_thread(g, p) { 2314 if (KDB_FLAG(CMD_INTERRUPT)) 2315 return 0; 2316 if (kdb_task_state(p, mask)) 2317 kdb_ps1(p); 2318 } kdb_while_each_thread(g, p); 2319 2320 return 0; 2321 } 2322 2323 /* 2324 * kdb_pid - This function implements the 'pid' command which switches 2325 * the currently active process. 2326 * pid [<pid> | R] 2327 */ 2328 static int kdb_pid(int argc, const char **argv) 2329 { 2330 struct task_struct *p; 2331 unsigned long val; 2332 int diag; 2333 2334 if (argc > 1) 2335 return KDB_ARGCOUNT; 2336 2337 if (argc) { 2338 if (strcmp(argv[1], "R") == 0) { 2339 p = KDB_TSK(kdb_initial_cpu); 2340 } else { 2341 diag = kdbgetularg(argv[1], &val); 2342 if (diag) 2343 return KDB_BADINT; 2344 2345 p = find_task_by_pid_ns((pid_t)val, &init_pid_ns); 2346 if (!p) { 2347 kdb_printf("No task with pid=%d\n", (pid_t)val); 2348 return 0; 2349 } 2350 } 2351 kdb_set_current_task(p); 2352 } 2353 kdb_printf("KDB current process is %s(pid=%d)\n", 2354 kdb_current_task->comm, 2355 kdb_current_task->pid); 2356 2357 return 0; 2358 } 2359 2360 /* 2361 * kdb_ll - This function implements the 'll' command which follows a 2362 * linked list and executes an arbitrary command for each 2363 * element. 2364 */ 2365 static int kdb_ll(int argc, const char **argv) 2366 { 2367 int diag = 0; 2368 unsigned long addr; 2369 long offset = 0; 2370 unsigned long va; 2371 unsigned long linkoffset; 2372 int nextarg; 2373 const char *command; 2374 2375 if (argc != 3) 2376 return KDB_ARGCOUNT; 2377 2378 nextarg = 1; 2379 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL); 2380 if (diag) 2381 return diag; 2382 2383 diag = kdbgetularg(argv[2], &linkoffset); 2384 if (diag) 2385 return diag; 2386 2387 /* 2388 * Using the starting address as 2389 * the first element in the list, and assuming that 2390 * the list ends with a null pointer. 2391 */ 2392 2393 va = addr; 2394 command = kdb_strdup(argv[3], GFP_KDB); 2395 if (!command) { 2396 kdb_printf("%s: cannot duplicate command\n", __func__); 2397 return 0; 2398 } 2399 /* Recursive use of kdb_parse, do not use argv after this point */ 2400 argv = NULL; 2401 2402 while (va) { 2403 char buf[80]; 2404 2405 if (KDB_FLAG(CMD_INTERRUPT)) 2406 goto out; 2407 2408 sprintf(buf, "%s " kdb_machreg_fmt "\n", command, va); 2409 diag = kdb_parse(buf); 2410 if (diag) 2411 goto out; 2412 2413 addr = va + linkoffset; 2414 if (kdb_getword(&va, addr, sizeof(va))) 2415 goto out; 2416 } 2417 2418 out: 2419 kfree(command); 2420 return diag; 2421 } 2422 2423 static int kdb_kgdb(int argc, const char **argv) 2424 { 2425 return KDB_CMD_KGDB; 2426 } 2427 2428 /* 2429 * kdb_help - This function implements the 'help' and '?' commands. 2430 */ 2431 static int kdb_help(int argc, const char **argv) 2432 { 2433 kdbtab_t *kt; 2434 int i; 2435 2436 kdb_printf("%-15.15s %-20.20s %s\n", "Command", "Usage", "Description"); 2437 kdb_printf("-----------------------------" 2438 "-----------------------------\n"); 2439 for_each_kdbcmd(kt, i) { 2440 if (kt->cmd_name) 2441 kdb_printf("%-15.15s %-20.20s %s\n", kt->cmd_name, 2442 kt->cmd_usage, kt->cmd_help); 2443 if (KDB_FLAG(CMD_INTERRUPT)) 2444 return 0; 2445 } 2446 return 0; 2447 } 2448 2449 /* 2450 * kdb_kill - This function implements the 'kill' commands. 2451 */ 2452 static int kdb_kill(int argc, const char **argv) 2453 { 2454 long sig, pid; 2455 char *endp; 2456 struct task_struct *p; 2457 struct siginfo info; 2458 2459 if (argc != 2) 2460 return KDB_ARGCOUNT; 2461 2462 sig = simple_strtol(argv[1], &endp, 0); 2463 if (*endp) 2464 return KDB_BADINT; 2465 if (sig >= 0) { 2466 kdb_printf("Invalid signal parameter.<-signal>\n"); 2467 return 0; 2468 } 2469 sig = -sig; 2470 2471 pid = simple_strtol(argv[2], &endp, 0); 2472 if (*endp) 2473 return KDB_BADINT; 2474 if (pid <= 0) { 2475 kdb_printf("Process ID must be large than 0.\n"); 2476 return 0; 2477 } 2478 2479 /* Find the process. */ 2480 p = find_task_by_pid_ns(pid, &init_pid_ns); 2481 if (!p) { 2482 kdb_printf("The specified process isn't found.\n"); 2483 return 0; 2484 } 2485 p = p->group_leader; 2486 info.si_signo = sig; 2487 info.si_errno = 0; 2488 info.si_code = SI_USER; 2489 info.si_pid = pid; /* same capabilities as process being signalled */ 2490 info.si_uid = 0; /* kdb has root authority */ 2491 kdb_send_sig_info(p, &info); 2492 return 0; 2493 } 2494 2495 struct kdb_tm { 2496 int tm_sec; /* seconds */ 2497 int tm_min; /* minutes */ 2498 int tm_hour; /* hours */ 2499 int tm_mday; /* day of the month */ 2500 int tm_mon; /* month */ 2501 int tm_year; /* year */ 2502 }; 2503 2504 static void kdb_gmtime(struct timespec *tv, struct kdb_tm *tm) 2505 { 2506 /* This will work from 1970-2099, 2100 is not a leap year */ 2507 static int mon_day[] = { 31, 29, 31, 30, 31, 30, 31, 2508 31, 30, 31, 30, 31 }; 2509 memset(tm, 0, sizeof(*tm)); 2510 tm->tm_sec = tv->tv_sec % (24 * 60 * 60); 2511 tm->tm_mday = tv->tv_sec / (24 * 60 * 60) + 2512 (2 * 365 + 1); /* shift base from 1970 to 1968 */ 2513 tm->tm_min = tm->tm_sec / 60 % 60; 2514 tm->tm_hour = tm->tm_sec / 60 / 60; 2515 tm->tm_sec = tm->tm_sec % 60; 2516 tm->tm_year = 68 + 4*(tm->tm_mday / (4*365+1)); 2517 tm->tm_mday %= (4*365+1); 2518 mon_day[1] = 29; 2519 while (tm->tm_mday >= mon_day[tm->tm_mon]) { 2520 tm->tm_mday -= mon_day[tm->tm_mon]; 2521 if (++tm->tm_mon == 12) { 2522 tm->tm_mon = 0; 2523 ++tm->tm_year; 2524 mon_day[1] = 28; 2525 } 2526 } 2527 ++tm->tm_mday; 2528 } 2529 2530 /* 2531 * Most of this code has been lifted from kernel/timer.c::sys_sysinfo(). 2532 * I cannot call that code directly from kdb, it has an unconditional 2533 * cli()/sti() and calls routines that take locks which can stop the debugger. 2534 */ 2535 static void kdb_sysinfo(struct sysinfo *val) 2536 { 2537 struct timespec uptime; 2538 do_posix_clock_monotonic_gettime(&uptime); 2539 memset(val, 0, sizeof(*val)); 2540 val->uptime = uptime.tv_sec; 2541 val->loads[0] = avenrun[0]; 2542 val->loads[1] = avenrun[1]; 2543 val->loads[2] = avenrun[2]; 2544 val->procs = nr_threads-1; 2545 si_meminfo(val); 2546 2547 return; 2548 } 2549 2550 /* 2551 * kdb_summary - This function implements the 'summary' command. 2552 */ 2553 static int kdb_summary(int argc, const char **argv) 2554 { 2555 struct timespec now; 2556 struct kdb_tm tm; 2557 struct sysinfo val; 2558 2559 if (argc) 2560 return KDB_ARGCOUNT; 2561 2562 kdb_printf("sysname %s\n", init_uts_ns.name.sysname); 2563 kdb_printf("release %s\n", init_uts_ns.name.release); 2564 kdb_printf("version %s\n", init_uts_ns.name.version); 2565 kdb_printf("machine %s\n", init_uts_ns.name.machine); 2566 kdb_printf("nodename %s\n", init_uts_ns.name.nodename); 2567 kdb_printf("domainname %s\n", init_uts_ns.name.domainname); 2568 kdb_printf("ccversion %s\n", __stringify(CCVERSION)); 2569 2570 now = __current_kernel_time(); 2571 kdb_gmtime(&now, &tm); 2572 kdb_printf("date %04d-%02d-%02d %02d:%02d:%02d " 2573 "tz_minuteswest %d\n", 2574 1900+tm.tm_year, tm.tm_mon+1, tm.tm_mday, 2575 tm.tm_hour, tm.tm_min, tm.tm_sec, 2576 sys_tz.tz_minuteswest); 2577 2578 kdb_sysinfo(&val); 2579 kdb_printf("uptime "); 2580 if (val.uptime > (24*60*60)) { 2581 int days = val.uptime / (24*60*60); 2582 val.uptime %= (24*60*60); 2583 kdb_printf("%d day%s ", days, days == 1 ? "" : "s"); 2584 } 2585 kdb_printf("%02ld:%02ld\n", val.uptime/(60*60), (val.uptime/60)%60); 2586 2587 /* lifted from fs/proc/proc_misc.c::loadavg_read_proc() */ 2588 2589 #define LOAD_INT(x) ((x) >> FSHIFT) 2590 #define LOAD_FRAC(x) LOAD_INT(((x) & (FIXED_1-1)) * 100) 2591 kdb_printf("load avg %ld.%02ld %ld.%02ld %ld.%02ld\n", 2592 LOAD_INT(val.loads[0]), LOAD_FRAC(val.loads[0]), 2593 LOAD_INT(val.loads[1]), LOAD_FRAC(val.loads[1]), 2594 LOAD_INT(val.loads[2]), LOAD_FRAC(val.loads[2])); 2595 #undef LOAD_INT 2596 #undef LOAD_FRAC 2597 /* Display in kilobytes */ 2598 #define K(x) ((x) << (PAGE_SHIFT - 10)) 2599 kdb_printf("\nMemTotal: %8lu kB\nMemFree: %8lu kB\n" 2600 "Buffers: %8lu kB\n", 2601 val.totalram, val.freeram, val.bufferram); 2602 return 0; 2603 } 2604 2605 /* 2606 * kdb_per_cpu - This function implements the 'per_cpu' command. 2607 */ 2608 static int kdb_per_cpu(int argc, const char **argv) 2609 { 2610 char fmtstr[64]; 2611 int cpu, diag, nextarg = 1; 2612 unsigned long addr, symaddr, val, bytesperword = 0, whichcpu = ~0UL; 2613 2614 if (argc < 1 || argc > 3) 2615 return KDB_ARGCOUNT; 2616 2617 diag = kdbgetaddrarg(argc, argv, &nextarg, &symaddr, NULL, NULL); 2618 if (diag) 2619 return diag; 2620 2621 if (argc >= 2) { 2622 diag = kdbgetularg(argv[2], &bytesperword); 2623 if (diag) 2624 return diag; 2625 } 2626 if (!bytesperword) 2627 bytesperword = KDB_WORD_SIZE; 2628 else if (bytesperword > KDB_WORD_SIZE) 2629 return KDB_BADWIDTH; 2630 sprintf(fmtstr, "%%0%dlx ", (int)(2*bytesperword)); 2631 if (argc >= 3) { 2632 diag = kdbgetularg(argv[3], &whichcpu); 2633 if (diag) 2634 return diag; 2635 if (!cpu_online(whichcpu)) { 2636 kdb_printf("cpu %ld is not online\n", whichcpu); 2637 return KDB_BADCPUNUM; 2638 } 2639 } 2640 2641 /* Most architectures use __per_cpu_offset[cpu], some use 2642 * __per_cpu_offset(cpu), smp has no __per_cpu_offset. 2643 */ 2644 #ifdef __per_cpu_offset 2645 #define KDB_PCU(cpu) __per_cpu_offset(cpu) 2646 #else 2647 #ifdef CONFIG_SMP 2648 #define KDB_PCU(cpu) __per_cpu_offset[cpu] 2649 #else 2650 #define KDB_PCU(cpu) 0 2651 #endif 2652 #endif 2653 for_each_online_cpu(cpu) { 2654 if (KDB_FLAG(CMD_INTERRUPT)) 2655 return 0; 2656 2657 if (whichcpu != ~0UL && whichcpu != cpu) 2658 continue; 2659 addr = symaddr + KDB_PCU(cpu); 2660 diag = kdb_getword(&val, addr, bytesperword); 2661 if (diag) { 2662 kdb_printf("%5d " kdb_bfd_vma_fmt0 " - unable to " 2663 "read, diag=%d\n", cpu, addr, diag); 2664 continue; 2665 } 2666 kdb_printf("%5d ", cpu); 2667 kdb_md_line(fmtstr, addr, 2668 bytesperword == KDB_WORD_SIZE, 2669 1, bytesperword, 1, 1, 0); 2670 } 2671 #undef KDB_PCU 2672 return 0; 2673 } 2674 2675 /* 2676 * display help for the use of cmd | grep pattern 2677 */ 2678 static int kdb_grep_help(int argc, const char **argv) 2679 { 2680 kdb_printf("Usage of cmd args | grep pattern:\n"); 2681 kdb_printf(" Any command's output may be filtered through an "); 2682 kdb_printf("emulated 'pipe'.\n"); 2683 kdb_printf(" 'grep' is just a key word.\n"); 2684 kdb_printf(" The pattern may include a very limited set of " 2685 "metacharacters:\n"); 2686 kdb_printf(" pattern or ^pattern or pattern$ or ^pattern$\n"); 2687 kdb_printf(" And if there are spaces in the pattern, you may " 2688 "quote it:\n"); 2689 kdb_printf(" \"pat tern\" or \"^pat tern\" or \"pat tern$\"" 2690 " or \"^pat tern$\"\n"); 2691 return 0; 2692 } 2693 2694 /* 2695 * kdb_register_repeat - This function is used to register a kernel 2696 * debugger command. 2697 * Inputs: 2698 * cmd Command name 2699 * func Function to execute the command 2700 * usage A simple usage string showing arguments 2701 * help A simple help string describing command 2702 * repeat Does the command auto repeat on enter? 2703 * Returns: 2704 * zero for success, one if a duplicate command. 2705 */ 2706 #define kdb_command_extend 50 /* arbitrary */ 2707 int kdb_register_repeat(char *cmd, 2708 kdb_func_t func, 2709 char *usage, 2710 char *help, 2711 short minlen, 2712 kdb_repeat_t repeat) 2713 { 2714 int i; 2715 kdbtab_t *kp; 2716 2717 /* 2718 * Brute force method to determine duplicates 2719 */ 2720 for_each_kdbcmd(kp, i) { 2721 if (kp->cmd_name && (strcmp(kp->cmd_name, cmd) == 0)) { 2722 kdb_printf("Duplicate kdb command registered: " 2723 "%s, func %p help %s\n", cmd, func, help); 2724 return 1; 2725 } 2726 } 2727 2728 /* 2729 * Insert command into first available location in table 2730 */ 2731 for_each_kdbcmd(kp, i) { 2732 if (kp->cmd_name == NULL) 2733 break; 2734 } 2735 2736 if (i >= kdb_max_commands) { 2737 kdbtab_t *new = kmalloc((kdb_max_commands - KDB_BASE_CMD_MAX + 2738 kdb_command_extend) * sizeof(*new), GFP_KDB); 2739 if (!new) { 2740 kdb_printf("Could not allocate new kdb_command " 2741 "table\n"); 2742 return 1; 2743 } 2744 if (kdb_commands) { 2745 memcpy(new, kdb_commands, 2746 (kdb_max_commands - KDB_BASE_CMD_MAX) * sizeof(*new)); 2747 kfree(kdb_commands); 2748 } 2749 memset(new + kdb_max_commands, 0, 2750 kdb_command_extend * sizeof(*new)); 2751 kdb_commands = new; 2752 kp = kdb_commands + kdb_max_commands - KDB_BASE_CMD_MAX; 2753 kdb_max_commands += kdb_command_extend; 2754 } 2755 2756 kp->cmd_name = cmd; 2757 kp->cmd_func = func; 2758 kp->cmd_usage = usage; 2759 kp->cmd_help = help; 2760 kp->cmd_flags = 0; 2761 kp->cmd_minlen = minlen; 2762 kp->cmd_repeat = repeat; 2763 2764 return 0; 2765 } 2766 EXPORT_SYMBOL_GPL(kdb_register_repeat); 2767 2768 2769 /* 2770 * kdb_register - Compatibility register function for commands that do 2771 * not need to specify a repeat state. Equivalent to 2772 * kdb_register_repeat with KDB_REPEAT_NONE. 2773 * Inputs: 2774 * cmd Command name 2775 * func Function to execute the command 2776 * usage A simple usage string showing arguments 2777 * help A simple help string describing command 2778 * Returns: 2779 * zero for success, one if a duplicate command. 2780 */ 2781 int kdb_register(char *cmd, 2782 kdb_func_t func, 2783 char *usage, 2784 char *help, 2785 short minlen) 2786 { 2787 return kdb_register_repeat(cmd, func, usage, help, minlen, 2788 KDB_REPEAT_NONE); 2789 } 2790 EXPORT_SYMBOL_GPL(kdb_register); 2791 2792 /* 2793 * kdb_unregister - This function is used to unregister a kernel 2794 * debugger command. It is generally called when a module which 2795 * implements kdb commands is unloaded. 2796 * Inputs: 2797 * cmd Command name 2798 * Returns: 2799 * zero for success, one command not registered. 2800 */ 2801 int kdb_unregister(char *cmd) 2802 { 2803 int i; 2804 kdbtab_t *kp; 2805 2806 /* 2807 * find the command. 2808 */ 2809 for_each_kdbcmd(kp, i) { 2810 if (kp->cmd_name && (strcmp(kp->cmd_name, cmd) == 0)) { 2811 kp->cmd_name = NULL; 2812 return 0; 2813 } 2814 } 2815 2816 /* Couldn't find it. */ 2817 return 1; 2818 } 2819 EXPORT_SYMBOL_GPL(kdb_unregister); 2820 2821 /* Initialize the kdb command table. */ 2822 static void __init kdb_inittab(void) 2823 { 2824 int i; 2825 kdbtab_t *kp; 2826 2827 for_each_kdbcmd(kp, i) 2828 kp->cmd_name = NULL; 2829 2830 kdb_register_repeat("md", kdb_md, "<vaddr>", 2831 "Display Memory Contents, also mdWcN, e.g. md8c1", 1, 2832 KDB_REPEAT_NO_ARGS); 2833 kdb_register_repeat("mdr", kdb_md, "<vaddr> <bytes>", 2834 "Display Raw Memory", 0, KDB_REPEAT_NO_ARGS); 2835 kdb_register_repeat("mdp", kdb_md, "<paddr> <bytes>", 2836 "Display Physical Memory", 0, KDB_REPEAT_NO_ARGS); 2837 kdb_register_repeat("mds", kdb_md, "<vaddr>", 2838 "Display Memory Symbolically", 0, KDB_REPEAT_NO_ARGS); 2839 kdb_register_repeat("mm", kdb_mm, "<vaddr> <contents>", 2840 "Modify Memory Contents", 0, KDB_REPEAT_NO_ARGS); 2841 kdb_register_repeat("go", kdb_go, "[<vaddr>]", 2842 "Continue Execution", 1, KDB_REPEAT_NONE); 2843 kdb_register_repeat("rd", kdb_rd, "", 2844 "Display Registers", 0, KDB_REPEAT_NONE); 2845 kdb_register_repeat("rm", kdb_rm, "<reg> <contents>", 2846 "Modify Registers", 0, KDB_REPEAT_NONE); 2847 kdb_register_repeat("ef", kdb_ef, "<vaddr>", 2848 "Display exception frame", 0, KDB_REPEAT_NONE); 2849 kdb_register_repeat("bt", kdb_bt, "[<vaddr>]", 2850 "Stack traceback", 1, KDB_REPEAT_NONE); 2851 kdb_register_repeat("btp", kdb_bt, "<pid>", 2852 "Display stack for process <pid>", 0, KDB_REPEAT_NONE); 2853 kdb_register_repeat("bta", kdb_bt, "[DRSTCZEUIMA]", 2854 "Display stack all processes", 0, KDB_REPEAT_NONE); 2855 kdb_register_repeat("btc", kdb_bt, "", 2856 "Backtrace current process on each cpu", 0, KDB_REPEAT_NONE); 2857 kdb_register_repeat("btt", kdb_bt, "<vaddr>", 2858 "Backtrace process given its struct task address", 0, 2859 KDB_REPEAT_NONE); 2860 kdb_register_repeat("ll", kdb_ll, "<first-element> <linkoffset> <cmd>", 2861 "Execute cmd for each element in linked list", 0, KDB_REPEAT_NONE); 2862 kdb_register_repeat("env", kdb_env, "", 2863 "Show environment variables", 0, KDB_REPEAT_NONE); 2864 kdb_register_repeat("set", kdb_set, "", 2865 "Set environment variables", 0, KDB_REPEAT_NONE); 2866 kdb_register_repeat("help", kdb_help, "", 2867 "Display Help Message", 1, KDB_REPEAT_NONE); 2868 kdb_register_repeat("?", kdb_help, "", 2869 "Display Help Message", 0, KDB_REPEAT_NONE); 2870 kdb_register_repeat("cpu", kdb_cpu, "<cpunum>", 2871 "Switch to new cpu", 0, KDB_REPEAT_NONE); 2872 kdb_register_repeat("kgdb", kdb_kgdb, "", 2873 "Enter kgdb mode", 0, KDB_REPEAT_NONE); 2874 kdb_register_repeat("ps", kdb_ps, "[<flags>|A]", 2875 "Display active task list", 0, KDB_REPEAT_NONE); 2876 kdb_register_repeat("pid", kdb_pid, "<pidnum>", 2877 "Switch to another task", 0, KDB_REPEAT_NONE); 2878 kdb_register_repeat("reboot", kdb_reboot, "", 2879 "Reboot the machine immediately", 0, KDB_REPEAT_NONE); 2880 #if defined(CONFIG_MODULES) 2881 kdb_register_repeat("lsmod", kdb_lsmod, "", 2882 "List loaded kernel modules", 0, KDB_REPEAT_NONE); 2883 #endif 2884 #if defined(CONFIG_MAGIC_SYSRQ) 2885 kdb_register_repeat("sr", kdb_sr, "<key>", 2886 "Magic SysRq key", 0, KDB_REPEAT_NONE); 2887 #endif 2888 #if defined(CONFIG_PRINTK) 2889 kdb_register_repeat("dmesg", kdb_dmesg, "[lines]", 2890 "Display syslog buffer", 0, KDB_REPEAT_NONE); 2891 #endif 2892 kdb_register_repeat("defcmd", kdb_defcmd, "name \"usage\" \"help\"", 2893 "Define a set of commands, down to endefcmd", 0, KDB_REPEAT_NONE); 2894 kdb_register_repeat("kill", kdb_kill, "<-signal> <pid>", 2895 "Send a signal to a process", 0, KDB_REPEAT_NONE); 2896 kdb_register_repeat("summary", kdb_summary, "", 2897 "Summarize the system", 4, KDB_REPEAT_NONE); 2898 kdb_register_repeat("per_cpu", kdb_per_cpu, "<sym> [<bytes>] [<cpu>]", 2899 "Display per_cpu variables", 3, KDB_REPEAT_NONE); 2900 kdb_register_repeat("grephelp", kdb_grep_help, "", 2901 "Display help on | grep", 0, KDB_REPEAT_NONE); 2902 } 2903 2904 /* Execute any commands defined in kdb_cmds. */ 2905 static void __init kdb_cmd_init(void) 2906 { 2907 int i, diag; 2908 for (i = 0; kdb_cmds[i]; ++i) { 2909 diag = kdb_parse(kdb_cmds[i]); 2910 if (diag) 2911 kdb_printf("kdb command %s failed, kdb diag %d\n", 2912 kdb_cmds[i], diag); 2913 } 2914 if (defcmd_in_progress) { 2915 kdb_printf("Incomplete 'defcmd' set, forcing endefcmd\n"); 2916 kdb_parse("endefcmd"); 2917 } 2918 } 2919 2920 /* Initialize kdb_printf, breakpoint tables and kdb state */ 2921 void __init kdb_init(int lvl) 2922 { 2923 static int kdb_init_lvl = KDB_NOT_INITIALIZED; 2924 int i; 2925 2926 if (kdb_init_lvl == KDB_INIT_FULL || lvl <= kdb_init_lvl) 2927 return; 2928 for (i = kdb_init_lvl; i < lvl; i++) { 2929 switch (i) { 2930 case KDB_NOT_INITIALIZED: 2931 kdb_inittab(); /* Initialize Command Table */ 2932 kdb_initbptab(); /* Initialize Breakpoints */ 2933 break; 2934 case KDB_INIT_EARLY: 2935 kdb_cmd_init(); /* Build kdb_cmds tables */ 2936 break; 2937 } 2938 } 2939 kdb_init_lvl = lvl; 2940 } 2941