Merge tag 'for_linus-3.19-rc4' of git://git.kernel.org/pub/scm/linux/kernel/git/jwessel/kgdb (aa929135) · Commits · 戴 / test

include/linux/kdb.h

+53 −9

Original line number	Diff line number	Diff line
		@@ -13,11 +13,54 @@
		* Copyright (C) 2009 Jason Wessel <jason.wessel@windriver.com>
		*/

		/* Shifted versions of the command enable bits are be used if the command
		* has no arguments (see kdb_check_flags). This allows commands, such as
		* go, to have different permissions depending upon whether it is called
		* with an argument.
		*/
		#define KDB_ENABLE_NO_ARGS_SHIFT 10

		typedef enum {
		KDB_REPEAT_NONE = 0, /* Do not repeat this command */
		KDB_REPEAT_NO_ARGS, /* Repeat the command without arguments */
		KDB_REPEAT_WITH_ARGS, /* Repeat the command including its arguments */
		} kdb_repeat_t;
		KDB_ENABLE_ALL = (1 << 0), /* Enable everything */
		KDB_ENABLE_MEM_READ = (1 << 1),
		KDB_ENABLE_MEM_WRITE = (1 << 2),
		KDB_ENABLE_REG_READ = (1 << 3),
		KDB_ENABLE_REG_WRITE = (1 << 4),
		KDB_ENABLE_INSPECT = (1 << 5),
		KDB_ENABLE_FLOW_CTRL = (1 << 6),
		KDB_ENABLE_SIGNAL = (1 << 7),
		KDB_ENABLE_REBOOT = (1 << 8),
		/* User exposed values stop here, all remaining flags are
		* exclusively used to describe a commands behaviour.
		*/

		KDB_ENABLE_ALWAYS_SAFE = (1 << 9),
		KDB_ENABLE_MASK = (1 << KDB_ENABLE_NO_ARGS_SHIFT) - 1,

		KDB_ENABLE_ALL_NO_ARGS = KDB_ENABLE_ALL << KDB_ENABLE_NO_ARGS_SHIFT,
		KDB_ENABLE_MEM_READ_NO_ARGS = KDB_ENABLE_MEM_READ
		<< KDB_ENABLE_NO_ARGS_SHIFT,
		KDB_ENABLE_MEM_WRITE_NO_ARGS = KDB_ENABLE_MEM_WRITE
		<< KDB_ENABLE_NO_ARGS_SHIFT,
		KDB_ENABLE_REG_READ_NO_ARGS = KDB_ENABLE_REG_READ
		<< KDB_ENABLE_NO_ARGS_SHIFT,
		KDB_ENABLE_REG_WRITE_NO_ARGS = KDB_ENABLE_REG_WRITE
		<< KDB_ENABLE_NO_ARGS_SHIFT,
		KDB_ENABLE_INSPECT_NO_ARGS = KDB_ENABLE_INSPECT
		<< KDB_ENABLE_NO_ARGS_SHIFT,
		KDB_ENABLE_FLOW_CTRL_NO_ARGS = KDB_ENABLE_FLOW_CTRL
		<< KDB_ENABLE_NO_ARGS_SHIFT,
		KDB_ENABLE_SIGNAL_NO_ARGS = KDB_ENABLE_SIGNAL
		<< KDB_ENABLE_NO_ARGS_SHIFT,
		KDB_ENABLE_REBOOT_NO_ARGS = KDB_ENABLE_REBOOT
		<< KDB_ENABLE_NO_ARGS_SHIFT,
		KDB_ENABLE_ALWAYS_SAFE_NO_ARGS = KDB_ENABLE_ALWAYS_SAFE
		<< KDB_ENABLE_NO_ARGS_SHIFT,
		KDB_ENABLE_MASK_NO_ARGS = KDB_ENABLE_MASK << KDB_ENABLE_NO_ARGS_SHIFT,

		KDB_REPEAT_NO_ARGS = 0x40000000, /* Repeat the command w/o arguments */
		KDB_REPEAT_WITH_ARGS = 0x80000000, /* Repeat the command with args */
		} kdb_cmdflags_t;

		typedef int (kdb_func_t)(int, const char *);

		@@ -62,6 +105,7 @@ extern atomic_t kdb_event;
		#define KDB_BADLENGTH (-19)
		#define KDB_NOBP (-20)
		#define KDB_BADADDR (-21)
		#define KDB_NOPERM (-22)

		/*
		* kdb_diemsg
		@@ -146,17 +190,17 @@ static inline const char kdb_walk_kallsyms(loff_t pos)

		/* Dynamic kdb shell command registration */
		extern int kdb_register(char , kdb_func_t, char , char *, short);
		extern int kdb_register_repeat(char , kdb_func_t, char , char *,
		short, kdb_repeat_t);
		extern int kdb_register_flags(char , kdb_func_t, char , char *,
		short, kdb_cmdflags_t);
		extern int kdb_unregister(char *);
		#else /* ! CONFIG_KGDB_KDB */
		static inline __printf(1, 2) int kdb_printf(const char *fmt, ...) { return 0; }
		static inline void kdb_init(int level) {}
		static inline int kdb_register(char cmd, kdb_func_t func, char usage,
		char *help, short minlen) { return 0; }
		static inline int kdb_register_repeat(char cmd, kdb_func_t func, char usage,
		static inline int kdb_register_flags(char cmd, kdb_func_t func, char usage,
		char *help, short minlen,
		kdb_repeat_t repeat) { return 0; }
		kdb_cmdflags_t flags) { return 0; }
		static inline int kdb_unregister(char *cmd) { return 0; }
		#endif /* CONFIG_KGDB_KDB */
		enum {

kernel/debug/debug_core.c

+28 −24

Original line number	Diff line number	Diff line
		@@ -27,6 +27,9 @@
		* version 2. This program is licensed "as is" without any warranty of any
		* kind, whether express or implied.
		*/

		#define pr_fmt(fmt) "KGDB: " fmt

		#include <linux/pid_namespace.h>
		#include <linux/clocksource.h>
		#include <linux/serial_core.h>
		@@ -196,8 +199,8 @@ int __weak kgdb_validate_break_address(unsigned long addr)
		return err;
		err = kgdb_arch_remove_breakpoint(&tmp);
		if (err)
		printk(KERN_ERR "KGDB: Critical breakpoint error, kernel "
		"memory destroyed at: %lx", addr);
		pr_err("Critical breakpoint error, kernel memory destroyed at: %lx\n",
		addr);
		return err;
		}

		@@ -256,7 +259,7 @@ int dbg_activate_sw_breakpoints(void)
		error = kgdb_arch_set_breakpoint(&kgdb_break[i]);
		if (error) {
		ret = error;
		printk(KERN_INFO "KGDB: BP install failed: %lx",
		pr_info("BP install failed: %lx\n",
		kgdb_break[i].bpt_addr);
		continue;
		}
		@@ -319,7 +322,7 @@ int dbg_deactivate_sw_breakpoints(void)
		continue;
		error = kgdb_arch_remove_breakpoint(&kgdb_break[i]);
		if (error) {
		printk(KERN_INFO "KGDB: BP remove failed: %lx\n",
		pr_info("BP remove failed: %lx\n",
		kgdb_break[i].bpt_addr);
		ret = error;
		}
		@@ -367,7 +370,7 @@ int dbg_remove_all_break(void)
		goto setundefined;
		error = kgdb_arch_remove_breakpoint(&kgdb_break[i]);
		if (error)
		printk(KERN_ERR "KGDB: breakpoint remove failed: %lx\n",
		pr_err("breakpoint remove failed: %lx\n",
		kgdb_break[i].bpt_addr);
		setundefined:
		kgdb_break[i].state = BP_UNDEFINED;
		@@ -400,9 +403,9 @@ static int kgdb_io_ready(int print_wait)
		if (print_wait) {
		#ifdef CONFIG_KGDB_KDB
		if (!dbg_kdb_mode)
		printk(KERN_CRIT "KGDB: waiting... or $3#33 for KDB\n");
		pr_crit("waiting... or $3#33 for KDB\n");
		#else
		printk(KERN_CRIT "KGDB: Waiting for remote debugger\n");
		pr_crit("Waiting for remote debugger\n");
		#endif
		}
		return 1;
		@@ -430,8 +433,7 @@ static int kgdb_reenter_check(struct kgdb_state *ks)
		exception_level = 0;
		kgdb_skipexception(ks->ex_vector, ks->linux_regs);
		dbg_activate_sw_breakpoints();
		printk(KERN_CRIT "KGDB: re-enter error: breakpoint removed %lx\n",
		addr);
		pr_crit("re-enter error: breakpoint removed %lx\n", addr);
		WARN_ON_ONCE(1);

		return 1;
		@@ -444,7 +446,7 @@ static int kgdb_reenter_check(struct kgdb_state *ks)
		panic("Recursive entry to debugger");
		}

		printk(KERN_CRIT "KGDB: re-enter exception: ALL breakpoints killed\n");
		pr_crit("re-enter exception: ALL breakpoints killed\n");
		#ifdef CONFIG_KGDB_KDB
		/* Allow kdb to debug itself one level */
		return 0;
		@@ -471,6 +473,7 @@ static int kgdb_cpu_enter(struct kgdb_state ks, struct pt_regs regs,
		int cpu;
		int trace_on = 0;
		int online_cpus = num_online_cpus();
		u64 time_left;

		kgdb_info[ks->cpu].enter_kgdb++;
		kgdb_info[ks->cpu].exception_state \|= exception_state;
		@@ -595,9 +598,13 @@ return_normal:
		/*
		* Wait for the other CPUs to be notified and be waiting for us:
		*/
		while (kgdb_do_roundup && (atomic_read(&masters_in_kgdb) +
		atomic_read(&slaves_in_kgdb)) != online_cpus)
		time_left = loops_per_jiffy * HZ;
		while (kgdb_do_roundup && --time_left &&
		(atomic_read(&masters_in_kgdb) + atomic_read(&slaves_in_kgdb)) !=
		online_cpus)
		cpu_relax();
		if (!time_left)
		pr_crit("KGDB: Timed out waiting for secondary CPUs.\n");

		/*
		* At this point the primary processor is completely
		@@ -795,15 +802,15 @@ static struct console kgdbcons = {
		static void sysrq_handle_dbg(int key)
		{
		if (!dbg_io_ops) {
		printk(KERN_CRIT "ERROR: No KGDB I/O module available\n");
		pr_crit("ERROR: No KGDB I/O module available\n");
		return;
		}
		if (!kgdb_connected) {
		#ifdef CONFIG_KGDB_KDB
		if (!dbg_kdb_mode)
		printk(KERN_CRIT "KGDB or $3#33 for KDB\n");
		pr_crit("KGDB or $3#33 for KDB\n");
		#else
		printk(KERN_CRIT "Entering KGDB\n");
		pr_crit("Entering KGDB\n");
		#endif
		}

		@@ -945,7 +952,7 @@ static void kgdb_initial_breakpoint(void)
		{
		kgdb_break_asap = 0;

		printk(KERN_CRIT "kgdb: Waiting for connection from remote gdb...\n");
		pr_crit("Waiting for connection from remote gdb...\n");
		kgdb_breakpoint();
		}

		@@ -964,8 +971,7 @@ int kgdb_register_io_module(struct kgdb_io *new_dbg_io_ops)
		if (dbg_io_ops) {
		spin_unlock(&kgdb_registration_lock);

		printk(KERN_ERR "kgdb: Another I/O driver is already "
		"registered with KGDB.\n");
		pr_err("Another I/O driver is already registered with KGDB\n");
		return -EBUSY;
		}

		@@ -981,8 +987,7 @@ int kgdb_register_io_module(struct kgdb_io *new_dbg_io_ops)

		spin_unlock(&kgdb_registration_lock);

		printk(KERN_INFO "kgdb: Registered I/O driver %s.\n",
		new_dbg_io_ops->name);
		pr_info("Registered I/O driver %s\n", new_dbg_io_ops->name);

		/* Arm KGDB now. */
		kgdb_register_callbacks();
		@@ -1017,8 +1022,7 @@ void kgdb_unregister_io_module(struct kgdb_io *old_dbg_io_ops)

		spin_unlock(&kgdb_registration_lock);

		printk(KERN_INFO
		"kgdb: Unregistered I/O driver %s, debugger disabled.\n",
		pr_info("Unregistered I/O driver %s, debugger disabled\n",
		old_dbg_io_ops->name);
		}
		EXPORT_SYMBOL_GPL(kgdb_unregister_io_module);

kernel/debug/kdb/kdb_bp.c

+22 −15

Original line number	Diff line number	Diff line
		@@ -531,22 +531,29 @@ void __init kdb_initbptab(void)
		for (i = 0, bp = kdb_breakpoints; i < KDB_MAXBPT; i++, bp++)
		bp->bp_free = 1;

		kdb_register_repeat("bp", kdb_bp, "[<vaddr>]",
		"Set/Display breakpoints", 0, KDB_REPEAT_NO_ARGS);
		kdb_register_repeat("bl", kdb_bp, "[<vaddr>]",
		"Display breakpoints", 0, KDB_REPEAT_NO_ARGS);
		kdb_register_flags("bp", kdb_bp, "[<vaddr>]",
		"Set/Display breakpoints", 0,
		KDB_ENABLE_FLOW_CTRL \| KDB_REPEAT_NO_ARGS);
		kdb_register_flags("bl", kdb_bp, "[<vaddr>]",
		"Display breakpoints", 0,
		KDB_ENABLE_FLOW_CTRL \| KDB_REPEAT_NO_ARGS);
		if (arch_kgdb_ops.flags & KGDB_HW_BREAKPOINT)
		kdb_register_repeat("bph", kdb_bp, "[<vaddr>]",
		"[datar [length]\|dataw [length]] Set hw brk", 0, KDB_REPEAT_NO_ARGS);
		kdb_register_repeat("bc", kdb_bc, "<bpnum>",
		"Clear Breakpoint", 0, KDB_REPEAT_NONE);
		kdb_register_repeat("be", kdb_bc, "<bpnum>",
		"Enable Breakpoint", 0, KDB_REPEAT_NONE);
		kdb_register_repeat("bd", kdb_bc, "<bpnum>",
		"Disable Breakpoint", 0, KDB_REPEAT_NONE);

		kdb_register_repeat("ss", kdb_ss, "",
		"Single Step", 1, KDB_REPEAT_NO_ARGS);
		kdb_register_flags("bph", kdb_bp, "[<vaddr>]",
		"[datar [length]\|dataw [length]] Set hw brk", 0,
		KDB_ENABLE_FLOW_CTRL \| KDB_REPEAT_NO_ARGS);
		kdb_register_flags("bc", kdb_bc, "<bpnum>",
		"Clear Breakpoint", 0,
		KDB_ENABLE_FLOW_CTRL);
		kdb_register_flags("be", kdb_bc, "<bpnum>",
		"Enable Breakpoint", 0,
		KDB_ENABLE_FLOW_CTRL);
		kdb_register_flags("bd", kdb_bc, "<bpnum>",
		"Disable Breakpoint", 0,
		KDB_ENABLE_FLOW_CTRL);

		kdb_register_flags("ss", kdb_ss, "",
		"Single Step", 1,
		KDB_ENABLE_FLOW_CTRL \| KDB_REPEAT_NO_ARGS);
		/*
		* Architecture dependent initialization.
		*/

kernel/debug/kdb/kdb_debugger.c

+4 −0

Original line number	Diff line number	Diff line
		@@ -129,6 +129,10 @@ int kdb_stub(struct kgdb_state *ks)
		ks->pass_exception = 1;
		KDB_FLAG_SET(CATASTROPHIC);
		}
		/* set CATASTROPHIC if the system contains unresponsive processors */
		for_each_online_cpu(i)
		if (!kgdb_info[i].enter_kgdb)
		KDB_FLAG_SET(CATASTROPHIC);
		if (KDB_STATE(SSBPT) && reason == KDB_REASON_SSTEP) {
		KDB_STATE_CLEAR(SSBPT);
		KDB_STATE_CLEAR(DOING_SS);

kernel/debug/kdb/kdb_main.c

+171 −96

Original line number	Diff line number	Diff line
		@@ -12,6 +12,7 @@
		*/

		#include <linux/ctype.h>
		#include <linux/types.h>
		#include <linux/string.h>
		#include <linux/kernel.h>
		#include <linux/kmsg_dump.h>
		@@ -23,6 +24,7 @@
		#include <linux/vmalloc.h>
		#include <linux/atomic.h>
		#include <linux/module.h>
		#include <linux/moduleparam.h>
		#include <linux/mm.h>
		#include <linux/init.h>
		#include <linux/kallsyms.h>
		@@ -42,6 +44,12 @@
		#include <linux/slab.h>
		#include "kdb_private.h"

		#undef MODULE_PARAM_PREFIX
		#define MODULE_PARAM_PREFIX "kdb."

		static int kdb_cmd_enabled = CONFIG_KDB_DEFAULT_ENABLE;
		module_param_named(cmd_enable, kdb_cmd_enabled, int, 0600);

		#define GREP_LEN 256
		char kdb_grep_string[GREP_LEN];
		int kdb_grepping_flag;
		@@ -121,6 +129,7 @@ static kdbmsg_t kdbmsgs[] = {
		KDBMSG(BADLENGTH, "Invalid length field"),
		KDBMSG(NOBP, "No Breakpoint exists"),
		KDBMSG(BADADDR, "Invalid address"),
		KDBMSG(NOPERM, "Permission denied"),
		};
		#undef KDBMSG

		@@ -187,6 +196,26 @@ struct task_struct *kdb_curr_task(int cpu)
		return p;
		}

		/*
		* Check whether the flags of the current command and the permissions
		* of the kdb console has allow a command to be run.
		*/
		static inline bool kdb_check_flags(kdb_cmdflags_t flags, int permissions,
		bool no_args)
		{
		/* permissions comes from userspace so needs massaging slightly */
		permissions &= KDB_ENABLE_MASK;
		permissions \|= KDB_ENABLE_ALWAYS_SAFE;

		/* some commands change group when launched with no arguments */
		if (no_args)
		permissions \|= permissions << KDB_ENABLE_NO_ARGS_SHIFT;

		flags \|= KDB_ENABLE_ALL;

		return permissions & flags;
		}

		/*
		* kdbgetenv - This function will return the character string value of
		* an environment variable.
		@@ -475,6 +504,15 @@ int kdbgetaddrarg(int argc, const char *argv, int nextarg,
		char *cp;
		kdb_symtab_t symtab;

		/*
		* If the enable flags prohibit both arbitrary memory access
		* and flow control then there are no reasonable grounds to
		* provide symbol lookup.
		*/
		if (!kdb_check_flags(KDB_ENABLE_MEM_READ \| KDB_ENABLE_FLOW_CTRL,
		kdb_cmd_enabled, false))
		return KDB_NOPERM;

		/*
		* Process arguments which follow the following syntax:
		*
		@@ -641,8 +679,13 @@ static int kdb_defcmd2(const char cmdstr, const char argv0)
		if (!s->count)
		s->usable = 0;
		if (s->usable)
		kdb_register(s->name, kdb_exec_defcmd,
		s->usage, s->help, 0);
		/* macros are always safe because when executed each
		* internal command re-enters kdb_parse() and is
		* safety checked individually.
		*/
		kdb_register_flags(s->name, kdb_exec_defcmd, s->usage,
		s->help, 0,
		KDB_ENABLE_ALWAYS_SAFE);
		return 0;
		}
		if (!s->usable)
		@@ -1003,25 +1046,22 @@ int kdb_parse(const char *cmdstr)

		if (i < kdb_max_commands) {
		int result;

		if (!kdb_check_flags(tp->cmd_flags, kdb_cmd_enabled, argc <= 1))
		return KDB_NOPERM;

		KDB_STATE_SET(CMD);
		result = (tp->cmd_func)(argc-1, (const char *)argv);
		if (result && ignore_errors && result > KDB_CMD_GO)
		result = 0;
		KDB_STATE_CLEAR(CMD);
		switch (tp->cmd_repeat) {
		case KDB_REPEAT_NONE:
		argc = 0;
		if (argv[0])
		*(argv[0]) = '\0';
		break;
		case KDB_REPEAT_NO_ARGS:
		argc = 1;
		if (argv[1])
		*(argv[1]) = '\0';
		break;
		case KDB_REPEAT_WITH_ARGS:
		break;
		}

		if (tp->cmd_flags & KDB_REPEAT_WITH_ARGS)
		return result;

		argc = tp->cmd_flags & KDB_REPEAT_NO_ARGS ? 1 : 0;
		if (argv[argc])
		*(argv[argc]) = '\0';
		return result;
		}

		@@ -1921,10 +1961,14 @@ static int kdb_rm(int argc, const char **argv)
		*/
		static int kdb_sr(int argc, const char **argv)
		{
		bool check_mask =
		!kdb_check_flags(KDB_ENABLE_ALL, kdb_cmd_enabled, false);

		if (argc != 1)
		return KDB_ARGCOUNT;

		kdb_trap_printk++;
		__handle_sysrq(*argv[1], false);
		__handle_sysrq(*argv[1], check_mask);
		kdb_trap_printk--;

		return 0;
		@@ -2157,6 +2201,8 @@ static void kdb_cpu_status(void)
		for (start_cpu = -1, i = 0; i < NR_CPUS; i++) {
		if (!cpu_online(i)) {
		state = 'F'; /* cpu is offline */
		} else if (!kgdb_info[i].enter_kgdb) {
		state = 'D'; /* cpu is online but unresponsive */
		} else {
		state = ' '; /* cpu is responding to kdb */
		if (kdb_task_state_char(KDB_TSK(i)) == 'I')
		@@ -2210,7 +2256,7 @@ static int kdb_cpu(int argc, const char **argv)
		/*
		* Validate cpunum
		*/
		if ((cpunum > NR_CPUS) \|\| !cpu_online(cpunum))
		if ((cpunum > NR_CPUS) \|\| !kgdb_info[cpunum].enter_kgdb)
		return KDB_BADCPUNUM;

		dbg_switch_cpu = cpunum;
		@@ -2375,6 +2421,8 @@ static int kdb_help(int argc, const char **argv)
		return 0;
		if (!kt->cmd_name)
		continue;
		if (!kdb_check_flags(kt->cmd_flags, kdb_cmd_enabled, true))
		continue;
		if (strlen(kt->cmd_usage) > 20)
		space = "\n ";
		kdb_printf("%-15.15s %-20s%s%s\n", kt->cmd_name,
		@@ -2629,7 +2677,7 @@ static int kdb_grep_help(int argc, const char **argv)
		}

		/*
		* kdb_register_repeat - This function is used to register a kernel
		* kdb_register_flags - This function is used to register a kernel
		* debugger command.
		* Inputs:
		* cmd Command name
		@@ -2641,12 +2689,12 @@ static int kdb_grep_help(int argc, const char **argv)
		* zero for success, one if a duplicate command.
		*/
		#define kdb_command_extend 50 /* arbitrary */
		int kdb_register_repeat(char *cmd,
		int kdb_register_flags(char *cmd,
		kdb_func_t func,
		char *usage,
		char *help,
		short minlen,
		kdb_repeat_t repeat)
		kdb_cmdflags_t flags)
		{
		int i;
		kdbtab_t *kp;
		@@ -2694,19 +2742,18 @@ int kdb_register_repeat(char *cmd,
		kp->cmd_func = func;
		kp->cmd_usage = usage;
		kp->cmd_help = help;
		kp->cmd_flags = 0;
		kp->cmd_minlen = minlen;
		kp->cmd_repeat = repeat;
		kp->cmd_flags = flags;

		return 0;
		}
		EXPORT_SYMBOL_GPL(kdb_register_repeat);
		EXPORT_SYMBOL_GPL(kdb_register_flags);


		/*
		* kdb_register - Compatibility register function for commands that do
		* not need to specify a repeat state. Equivalent to
		* kdb_register_repeat with KDB_REPEAT_NONE.
		* kdb_register_flags with flags set to 0.
		* Inputs:
		* cmd Command name
		* func Function to execute the command
		@@ -2721,8 +2768,7 @@ int kdb_register(char *cmd,
		char *help,
		short minlen)
		{
		return kdb_register_repeat(cmd, func, usage, help, minlen,
		KDB_REPEAT_NONE);
		return kdb_register_flags(cmd, func, usage, help, minlen, 0);
		}
		EXPORT_SYMBOL_GPL(kdb_register);

		@@ -2764,80 +2810,109 @@ static void __init kdb_inittab(void)
		for_each_kdbcmd(kp, i)
		kp->cmd_name = NULL;

		kdb_register_repeat("md", kdb_md, "<vaddr>",
		kdb_register_flags("md", kdb_md, "<vaddr>",
		"Display Memory Contents, also mdWcN, e.g. md8c1", 1,
		KDB_REPEAT_NO_ARGS);
		kdb_register_repeat("mdr", kdb_md, "<vaddr> <bytes>",
		"Display Raw Memory", 0, KDB_REPEAT_NO_ARGS);
		kdb_register_repeat("mdp", kdb_md, "<paddr> <bytes>",
		"Display Physical Memory", 0, KDB_REPEAT_NO_ARGS);
		kdb_register_repeat("mds", kdb_md, "<vaddr>",
		"Display Memory Symbolically", 0, KDB_REPEAT_NO_ARGS);
		kdb_register_repeat("mm", kdb_mm, "<vaddr> <contents>",
		"Modify Memory Contents", 0, KDB_REPEAT_NO_ARGS);
		kdb_register_repeat("go", kdb_go, "[<vaddr>]",
		"Continue Execution", 1, KDB_REPEAT_NONE);
		kdb_register_repeat("rd", kdb_rd, "",
		"Display Registers", 0, KDB_REPEAT_NONE);
		kdb_register_repeat("rm", kdb_rm, "<reg> <contents>",
		"Modify Registers", 0, KDB_REPEAT_NONE);
		kdb_register_repeat("ef", kdb_ef, "<vaddr>",
		"Display exception frame", 0, KDB_REPEAT_NONE);
		kdb_register_repeat("bt", kdb_bt, "[<vaddr>]",
		"Stack traceback", 1, KDB_REPEAT_NONE);
		kdb_register_repeat("btp", kdb_bt, "<pid>",
		"Display stack for process <pid>", 0, KDB_REPEAT_NONE);
		kdb_register_repeat("bta", kdb_bt, "[D\|R\|S\|T\|C\|Z\|E\|U\|I\|M\|A]",
		"Backtrace all processes matching state flag", 0, KDB_REPEAT_NONE);
		kdb_register_repeat("btc", kdb_bt, "",
		"Backtrace current process on each cpu", 0, KDB_REPEAT_NONE);
		kdb_register_repeat("btt", kdb_bt, "<vaddr>",
		KDB_ENABLE_MEM_READ \| KDB_REPEAT_NO_ARGS);
		kdb_register_flags("mdr", kdb_md, "<vaddr> <bytes>",
		"Display Raw Memory", 0,
		KDB_ENABLE_MEM_READ \| KDB_REPEAT_NO_ARGS);
		kdb_register_flags("mdp", kdb_md, "<paddr> <bytes>",
		"Display Physical Memory", 0,
		KDB_ENABLE_MEM_READ \| KDB_REPEAT_NO_ARGS);
		kdb_register_flags("mds", kdb_md, "<vaddr>",
		"Display Memory Symbolically", 0,
		KDB_ENABLE_MEM_READ \| KDB_REPEAT_NO_ARGS);
		kdb_register_flags("mm", kdb_mm, "<vaddr> <contents>",
		"Modify Memory Contents", 0,
		KDB_ENABLE_MEM_WRITE \| KDB_REPEAT_NO_ARGS);
		kdb_register_flags("go", kdb_go, "[<vaddr>]",
		"Continue Execution", 1,
		KDB_ENABLE_REG_WRITE \| KDB_ENABLE_ALWAYS_SAFE_NO_ARGS);
		kdb_register_flags("rd", kdb_rd, "",
		"Display Registers", 0,
		KDB_ENABLE_REG_READ);
		kdb_register_flags("rm", kdb_rm, "<reg> <contents>",
		"Modify Registers", 0,
		KDB_ENABLE_REG_WRITE);
		kdb_register_flags("ef", kdb_ef, "<vaddr>",
		"Display exception frame", 0,
		KDB_ENABLE_MEM_READ);
		kdb_register_flags("bt", kdb_bt, "[<vaddr>]",
		"Stack traceback", 1,
		KDB_ENABLE_MEM_READ \| KDB_ENABLE_INSPECT_NO_ARGS);
		kdb_register_flags("btp", kdb_bt, "<pid>",
		"Display stack for process <pid>", 0,
		KDB_ENABLE_INSPECT);
		kdb_register_flags("bta", kdb_bt, "[D\|R\|S\|T\|C\|Z\|E\|U\|I\|M\|A]",
		"Backtrace all processes matching state flag", 0,
		KDB_ENABLE_INSPECT);
		kdb_register_flags("btc", kdb_bt, "",
		"Backtrace current process on each cpu", 0,
		KDB_ENABLE_INSPECT);
		kdb_register_flags("btt", kdb_bt, "<vaddr>",
		"Backtrace process given its struct task address", 0,
		KDB_REPEAT_NONE);
		kdb_register_repeat("env", kdb_env, "",
		"Show environment variables", 0, KDB_REPEAT_NONE);
		kdb_register_repeat("set", kdb_set, "",
		"Set environment variables", 0, KDB_REPEAT_NONE);
		kdb_register_repeat("help", kdb_help, "",
		"Display Help Message", 1, KDB_REPEAT_NONE);
		kdb_register_repeat("?", kdb_help, "",
		"Display Help Message", 0, KDB_REPEAT_NONE);
		kdb_register_repeat("cpu", kdb_cpu, "<cpunum>",
		"Switch to new cpu", 0, KDB_REPEAT_NONE);
		kdb_register_repeat("kgdb", kdb_kgdb, "",
		"Enter kgdb mode", 0, KDB_REPEAT_NONE);
		kdb_register_repeat("ps", kdb_ps, "[<flags>\|A]",
		"Display active task list", 0, KDB_REPEAT_NONE);
		kdb_register_repeat("pid", kdb_pid, "<pidnum>",
		"Switch to another task", 0, KDB_REPEAT_NONE);
		kdb_register_repeat("reboot", kdb_reboot, "",
		"Reboot the machine immediately", 0, KDB_REPEAT_NONE);
		KDB_ENABLE_MEM_READ \| KDB_ENABLE_INSPECT_NO_ARGS);
		kdb_register_flags("env", kdb_env, "",
		"Show environment variables", 0,
		KDB_ENABLE_ALWAYS_SAFE);
		kdb_register_flags("set", kdb_set, "",
		"Set environment variables", 0,
		KDB_ENABLE_ALWAYS_SAFE);
		kdb_register_flags("help", kdb_help, "",
		"Display Help Message", 1,
		KDB_ENABLE_ALWAYS_SAFE);
		kdb_register_flags("?", kdb_help, "",
		"Display Help Message", 0,
		KDB_ENABLE_ALWAYS_SAFE);
		kdb_register_flags("cpu", kdb_cpu, "<cpunum>",
		"Switch to new cpu", 0,
		KDB_ENABLE_ALWAYS_SAFE_NO_ARGS);
		kdb_register_flags("kgdb", kdb_kgdb, "",
		"Enter kgdb mode", 0, 0);
		kdb_register_flags("ps", kdb_ps, "[<flags>\|A]",
		"Display active task list", 0,
		KDB_ENABLE_INSPECT);
		kdb_register_flags("pid", kdb_pid, "<pidnum>",
		"Switch to another task", 0,
		KDB_ENABLE_INSPECT);
		kdb_register_flags("reboot", kdb_reboot, "",
		"Reboot the machine immediately", 0,
		KDB_ENABLE_REBOOT);
		#if defined(CONFIG_MODULES)
		kdb_register_repeat("lsmod", kdb_lsmod, "",
		"List loaded kernel modules", 0, KDB_REPEAT_NONE);
		kdb_register_flags("lsmod", kdb_lsmod, "",
		"List loaded kernel modules", 0,
		KDB_ENABLE_INSPECT);
		#endif
		#if defined(CONFIG_MAGIC_SYSRQ)
		kdb_register_repeat("sr", kdb_sr, "<key>",
		"Magic SysRq key", 0, KDB_REPEAT_NONE);
		kdb_register_flags("sr", kdb_sr, "<key>",
		"Magic SysRq key", 0,
		KDB_ENABLE_ALWAYS_SAFE);
		#endif
		#if defined(CONFIG_PRINTK)
		kdb_register_repeat("dmesg", kdb_dmesg, "[lines]",
		"Display syslog buffer", 0, KDB_REPEAT_NONE);
		kdb_register_flags("dmesg", kdb_dmesg, "[lines]",
		"Display syslog buffer", 0,
		KDB_ENABLE_ALWAYS_SAFE);
		#endif
		if (arch_kgdb_ops.enable_nmi) {
		kdb_register_repeat("disable_nmi", kdb_disable_nmi, "",
		"Disable NMI entry to KDB", 0, KDB_REPEAT_NONE);
		}
		kdb_register_repeat("defcmd", kdb_defcmd, "name \"usage\" \"help\"",
		"Define a set of commands, down to endefcmd", 0, KDB_REPEAT_NONE);
		kdb_register_repeat("kill", kdb_kill, "<-signal> <pid>",
		"Send a signal to a process", 0, KDB_REPEAT_NONE);
		kdb_register_repeat("summary", kdb_summary, "",
		"Summarize the system", 4, KDB_REPEAT_NONE);
		kdb_register_repeat("per_cpu", kdb_per_cpu, "<sym> [<bytes>] [<cpu>]",
		"Display per_cpu variables", 3, KDB_REPEAT_NONE);
		kdb_register_repeat("grephelp", kdb_grep_help, "",
		"Display help on \| grep", 0, KDB_REPEAT_NONE);
		kdb_register_flags("disable_nmi", kdb_disable_nmi, "",
		"Disable NMI entry to KDB", 0,
		KDB_ENABLE_ALWAYS_SAFE);
		}
		kdb_register_flags("defcmd", kdb_defcmd, "name \"usage\" \"help\"",
		"Define a set of commands, down to endefcmd", 0,
		KDB_ENABLE_ALWAYS_SAFE);
		kdb_register_flags("kill", kdb_kill, "<-signal> <pid>",
		"Send a signal to a process", 0,
		KDB_ENABLE_SIGNAL);
		kdb_register_flags("summary", kdb_summary, "",
		"Summarize the system", 4,
		KDB_ENABLE_ALWAYS_SAFE);
		kdb_register_flags("per_cpu", kdb_per_cpu, "<sym> [<bytes>] [<cpu>]",
		"Display per_cpu variables", 3,
		KDB_ENABLE_MEM_READ);
		kdb_register_flags("grephelp", kdb_grep_help, "",
		"Display help on \| grep", 0,
		KDB_ENABLE_ALWAYS_SAFE);
		}

		/* Execute any commands defined in kdb_cmds. */

Admin message