Merge tag 'for_linus-3.4-rc2' of git://git.kernel.org/pub/scm/linux/kernel/git/jwessel/kgdb (6c216ec6) · Commits · 戴 / test

arch/x86/kernel/kgdb.c

+60 −0

Original line number	Diff line number	Diff line
		@@ -43,6 +43,8 @@
		#include <linux/smp.h>
		#include <linux/nmi.h>
		#include <linux/hw_breakpoint.h>
		#include <linux/uaccess.h>
		#include <linux/memory.h>

		#include <asm/debugreg.h>
		#include <asm/apicdef.h>
		@@ -741,6 +743,64 @@ void kgdb_arch_set_pc(struct pt_regs *regs, unsigned long ip)
		regs->ip = ip;
		}

		int kgdb_arch_set_breakpoint(struct kgdb_bkpt *bpt)
		{
		int err;
		char opc[BREAK_INSTR_SIZE];

		bpt->type = BP_BREAKPOINT;
		err = probe_kernel_read(bpt->saved_instr, (char *)bpt->bpt_addr,
		BREAK_INSTR_SIZE);
		if (err)
		return err;
		err = probe_kernel_write((char *)bpt->bpt_addr,
		arch_kgdb_ops.gdb_bpt_instr, BREAK_INSTR_SIZE);
		#ifdef CONFIG_DEBUG_RODATA
		if (!err)
		return err;
		/*
		* It is safe to call text_poke() because normal kernel execution
		* is stopped on all cores, so long as the text_mutex is not locked.
		*/
		if (mutex_is_locked(&text_mutex))
		return -EBUSY;
		text_poke((void *)bpt->bpt_addr, arch_kgdb_ops.gdb_bpt_instr,
		BREAK_INSTR_SIZE);
		err = probe_kernel_read(opc, (char *)bpt->bpt_addr, BREAK_INSTR_SIZE);
		if (err)
		return err;
		if (memcmp(opc, arch_kgdb_ops.gdb_bpt_instr, BREAK_INSTR_SIZE))
		return -EINVAL;
		bpt->type = BP_POKE_BREAKPOINT;
		#endif /* CONFIG_DEBUG_RODATA */
		return err;
		}

		int kgdb_arch_remove_breakpoint(struct kgdb_bkpt *bpt)
		{
		#ifdef CONFIG_DEBUG_RODATA
		int err;
		char opc[BREAK_INSTR_SIZE];

		if (bpt->type != BP_POKE_BREAKPOINT)
		goto knl_write;
		/*
		* It is safe to call text_poke() because normal kernel execution
		* is stopped on all cores, so long as the text_mutex is not locked.
		*/
		if (mutex_is_locked(&text_mutex))
		goto knl_write;
		text_poke((void *)bpt->bpt_addr, bpt->saved_instr, BREAK_INSTR_SIZE);
		err = probe_kernel_read(opc, (char *)bpt->bpt_addr, BREAK_INSTR_SIZE);
		if (err \|\| memcmp(opc, bpt->saved_instr, BREAK_INSTR_SIZE))
		goto knl_write;
		return err;
		knl_write:
		#endif /* CONFIG_DEBUG_RODATA */
		return probe_kernel_write((char *)bpt->bpt_addr,
		(char *)bpt->saved_instr, BREAK_INSTR_SIZE);
		}

		struct kgdb_arch arch_kgdb_ops = {
		/* Breakpoint instruction: */
		.gdb_bpt_instr = { 0xcc },

drivers/misc/kgdbts.c

+115 −45

Original line number	Diff line number	Diff line
		@@ -134,12 +134,17 @@ static int force_hwbrks;
		static int hwbreaks_ok;
		static int hw_break_val;
		static int hw_break_val2;
		static int cont_instead_of_sstep;
		static unsigned long cont_thread_id;
		static unsigned long sstep_thread_id;
		#if defined(CONFIG_ARM) \|\| defined(CONFIG_MIPS) \|\| defined(CONFIG_SPARC)
		static int arch_needs_sstep_emulation = 1;
		#else
		static int arch_needs_sstep_emulation;
		#endif
		static unsigned long cont_addr;
		static unsigned long sstep_addr;
		static int restart_from_top_after_write;
		static int sstep_state;

		/* Storage for the registers, in GDB format. */
		@@ -187,7 +192,8 @@ static int kgdbts_unreg_thread(void *ptr)
		*/
		while (!final_ack)
		msleep_interruptible(1500);

		/* Pause for any other threads to exit after final ack. */
		msleep_interruptible(1000);
		if (configured)
		kgdb_unregister_io_module(&kgdbts_io_ops);
		configured = 0;
		@@ -211,7 +217,7 @@ static unsigned long lookup_addr(char *arg)
		if (!strcmp(arg, "kgdbts_break_test"))
		addr = (unsigned long)kgdbts_break_test;
		else if (!strcmp(arg, "sys_open"))
		addr = (unsigned long)sys_open;
		addr = (unsigned long)do_sys_open;
		else if (!strcmp(arg, "do_fork"))
		addr = (unsigned long)do_fork;
		else if (!strcmp(arg, "hw_break_val"))
		@@ -283,6 +289,16 @@ static void hw_break_val_write(void)
		hw_break_val++;
		}

		static int get_thread_id_continue(char put_str, char arg)
		{
		char *ptr = &put_str[11];

		if (put_str[1] != 'T' \|\| put_str[2] != '0')
		return 1;
		kgdb_hex2long(&ptr, &cont_thread_id);
		return 0;
		}

		static int check_and_rewind_pc(char put_str, char arg)
		{
		unsigned long addr = lookup_addr(arg);
		@@ -299,13 +315,21 @@ static int check_and_rewind_pc(char put_str, char arg)
		if (addr + BREAK_INSTR_SIZE == ip)
		offset = -BREAK_INSTR_SIZE;
		#endif
		if (strcmp(arg, "silent") && ip + offset != addr) {

		if (arch_needs_sstep_emulation && sstep_addr &&
		ip + offset == sstep_addr &&
		((!strcmp(arg, "sys_open") \|\| !strcmp(arg, "do_fork")))) {
		/* This is special case for emulated single step */
		v2printk("Emul: rewind hit single step bp\n");
		restart_from_top_after_write = 1;
		} else if (strcmp(arg, "silent") && ip + offset != addr) {
		eprintk("kgdbts: BP mismatch %lx expected %lx\n",
		ip + offset, addr);
		return 1;
		}
		/* Readjust the instruction pointer if needed */
		ip += offset;
		cont_addr = ip;
		#ifdef GDB_ADJUSTS_BREAK_OFFSET
		instruction_pointer_set(&kgdbts_regs, ip);
		#endif
		@@ -315,6 +339,8 @@ static int check_and_rewind_pc(char put_str, char arg)
		static int check_single_step(char put_str, char arg)
		{
		unsigned long addr = lookup_addr(arg);
		static int matched_id;

		/*
		* From an arch indepent point of view the instruction pointer
		* should be on a different instruction
		@@ -324,6 +350,29 @@ static int check_single_step(char put_str, char arg)
		gdb_regs_to_pt_regs(kgdbts_gdb_regs, &kgdbts_regs);
		v2printk("Singlestep stopped at IP: %lx\n",
		instruction_pointer(&kgdbts_regs));

		if (sstep_thread_id != cont_thread_id) {
		/*
		* Ensure we stopped in the same thread id as before, else the
		* debugger should continue until the original thread that was
		* single stepped is scheduled again, emulating gdb's behavior.
		*/
		v2printk("ThrID does not match: %lx\n", cont_thread_id);
		if (arch_needs_sstep_emulation) {
		if (matched_id &&
		instruction_pointer(&kgdbts_regs) != addr)
		goto continue_test;
		matched_id++;
		ts.idx -= 2;
		sstep_state = 0;
		return 0;
		}
		cont_instead_of_sstep = 1;
		ts.idx -= 4;
		return 0;
		}
		continue_test:
		matched_id = 0;
		if (instruction_pointer(&kgdbts_regs) == addr) {
		eprintk("kgdbts: SingleStep failed at %lx\n",
		instruction_pointer(&kgdbts_regs));
		@@ -365,10 +414,40 @@ static int got_break(char put_str, char arg)
		return 1;
		}

		static void get_cont_catch(char *arg)
		{
		/* Always send detach because the test is completed at this point */
		fill_get_buf("D");
		}

		static int put_cont_catch(char put_str, char arg)
		{
		/* This is at the end of the test and we catch any and all input */
		v2printk("kgdbts: cleanup task: %lx\n", sstep_thread_id);
		ts.idx--;
		return 0;
		}

		static int emul_reset(char put_str, char arg)
		{
		if (strncmp(put_str, "$OK", 3))
		return 1;
		if (restart_from_top_after_write) {
		restart_from_top_after_write = 0;
		ts.idx = -1;
		}
		return 0;
		}

		static void emul_sstep_get(char *arg)
		{
		if (!arch_needs_sstep_emulation) {
		if (cont_instead_of_sstep) {
		cont_instead_of_sstep = 0;
		fill_get_buf("c");
		} else {
		fill_get_buf(arg);
		}
		return;
		}
		switch (sstep_state) {
		@@ -398,9 +477,11 @@ static void emul_sstep_get(char *arg)
		static int emul_sstep_put(char put_str, char arg)
		{
		if (!arch_needs_sstep_emulation) {
		if (!strncmp(put_str+1, arg, 2))
		return 0;
		char *ptr = &put_str[11];
		if (put_str[1] != 'T' \|\| put_str[2] != '0')
		return 1;
		kgdb_hex2long(&ptr, &sstep_thread_id);
		return 0;
		}
		switch (sstep_state) {
		case 1:
		@@ -411,8 +492,7 @@ static int emul_sstep_put(char put_str, char arg)
		v2printk("Stopped at IP: %lx\n",
		instruction_pointer(&kgdbts_regs));
		/* Want to stop at IP + break instruction size by default */
		sstep_addr = instruction_pointer(&kgdbts_regs) +
		BREAK_INSTR_SIZE;
		sstep_addr = cont_addr + BREAK_INSTR_SIZE;
		break;
		case 2:
		if (strncmp(put_str, "$OK", 3)) {
		@@ -424,6 +504,9 @@ static int emul_sstep_put(char put_str, char arg)
		if (strncmp(put_str, "$T0", 3)) {
		eprintk("kgdbts: failed continue sstep\n");
		return 1;
		} else {
		char *ptr = &put_str[11];
		kgdb_hex2long(&ptr, &sstep_thread_id);
		}
		break;
		case 4:
		@@ -502,10 +585,10 @@ static struct test_struct bad_read_test[] = {
		static struct test_struct singlestep_break_test[] = {
		{ "?", "S0" }, / Clear break points */
		{ "kgdbts_break_test", "OK", sw_break, }, /* set sw breakpoint */
		{ "c", "T0", }, / Continue */
		{ "c", "T0", NULL, get_thread_id_continue }, / Continue */
		{ "kgdbts_break_test", "OK", sw_rem_break }, /remove breakpoint /
		{ "g", "kgdbts_break_test", NULL, check_and_rewind_pc },
		{ "write", "OK", write_regs }, /* Write registers */
		{ "kgdbts_break_test", "OK", sw_rem_break }, /remove breakpoint /
		{ "s", "T0", emul_sstep_get, emul_sstep_put }, / Single step */
		{ "g", "kgdbts_break_test", NULL, check_single_step },
		{ "kgdbts_break_test", "OK", sw_break, }, /* set sw breakpoint */
		@@ -523,16 +606,16 @@ static struct test_struct singlestep_break_test[] = {
		static struct test_struct do_fork_test[] = {
		{ "?", "S0" }, / Clear break points */
		{ "do_fork", "OK", sw_break, }, /* set sw breakpoint */
		{ "c", "T0", }, / Continue */
		{ "g", "do_fork", NULL, check_and_rewind_pc }, /* check location */
		{ "write", "OK", write_regs }, /* Write registers */
		{ "c", "T0", NULL, get_thread_id_continue }, / Continue */
		{ "do_fork", "OK", sw_rem_break }, /remove breakpoint /
		{ "g", "do_fork", NULL, check_and_rewind_pc }, /* check location */
		{ "write", "OK", write_regs, emul_reset }, /* Write registers */
		{ "s", "T0", emul_sstep_get, emul_sstep_put }, / Single step */
		{ "g", "do_fork", NULL, check_single_step },
		{ "do_fork", "OK", sw_break, }, /* set sw breakpoint */
		{ "7", "T0", skip_back_repeat_test }, / Loop based on repeat_test */
		{ "D", "OK", NULL, final_ack_set }, /* detach and unregister I/O */
		{ "", "" },
		{ "", "", get_cont_catch, put_cont_catch },
		};

		/* Test for hitting a breakpoint at sys_open for what ever the number
		@@ -541,16 +624,16 @@ static struct test_struct do_fork_test[] = {
		static struct test_struct sys_open_test[] = {
		{ "?", "S0" }, / Clear break points */
		{ "sys_open", "OK", sw_break, }, /* set sw breakpoint */
		{ "c", "T0", }, / Continue */
		{ "g", "sys_open", NULL, check_and_rewind_pc }, /* check location */
		{ "write", "OK", write_regs }, /* Write registers */
		{ "c", "T0", NULL, get_thread_id_continue }, / Continue */
		{ "sys_open", "OK", sw_rem_break }, /remove breakpoint /
		{ "g", "sys_open", NULL, check_and_rewind_pc }, /* check location */
		{ "write", "OK", write_regs, emul_reset }, /* Write registers */
		{ "s", "T0", emul_sstep_get, emul_sstep_put }, / Single step */
		{ "g", "sys_open", NULL, check_single_step },
		{ "sys_open", "OK", sw_break, }, /* set sw breakpoint */
		{ "7", "T0", skip_back_repeat_test }, / Loop based on repeat_test */
		{ "D", "OK", NULL, final_ack_set }, /* detach and unregister I/O */
		{ "", "" },
		{ "", "", get_cont_catch, put_cont_catch },
		};

		/*
		@@ -693,8 +776,8 @@ static int run_simple_test(int is_get_char, int chr)
		/* This callback is a put char which is when kgdb sends data to
		* this I/O module.
		*/
		if (ts.tst[ts.idx].get[0] == '\0' &&
		ts.tst[ts.idx].put[0] == '\0') {
		if (ts.tst[ts.idx].get[0] == '\0' && ts.tst[ts.idx].put[0] == '\0' &&
		!ts.tst[ts.idx].get_handler) {
		eprintk("kgdbts: ERROR: beyond end of test on"
		" '%s' line %i\n", ts.name, ts.idx);
		return 0;
		@@ -907,6 +990,17 @@ static void kgdbts_run_tests(void)
		if (ptr)
		sstep_test = simple_strtol(ptr+1, NULL, 10);

		/* All HW break point tests */
		if (arch_kgdb_ops.flags & KGDB_HW_BREAKPOINT) {
		hwbreaks_ok = 1;
		v1printk("kgdbts:RUN hw breakpoint test\n");
		run_breakpoint_test(1);
		v1printk("kgdbts:RUN hw write breakpoint test\n");
		run_hw_break_test(1);
		v1printk("kgdbts:RUN access write breakpoint test\n");
		run_hw_break_test(0);
		}

		/* required internal KGDB tests */
		v1printk("kgdbts:RUN plant and detach test\n");
		run_plant_and_detach_test(0);
		@@ -924,35 +1018,11 @@ static void kgdbts_run_tests(void)

		/* ===Optional tests=== */

		/* All HW break point tests */
		if (arch_kgdb_ops.flags & KGDB_HW_BREAKPOINT) {
		hwbreaks_ok = 1;
		v1printk("kgdbts:RUN hw breakpoint test\n");
		run_breakpoint_test(1);
		v1printk("kgdbts:RUN hw write breakpoint test\n");
		run_hw_break_test(1);
		v1printk("kgdbts:RUN access write breakpoint test\n");
		run_hw_break_test(0);
		}

		if (nmi_sleep) {
		v1printk("kgdbts:RUN NMI sleep %i seconds test\n", nmi_sleep);
		run_nmi_sleep_test(nmi_sleep);
		}

		#ifdef CONFIG_DEBUG_RODATA
		/* Until there is an api to write to read-only text segments, use
		* HW breakpoints for the remainder of any tests, else print a
		* failure message if hw breakpoints do not work.
		*/
		if (!(arch_kgdb_ops.flags & KGDB_HW_BREAKPOINT && hwbreaks_ok)) {
		eprintk("kgdbts: HW breakpoints do not work,"
		"skipping remaining tests\n");
		return;
		}
		force_hwbrks = 1;
		#endif /* CONFIG_DEBUG_RODATA */

		/* If the do_fork test is run it will be the last test that is
		* executed because a kernel thread will be spawned at the very
		* end to unregister the debug hooks.

include/linux/kgdb.h

+4 −3

Original line number	Diff line number	Diff line
		@@ -63,7 +63,8 @@ enum kgdb_bptype {
		BP_HARDWARE_BREAKPOINT,
		BP_WRITE_WATCHPOINT,
		BP_READ_WATCHPOINT,
		BP_ACCESS_WATCHPOINT
		BP_ACCESS_WATCHPOINT,
		BP_POKE_BREAKPOINT,
		};

		enum kgdb_bpstate {
		@@ -207,8 +208,8 @@ extern void kgdb_arch_set_pc(struct pt_regs *regs, unsigned long pc);

		/* Optional functions. */
		extern int kgdb_validate_break_address(unsigned long addr);
		extern int kgdb_arch_set_breakpoint(unsigned long addr, char *saved_instr);
		extern int kgdb_arch_remove_breakpoint(unsigned long addr, char *bundle);
		extern int kgdb_arch_set_breakpoint(struct kgdb_bkpt *bpt);
		extern int kgdb_arch_remove_breakpoint(struct kgdb_bkpt *bpt);

		/**
		* kgdb_arch_late - Perform any architecture specific initalization.

kernel/debug/debug_core.c

+24 −29

Original line number	Diff line number	Diff line
		@@ -160,37 +160,39 @@ early_param("nokgdbroundup", opt_nokgdbroundup);
		* Weak aliases for breakpoint management,
		* can be overriden by architectures when needed:
		*/
		int __weak kgdb_arch_set_breakpoint(unsigned long addr, char *saved_instr)
		int __weak kgdb_arch_set_breakpoint(struct kgdb_bkpt *bpt)
		{
		int err;

		err = probe_kernel_read(saved_instr, (char *)addr, BREAK_INSTR_SIZE);
		err = probe_kernel_read(bpt->saved_instr, (char *)bpt->bpt_addr,
		BREAK_INSTR_SIZE);
		if (err)
		return err;

		return probe_kernel_write((char *)addr, arch_kgdb_ops.gdb_bpt_instr,
		BREAK_INSTR_SIZE);
		err = probe_kernel_write((char *)bpt->bpt_addr,
		arch_kgdb_ops.gdb_bpt_instr, BREAK_INSTR_SIZE);
		return err;
		}

		int __weak kgdb_arch_remove_breakpoint(unsigned long addr, char *bundle)
		int __weak kgdb_arch_remove_breakpoint(struct kgdb_bkpt *bpt)
		{
		return probe_kernel_write((char *)addr,
		(char *)bundle, BREAK_INSTR_SIZE);
		return probe_kernel_write((char *)bpt->bpt_addr,
		(char *)bpt->saved_instr, BREAK_INSTR_SIZE);
		}

		int __weak kgdb_validate_break_address(unsigned long addr)
		{
		char tmp_variable[BREAK_INSTR_SIZE];
		struct kgdb_bkpt tmp;
		int err;
		/* Validate setting the breakpoint and then removing it. In the
		/* Validate setting the breakpoint and then removing it. If the
		* remove fails, the kernel needs to emit a bad message because we
		* are deep trouble not being able to put things back the way we
		* found them.
		*/
		err = kgdb_arch_set_breakpoint(addr, tmp_variable);
		tmp.bpt_addr = addr;
		err = kgdb_arch_set_breakpoint(&tmp);
		if (err)
		return err;
		err = kgdb_arch_remove_breakpoint(addr, tmp_variable);
		err = kgdb_arch_remove_breakpoint(&tmp);
		if (err)
		printk(KERN_ERR "KGDB: Critical breakpoint error, kernel "
		"memory destroyed at: %lx", addr);
		@@ -234,7 +236,6 @@ static void kgdb_flush_swbreak_addr(unsigned long addr)
		*/
		int dbg_activate_sw_breakpoints(void)
		{
		unsigned long addr;
		int error;
		int ret = 0;
		int i;
		@@ -243,16 +244,15 @@ int dbg_activate_sw_breakpoints(void)
		if (kgdb_break[i].state != BP_SET)
		continue;

		addr = kgdb_break[i].bpt_addr;
		error = kgdb_arch_set_breakpoint(addr,
		kgdb_break[i].saved_instr);
		error = kgdb_arch_set_breakpoint(&kgdb_break[i]);
		if (error) {
		ret = error;
		printk(KERN_INFO "KGDB: BP install failed: %lx", addr);
		printk(KERN_INFO "KGDB: BP install failed: %lx",
		kgdb_break[i].bpt_addr);
		continue;
		}

		kgdb_flush_swbreak_addr(addr);
		kgdb_flush_swbreak_addr(kgdb_break[i].bpt_addr);
		kgdb_break[i].state = BP_ACTIVE;
		}
		return ret;
		@@ -301,7 +301,6 @@ int dbg_set_sw_break(unsigned long addr)

		int dbg_deactivate_sw_breakpoints(void)
		{
		unsigned long addr;
		int error;
		int ret = 0;
		int i;
		@@ -309,15 +308,14 @@ int dbg_deactivate_sw_breakpoints(void)
		for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
		if (kgdb_break[i].state != BP_ACTIVE)
		continue;
		addr = kgdb_break[i].bpt_addr;
		error = kgdb_arch_remove_breakpoint(addr,
		kgdb_break[i].saved_instr);
		error = kgdb_arch_remove_breakpoint(&kgdb_break[i]);
		if (error) {
		printk(KERN_INFO "KGDB: BP remove failed: %lx\n", addr);
		printk(KERN_INFO "KGDB: BP remove failed: %lx\n",
		kgdb_break[i].bpt_addr);
		ret = error;
		}

		kgdb_flush_swbreak_addr(addr);
		kgdb_flush_swbreak_addr(kgdb_break[i].bpt_addr);
		kgdb_break[i].state = BP_SET;
		}
		return ret;
		@@ -351,7 +349,6 @@ int kgdb_isremovedbreak(unsigned long addr)

		int dbg_remove_all_break(void)
		{
		unsigned long addr;
		int error;
		int i;

		@@ -359,12 +356,10 @@ int dbg_remove_all_break(void)
		for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
		if (kgdb_break[i].state != BP_ACTIVE)
		goto setundefined;
		addr = kgdb_break[i].bpt_addr;
		error = kgdb_arch_remove_breakpoint(addr,
		kgdb_break[i].saved_instr);
		error = kgdb_arch_remove_breakpoint(&kgdb_break[i]);
		if (error)
		printk(KERN_ERR "KGDB: breakpoint remove failed: %lx\n",
		addr);
		kgdb_break[i].bpt_addr);
		setundefined:
		kgdb_break[i].state = BP_UNDEFINED;
		}

kernel/debug/kdb/kdb_io.c

+1 −1

Original line number	Diff line number	Diff line
		@@ -743,7 +743,7 @@ kdb_printit:
		kdb_input_flush();
		c = console_drivers;

		if (!dbg_io_ops->is_console) {
		if (dbg_io_ops && !dbg_io_ops->is_console) {
		len = strlen(moreprompt);
		cp = moreprompt;
		while (len--) {

Admin message