Merge tag 'kgdb-5.15-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/danielt/linux

+17 -10

include/linux/kdb.h

··· 13 13 * Copyright (C) 2009 Jason Wessel <jason.wessel@windriver.com> 14 14 */ 15 15 16 + #include <linux/list.h> 17 + 16 18 /* Shifted versions of the command enable bits are be used if the command 17 19 * has no arguments (see kdb_check_flags). This allows commands, such as 18 20 * go, to have different permissions depending upon whether it is called ··· 65 63 } kdb_cmdflags_t; 66 64 67 65 typedef int (*kdb_func_t)(int, const char **); 66 + 67 + /* The KDB shell command table */ 68 + typedef struct _kdbtab { 69 + char *name; /* Command name */ 70 + kdb_func_t func; /* Function to execute command */ 71 + char *usage; /* Usage String for this command */ 72 + char *help; /* Help message for this command */ 73 + short minlen; /* Minimum legal # cmd chars required */ 74 + kdb_cmdflags_t flags; /* Command behaviour flags */ 75 + struct list_head list_node; /* Command list */ 76 + } kdbtab_t; 68 77 69 78 #ifdef CONFIG_KGDB_KDB 70 79 #include <linux/init.h> ··· 206 193 #endif /* ! CONFIG_KALLSYMS */ 207 194 208 195 /* Dynamic kdb shell command registration */ 209 - extern int kdb_register(char *, kdb_func_t, char *, char *, short); 210 - extern int kdb_register_flags(char *, kdb_func_t, char *, char *, 211 - short, kdb_cmdflags_t); 212 - extern int kdb_unregister(char *); 196 + extern int kdb_register(kdbtab_t *cmd); 197 + extern void kdb_unregister(kdbtab_t *cmd); 213 198 #else /* ! CONFIG_KGDB_KDB */ 214 199 static inline __printf(1, 2) int kdb_printf(const char *fmt, ...) { return 0; } 215 200 static inline void kdb_init(int level) {} 216 - static inline int kdb_register(char *cmd, kdb_func_t func, char *usage, 217 - char *help, short minlen) { return 0; } 218 - static inline int kdb_register_flags(char *cmd, kdb_func_t func, char *usage, 219 - char *help, short minlen, 220 - kdb_cmdflags_t flags) { return 0; } 221 - static inline int kdb_unregister(char *cmd) { return 0; } 201 + static inline int kdb_register(kdbtab_t *cmd) { return 0; } 202 + static inline void kdb_unregister(kdbtab_t *cmd) {} 222 203 #endif /* CONFIG_KGDB_KDB */ 223 204 enum { 224 205 KDB_NOT_INITIALIZED,

+1 -4

kernel/debug/debug_core.c

··· 1 + // SPDX-License-Identifier: GPL-2.0-only 1 2 /* 2 3 * Kernel Debug Core 3 4 * ··· 23 22 * 24 23 * Original KGDB stub: David Grothe <dave@gcom.com>, 25 24 * Tigran Aivazian <tigran@sco.com> 26 - * 27 - * This file is licensed under the terms of the GNU General Public License 28 - * version 2. This program is licensed "as is" without any warranty of any 29 - * kind, whether express or implied. 30 25 */ 31 26 32 27 #define pr_fmt(fmt) "KGDB: " fmt

+1 -4

kernel/debug/gdbstub.c

··· 1 + // SPDX-License-Identifier: GPL-2.0-only 1 2 /* 2 3 * Kernel Debug Core 3 4 * ··· 23 22 * 24 23 * Original KGDB stub: David Grothe <dave@gcom.com>, 25 24 * Tigran Aivazian <tigran@sco.com> 26 - * 27 - * This file is licensed under the terms of the GNU General Public License 28 - * version 2. This program is licensed "as is" without any warranty of any 29 - * kind, whether express or implied. 30 25 */ 31 26 32 27 #include <linux/kernel.h>

+36 -36

kernel/debug/kdb/kdb_bp.c

