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