kdb: Rename members of struct kdbtab_t · tjh.dev/kernel@e868f0a

+6 -6

include/linux/kdb.h

··· 68 68 69 69 /* The KDB shell command table */ 70 70 typedef struct _kdbtab { 71 - char *cmd_name; /* Command name */ 72 - kdb_func_t cmd_func; /* Function to execute command */ 73 - char *cmd_usage; /* Usage String for this command */ 74 - char *cmd_help; /* Help message for this command */ 75 - short cmd_minlen; /* Minimum legal # cmd chars required */ 76 - kdb_cmdflags_t cmd_flags; /* Command behaviour flags */ 71 + char *name; /* Command name */ 72 + kdb_func_t func; /* Function to execute command */ 73 + char *usage; /* Usage String for this command */ 74 + char *help; /* Help message for this command */ 75 + short minlen; /* Minimum legal # cmd chars required */ 76 + kdb_cmdflags_t flags; /* Command behaviour flags */ 77 77 struct list_head list_node; /* Command list */ 78 78 } kdbtab_t; 79 79

+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. */

+201 -203

kernel/debug/kdb/kdb_main.c

··· 711 711 struct kdb_macro_statement *kms; 712 712 713 713 list_for_each_entry(kp, &kdb_cmds_head, list_node) { 714 - if (kp->cmd_func == kdb_exec_defcmd) { 714 + if (kp->func == kdb_exec_defcmd) { 715 715 kdb_printf("defcmd %s \"%s\" \"%s\"\n", 716 - kp->cmd_name, kp->cmd_usage, 717 - kp->cmd_help); 716 + kp->name, kp->usage, kp->help); 718 717 kmp = container_of(kp, struct kdb_macro, cmd); 719 718 list_for_each_entry(kms, &kmp->statements, 720 719 list_node) ··· 734 735 goto fail_defcmd; 735 736 736 737 mp = &kdb_macro->cmd; 737 - mp->cmd_func = kdb_exec_defcmd; 738 - mp->cmd_minlen = 0; 739 - mp->cmd_flags = KDB_ENABLE_ALWAYS_SAFE; 740 - mp->cmd_name = kdb_strdup(argv[1], GFP_KDB); 741 - if (!mp->cmd_name) 738 + mp->func = kdb_exec_defcmd; 739 + mp->minlen = 0; 740 + mp->flags = KDB_ENABLE_ALWAYS_SAFE; 741 + mp->name = kdb_strdup(argv[1], GFP_KDB); 742 + if (!mp->name) 742 743 goto fail_name; 743 - mp->cmd_usage = kdb_strdup(argv[2], GFP_KDB); 744 - if (!mp->cmd_usage) 744 + mp->usage = kdb_strdup(argv[2], GFP_KDB); 745 + if (!mp->usage) 745 746 goto fail_usage; 746 - mp->cmd_help = kdb_strdup(argv[3], GFP_KDB); 747 - if (!mp->cmd_help) 747 + mp->help = kdb_strdup(argv[3], GFP_KDB); 748 + if (!mp->help) 748 749 goto fail_help; 749 - if (mp->cmd_usage[0] == '"') { 750 - strcpy(mp->cmd_usage, argv[2]+1); 751 - mp->cmd_usage[strlen(mp->cmd_usage)-1] = '\0'; 750 + if (mp->usage[0] == '"') { 751 + strcpy(mp->usage, argv[2]+1); 752 + mp->usage[strlen(mp->usage)-1] = '\0'; 752 753 } 753 - if (mp->cmd_help[0] == '"') { 754 - strcpy(mp->cmd_help, argv[3]+1); 755 - mp->cmd_help[strlen(mp->cmd_help)-1] = '\0'; 754 + if (mp->help[0] == '"') { 755 + strcpy(mp->help, argv[3]+1); 756 + mp->help[strlen(mp->help)-1] = '\0'; 756 757 } 757 758 758 759 INIT_LIST_HEAD(&kdb_macro->statements); 759 760 defcmd_in_progress = true; 760 761 return 0; 761 762 fail_help: 762 - kfree(mp->cmd_usage); 763 + kfree(mp->usage); 763 764 fail_usage: 764 - kfree(mp->cmd_name); 765 + kfree(mp->name); 765 766 fail_name: 766 767 kfree(kdb_macro); 767 768 fail_defcmd: ··· 789 790 return KDB_ARGCOUNT; 790 791 791 792 list_for_each_entry(kp, &kdb_cmds_head, list_node) { 792 - if (strcmp(kp->cmd_name, argv[0]) == 0) 793 + if (strcmp(kp->name, argv[0]) == 0) 793 794 break; 794 795 } 795 796 if (list_entry_is_head(kp, &kdb_cmds_head, list_node)) { ··· 803 804 * Recursive use of kdb_parse, do not use argv after this point. 804 805 */ 805 806 argv = NULL; 806 - kdb_printf("[%s]kdb> %s\n", kmp->cmd.cmd_name, kms->statement); 807 + kdb_printf("[%s]kdb> %s\n", kmp->cmd.name, kms->statement); 807 808 ret = kdb_parse(kms->statement); 808 809 if (ret) 809 810 return ret; ··· 1015 1016 * If this command is allowed to be abbreviated, 1016 1017 * check to see if this is it. 1017 1018 */ 1018 - if (tp->cmd_minlen && (strlen(argv[0]) <= tp->cmd_minlen) && 1019 - (strncmp(argv[0], tp->cmd_name, tp->cmd_minlen) == 0)) 1019 + if (tp->minlen && (strlen(argv[0]) <= tp->minlen) && 1020 + (strncmp(argv[0], tp->name, tp->minlen) == 0)) 1020 1021 break; 1021 1022 1022 - if (strcmp(argv[0], tp->cmd_name) == 0) 1023 + if (strcmp(argv[0], tp->name) == 0) 1023 1024 break; 1024 1025 } 1025 1026 ··· 1030 1031 */ 1031 1032 if (list_entry_is_head(tp, &kdb_cmds_head, list_node)) { 1032 1033 list_for_each_entry(tp, &kdb_cmds_head, list_node) { 1033 - if (strncmp(argv[0], tp->cmd_name, 1034 - strlen(tp->cmd_name)) == 0) 1034 + if (strncmp(argv[0], tp->name, strlen(tp->name)) == 0) 1035 1035 break; 1036 1036 } 1037 1037 } ··· 1038 1040 if (!list_entry_is_head(tp, &kdb_cmds_head, list_node)) { 1039 1041 int result; 1040 1042 1041 - if (!kdb_check_flags(tp->cmd_flags, kdb_cmd_enabled, argc <= 1)) 1043 + if (!kdb_check_flags(tp->flags, kdb_cmd_enabled, argc <= 1)) 1042 1044 return KDB_NOPERM; 1043 1045 1044 1046 KDB_STATE_SET(CMD); 1045 - result = (*tp->cmd_func)(argc-1, (const char **)argv); 1047 + result = (*tp->func)(argc-1, (const char **)argv); 1046 1048 if (result && ignore_errors && result > KDB_CMD_GO) 1047 1049 result = 0; 1048 1050 KDB_STATE_CLEAR(CMD); 1049 1051 1050 - if (tp->cmd_flags & KDB_REPEAT_WITH_ARGS) 1052 + if (tp->flags & KDB_REPEAT_WITH_ARGS) 1051 1053 return result; 1052 1054 1053 - argc = tp->cmd_flags & KDB_REPEAT_NO_ARGS ? 1 : 0; 1055 + argc = tp->flags & KDB_REPEAT_NO_ARGS ? 1 : 0; 1054 1056 if (argv[argc]) 1055 1057 *(argv[argc]) = '\0'; 1056 1058 return result; ··· 2417 2419 char *space = ""; 2418 2420 if (KDB_FLAG(CMD_INTERRUPT)) 2419 2421 return 0; 2420 - if (!kdb_check_flags(kt->cmd_flags, kdb_cmd_enabled, true)) 2422 + if (!kdb_check_flags(kt->flags, kdb_cmd_enabled, true)) 2421 2423 continue; 2422 - if (strlen(kt->cmd_usage) > 20) 2424 + if (strlen(kt->usage) > 20) 2423 2425 space = "\n "; 2424 - kdb_printf("%-15.15s %-20s%s%s\n", kt->cmd_name, 2425 - kt->cmd_usage, space, kt->cmd_help); 2426 + kdb_printf("%-15.15s %-20s%s%s\n", kt->name, 2427 + kt->usage, space, kt->help); 2426 2428 } 2427 2429 return 0; 2428 2430 } ··· 2631 2633 kdbtab_t *kp; 2632 2634 2633 2635 list_for_each_entry(kp, &kdb_cmds_head, list_node) { 2634 - if (strcmp(kp->cmd_name, cmd->cmd_name) == 0) { 2636 + if (strcmp(kp->name, cmd->name) == 0) { 2635 2637 kdb_printf("Duplicate kdb cmd: %s, func %p help %s\n", 2636 - cmd->cmd_name, cmd->cmd_func, cmd->cmd_help); 2638 + cmd->name, cmd->func, cmd->help); 2637 2639 return 1; 2638 2640 } 2639 2641 } ··· 2670 2672 EXPORT_SYMBOL_GPL(kdb_unregister); 2671 2673 2672 2674 static kdbtab_t maintab[] = { 2673 - { .cmd_name = "md", 2674 - .cmd_func = kdb_md, 2675 - .cmd_usage = "<vaddr>", 2676 - .cmd_help = "Display Memory Contents, also mdWcN, e.g. md8c1", 2677 - .cmd_minlen = 1, 2678 - .cmd_flags = KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS, 2675 + { .name = "md", 2676 + .func = kdb_md, 2677 + .usage = "<vaddr>", 2678 + .help = "Display Memory Contents, also mdWcN, e.g. md8c1", 2679 + .minlen = 1, 2680 + .flags = KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS, 2679 2681 }, 2680 - { .cmd_name = "mdr", 2681 - .cmd_func = kdb_md, 2682 - .cmd_usage = "<vaddr> <bytes>", 2683 - .cmd_help = "Display Raw Memory", 2684 - .cmd_flags = KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS, 2682 + { .name = "mdr", 2683 + .func = kdb_md, 2684 + .usage = "<vaddr> <bytes>", 2685 + .help = "Display Raw Memory", 2686 + .flags = KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS, 2685 2687 }, 2686 - { .cmd_name = "mdp", 2687 - .cmd_func = kdb_md, 2688 - .cmd_usage = "<paddr> <bytes>", 2689 - .cmd_help = "Display Physical Memory", 2690 - .cmd_flags = KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS, 2688 + { .name = "mdp", 2689 + .func = kdb_md, 2690 + .usage = "<paddr> <bytes>", 2691 + .help = "Display Physical Memory", 2692 + .flags = KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS, 2691 2693 }, 2692 - { .cmd_name = "mds", 2693 - .cmd_func = kdb_md, 2694 - .cmd_usage = "<vaddr>", 2695 - .cmd_help = "Display Memory Symbolically", 2696 - .cmd_flags = KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS, 2694 + { .name = "mds", 2695 + .func = kdb_md, 2696 + .usage = "<vaddr>", 2697 + .help = "Display Memory Symbolically", 2698 + .flags = KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS, 2697 2699 }, 2698 - { .cmd_name = "mm", 2699 - .cmd_func = kdb_mm, 2700 - .cmd_usage = "<vaddr> <contents>", 2701 - .cmd_help = "Modify Memory Contents", 2702 - .cmd_flags = KDB_ENABLE_MEM_WRITE | KDB_REPEAT_NO_ARGS, 2700 + { .name = "mm", 2701 + .func = kdb_mm, 2702 + .usage = "<vaddr> <contents>", 2703 + .help = "Modify Memory Contents", 2704 + .flags = KDB_ENABLE_MEM_WRITE | KDB_REPEAT_NO_ARGS, 2703 2705 }, 2704 - { .cmd_name = "go", 2705 - .cmd_func = kdb_go, 2706 - .cmd_usage = "[<vaddr>]", 2707 - .cmd_help = "Continue Execution", 2708 - .cmd_minlen = 1, 2709 - .cmd_flags = KDB_ENABLE_REG_WRITE | 2706 + { .name = "go", 2707 + .func = kdb_go, 2708 + .usage = "[<vaddr>]", 2709 + .help = "Continue Execution", 2710 + .minlen = 1, 2711 + .flags = KDB_ENABLE_REG_WRITE | 2710 2712 KDB_ENABLE_ALWAYS_SAFE_NO_ARGS, 2711 2713 }, 2712 - { .cmd_name = "rd", 2713 - .cmd_func = kdb_rd, 2714 - .cmd_usage = "", 2715 - .cmd_help = "Display Registers", 2716 - .cmd_flags = KDB_ENABLE_REG_READ, 2714 + { .name = "rd", 2715 + .func = kdb_rd, 2716 + .usage = "", 2717 + .help = "Display Registers", 2718 + .flags = KDB_ENABLE_REG_READ, 2717 2719 }, 2718 - { .cmd_name = "rm", 2719 - .cmd_func = kdb_rm, 2720 - .cmd_usage = "<reg> <contents>", 2721 - .cmd_help = "Modify Registers", 2722 - .cmd_flags = KDB_ENABLE_REG_WRITE, 2720 + { .name = "rm", 2721 + .func = kdb_rm, 2722 + .usage = "<reg> <contents>", 2723 + .help = "Modify Registers", 2724 + .flags = KDB_ENABLE_REG_WRITE, 2723 2725 }, 2724 - { .cmd_name = "ef", 2725 - .cmd_func = kdb_ef, 2726 - .cmd_usage = "<vaddr>", 2727 - .cmd_help = "Display exception frame", 2728 - .cmd_flags = KDB_ENABLE_MEM_READ, 2726 + { .name = "ef", 2727 + .func = kdb_ef, 2728 + .usage = "<vaddr>", 2729 + .help = "Display exception frame", 2730 + .flags = KDB_ENABLE_MEM_READ, 2729 2731 }, 2730 - { .cmd_name = "bt", 2731 - .cmd_func = kdb_bt, 2732 - .cmd_usage = "[<vaddr>]", 2733 - .cmd_help = "Stack traceback", 2734 - .cmd_minlen = 1, 2735 - .cmd_flags = KDB_ENABLE_MEM_READ | KDB_ENABLE_INSPECT_NO_ARGS, 2732 + { .name = "bt", 2733 + .func = kdb_bt, 2734 + .usage = "[<vaddr>]", 2735 + .help = "Stack traceback", 2736 + .minlen = 1, 2737 + .flags = KDB_ENABLE_MEM_READ | KDB_ENABLE_INSPECT_NO_ARGS, 2736 2738 }, 2737 - { .cmd_name = "btp", 2738 - .cmd_func = kdb_bt, 2739 - .cmd_usage = "<pid>", 2740 - .cmd_help = "Display stack for process <pid>", 2741 - .cmd_flags = KDB_ENABLE_INSPECT, 2739 + { .name = "btp", 2740 + .func = kdb_bt, 2741 + .usage = "<pid>", 2742 + .help = "Display stack for process <pid>", 2743 + .flags = KDB_ENABLE_INSPECT, 2742 2744 }, 2743 - { .cmd_name = "bta", 2744 - .cmd_func = kdb_bt, 2745 - .cmd_usage = "[D|R|S|T|C|Z|E|U|I|M|A]", 2746 - .cmd_help = "Backtrace all processes matching state flag", 2747 - .cmd_flags = KDB_ENABLE_INSPECT, 2745 + { .name = "bta", 2746 + .func = kdb_bt, 2747 + .usage = "[D|R|S|T|C|Z|E|U|I|M|A]", 2748 + .help = "Backtrace all processes matching state flag", 2749 + .flags = KDB_ENABLE_INSPECT, 2748 2750 }, 2749 - { .cmd_name = "btc", 2750 - .cmd_func = kdb_bt, 2751 - .cmd_usage = "", 2752 - .cmd_help = "Backtrace current process on each cpu", 2753 - .cmd_flags = KDB_ENABLE_INSPECT, 2751 + { .name = "btc", 2752 + .func = kdb_bt, 2753 + .usage = "", 2754 + .help = "Backtrace current process on each cpu", 2755 + .flags = KDB_ENABLE_INSPECT, 2754 2756 }, 2755 - { .cmd_name = "btt", 2756 - .cmd_func = kdb_bt, 2757 - .cmd_usage = "<vaddr>", 2758 - .cmd_help = "Backtrace process given its struct task address", 2759 - .cmd_flags = KDB_ENABLE_MEM_READ | KDB_ENABLE_INSPECT_NO_ARGS, 2757 + { .name = "btt", 2758 + .func = kdb_bt, 2759 + .usage = "<vaddr>", 2760 + .help = "Backtrace process given its struct task address", 2761 + .flags = KDB_ENABLE_MEM_READ | KDB_ENABLE_INSPECT_NO_ARGS, 2760 2762 }, 2761 - { .cmd_name = "env", 2762 - .cmd_func = kdb_env, 2763 - .cmd_usage = "", 2764 - .cmd_help = "Show environment variables", 2765 - .cmd_flags = KDB_ENABLE_ALWAYS_SAFE, 2763 + { .name = "env", 2764 + .func = kdb_env, 2765 + .usage = "", 2766 + .help = "Show environment variables", 2767 + .flags = KDB_ENABLE_ALWAYS_SAFE, 2766 2768 }, 2767 - { .cmd_name = "set", 2768 - .cmd_func = kdb_set, 2769 - .cmd_usage = "", 2770 - .cmd_help = "Set environment variables", 2771 - .cmd_flags = KDB_ENABLE_ALWAYS_SAFE, 2769 + { .name = "set", 2770 + .func = kdb_set, 2771 + .usage = "", 2772 + .help = "Set environment variables", 2773 + .flags = KDB_ENABLE_ALWAYS_SAFE, 2772 2774 }, 2773 - { .cmd_name = "help", 2774 - .cmd_func = kdb_help, 2775 - .cmd_usage = "", 2776 - .cmd_help = "Display Help Message", 2777 - .cmd_minlen = 1, 2778 - .cmd_flags = KDB_ENABLE_ALWAYS_SAFE, 2775 + { .name = "help", 2776 + .func = kdb_help, 2777 + .usage = "", 2778 + .help = "Display Help Message", 2779 + .minlen = 1, 2780 + .flags = KDB_ENABLE_ALWAYS_SAFE, 2779 2781 }, 2780 - { .cmd_name = "?", 2781 - .cmd_func = kdb_help, 2782 - .cmd_usage = "", 2783 - .cmd_help = "Display Help Message", 2784 - .cmd_flags = KDB_ENABLE_ALWAYS_SAFE, 2782 + { .name = "?", 2783 + .func = kdb_help, 2784 + .usage = "", 2785 + .help = "Display Help Message", 2786 + .flags = KDB_ENABLE_ALWAYS_SAFE, 2785 2787 }, 2786 - { .cmd_name = "cpu", 2787 - .cmd_func = kdb_cpu, 2788 - .cmd_usage = "<cpunum>", 2789 - .cmd_help = "Switch to new cpu", 2790 - .cmd_flags = KDB_ENABLE_ALWAYS_SAFE_NO_ARGS, 2788 + { .name = "cpu", 2789 + .func = kdb_cpu, 2790 + .usage = "<cpunum>", 2791 + .help = "Switch to new cpu", 2792 + .flags = KDB_ENABLE_ALWAYS_SAFE_NO_ARGS, 2791 2793 }, 2792 - { .cmd_name = "kgdb", 2793 - .cmd_func = kdb_kgdb, 2794 - .cmd_usage = "", 2795 - .cmd_help = "Enter kgdb mode", 2796 - .cmd_flags = 0, 2794 + { .name = "kgdb", 2795 + .func = kdb_kgdb, 2796 + .usage = "", 2797 + .help = "Enter kgdb mode", 2798 + .flags = 0, 2797 2799 }, 2798 - { .cmd_name = "ps", 2799 - .cmd_func = kdb_ps, 2800 - .cmd_usage = "[<flags>|A]", 2801 - .cmd_help = "Display active task list", 2802 - .cmd_flags = KDB_ENABLE_INSPECT, 2800 + { .name = "ps", 2801 + .func = kdb_ps, 2802 + .usage = "[<flags>|A]", 2803 + .help = "Display active task list", 2804 + .flags = KDB_ENABLE_INSPECT, 2803 2805 }, 2804 - { .cmd_name = "pid", 2805 - .cmd_func = kdb_pid, 2806 - .cmd_usage = "<pidnum>", 2807 - .cmd_help = "Switch to another task", 2808 - .cmd_flags = KDB_ENABLE_INSPECT, 2806 + { .name = "pid", 2807 + .func = kdb_pid, 2808 + .usage = "<pidnum>", 2809 + .help = "Switch to another task", 2810 + .flags = KDB_ENABLE_INSPECT, 2809 2811 }, 2810 - { .cmd_name = "reboot", 2811 - .cmd_func = kdb_reboot, 2812 - .cmd_usage = "", 2813 - .cmd_help = "Reboot the machine immediately", 2814 - .cmd_flags = KDB_ENABLE_REBOOT, 2812 + { .name = "reboot", 2813 + .func = kdb_reboot, 2814 + .usage = "", 2815 + .help = "Reboot the machine immediately", 2816 + .flags = KDB_ENABLE_REBOOT, 2815 2817 }, 2816 2818 #if defined(CONFIG_MODULES) 2817 - { .cmd_name = "lsmod", 2818 - .cmd_func = kdb_lsmod, 2819 - .cmd_usage = "", 2820 - .cmd_help = "List loaded kernel modules", 2821 - .cmd_flags = KDB_ENABLE_INSPECT, 2819 + { .name = "lsmod", 2820 + .func = kdb_lsmod, 2821 + .usage = "", 2822 + .help = "List loaded kernel modules", 2823 + .flags = KDB_ENABLE_INSPECT, 2822 2824 }, 2823 2825 #endif 2824 2826 #if defined(CONFIG_MAGIC_SYSRQ) 2825 - { .cmd_name = "sr", 2826 - .cmd_func = kdb_sr, 2827 - .cmd_usage = "<key>", 2828 - .cmd_help = "Magic SysRq key", 2829 - .cmd_flags = KDB_ENABLE_ALWAYS_SAFE, 2827 + { .name = "sr", 2828 + .func = kdb_sr, 2829 + .usage = "<key>", 2830 + .help = "Magic SysRq key", 2831 + .flags = KDB_ENABLE_ALWAYS_SAFE, 2830 2832 }, 2831 2833 #endif 2832 2834 #if defined(CONFIG_PRINTK) 2833 - { .cmd_name = "dmesg", 2834 - .cmd_func = kdb_dmesg, 2835 - .cmd_usage = "[lines]", 2836 - .cmd_help = "Display syslog buffer", 2837 - .cmd_flags = KDB_ENABLE_ALWAYS_SAFE, 2835 + { .name = "dmesg", 2836 + .func = kdb_dmesg, 2837 + .usage = "[lines]", 2838 + .help = "Display syslog buffer", 2839 + .flags = KDB_ENABLE_ALWAYS_SAFE, 2838 2840 }, 2839 2841 #endif 2840 - { .cmd_name = "defcmd", 2841 - .cmd_func = kdb_defcmd, 2842 - .cmd_usage = "name \"usage\" \"help\"", 2843 - .cmd_help = "Define a set of commands, down to endefcmd", 2842 + { .name = "defcmd", 2843 + .func = kdb_defcmd, 2844 + .usage = "name \"usage\" \"help\"", 2845 + .help = "Define a set of commands, down to endefcmd", 2844 2846 /* 2845 2847 * Macros are always safe because when executed each 2846 2848 * internal command re-enters kdb_parse() and is safety 2847 2849 * checked individually. 2848 2850 */ 2849 - .cmd_flags = KDB_ENABLE_ALWAYS_SAFE, 2851 + .flags = KDB_ENABLE_ALWAYS_SAFE, 2850 2852 }, 2851 - { .cmd_name = "kill", 2852 - .cmd_func = kdb_kill, 2853 - .cmd_usage = "<-signal> <pid>", 2854 - .cmd_help = "Send a signal to a process", 2855 - .cmd_flags = KDB_ENABLE_SIGNAL, 2853 + { .name = "kill", 2854 + .func = kdb_kill, 2855 + .usage = "<-signal> <pid>", 2856 + .help = "Send a signal to a process", 2857 + .flags = KDB_ENABLE_SIGNAL, 2856 2858 }, 2857 - { .cmd_name = "summary", 2858 - .cmd_func = kdb_summary, 2859 - .cmd_usage = "", 2860 - .cmd_help = "Summarize the system", 2861 - .cmd_minlen = 4, 2862 - .cmd_flags = KDB_ENABLE_ALWAYS_SAFE, 2859 + { .name = "summary", 2860 + .func = kdb_summary, 2861 + .usage = "", 2862 + .help = "Summarize the system", 2863 + .minlen = 4, 2864 + .flags = KDB_ENABLE_ALWAYS_SAFE, 2863 2865 }, 2864 - { .cmd_name = "per_cpu", 2865 - .cmd_func = kdb_per_cpu, 2866 - .cmd_usage = "<sym> [<bytes>] [<cpu>]", 2867 - .cmd_help = "Display per_cpu variables", 2868 - .cmd_minlen = 3, 2869 - .cmd_flags = KDB_ENABLE_MEM_READ, 2866 + { .name = "per_cpu", 2867 + .func = kdb_per_cpu, 2868 + .usage = "<sym> [<bytes>] [<cpu>]", 2869 + .help = "Display per_cpu variables", 2870 + .minlen = 3, 2871 + .flags = KDB_ENABLE_MEM_READ, 2870 2872 }, 2871 - { .cmd_name = "grephelp", 2872 - .cmd_func = kdb_grep_help, 2873 - .cmd_usage = "", 2874 - .cmd_help = "Display help on | grep", 2875 - .cmd_flags = KDB_ENABLE_ALWAYS_SAFE, 2873 + { .name = "grephelp", 2874 + .func = kdb_grep_help, 2875 + .usage = "", 2876 + .help = "Display help on | grep", 2877 + .flags = KDB_ENABLE_ALWAYS_SAFE, 2876 2878 }, 2877 2879 }; 2878 2880 2879 2881 static kdbtab_t nmicmd = { 2880 - .cmd_name = "disable_nmi", 2881 - .cmd_func = kdb_disable_nmi, 2882 - .cmd_usage = "", 2883 - .cmd_help = "Disable NMI entry to KDB", 2884 - .cmd_flags = KDB_ENABLE_ALWAYS_SAFE, 2882 + .name = "disable_nmi", 2883 + .func = kdb_disable_nmi, 2884 + .usage = "", 2885 + .help = "Disable NMI entry to KDB", 2886 + .flags = KDB_ENABLE_ALWAYS_SAFE, 2885 2887 }; 2886 2888 2887 2889 /* Initialize the kdb command table. */

+5 -5

kernel/trace/trace_kdb.c

··· 148 148 } 149 149 150 150 static kdbtab_t ftdump_cmd = { 151 - .cmd_name = "ftdump", 152 - .cmd_func = kdb_ftdump, 153 - .cmd_usage = "[skip_#entries] [cpu]", 154 - .cmd_help = "Dump ftrace log; -skip dumps last #entries", 155 - .cmd_flags = KDB_ENABLE_ALWAYS_SAFE, 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 156 }; 157 157 158 158 static __init int kdb_ftrace_register(void)

+4 -4

samples/kdb/kdb_hello.c

··· 29 29 } 30 30 31 31 static kdbtab_t hello_cmd = { 32 - .cmd_name = "hello", 33 - .cmd_func = kdb_hello_cmd, 34 - .cmd_usage = "[string]", 35 - .cmd_help = "Say Hello World or Hello [string]", 32 + .name = "hello", 33 + .func = kdb_hello_cmd, 34 + .usage = "[string]", 35 + .help = "Say Hello World or Hello [string]", 36 36 }; 37 37 38 38 static int __init kdb_hello_cmd_init(void)

Configure Feed

Configure Feed