··· 523 523 } 524 524 525 525 static kdbtab_t bptab[] = { 526 - { .cmd_name = "bp", 527 - .cmd_func = kdb_bp, 528 - .cmd_usage = "[<vaddr>]", 529 - .cmd_help = "Set/Display breakpoints", 530 - .cmd_flags = KDB_ENABLE_FLOW_CTRL | KDB_REPEAT_NO_ARGS, 526 + { .name = "bp", 527 + .func = kdb_bp, 528 + .usage = "[<vaddr>]", 529 + .help = "Set/Display breakpoints", 530 + .flags = KDB_ENABLE_FLOW_CTRL | KDB_REPEAT_NO_ARGS, 531 531 }, 532 - { .cmd_name = "bl", 533 - .cmd_func = kdb_bp, 534 - .cmd_usage = "[<vaddr>]", 535 - .cmd_help = "Display breakpoints", 536 - .cmd_flags = KDB_ENABLE_FLOW_CTRL | KDB_REPEAT_NO_ARGS, 532 + { .name = "bl", 533 + .func = kdb_bp, 534 + .usage = "[<vaddr>]", 535 + .help = "Display breakpoints", 536 + .flags = KDB_ENABLE_FLOW_CTRL | KDB_REPEAT_NO_ARGS, 537 537 }, 538 - { .cmd_name = "bc", 539 - .cmd_func = kdb_bc, 540 - .cmd_usage = "<bpnum>", 541 - .cmd_help = "Clear Breakpoint", 542 - .cmd_flags = KDB_ENABLE_FLOW_CTRL, 538 + { .name = "bc", 539 + .func = kdb_bc, 540 + .usage = "<bpnum>", 541 + .help = "Clear Breakpoint", 542 + .flags = KDB_ENABLE_FLOW_CTRL, 543 543 }, 544 - { .cmd_name = "be", 545 - .cmd_func = kdb_bc, 546 - .cmd_usage = "<bpnum>", 547 - .cmd_help = "Enable Breakpoint", 548 - .cmd_flags = KDB_ENABLE_FLOW_CTRL, 544 + { .name = "be", 545 + .func = kdb_bc, 546 + .usage = "<bpnum>", 547 + .help = "Enable Breakpoint", 548 + .flags = KDB_ENABLE_FLOW_CTRL, 549 549 }, 550 - { .cmd_name = "bd", 551 - .cmd_func = kdb_bc, 552 - .cmd_usage = "<bpnum>", 553 - .cmd_help = "Disable Breakpoint", 554 - .cmd_flags = KDB_ENABLE_FLOW_CTRL, 550 + { .name = "bd", 551 + .func = kdb_bc, 552 + .usage = "<bpnum>", 553 + .help = "Disable Breakpoint", 554 + .flags = KDB_ENABLE_FLOW_CTRL, 555 555 }, 556 - { .cmd_name = "ss", 557 - .cmd_func = kdb_ss, 558 - .cmd_usage = "", 559 - .cmd_help = "Single Step", 560 - .cmd_minlen = 1, 561 - .cmd_flags = KDB_ENABLE_FLOW_CTRL | KDB_REPEAT_NO_ARGS, 556 + { .name = "ss", 557 + .func = kdb_ss, 558 + .usage = "", 559 + .help = "Single Step", 560 + .minlen = 1, 561 + .flags = KDB_ENABLE_FLOW_CTRL | KDB_REPEAT_NO_ARGS, 562 562 }, 563 563 }; 564 564 565 565 static kdbtab_t bphcmd = { 566 - .cmd_name = "bph", 567 - .cmd_func = kdb_bp, 568 - .cmd_usage = "[<vaddr>]", 569 - .cmd_help = "[datar [length]|dataw [length]] Set hw brk", 570 - .cmd_flags = KDB_ENABLE_FLOW_CTRL | KDB_REPEAT_NO_ARGS, 566 + .name = "bph", 567 + .func = kdb_bp, 568 + .usage = "[<vaddr>]", 569 + .help = "[datar [length]|dataw [length]] Set hw brk", 570 + .flags = KDB_ENABLE_FLOW_CTRL | KDB_REPEAT_NO_ARGS, 571 571 }; 572 572 573 573 /* Initialize the breakpoint table and register breakpoint commands. */

-1

kernel/debug/kdb/kdb_debugger.c

··· 140 140 */ 141 141 kdb_common_deinit_state(); 142 142 KDB_STATE_CLEAR(PAGER); 143 - kdbnearsym_cleanup(); 144 143 if (error == KDB_CMD_KGDB) { 145 144 if (KDB_STATE(DOING_KGDB)) 146 145 KDB_STATE_CLEAR(DOING_KGDB);

+286 -340

kernel/debug/kdb/kdb_main.c

··· 33 33 #include <linux/kallsyms.h> 34 34 #include <linux/kgdb.h> 35 35 #include <linux/kdb.h> 36 - #include <linux/list.h> 37 36 #include <linux/notifier.h> 38 37 #include <linux/interrupt.h> 39 38 #include <linux/delay.h> ··· 653 654 * Returns: 654 655 * zero for success, a kdb diagnostic if error 655 656 */ 656 - struct defcmd_set { 657 - int count; 658 - bool usable; 659 - char *name; 660 - char *usage; 661 - char *help; 662 - char **command; 657 + struct kdb_macro { 658 + kdbtab_t cmd; /* Macro command */ 659 + struct list_head statements; /* Associated statement list */ 663 660 }; 664 - static struct defcmd_set *defcmd_set; 665 - static int defcmd_set_count; 661 + 662 + struct kdb_macro_statement { 663 + char *statement; /* Statement text */ 664 + struct list_head list_node; /* Statement list node */ 665 + }; 666 + 667 + static struct kdb_macro *kdb_macro; 666 668 static bool defcmd_in_progress; 667 669 668 670 /* Forward references */ ··· 671 671 672 672 static int kdb_defcmd2(const char *cmdstr, const char *argv0) 673 673 { 674 - struct defcmd_set *s = defcmd_set + defcmd_set_count - 1; 675 - char **save_command = s->command; 674 + struct kdb_macro_statement *kms; 675 + 676 + if (!kdb_macro) 677 + return KDB_NOTIMP; 678 + 676 679 if (strcmp(argv0, "endefcmd") == 0) { 677 680 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); 681 + if (!list_empty(&kdb_macro->statements)) 682 + kdb_register(&kdb_macro->cmd); 688 683 return 0; 689 684 } 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", 685 + 686 + kms = kmalloc(sizeof(*kms), GFP_KDB); 687 + if (!kms) { 688 + kdb_printf("Could not allocate new kdb macro command: %s\n", 695 689 cmdstr); 696 - s->usable = false; 697 690 return KDB_NOTIMP; 698 691 } 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); 692 + 693 + kms->statement = kdb_strdup(cmdstr, GFP_KDB); 694 + list_add_tail(&kms->list_node, &kdb_macro->statements); 695 + 702 696 return 0; 703 697 } 704 698 705 699 static int kdb_defcmd(int argc, const char **argv) 706 700 { 707 - struct defcmd_set *save_defcmd_set = defcmd_set, *s; 701 + kdbtab_t *mp; 702 + 708 703 if (defcmd_in_progress) { 709 704 kdb_printf("kdb: nested defcmd detected, assuming missing " 710 705 "endefcmd\n"); 711 706 kdb_defcmd2("endefcmd", "endefcmd"); 712 707 } 713 708 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"); 709 + kdbtab_t *kp; 710 + struct kdb_macro *kmp; 711 + struct kdb_macro_statement *kms; 712 + 713 + list_for_each_entry(kp, &kdb_cmds_head, list_node) { 714 + if (kp->func == kdb_exec_defcmd) { 715 + kdb_printf("defcmd %s \"%s\" \"%s\"\n", 716 + kp->name, kp->usage, kp->help); 717 + kmp = container_of(kp, struct kdb_macro, cmd); 718 + list_for_each_entry(kms, &kmp->statements, 719 + list_node) 720 + kdb_printf("%s", kms->statement); 721 + kdb_printf("endefcmd\n"); 722 + } 721 723 } 722 724 return 0; 723 725 } ··· 729 727 kdb_printf("Command only available during kdb_init()\n"); 730 728 return KDB_NOTIMP; 731 729 } 732 - defcmd_set = kmalloc_array(defcmd_set_count + 1, sizeof(*defcmd_set), 733 - GFP_KDB); 734 - if (!defcmd_set) 730 + kdb_macro = kzalloc(sizeof(*kdb_macro), GFP_KDB); 731 + if (!kdb_macro) 735 732 goto fail_defcmd; 736 - memcpy(defcmd_set, save_defcmd_set, 737 - defcmd_set_count * sizeof(*defcmd_set)); 738 - s = defcmd_set + defcmd_set_count; 739 - memset(s, 0, sizeof(*s)); 740 - s->usable = true; 741 - s->name = kdb_strdup(argv[1], GFP_KDB); 742 - if (!s->name) 733 + 734 + mp = &kdb_macro->cmd; 735 + mp->func = kdb_exec_defcmd; 736 + mp->minlen = 0; 737 + mp->flags = KDB_ENABLE_ALWAYS_SAFE; 738 + mp->name = kdb_strdup(argv[1], GFP_KDB); 739 + if (!mp->name) 743 740 goto fail_name; 744 - s->usage = kdb_strdup(argv[2], GFP_KDB); 745 - if (!s->usage) 741 + mp->usage = kdb_strdup(argv[2], GFP_KDB); 742 + if (!mp->usage) 746 743 goto fail_usage; 747 - s->help = kdb_strdup(argv[3], GFP_KDB); 748 - if (!s->help) 744 + mp->help = kdb_strdup(argv[3], GFP_KDB); 745 + if (!mp->help) 749 746 goto fail_help; 750 - if (s->usage[0] == '"') { 751 - strcpy(s->usage, argv[2]+1); 752 - s->usage[strlen(s->usage)-1] = '\0'; 747 + if (mp->usage[0] == '"') { 748 + strcpy(mp->usage, argv[2]+1); 749 + mp->usage[strlen(mp->usage)-1] = '\0'; 753 750 } 754 - if (s->help[0] == '"') { 755 - strcpy(s->help, argv[3]+1); 756 - s->help[strlen(s->help)-1] = '\0'; 751 + if (mp->help[0] == '"') { 752 + strcpy(mp->help, argv[3]+1); 753 + mp->help[strlen(mp->help)-1] = '\0'; 757 754 } 758 - ++defcmd_set_count; 755 + 756 + INIT_LIST_HEAD(&kdb_macro->statements); 759 757 defcmd_in_progress = true; 760 - kfree(save_defcmd_set); 761 758 return 0; 762 759 fail_help: 763 - kfree(s->usage); 760 + kfree(mp->usage); 764 761 fail_usage: 765 - kfree(s->name); 762 + kfree(mp->name); 766 763 fail_name: 767 - kfree(defcmd_set); 764 + kfree(kdb_macro); 768 765 fail_defcmd: 769 - kdb_printf("Could not allocate new defcmd_set entry for %s\n", argv[1]); 770 - defcmd_set = save_defcmd_set; 766 + kdb_printf("Could not allocate new kdb_macro entry for %s\n", argv[1]); 771 767 return KDB_NOTIMP; 772 768 } 773 769 ··· 780 780 */ 781 781 static int kdb_exec_defcmd(int argc, const char **argv) 782 782 { 783 - int i, ret; 784 - struct defcmd_set *s; 783 + int ret; 784 + kdbtab_t *kp; 785 + struct kdb_macro *kmp; 786 + struct kdb_macro_statement *kms; 787 + 785 788 if (argc != 0) 786 789 return KDB_ARGCOUNT; 787 - for (s = defcmd_set, i = 0; i < defcmd_set_count; ++i, ++s) { 788 - if (strcmp(s->name, argv[0]) == 0) 790 + 791 + list_for_each_entry(kp, &kdb_cmds_head, list_node) { 792 + if (strcmp(kp->name, argv[0]) == 0) 789 793 break; 790 794 } 791 - if (i == defcmd_set_count) { 795 + if (list_entry_is_head(kp, &kdb_cmds_head, list_node)) { 792 796 kdb_printf("kdb_exec_defcmd: could not find commands for %s\n", 793 797 argv[0]); 794 798 return KDB_NOTIMP; 795 799 } 796 - for (i = 0; i < s->count; ++i) { 797 - /* Recursive use of kdb_parse, do not use argv after 798 - * this point */ 800 + kmp = container_of(kp, struct kdb_macro, cmd); 801 + list_for_each_entry(kms, &kmp->statements, list_node) { 802 + /* 803 + * Recursive use of kdb_parse, do not use argv after this point. 804 + */ 799 805 argv = NULL; 800 - kdb_printf("[%s]kdb> %s\n", s->name, s->command[i]); 801 - ret = kdb_parse(s->command[i]); 806 + kdb_printf("[%s]kdb> %s\n", kmp->cmd.name, kms->statement); 807 + ret = kdb_parse(kms->statement); 802 808 if (ret) 803 809 return ret; 804 810 } ··· 1015 1009 * If this command is allowed to be abbreviated, 1016 1010 * check to see if this is it. 1017 1011 */ 1018 - if (tp->cmd_minlen && (strlen(argv[0]) <= tp->cmd_minlen) && 1019 - (strncmp(argv[0], tp->cmd_name, tp->cmd_minlen) == 0)) 1012 + if (tp->minlen && (strlen(argv[0]) <= tp->minlen) && 1013 + (strncmp(argv[0], tp->name, tp->minlen) == 0)) 1020 1014 break; 1021 1015 1022 - if (strcmp(argv[0], tp->cmd_name) == 0) 1016 + if (strcmp(argv[0], tp->name) == 0) 1023 1017 break; 1024 1018 } 1025 1019 ··· 1030 1024 */ 1031 1025 if (list_entry_is_head(tp, &kdb_cmds_head, list_node)) { 1032 1026 list_for_each_entry(tp, &kdb_cmds_head, list_node) { 1033 - if (strncmp(argv[0], tp->cmd_name, 1034 - strlen(tp->cmd_name)) == 0) 1027 + if (strncmp(argv[0], tp->name, strlen(tp->name)) == 0) 1035 1028 break; 1036 1029 } 1037 1030 } ··· 1038 1033 if (!list_entry_is_head(tp, &kdb_cmds_head, list_node)) { 1039 1034 int result; 1040 1035 1041 - if (!kdb_check_flags(tp->cmd_flags, kdb_cmd_enabled, argc <= 1)) 1036 + if (!kdb_check_flags(tp->flags, kdb_cmd_enabled, argc <= 1)) 1042 1037 return KDB_NOPERM; 1043 1038 1044 1039 KDB_STATE_SET(CMD); 1045 - result = (*tp->cmd_func)(argc-1, (const char **)argv); 1040 + result = (*tp->func)(argc-1, (const char **)argv); 1046 1041 if (result && ignore_errors && result > KDB_CMD_GO) 1047 1042 result = 0; 1048 1043 KDB_STATE_CLEAR(CMD); 1049 1044 1050 - if (tp->cmd_flags & KDB_REPEAT_WITH_ARGS) 1045 + if (tp->flags & KDB_REPEAT_WITH_ARGS) 1051 1046 return result; 1052 1047 1053 - argc = tp->cmd_flags & KDB_REPEAT_NO_ARGS ? 1 : 0; 1048 + argc = tp->flags & KDB_REPEAT_NO_ARGS ? 1 : 0; 1054 1049 if (argv[argc]) 1055 1050 *(argv[argc]) = '\0'; 1056 1051 return result; ··· 2417 2412 char *space = ""; 2418 2413 if (KDB_FLAG(CMD_INTERRUPT)) 2419 2414 return 0; 2420 - if (!kdb_check_flags(kt->cmd_flags, kdb_cmd_enabled, true)) 2415 + if (!kdb_check_flags(kt->flags, kdb_cmd_enabled, true)) 2421 2416 continue; 2422 - if (strlen(kt->cmd_usage) > 20) 2417 + if (strlen(kt->usage) > 20) 2423 2418 space = "\n "; 2424 - kdb_printf("%-15.15s %-20s%s%s\n", kt->cmd_name, 2425 - kt->cmd_usage, space, kt->cmd_help); 2419 + kdb_printf("%-15.15s %-20s%s%s\n", kt->name, 2420 + kt->usage, space, kt->help); 2426 2421 } 2427 2422 return 0; 2428 2423 } ··· 2618 2613 return 0; 2619 2614 } 2620 2615 2621 - /* 2622 - * kdb_register_flags - This function is used to register a kernel 2623 - * debugger command. 2624 - * Inputs: 2625 - * cmd Command name 2626 - * func Function to execute the command 2627 - * usage A simple usage string showing arguments 2628 - * help A simple help string describing command 2629 - * repeat Does the command auto repeat on enter? 2630 - * Returns: 2631 - * zero for success, one if a duplicate command. 2616 + /** 2617 + * kdb_register() - This function is used to register a kernel debugger 2618 + * command. 2619 + * @cmd: pointer to kdb command 2620 + * 2621 + * Note that it's the job of the caller to keep the memory for the cmd 2622 + * allocated until unregister is called. 2632 2623 */ 2633 - int kdb_register_flags(char *cmd, 2634 - kdb_func_t func, 2635 - char *usage, 2636 - char *help, 2637 - short minlen, 2638 - kdb_cmdflags_t flags) 2624 + int kdb_register(kdbtab_t *cmd) 2639 2625 { 2640 2626 kdbtab_t *kp; 2641 2627 2642 2628 list_for_each_entry(kp, &kdb_cmds_head, list_node) { 2643 - if (strcmp(kp->cmd_name, cmd) == 0) { 2644 - kdb_printf("Duplicate kdb command registered: " 2645 - "%s, func %px help %s\n", cmd, func, help); 2629 + if (strcmp(kp->name, cmd->name) == 0) { 2630 + kdb_printf("Duplicate kdb cmd: %s, func %p help %s\n", 2631 + cmd->name, cmd->func, cmd->help); 2646 2632 return 1; 2647 2633 } 2648 2634 } 2649 2635 2650 - kp = kmalloc(sizeof(*kp), GFP_KDB); 2651 - if (!kp) { 2652 - kdb_printf("Could not allocate new kdb_command table\n"); 2653 - return 1; 2654 - } 2655 - 2656 - kp->cmd_name = cmd; 2657 - kp->cmd_func = func; 2658 - kp->cmd_usage = usage; 2659 - kp->cmd_help = help; 2660 - kp->cmd_minlen = minlen; 2661 - kp->cmd_flags = flags; 2662 - kp->is_dynamic = true; 2663 - 2664 - list_add_tail(&kp->list_node, &kdb_cmds_head); 2665 - 2636 + list_add_tail(&cmd->list_node, &kdb_cmds_head); 2666 2637 return 0; 2667 2638 } 2668 - EXPORT_SYMBOL_GPL(kdb_register_flags); 2639 + EXPORT_SYMBOL_GPL(kdb_register); 2669 2640 2670 - /* 2641 + /** 2671 2642 * kdb_register_table() - This function is used to register a kdb command 2672 2643 * table. 2673 2644 * @kp: pointer to kdb command table ··· 2657 2676 } 2658 2677 } 2659 2678 2660 - /* 2661 - * kdb_register - Compatibility register function for commands that do 2662 - * not need to specify a repeat state. Equivalent to 2663 - * kdb_register_flags with flags set to 0. 2664 - * Inputs: 2665 - * cmd Command name 2666 - * func Function to execute the command 2667 - * usage A simple usage string showing arguments 2668 - * help A simple help string describing command 2669 - * Returns: 2670 - * zero for success, one if a duplicate command. 2679 + /** 2680 + * kdb_unregister() - This function is used to unregister a kernel debugger 2681 + * command. It is generally called when a module which 2682 + * implements kdb command is unloaded. 2683 + * @cmd: pointer to kdb command 2671 2684 */ 2672 - int kdb_register(char *cmd, 2673 - kdb_func_t func, 2674 - char *usage, 2675 - char *help, 2676 - short minlen) 2685 + void kdb_unregister(kdbtab_t *cmd) 2677 2686 { 2678 - return kdb_register_flags(cmd, func, usage, help, minlen, 0); 2679 - } 2680 - EXPORT_SYMBOL_GPL(kdb_register); 2681 - 2682 - /* 2683 - * kdb_unregister - This function is used to unregister a kernel 2684 - * debugger command. It is generally called when a module which 2685 - * implements kdb commands is unloaded. 2686 - * Inputs: 2687 - * cmd Command name 2688 - * Returns: 2689 - * zero for success, one command not registered. 2690 - */ 2691 - int kdb_unregister(char *cmd) 2692 - { 2693 - kdbtab_t *kp; 2694 - 2695 - /* 2696 - * find the command. 2697 - */ 2698 - list_for_each_entry(kp, &kdb_cmds_head, list_node) { 2699 - if (strcmp(kp->cmd_name, cmd) == 0) { 2700 - list_del(&kp->list_node); 2701 - if (kp->is_dynamic) 2702 - kfree(kp); 2703 - return 0; 2704 - } 2705 - } 2706 - 2707 - /* Couldn't find it. */ 2708 - return 1; 2687 + list_del(&cmd->list_node); 2709 2688 } 2710 2689 EXPORT_SYMBOL_GPL(kdb_unregister); 2711 2690 2712 2691 static kdbtab_t maintab[] = { 2713 - { .cmd_name = "md", 2714 - .cmd_func = kdb_md, 2715 - .cmd_usage = "<vaddr>", 2716 - .cmd_help = "Display Memory Contents, also mdWcN, e.g. md8c1", 2717 - .cmd_minlen = 1, 2718 - .cmd_flags = KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS, 2692 + { .name = "md", 2693 + .func = kdb_md, 2694 + .usage = "<vaddr>", 2695 + .help = "Display Memory Contents, also mdWcN, e.g. md8c1", 2696 + .minlen = 1, 2697 + .flags = KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS, 2719 2698 }, 2720 - { .cmd_name = "mdr", 2721 - .cmd_func = kdb_md, 2722 - .cmd_usage = "<vaddr> <bytes>", 2723 - .cmd_help = "Display Raw Memory", 2724 - .cmd_flags = KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS, 2699 + { .name = "mdr", 2700 + .func = kdb_md, 2701 + .usage = "<vaddr> <bytes>", 2702 + .help = "Display Raw Memory", 2703 + .flags = KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS, 2725 2704 }, 2726 - { .cmd_name = "mdp", 2727 - .cmd_func = kdb_md, 2728 - .cmd_usage = "<paddr> <bytes>", 2729 - .cmd_help = "Display Physical Memory", 2730 - .cmd_flags = KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS, 2705 + { .name = "mdp", 2706 + .func = kdb_md, 2707 + .usage = "<paddr> <bytes>", 2708 + .help = "Display Physical Memory", 2709 + .flags = KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS, 2731 2710 }, 2732 - { .cmd_name = "mds", 2733 - .cmd_func = kdb_md, 2734 - .cmd_usage = "<vaddr>", 2735 - .cmd_help = "Display Memory Symbolically", 2736 - .cmd_flags = KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS, 2711 + { .name = "mds", 2712 + .func = kdb_md, 2713 + .usage = "<vaddr>", 2714 + .help = "Display Memory Symbolically", 2715 + .flags = KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS, 2737 2716 }, 2738 - { .cmd_name = "mm", 2739 - .cmd_func = kdb_mm, 2740 - .cmd_usage = "<vaddr> <contents>", 2741 - .cmd_help = "Modify Memory Contents", 2742 - .cmd_flags = KDB_ENABLE_MEM_WRITE | KDB_REPEAT_NO_ARGS, 2717 + { .name = "mm", 2718 + .func = kdb_mm, 2719 + .usage = "<vaddr> <contents>", 2720 + .help = "Modify Memory Contents", 2721 + .flags = KDB_ENABLE_MEM_WRITE | KDB_REPEAT_NO_ARGS, 2743 2722 }, 2744 - { .cmd_name = "go", 2745 - .cmd_func = kdb_go, 2746 - .cmd_usage = "[<vaddr>]", 2747 - .cmd_help = "Continue Execution", 2748 - .cmd_minlen = 1, 2749 - .cmd_flags = KDB_ENABLE_REG_WRITE | 2723 + { .name = "go", 2724 + .func = kdb_go, 2725 + .usage = "[<vaddr>]", 2726 + .help = "Continue Execution", 2727 + .minlen = 1, 2728 + .flags = KDB_ENABLE_REG_WRITE | 2750 2729 KDB_ENABLE_ALWAYS_SAFE_NO_ARGS, 2751 2730 }, 2752 - { .cmd_name = "rd", 2753 - .cmd_func = kdb_rd, 2754 - .cmd_usage = "", 2755 - .cmd_help = "Display Registers", 2756 - .cmd_flags = KDB_ENABLE_REG_READ, 2731 + { .name = "rd", 2732 + .func = kdb_rd, 2733 + .usage = "", 2734 + .help = "Display Registers", 2735 + .flags = KDB_ENABLE_REG_READ, 2757 2736 }, 2758 - { .cmd_name = "rm", 2759 - .cmd_func = kdb_rm, 2760 - .cmd_usage = "<reg> <contents>", 2761 - .cmd_help = "Modify Registers", 2762 - .cmd_flags = KDB_ENABLE_REG_WRITE, 2737 + { .name = "rm", 2738 + .func = kdb_rm, 2739 + .usage = "<reg> <contents>", 2740 + .help = "Modify Registers", 2741 + .flags = KDB_ENABLE_REG_WRITE, 2763 2742 }, 2764 - { .cmd_name = "ef", 2765 - .cmd_func = kdb_ef, 2766 - .cmd_usage = "<vaddr>", 2767 - .cmd_help = "Display exception frame", 2768 - .cmd_flags = KDB_ENABLE_MEM_READ, 2743 + { .name = "ef", 2744 + .func = kdb_ef, 2745 + .usage = "<vaddr>", 2746 + .help = "Display exception frame", 2747 + .flags = KDB_ENABLE_MEM_READ, 2769 2748 }, 2770 - { .cmd_name = "bt", 2771 - .cmd_func = kdb_bt, 2772 - .cmd_usage = "[<vaddr>]", 2773 - .cmd_help = "Stack traceback", 2774 - .cmd_minlen = 1, 2775 - .cmd_flags = KDB_ENABLE_MEM_READ | KDB_ENABLE_INSPECT_NO_ARGS, 2749 + { .name = "bt", 2750 + .func = kdb_bt, 2751 + .usage = "[<vaddr>]", 2752 + .help = "Stack traceback", 2753 + .minlen = 1, 2754 + .flags = KDB_ENABLE_MEM_READ | KDB_ENABLE_INSPECT_NO_ARGS, 2776 2755 }, 2777 - { .cmd_name = "btp", 2778 - .cmd_func = kdb_bt, 2779 - .cmd_usage = "<pid>", 2780 - .cmd_help = "Display stack for process <pid>", 2781 - .cmd_flags = KDB_ENABLE_INSPECT, 2756 + { .name = "btp", 2757 + .func = kdb_bt, 2758 + .usage = "<pid>", 2759 + .help = "Display stack for process <pid>", 2760 + .flags = KDB_ENABLE_INSPECT, 2782 2761 }, 2783 - { .cmd_name = "bta", 2784 - .cmd_func = kdb_bt, 2785 - .cmd_usage = "[D|R|S|T|C|Z|E|U|I|M|A]", 2786 - .cmd_help = "Backtrace all processes matching state flag", 2787 - .cmd_flags = KDB_ENABLE_INSPECT, 2762 + { .name = "bta", 2763 + .func = kdb_bt, 2764 + .usage = "[D|R|S|T|C|Z|E|U|I|M|A]", 2765 + .help = "Backtrace all processes matching state flag", 2766 + .flags = KDB_ENABLE_INSPECT, 2788 2767 }, 2789 - { .cmd_name = "btc", 2790 - .cmd_func = kdb_bt, 2791 - .cmd_usage = "", 2792 - .cmd_help = "Backtrace current process on each cpu", 2793 - .cmd_flags = KDB_ENABLE_INSPECT, 2768 + { .name = "btc", 2769 + .func = kdb_bt, 2770 + .usage = "", 2771 + .help = "Backtrace current process on each cpu", 2772 + .flags = KDB_ENABLE_INSPECT, 2794 2773 }, 2795 - { .cmd_name = "btt", 2796 - .cmd_func = kdb_bt, 2797 - .cmd_usage = "<vaddr>", 2798 - .cmd_help = "Backtrace process given its struct task address", 2799 - .cmd_flags = KDB_ENABLE_MEM_READ | KDB_ENABLE_INSPECT_NO_ARGS, 2774 + { .name = "btt", 2775 + .func = kdb_bt, 2776 + .usage = "<vaddr>", 2777 + .help = "Backtrace process given its struct task address", 2778 + .flags = KDB_ENABLE_MEM_READ | KDB_ENABLE_INSPECT_NO_ARGS, 2800 2779 }, 2801 - { .cmd_name = "env", 2802 - .cmd_func = kdb_env, 2803 - .cmd_usage = "", 2804 - .cmd_help = "Show environment variables", 2805 - .cmd_flags = KDB_ENABLE_ALWAYS_SAFE, 2780 + { .name = "env", 2781 + .func = kdb_env, 2782 + .usage = "", 2783 + .help = "Show environment variables", 2784 + .flags = KDB_ENABLE_ALWAYS_SAFE, 2806 2785 }, 2807 - { .cmd_name = "set", 2808 - .cmd_func = kdb_set, 2809 - .cmd_usage = "", 2810 - .cmd_help = "Set environment variables", 2811 - .cmd_flags = KDB_ENABLE_ALWAYS_SAFE, 2786 + { .name = "set", 2787 + .func = kdb_set, 2788 + .usage = "", 2789 + .help = "Set environment variables", 2790 + .flags = KDB_ENABLE_ALWAYS_SAFE, 2812 2791 }, 2813 - { .cmd_name = "help", 2814 - .cmd_func = kdb_help, 2815 - .cmd_usage = "", 2816 - .cmd_help = "Display Help Message", 2817 - .cmd_minlen = 1, 2818 - .cmd_flags = KDB_ENABLE_ALWAYS_SAFE, 2792 + { .name = "help", 2793 + .func = kdb_help, 2794 + .usage = "", 2795 + .help = "Display Help Message", 2796 + .minlen = 1, 2797 + .flags = KDB_ENABLE_ALWAYS_SAFE, 2819 2798 }, 2820 - { .cmd_name = "?", 2821 - .cmd_func = kdb_help, 2822 - .cmd_usage = "", 2823 - .cmd_help = "Display Help Message", 2824 - .cmd_flags = KDB_ENABLE_ALWAYS_SAFE, 2799 + { .name = "?", 2800 + .func = kdb_help, 2801 + .usage = "", 2802 + .help = "Display Help Message", 2803 + .flags = KDB_ENABLE_ALWAYS_SAFE, 2825 2804 }, 2826 - { .cmd_name = "cpu", 2827 - .cmd_func = kdb_cpu, 2828 - .cmd_usage = "<cpunum>", 2829 - .cmd_help = "Switch to new cpu", 2830 - .cmd_flags = KDB_ENABLE_ALWAYS_SAFE_NO_ARGS, 2805 + { .name = "cpu", 2806 + .func = kdb_cpu, 2807 + .usage = "<cpunum>", 2808 + .help = "Switch to new cpu", 2809 + .flags = KDB_ENABLE_ALWAYS_SAFE_NO_ARGS, 2831 2810 }, 2832 - { .cmd_name = "kgdb", 2833 - .cmd_func = kdb_kgdb, 2834 - .cmd_usage = "", 2835 - .cmd_help = "Enter kgdb mode", 2836 - .cmd_flags = 0, 2811 + { .name = "kgdb", 2812 + .func = kdb_kgdb, 2813 + .usage = "", 2814 + .help = "Enter kgdb mode", 2815 + .flags = 0, 2837 2816 }, 2838 - { .cmd_name = "ps", 2839 - .cmd_func = kdb_ps, 2840 - .cmd_usage = "[<flags>|A]", 2841 - .cmd_help = "Display active task list", 2842 - .cmd_flags = KDB_ENABLE_INSPECT, 2817 + { .name = "ps", 2818 + .func = kdb_ps, 2819 + .usage = "[<flags>|A]", 2820 + .help = "Display active task list", 2821 + .flags = KDB_ENABLE_INSPECT, 2843 2822 }, 2844 - { .cmd_name = "pid", 2845 - .cmd_func = kdb_pid, 2846 - .cmd_usage = "<pidnum>", 2847 - .cmd_help = "Switch to another task", 2848 - .cmd_flags = KDB_ENABLE_INSPECT, 2823 + { .name = "pid", 2824 + .func = kdb_pid, 2825 + .usage = "<pidnum>", 2826 + .help = "Switch to another task", 2827 + .flags = KDB_ENABLE_INSPECT, 2849 2828 }, 2850 - { .cmd_name = "reboot", 2851 - .cmd_func = kdb_reboot, 2852 - .cmd_usage = "", 2853 - .cmd_help = "Reboot the machine immediately", 2854 - .cmd_flags = KDB_ENABLE_REBOOT, 2829 + { .name = "reboot", 2830 + .func = kdb_reboot, 2831 + .usage = "", 2832 + .help = "Reboot the machine immediately", 2833 + .flags = KDB_ENABLE_REBOOT, 2855 2834 }, 2856 2835 #if defined(CONFIG_MODULES) 2857 - { .cmd_name = "lsmod", 2858 - .cmd_func = kdb_lsmod, 2859 - .cmd_usage = "", 2860 - .cmd_help = "List loaded kernel modules", 2861 - .cmd_flags = KDB_ENABLE_INSPECT, 2836 + { .name = "lsmod", 2837 + .func = kdb_lsmod, 2838 + .usage = "", 2839 + .help = "List loaded kernel modules", 2840 + .flags = KDB_ENABLE_INSPECT, 2862 2841 }, 2863 2842 #endif 2864 2843 #if defined(CONFIG_MAGIC_SYSRQ) 2865 - { .cmd_name = "sr", 2866 - .cmd_func = kdb_sr, 2867 - .cmd_usage = "<key>", 2868 - .cmd_help = "Magic SysRq key", 2869 - .cmd_flags = KDB_ENABLE_ALWAYS_SAFE, 2844 + { .name = "sr", 2845 + .func = kdb_sr, 2846 + .usage = "<key>", 2847 + .help = "Magic SysRq key", 2848 + .flags = KDB_ENABLE_ALWAYS_SAFE, 2870 2849 }, 2871 2850 #endif 2872 2851 #if defined(CONFIG_PRINTK) 2873 - { .cmd_name = "dmesg", 2874 - .cmd_func = kdb_dmesg, 2875 - .cmd_usage = "[lines]", 2876 - .cmd_help = "Display syslog buffer", 2877 - .cmd_flags = KDB_ENABLE_ALWAYS_SAFE, 2852 + { .name = "dmesg", 2853 + .func = kdb_dmesg, 2854 + .usage = "[lines]", 2855 + .help = "Display syslog buffer", 2856 + .flags = KDB_ENABLE_ALWAYS_SAFE, 2878 2857 }, 2879 2858 #endif 2880 - { .cmd_name = "defcmd", 2881 - .cmd_func = kdb_defcmd, 2882 - .cmd_usage = "name \"usage\" \"help\"", 2883 - .cmd_help = "Define a set of commands, down to endefcmd", 2884 - .cmd_flags = KDB_ENABLE_ALWAYS_SAFE, 2859 + { .name = "defcmd", 2860 + .func = kdb_defcmd, 2861 + .usage = "name \"usage\" \"help\"", 2862 + .help = "Define a set of commands, down to endefcmd", 2863 + /* 2864 + * Macros are always safe because when executed each 2865 + * internal command re-enters kdb_parse() and is safety 2866 + * checked individually. 2867 + */ 2868 + .flags = KDB_ENABLE_ALWAYS_SAFE, 2885 2869 }, 2886 - { .cmd_name = "kill", 2887 - .cmd_func = kdb_kill, 2888 - .cmd_usage = "<-signal> <pid>", 2889 - .cmd_help = "Send a signal to a process", 2890 - .cmd_flags = KDB_ENABLE_SIGNAL, 2870 + { .name = "kill", 2871 + .func = kdb_kill, 2872 + .usage = "<-signal> <pid>", 2873 + .help = "Send a signal to a process", 2874 + .flags = KDB_ENABLE_SIGNAL, 2891 2875 }, 2892 - { .cmd_name = "summary", 2893 - .cmd_func = kdb_summary, 2894 - .cmd_usage = "", 2895 - .cmd_help = "Summarize the system", 2896 - .cmd_minlen = 4, 2897 - .cmd_flags = KDB_ENABLE_ALWAYS_SAFE, 2876 + { .name = "summary", 2877 + .func = kdb_summary, 2878 + .usage = "", 2879 + .help = "Summarize the system", 2880 + .minlen = 4, 2881 + .flags = KDB_ENABLE_ALWAYS_SAFE, 2898 2882 }, 2899 - { .cmd_name = "per_cpu", 2900 - .cmd_func = kdb_per_cpu, 2901 - .cmd_usage = "<sym> [<bytes>] [<cpu>]", 2902 - .cmd_help = "Display per_cpu variables", 2903 - .cmd_minlen = 3, 2904 - .cmd_flags = KDB_ENABLE_MEM_READ, 2883 + { .name = "per_cpu", 2884 + .func = kdb_per_cpu, 2885 + .usage = "<sym> [<bytes>] [<cpu>]", 2886 + .help = "Display per_cpu variables", 2887 + .minlen = 3, 2888 + .flags = KDB_ENABLE_MEM_READ, 2905 2889 }, 2906 - { .cmd_name = "grephelp", 2907 - .cmd_func = kdb_grep_help, 2908 - .cmd_usage = "", 2909 - .cmd_help = "Display help on | grep", 2910 - .cmd_flags = KDB_ENABLE_ALWAYS_SAFE, 2890 + { .name = "grephelp", 2891 + .func = kdb_grep_help, 2892 + .usage = "", 2893 + .help = "Display help on | grep", 2894 + .flags = KDB_ENABLE_ALWAYS_SAFE, 2911 2895 }, 2912 2896 }; 2913 2897 2914 2898 static kdbtab_t nmicmd = { 2915 - .cmd_name = "disable_nmi", 2916 - .cmd_func = kdb_disable_nmi, 2917 - .cmd_usage = "", 2918 - .cmd_help = "Disable NMI entry to KDB", 2919 - .cmd_flags = KDB_ENABLE_ALWAYS_SAFE, 2899 + .name = "disable_nmi", 2900 + .func = kdb_disable_nmi, 2901 + .usage = "", 2902 + .help = "Disable NMI entry to KDB", 2903 + .flags = KDB_ENABLE_ALWAYS_SAFE, 2920 2904 }; 2921 2905 2922 2906 /* Initialize the kdb command table. */

-18

kernel/debug/kdb/kdb_private.h

··· 109 109 long *, char **); 110 110 extern int kdbgetsymval(const char *, kdb_symtab_t *); 111 111 extern int kdbnearsym(unsigned long, kdb_symtab_t *); 112 - extern void kdbnearsym_cleanup(void); 113 112 extern char *kdb_strdup(const char *str, gfp_t type); 114 113 extern void kdb_symbol_print(unsigned long, const kdb_symtab_t *, unsigned int); 115 114 ··· 164 165 #ifdef CONFIG_KGDB_KDB 165 166 extern kdb_bp_t kdb_breakpoints[/* KDB_MAXBPT */]; 166 167 167 - /* The KDB shell command table */ 168 - typedef struct _kdbtab { 169 - char *cmd_name; /* Command name */ 170 - kdb_func_t cmd_func; /* Function to execute command */ 171 - char *cmd_usage; /* Usage String for this command */ 172 - char *cmd_help; /* Help message for this command */ 173 - short cmd_minlen; /* Minimum legal # command 174 - * chars required */ 175 - kdb_cmdflags_t cmd_flags; /* Command behaviour flags */ 176 - struct list_head list_node; /* Command list */ 177 - bool is_dynamic; /* Command table allocation type */ 178 - } kdbtab_t; 179 - 180 168 extern void kdb_register_table(kdbtab_t *kp, size_t len); 181 169 extern int kdb_bt(int, const char **); /* KDB display back trace */ 182 170 ··· 218 232 #define kdb_task_has_cpu(p) (task_curr(p)) 219 233 220 234 #define GFP_KDB (in_dbg_master() ? GFP_ATOMIC : GFP_KERNEL) 221 - 222 - extern void *debug_kmalloc(size_t size, gfp_t flags); 223 - extern void debug_kfree(void *); 224 - extern void debug_kusage(void); 225 235 226 236 extern struct task_struct *kdb_current_task; 227 237 extern struct pt_regs *kdb_current_regs;

+28 -301

kernel/debug/kdb/kdb_support.c

··· 51 51 } 52 52 EXPORT_SYMBOL(kdbgetsymval); 53 53 54 - static char *kdb_name_table[100]; /* arbitrary size */ 55 - 56 - /* 57 - * kdbnearsym - Return the name of the symbol with the nearest address 58 - * less than 'addr'. 54 + /** 55 + * kdbnearsym() - Return the name of the symbol with the nearest address 56 + * less than @addr. 57 + * @addr: Address to check for near symbol 58 + * @symtab: Structure to receive results 59 59 * 60 - * Parameters: 61 - * addr Address to check for symbol near 62 - * symtab Structure to receive results 63 - * Returns: 64 - * 0 No sections contain this address, symtab zero filled 65 - * 1 Address mapped to module/symbol/section, data in symtab 66 - * Remarks: 67 - * 2.6 kallsyms has a "feature" where it unpacks the name into a 68 - * string. If that string is reused before the caller expects it 69 - * then the caller sees its string change without warning. To 70 - * avoid cluttering up the main kdb code with lots of kdb_strdup, 71 - * tests and kfree calls, kdbnearsym maintains an LRU list of the 72 - * last few unique strings. The list is sized large enough to 73 - * hold active strings, no kdb caller of kdbnearsym makes more 74 - * than ~20 later calls before using a saved value. 60 + * WARNING: This function may return a pointer to a single statically 61 + * allocated buffer (namebuf). kdb's unusual calling context (single 62 + * threaded, all other CPUs halted) provides us sufficient locking for 63 + * this to be safe. The only constraint imposed by the static buffer is 64 + * that the caller must consume any previous reply prior to another call 65 + * to lookup a new symbol. 66 + * 67 + * Note that, strictly speaking, some architectures may re-enter the kdb 68 + * trap if the system turns out to be very badly damaged and this breaks 69 + * the single-threaded assumption above. In these circumstances successful 70 + * continuation and exit from the inner trap is unlikely to work and any 71 + * user attempting this receives a prominent warning before being allowed 72 + * to progress. In these circumstances we remain memory safe because 73 + * namebuf[KSYM_NAME_LEN-1] will never change from '\0' although we do 74 + * tolerate the possibility of garbled symbol display from the outer kdb 75 + * trap. 76 + * 77 + * Return: 78 + * * 0 - No sections contain this address, symtab zero filled 79 + * * 1 - Address mapped to module/symbol/section, data in symtab 75 80 */ 76 81 int kdbnearsym(unsigned long addr, kdb_symtab_t *symtab) 77 82 { 78 83 int ret = 0; 79 84 unsigned long symbolsize = 0; 80 85 unsigned long offset = 0; 81 - #define knt1_size 128 /* must be >= kallsyms table size */ 82 - char *knt1 = NULL; 86 + static char namebuf[KSYM_NAME_LEN]; 83 87 84 88 kdb_dbg_printf(AR, "addr=0x%lx, symtab=%px\n", addr, symtab); 85 89 memset(symtab, 0, sizeof(*symtab)); 86 90 87 91 if (addr < 4096) 88 92 goto out; 89 - knt1 = debug_kmalloc(knt1_size, GFP_ATOMIC); 90 - if (!knt1) { 91 - kdb_func_printf("addr=0x%lx cannot kmalloc knt1\n", addr); 92 - goto out; 93 - } 93 + 94 94 symtab->sym_name = kallsyms_lookup(addr, &symbolsize , &offset, 95 - (char **)(&symtab->mod_name), knt1); 95 + (char **)(&symtab->mod_name), namebuf); 96 96 if (offset > 8*1024*1024) { 97 97 symtab->sym_name = NULL; 98 98 addr = offset = symbolsize = 0; ··· 101 101 symtab->sym_end = symtab->sym_start + symbolsize; 102 102 ret = symtab->sym_name != NULL && *(symtab->sym_name) != '\0'; 103 103 104 - if (ret) { 105 - int i; 106 - /* Another 2.6 kallsyms "feature". Sometimes the sym_name is 107 - * set but the buffer passed into kallsyms_lookup is not used, 108 - * so it contains garbage. The caller has to work out which 109 - * buffer needs to be saved. 110 - * 111 - * What was Rusty smoking when he wrote that code? 112 - */ 113 - if (symtab->sym_name != knt1) { 114 - strncpy(knt1, symtab->sym_name, knt1_size); 115 - knt1[knt1_size-1] = '\0'; 116 - } 117 - for (i = 0; i < ARRAY_SIZE(kdb_name_table); ++i) { 118 - if (kdb_name_table[i] && 119 - strcmp(kdb_name_table[i], knt1) == 0) 120 - break; 121 - } 122 - if (i >= ARRAY_SIZE(kdb_name_table)) { 123 - debug_kfree(kdb_name_table[0]); 124 - memmove(kdb_name_table, kdb_name_table+1, 125 - sizeof(kdb_name_table[0]) * 126 - (ARRAY_SIZE(kdb_name_table)-1)); 127 - } else { 128 - debug_kfree(knt1); 129 - knt1 = kdb_name_table[i]; 130 - memmove(kdb_name_table+i, kdb_name_table+i+1, 131 - sizeof(kdb_name_table[0]) * 132 - (ARRAY_SIZE(kdb_name_table)-i-1)); 133 - } 134 - i = ARRAY_SIZE(kdb_name_table) - 1; 135 - kdb_name_table[i] = knt1; 136 - symtab->sym_name = kdb_name_table[i]; 137 - knt1 = NULL; 138 - } 139 - 140 104 if (symtab->mod_name == NULL) 141 105 symtab->mod_name = "kernel"; 142 106 kdb_dbg_printf(AR, "returns %d symtab->sym_start=0x%lx, symtab->mod_name=%px, symtab->sym_name=%px (%s)\n", 143 107 ret, symtab->sym_start, symtab->mod_name, symtab->sym_name, symtab->sym_name); 144 - 145 108 out: 146 - debug_kfree(knt1); 147 109 return ret; 148 - } 149 - 150 - void kdbnearsym_cleanup(void) 151 - { 152 - int i; 153 - for (i = 0; i < ARRAY_SIZE(kdb_name_table); ++i) { 154 - if (kdb_name_table[i]) { 155 - debug_kfree(kdb_name_table[i]); 156 - kdb_name_table[i] = NULL; 157 - } 158 - } 159 110 } 160 111 161 112 static char ks_namebuf[KSYM_NAME_LEN+1], ks_namebuf_prev[KSYM_NAME_LEN+1]; ··· 604 653 { 605 654 char state[] = { kdb_task_state_char(p), '\0' }; 606 655 return (mask & kdb_task_state_string(state)) != 0; 607 - } 608 - 609 - /* Last ditch allocator for debugging, so we can still debug even when 610 - * the GFP_ATOMIC pool has been exhausted. The algorithms are tuned 611 - * for space usage, not for speed. One smallish memory pool, the free 612 - * chain is always in ascending address order to allow coalescing, 613 - * allocations are done in brute force best fit. 614 - */ 615 - 616 - struct debug_alloc_header { 617 - u32 next; /* offset of next header from start of pool */ 618 - u32 size; 619 - void *caller; 620 - }; 621 - 622 - /* The memory returned by this allocator must be aligned, which means 623 - * so must the header size. Do not assume that sizeof(struct 624 - * debug_alloc_header) is a multiple of the alignment, explicitly 625 - * calculate the overhead of this header, including the alignment. 626 - * The rest of this code must not use sizeof() on any header or 627 - * pointer to a header. 628 - */ 629 - #define dah_align 8 630 - #define dah_overhead ALIGN(sizeof(struct debug_alloc_header), dah_align) 631 - 632 - static u64 debug_alloc_pool_aligned[256*1024/dah_align]; /* 256K pool */ 633 - static char *debug_alloc_pool = (char *)debug_alloc_pool_aligned; 634 - static u32 dah_first, dah_first_call = 1, dah_used, dah_used_max; 635 - 636 - /* Locking is awkward. The debug code is called from all contexts, 637 - * including non maskable interrupts. A normal spinlock is not safe 638 - * in NMI context. Try to get the debug allocator lock, if it cannot 639 - * be obtained after a second then give up. If the lock could not be 640 - * previously obtained on this cpu then only try once. 641 - * 642 - * sparse has no annotation for "this function _sometimes_ acquires a 643 - * lock", so fudge the acquire/release notation. 644 - */ 645 - static DEFINE_SPINLOCK(dap_lock); 646 - static int get_dap_lock(void) 647 - __acquires(dap_lock) 648 - { 649 - static int dap_locked = -1; 650 - int count; 651 - if (dap_locked == smp_processor_id()) 652 - count = 1; 653 - else 654 - count = 1000; 655 - while (1) { 656 - if (spin_trylock(&dap_lock)) { 657 - dap_locked = -1; 658 - return 1; 659 - } 660 - if (!count--) 661 - break; 662 - udelay(1000); 663 - } 664 - dap_locked = smp_processor_id(); 665 - __acquire(dap_lock); 666 - return 0; 667 - } 668 - 669 - void *debug_kmalloc(size_t size, gfp_t flags) 670 - { 671 - unsigned int rem, h_offset; 672 - struct debug_alloc_header *best, *bestprev, *prev, *h; 673 - void *p = NULL; 674 - if (!get_dap_lock()) { 675 - __release(dap_lock); /* we never actually got it */ 676 - return NULL; 677 - } 678 - h = (struct debug_alloc_header *)(debug_alloc_pool + dah_first); 679 - if (dah_first_call) { 680 - h->size = sizeof(debug_alloc_pool_aligned) - dah_overhead; 681 - dah_first_call = 0; 682 - } 683 - size = ALIGN(size, dah_align); 684 - prev = best = bestprev = NULL; 685 - while (1) { 686 - if (h->size >= size && (!best || h->size < best->size)) { 687 - best = h; 688 - bestprev = prev; 689 - if (h->size == size) 690 - break; 691 - } 692 - if (!h->next) 693 - break; 694 - prev = h; 695 - h = (struct debug_alloc_header *)(debug_alloc_pool + h->next); 696 - } 697 - if (!best) 698 - goto out; 699 - rem = best->size - size; 700 - /* The pool must always contain at least one header */ 701 - if (best->next == 0 && bestprev == NULL && rem < dah_overhead) 702 - goto out; 703 - if (rem >= dah_overhead) { 704 - best->size = size; 705 - h_offset = ((char *)best - debug_alloc_pool) + 706 - dah_overhead + best->size; 707 - h = (struct debug_alloc_header *)(debug_alloc_pool + h_offset); 708 - h->size = rem - dah_overhead; 709 - h->next = best->next; 710 - } else 711 - h_offset = best->next; 712 - best->caller = __builtin_return_address(0); 713 - dah_used += best->size; 714 - dah_used_max = max(dah_used, dah_used_max); 715 - if (bestprev) 716 - bestprev->next = h_offset; 717 - else 718 - dah_first = h_offset; 719 - p = (char *)best + dah_overhead; 720 - memset(p, POISON_INUSE, best->size - 1); 721 - *((char *)p + best->size - 1) = POISON_END; 722 - out: 723 - spin_unlock(&dap_lock); 724 - return p; 725 - } 726 - 727 - void debug_kfree(void *p) 728 - { 729 - struct debug_alloc_header *h; 730 - unsigned int h_offset; 731 - if (!p) 732 - return; 733 - if ((char *)p < debug_alloc_pool || 734 - (char *)p >= debug_alloc_pool + sizeof(debug_alloc_pool_aligned)) { 735 - kfree(p); 736 - return; 737 - } 738 - if (!get_dap_lock()) { 739 - __release(dap_lock); /* we never actually got it */ 740 - return; /* memory leak, cannot be helped */ 741 - } 742 - h = (struct debug_alloc_header *)((char *)p - dah_overhead); 743 - memset(p, POISON_FREE, h->size - 1); 744 - *((char *)p + h->size - 1) = POISON_END; 745 - h->caller = NULL; 746 - dah_used -= h->size; 747 - h_offset = (char *)h - debug_alloc_pool; 748 - if (h_offset < dah_first) { 749 - h->next = dah_first; 750 - dah_first = h_offset; 751 - } else { 752 - struct debug_alloc_header *prev; 753 - unsigned int prev_offset; 754 - prev = (struct debug_alloc_header *)(debug_alloc_pool + 755 - dah_first); 756 - while (1) { 757 - if (!prev->next || prev->next > h_offset) 758 - break; 759 - prev = (struct debug_alloc_header *) 760 - (debug_alloc_pool + prev->next); 761 - } 762 - prev_offset = (char *)prev - debug_alloc_pool; 763 - if (prev_offset + dah_overhead + prev->size == h_offset) { 764 - prev->size += dah_overhead + h->size; 765 - memset(h, POISON_FREE, dah_overhead - 1); 766 - *((char *)h + dah_overhead - 1) = POISON_END; 767 - h = prev; 768 - h_offset = prev_offset; 769 - } else { 770 - h->next = prev->next; 771 - prev->next = h_offset; 772 - } 773 - } 774 - if (h_offset + dah_overhead + h->size == h->next) { 775 - struct debug_alloc_header *next; 776 - next = (struct debug_alloc_header *) 777 - (debug_alloc_pool + h->next); 778 - h->size += dah_overhead + next->size; 779 - h->next = next->next; 780 - memset(next, POISON_FREE, dah_overhead - 1); 781 - *((char *)next + dah_overhead - 1) = POISON_END; 782 - } 783 - spin_unlock(&dap_lock); 784 - } 785 - 786 - void debug_kusage(void) 787 - { 788 - struct debug_alloc_header *h_free, *h_used; 789 - #ifdef CONFIG_IA64 790 - /* FIXME: using dah for ia64 unwind always results in a memory leak. 791 - * Fix that memory leak first, then set debug_kusage_one_time = 1 for 792 - * all architectures. 793 - */ 794 - static int debug_kusage_one_time; 795 - #else 796 - static int debug_kusage_one_time = 1; 797 - #endif 798 - if (!get_dap_lock()) { 799 - __release(dap_lock); /* we never actually got it */ 800 - return; 801 - } 802 - h_free = (struct debug_alloc_header *)(debug_alloc_pool + dah_first); 803 - if (dah_first == 0 && 804 - (h_free->size == sizeof(debug_alloc_pool_aligned) - dah_overhead || 805 - dah_first_call)) 806 - goto out; 807 - if (!debug_kusage_one_time) 808 - goto out; 809 - debug_kusage_one_time = 0; 810 - kdb_func_printf("debug_kmalloc memory leak dah_first %d\n", dah_first); 811 - if (dah_first) { 812 - h_used = (struct debug_alloc_header *)debug_alloc_pool; 813 - kdb_func_printf("h_used %px size %d\n", h_used, h_used->size); 814 - } 815 - do { 816 - h_used = (struct debug_alloc_header *) 817 - ((char *)h_free + dah_overhead + h_free->size); 818 - kdb_func_printf("h_used %px size %d caller %px\n", 819 - h_used, h_used->size, h_used->caller); 820 - h_free = (struct debug_alloc_header *) 821 - (debug_alloc_pool + h_free->next); 822 - } while (h_free->next); 823 - h_used = (struct debug_alloc_header *) 824 - ((char *)h_free + dah_overhead + h_free->size); 825 - if ((char *)h_used - debug_alloc_pool != 826 - sizeof(debug_alloc_pool_aligned)) 827 - kdb_func_printf("h_used %px size %d caller %px\n", 828 - h_used, h_used->size, h_used->caller); 829 - out: 830 - spin_unlock(&dap_lock); 831 656 } 832 657 833 658 /* Maintain a small stack of kdb_flags to allow recursion without disturbing

+9 -3

kernel/trace/trace_kdb.c

··· 147 147 return 0; 148 148 } 149 149 150 + static kdbtab_t ftdump_cmd = { 151 + .name = "ftdump", 152 + .func = kdb_ftdump, 153 + .usage = "[skip_#entries] [cpu]", 154 + .help = "Dump ftrace log; -skip dumps last #entries", 155 + .flags = KDB_ENABLE_ALWAYS_SAFE, 156 + }; 157 + 150 158 static __init int kdb_ftrace_register(void) 151 159 { 152 - kdb_register_flags("ftdump", kdb_ftdump, "[skip_#entries] [cpu]", 153 - "Dump ftrace log; -skip dumps last #entries", 0, 154 - KDB_ENABLE_ALWAYS_SAFE); 160 + kdb_register(&ftdump_cmd); 155 161 return 0; 156 162 } 157 163

+9 -11

samples/kdb/kdb_hello.c

··· 28 28 return 0; 29 29 } 30 30 31 + static kdbtab_t hello_cmd = { 32 + .name = "hello", 33 + .func = kdb_hello_cmd, 34 + .usage = "[string]", 35 + .help = "Say Hello World or Hello [string]", 36 + }; 31 37 32 38 static int __init kdb_hello_cmd_init(void) 33 39 { 34 40 /* 35 41 * Registration of a dynamically added kdb command is done with 36 - * kdb_register() with the arguments being: 37 - * 1: The name of the shell command 38 - * 2: The function that processes the command 39 - * 3: Description of the usage of any arguments 40 - * 4: Descriptive text when you run help 41 - * 5: Number of characters to complete the command 42 - * 0 == type the whole command 43 - * 1 == match both "g" and "go" for example 42 + * kdb_register(). 44 43 */ 45 - kdb_register("hello", kdb_hello_cmd, "[string]", 46 - "Say Hello World or Hello [string]", 0); 44 + kdb_register(&hello_cmd); 47 45 return 0; 48 46 } 49 47 50 48 static void __exit kdb_hello_cmd_exit(void) 51 49 { 52 - kdb_unregister("hello"); 50 + kdb_unregister(&hello_cmd); 53 51 } 54 52 55 53 module_init(kdb_hello_cmd_init);

Configure Feed

Configure Feed