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