Skip to contentSkip to conversation

AArch64: KGDB support

PATCH Superseded vijay.kilari at gmail.com 4 participants 12 messages Nov 30, 2013 – Dec 19, 2013

Subsystems (2)

v5 of 6 Superseded Latest is v6 →

lore
Share & tools
lore
#0 lore raw

v5 cover AArch64: KGDB support

From: Vijaya Kumar K <[email protected]>

Based on the step-handler and break-handler hooks patch from Sandeepa (Patch 1), KGDB debugging support is added for EL1 debug in AArch64 mode. Any updates that come for Patch 1 from Sandeepa will be rebased in next version

With second patch,register layout is updated to be inline with GDB tool. Basic GDB connection, break point set/clear and info commands are supported except step/next debugging

With third patch, step/next debugging support is added, where in pc is updated to point to the instruction to be stepped and stopped.

With fourth patch, the compile time breakpoint instruction reordering is fixed by making kgbd_breakpoint() as noinline

Tested with ARM64 simulator

v5:
- Updated BRK #imm16 value to 0x400 & 0x401 as per recommendation as per Marcus recommendataion
http://patchwork.ozlabs.org/patch/290801/
- Rebased to 3.13 AArch64 kernel

v4:
- Updated kgdb_single_step and kgdb_cpu_doing_single_step variables properly based on gdb state

v3:
- Rebased to v4 version of Sandeepa Prabhu's patch (patch 1)
- Made dynamic break point instruction encoding generic
- Made ESR value encoding generic for dynamic and compile break point
- Used memcpy and memset to copy register contents to gdb buffer
- Fixed reordering of break point instruction by compiler with patch 3
- Rebased against AAach64 upstream kernel

v2:
- Moved break instruction encoding to debug-monitors.h file
- Fixed endianess of compile break instruction encoding
- Updated I/O buffer sizes
- Updated register buffer size
- Remove changes to debug_exception handler in entry.S for
- ELR update and step debugging with update pc instead of ELR
- Rebased against AArch64 upstream kernel

v1:
- Initial patch-set

Sandeepa Prabhu (1):
arm64: support single-step and breakpoint handler hooks

Vijaya Kumar K (3):
AArch64: KGDB: Add Basic KGDB support
AArch64: KGDB: Add step debugging support
KGDB: make kgdb_breakpoint() as noinline

 arch/arm64/include/asm/debug-monitors.h |   68 +++++++
 arch/arm64/include/asm/kgdb.h           |   86 ++++++++
 arch/arm64/kernel/Makefile              |    1 +
 arch/arm64/kernel/debug-monitors.c      |   86 +++++++-
 arch/arm64/kernel/entry.S               |    2 +
 arch/arm64/kernel/kgdb.c                |  338 +++++++++++++++++++++++++++++++
 kernel/debug/debug_core.c               |    2 +-
 7 files changed, 581 insertions(+), 2 deletions(-)
 create mode 100644 arch/arm64/include/asm/kgdb.h
 create mode 100644 arch/arm64/kernel/kgdb.c
Signature · 1 line
1.7.9.5
#1 lore raw

PATCH v5 1/4 arm64: support single-step and breakpoint handler hooks

From: Sandeepa Prabhu <[email protected]>

AArch64 Single Steping and Breakpoint debug exceptions will be used by multiple debug framworks like kprobes & kgdb.

This patch implements the hooks for those frameworks to register their own handlers for handling breakpoint and single step events.

Reworked the debug exception handler in entry.S: do_dbg to route software breakpoint (BRK64) exception to do_debug_exception()

---
 arch/arm64/include/asm/debug-monitors.h |   21 ++++++++
 arch/arm64/kernel/debug-monitors.c      |   86 ++++++++++++++++++++++++++++++-
 arch/arm64/kernel/entry.S               |    2 +
 3 files changed, 108 insertions(+), 1 deletion(-)
arch/arm64/include/asm/debug-monitors.h +21 -0
index a2232d0..6231479 100644
@@ -62,6 +62,27 @@ struct task_struct;
 
 #define DBG_ARCH_ID_RESERVED	0	/* In case of ptrace ABI updates. */
 
+#define DBG_HOOK_HANDLED	0
+#define DBG_HOOK_ERROR		1
+
+struct step_hook {
+	struct list_head node;
+	int (*fn)(struct pt_regs *regs, unsigned int esr);
+};
+
+void register_step_hook(struct step_hook *hook);
+void unregister_step_hook(struct step_hook *hook);
+
+struct break_hook {
+	struct list_head node;
+	u32 esr_val;
+	u32 esr_mask;
+	int (*fn)(struct pt_regs *regs, unsigned int esr);
+};
+
+void register_break_hook(struct break_hook *hook);
+void unregister_break_hook(struct break_hook *hook);
+
 u8 debug_monitors_arch(void);
 
 void enable_debug_monitors(enum debug_el el);
arch/arm64/kernel/debug-monitors.c +85 -1

109 lines not on this page · raw message

arch/arm64/kernel/entry.S +2 -0
index 4d2c6f3..32d7fe6 100644
@@ -288,6 +288,8 @@ el1_dbg:
 	/*
 	 * Debug exception handling
 	 */
+	cmp	x24, #ESR_EL1_EC_BRK64		// if BRK64
+	cinc	x24, x24, eq			// set bit '0'
 	tbz	x24, #0, el1_inv		// EL1 only
 	mrs	x0, far_el1
 	mov	x2, sp				// struct pt_regs
Signature · 1 line
1.7.9.5
#2 lore raw

PATCH v5 1/4 arm64: support single-step and breakpoint handler hooks

Hi Will,

If you have no further issues or objections with this patch, please can you Ack this patch and consider for queuing it on upstream branch? (Or should it merge along with kgdb series?)

Thanks,
Sandeepa

Quoted 183 lines · On 30 November 2013 12:02, <[email protected]> wrote:

From: Sandeepa Prabhu <[email protected]>

AArch64 Single Steping and Breakpoint debug exceptions will be used by multiple debug framworks like kprobes & kgdb.

This patch implements the hooks for those frameworks to register their own handlers for handling breakpoint and single step events.

Reworked the debug exception handler in entry.S: do_dbg to route software breakpoint (BRK64) exception to do_debug_exception()

---
 arch/arm64/include/asm/debug-monitors.h |   21 ++++++++
 arch/arm64/kernel/debug-monitors.c      |   86 ++++++++++++++++++++++++++++++-
 arch/arm64/kernel/entry.S               |    2 +
 3 files changed, 108 insertions(+), 1 deletion(-)
arch/arm64/include/asm/debug-monitors.h +21 -0
index a2232d0..6231479 100644
@@ -62,6 +62,27 @@ struct task_struct;
 
 #define DBG_ARCH_ID_RESERVED   0       /* In case of ptrace ABI updates. */
 
+#define DBG_HOOK_HANDLED       0
+#define DBG_HOOK_ERROR         1
+
+struct step_hook {
+       struct list_head node;
+       int (*fn)(struct pt_regs *regs, unsigned int esr);
+};
+
+void register_step_hook(struct step_hook *hook);
+void unregister_step_hook(struct step_hook *hook);
+
+struct break_hook {
+       struct list_head node;
+       u32 esr_val;
+       u32 esr_mask;
+       int (*fn)(struct pt_regs *regs, unsigned int esr);
+};
+
+void register_break_hook(struct break_hook *hook);
+void unregister_break_hook(struct break_hook *hook);
+
 u8 debug_monitors_arch(void);
 
 void enable_debug_monitors(enum debug_el el);
arch/arm64/kernel/debug-monitors.c +85 -1
index 4ae6857..23586bd 100644
@@ -187,6 +187,48 @@ static void clear_regs_spsr_ss(struct pt_regs *regs)
        regs->pstate = spsr;
 }
 
+/* EL1 Single Step Handler hooks */
+static LIST_HEAD(step_hook);
+DEFINE_RWLOCK(step_hook_lock);
+
+void register_step_hook(struct step_hook *hook)
+{
+       write_lock(&step_hook_lock);
+       list_add(&hook->node, &step_hook);
+       write_unlock(&step_hook_lock);
+}
+
+void unregister_step_hook(struct step_hook *hook)
+{
+       write_lock(&step_hook_lock);
+       list_del(&hook->node);
+       write_unlock(&step_hook_lock);
+}
+
+/*
+ * Call registered single step handers
+ * There is no Syndrome info to check for determining the handler.
+ * So we call all the registered handlers, until the right handler is
+ * found which returns zero.
+ */
+static int call_step_hook(struct pt_regs *regs, unsigned int esr)
+{
+       struct step_hook *hook;
+       int retval = DBG_HOOK_ERROR;
+
+       read_lock(&step_hook_lock);
+
+       list_for_each_entry(hook, &step_hook, node)     {
+               retval = hook->fn(regs, esr);
+               if (retval == DBG_HOOK_HANDLED)
+                       break;
+       }
+
+       read_unlock(&step_hook_lock);
+
+       return retval;
+}
+
 static int single_step_handler(unsigned long addr, unsigned int esr,
                               struct pt_regs *regs)
 {
@@ -214,7 +256,10 @@ static int single_step_handler(unsigned long addr, unsigned int esr,
                 */
                user_rewind_single_step(current);
        } else {
-               /* TODO: route to KGDB */
+               /* call registered single step handlers */
+               if (call_step_hook(regs, esr) == DBG_HOOK_HANDLED)
+                       return 0;
+
                pr_warning("Unexpected kernel single-step exception at EL1\n");
                /*
                 * Re-enable stepping since we know that we will be
@@ -226,11 +271,50 @@ static int single_step_handler(unsigned long addr, unsigned int esr,
        return 0;
 }
 
+
+static LIST_HEAD(break_hook);
+DEFINE_RWLOCK(break_hook_lock);
+
+void register_break_hook(struct break_hook *hook)
+{
+       write_lock(&break_hook_lock);
+       list_add(&hook->node, &break_hook);
+       write_unlock(&break_hook_lock);
+}
+
+void unregister_break_hook(struct break_hook *hook)
+{
+       write_lock(&break_hook_lock);
+       list_del(&hook->node);
+       write_unlock(&break_hook_lock);
+}
+
+static int call_break_hook(struct pt_regs *regs, unsigned int esr)
+{
+       struct break_hook *hook;
+       int (*fn)(struct pt_regs *regs, unsigned int esr) = NULL;
+
+       read_lock(&break_hook_lock);
+       list_for_each_entry(hook, &break_hook, node)
+               if ((esr & hook->esr_mask) == hook->esr_val)
+                       fn = hook->fn;
+       read_unlock(&break_hook_lock);
+
+       return fn ? fn(regs, esr) : DBG_HOOK_ERROR;
+}
+
 static int brk_handler(unsigned long addr, unsigned int esr,
                       struct pt_regs *regs)
 {
        siginfo_t info;
 
+       /* call the registered breakpoint handler */
+       if (call_break_hook(regs, esr) == DBG_HOOK_HANDLED)
+               return 0;
+
+       pr_warn("unexpected brk exception at %lx, esr=0x%x\n",
+                       (long)instruction_pointer(regs), esr);
+
        if (!user_mode(regs))
                return -EFAULT;
 
arch/arm64/kernel/entry.S +2 -1
index 4d2c6f3..32d7fe6 100644
@@ -288,6 +288,8 @@ el1_dbg:
        /*
         * Debug exception handling
         */
+       cmp     x24, #ESR_EL1_EC_BRK64          // if BRK64
+       cinc    x24, x24, eq                    // set bit '0'
        tbz     x24, #0, el1_inv                // EL1 only
        mrs     x0, far_el1
        mov     x2, sp                          // struct pt_regs
--

1.7.9.5

#3 lore raw

PATCH v5 1/4 arm64: support single-step and breakpoint handler hooks

Quoted 5 lines · Sandeepa Prabhu

Hi Will,

If you have no further issues or objections with this patch, please can you Ack this patch and consider for queuing it on upstream branch? (Or should it merge along with kgdb series?)

I reviewed it here:

http://lists.infradead.org/pipermail/linux-arm-kernel/2013-October/207372.html

and you still haven't addressed my two, minor comments.

Will

#4 lore raw

PATCH v5 2/4 AArch64: KGDB: Add Basic KGDB support

In reply to vijay.kilari at gmail.com

From: Vijaya Kumar K <[email protected]>

Add KGDB debug support for kernel debugging.
With this patch, basic KGDB debugging is possible.GDB register layout is updated and GDB tool can establish connection with target and can set/clear breakpoints.

---
 arch/arm64/include/asm/debug-monitors.h |   47 +++++
 arch/arm64/include/asm/kgdb.h           |   86 +++++++++
 arch/arm64/kernel/Makefile              |    1 +
 arch/arm64/kernel/kgdb.c                |  289 +++++++++++++++++++++++++++++++
 4 files changed, 423 insertions(+)
arch/arm64/include/asm/debug-monitors.h +47 -0
index 6231479..6926497 100644
@@ -26,6 +26,53 @@
 #define DBG_ESR_EVT_HWWP	0x2
 #define DBG_ESR_EVT_BRK		0x6
 
+/*
+ * Break point instruction encoding
+ */
+#define BREAK_INSTR_SIZE		4
+
+/*
+ * ESR values expected for dynamic and compile time BRK instruction
+ */
+#define DBG_ESR_VAL_BRK(x)	(0xf2000000 | ((x) & 0xfffff))
+
+/*
+ * #imm16 values used for BRK instruction generation
+ * Allowed values for kgbd are 0x400 - 0x7ff
+ * 0x400: for dynamic BRK instruction
+ * 0x401: for compile time BRK instruction
+ */
+#define KGDB_DYN_DGB_BRK_IMM		0x400
+#define KDBG_COMPILED_DBG_BRK_IMM	0x401
+
+/*
+ * BRK instruction encoding
+ * The #imm16 value should be placed at bits[20:5] within BRK ins
+ */
+#define AARCH64_BREAK_MON	0xd4200000
+
+/*
+ * Extract byte from BRK instruction
+ */
+#define KGDB_DYN_DGB_BRK_INS_BYTE(x) \
+	((((AARCH64_BREAK_MON) & 0xffe0001f) >> (x * 8)) & 0xff)
+
+/*
+ * Extract byte from BRK #imm16
+ */
+#define KGBD_DYN_DGB_BRK_IMM_BYTE(x) \
+	(((((KGDB_DYN_DGB_BRK_IMM) & 0xffff) << 5) >> (x * 8)) & 0xff)
+
+#define KGDB_DYN_DGB_BRK_BYTE(x) \
+	(KGDB_DYN_DGB_BRK_INS_BYTE(x) | KGBD_DYN_DGB_BRK_IMM_BYTE(x))
+
+#define  KGDB_DYN_BRK_INS_BYTE0  KGDB_DYN_DGB_BRK_BYTE(0)
+#define  KGDB_DYN_BRK_INS_BYTE1  KGDB_DYN_DGB_BRK_BYTE(1)
+#define  KGDB_DYN_BRK_INS_BYTE2  KGDB_DYN_DGB_BRK_BYTE(2)
+#define  KGDB_DYN_BRK_INS_BYTE3  KGDB_DYN_DGB_BRK_BYTE(3)
+
+#define CACHE_FLUSH_IS_SAFE		1
+
 enum debug_el {
 	DBG_ACTIVE_EL0 = 0,
 	DBG_ACTIVE_EL1,
arch/arm64/include/asm/kgdb.h new file +86 -0

86 lines not on this page · raw message

arch/arm64/kernel/Makefile +1 -0
index 5ba2fd4..b9b87fa 100644
@@ -18,6 +18,7 @@ arm64-obj-$(CONFIG_SMP)			+= smp.o smp_spin_table.o
 arm64-obj-$(CONFIG_HW_PERF_EVENTS)	+= perf_event.o
 arm64-obj-$(CONFIG_HAVE_HW_BREAKPOINT)+= hw_breakpoint.o
 arm64-obj-$(CONFIG_EARLY_PRINTK)	+= early_printk.o
+arm64-obj-$(CONFIG_KGDB)		+= kgdb.o
 
 obj-y					+= $(arm64-obj-y) vdso/
 obj-m					+= $(arm64-obj-m)
arch/arm64/kernel/kgdb.c new file +289 -0

289 lines not on this page · raw message

Signature · 1 line
1.7.9.5
reviewer
#5 lore raw

PATCH v5 2/4 AArch64: KGDB: Add Basic KGDB support

Hi,

I think that there's a slight problem with this on BE systems.

Quoted 15 lines · vijay.kilari at gmail.com

From: Vijaya Kumar K <[email protected]>

Add KGDB debug support for kernel debugging.
With this patch, basic KGDB debugging is possible.GDB register layout is updated and GDB tool can establish connection with target and can set/clear breakpoints.

---
 arch/arm64/include/asm/debug-monitors.h |   47 +++++
 arch/arm64/include/asm/kgdb.h           |   86 +++++++++
 arch/arm64/kernel/Makefile              |    1 +
 arch/arm64/kernel/kgdb.c                |  289 +++++++++++++++++++++++++++++++
 4 files changed, 423 insertions(+)

[...]

Quoted 25 lines
arch/arm64/kernel/kgdb.c new file +25 -0
+struct dbg_reg_def_t dbg_reg_def[DBG_MAX_REG_NUM] = {
+       { "x0", 8, offsetof(struct pt_regs, regs[0])},
+       { "x1", 8, offsetof(struct pt_regs, regs[1])},
+       { "x2", 8, offsetof(struct pt_regs, regs[2])},
+       { "x3", 8, offsetof(struct pt_regs, regs[3])},
+       { "x4", 8, offsetof(struct pt_regs, regs[4])},
+       { "x5", 8, offsetof(struct pt_regs, regs[5])},
+       { "x6", 8, offsetof(struct pt_regs, regs[6])},
+       { "x7", 8, offsetof(struct pt_regs, regs[7])},
+       { "x8", 8, offsetof(struct pt_regs, regs[8])},
+       { "x9", 8, offsetof(struct pt_regs, regs[9])},
+       { "x10", 8, offsetof(struct pt_regs, regs[10])},
+       { "x11", 8, offsetof(struct pt_regs, regs[11])},
+       { "x12", 8, offsetof(struct pt_regs, regs[12])},
+       { "x13", 8, offsetof(struct pt_regs, regs[13])},
+       { "x14", 8, offsetof(struct pt_regs, regs[14])},
+       { "x15", 8, offsetof(struct pt_regs, regs[15])},
+       { "x16", 8, offsetof(struct pt_regs, regs[16])},
+       { "x17", 8, offsetof(struct pt_regs, regs[17])},
+       { "x18", 8, offsetof(struct pt_regs, regs[18])},
+       { "x19", 8, offsetof(struct pt_regs, regs[19])},
+       { "x20", 8, offsetof(struct pt_regs, regs[20])},
+       { "x21", 8, offsetof(struct pt_regs, regs[21])},
+       { "x22", 8, offsetof(struct pt_regs, regs[22])},
+       { "x23", 8, offsetof(struct pt_regs, regs[23])},

arch/arm64/kernel/kgdb.c line 61

Quoted 10 lines
arch/arm64/kernel/kgdb.c new file +10 -0
+       { "x24", 8, offsetof(struct pt_regs, regs[24])},
+       { "x25", 8, offsetof(struct pt_regs, regs[25])},
+       { "x26", 8, offsetof(struct pt_regs, regs[26])},
+       { "x27", 8, offsetof(struct pt_regs, regs[27])},
+       { "x28", 8, offsetof(struct pt_regs, regs[28])},
+       { "x29", 8, offsetof(struct pt_regs, regs[29])},
+       { "x30", 8, offsetof(struct pt_regs, regs[30])},
+       { "sp", 8, offsetof(struct pt_regs, sp)},
+       { "pc", 8, offsetof(struct pt_regs, pc)},
+       { "pstate", 4, offsetof(struct pt_regs, pstate)},

As pt_regs::pstate is a u64, we're only describing half of the field here (to match GDB's expectations). While we happen to get the half we're interested in on an LE system, on a BE system this will point at the zeroed half.

[...]

arch/arm64/kernel/kgdb.c line 105

Quoted 8 lines
arch/arm64/kernel/kgdb.c new file +8 -0
+char *dbg_get_reg(int regno, void *mem, struct pt_regs *regs)
+{
+       if (regno >= DBG_MAX_REG_NUM || regno < 0)
+               return NULL;
+
+       if (dbg_reg_def[regno].offset != -1)
+               memcpy(mem, (void *)regs + dbg_reg_def[regno].offset,
+                      dbg_reg_def[regno].size);

So here we'll read zeroes rather than the bits we're interested in.

arch/arm64/kernel/kgdb.c line 118

Quoted 13 lines
arch/arm64/kernel/kgdb.c new file +13 -0
+       else
+               memset(mem, 0, dbg_reg_def[regno].size);
+       return dbg_reg_def[regno].name;
+}
+
+int dbg_set_reg(int regno, void *mem, struct pt_regs *regs)
+{
+       if (regno >= DBG_MAX_REG_NUM || regno < 0)
+               return -EINVAL;
+
+       if (dbg_reg_def[regno].offset != -1)
+               memcpy((void *)regs + dbg_reg_def[regno].offset, mem,
+                      dbg_reg_def[regno].size);

And here we'll write to bits which should be zero, not the bits we're interested in.

[...]

arch/arm64/kernel/kgdb.c line 245

Quoted 3 lines
arch/arm64/kernel/kgdb.c new file +3 -0
+static struct notifier_block kgdb_notifier = {
+       .notifier_call  = kgdb_notify,
+       .priority       = -INT_MAX,

On an unrelated note, is there a reason this isn't INT_MIN? This is one-off.

Thanks,
Mark.

#6 lore raw

PATCH v5 2/4 AArch64: KGDB: Add Basic KGDB support

Quoted 1 line · Mark Rutland

I think that there's a slight problem with this on BE systems.

[...]

Quoted 7 lines · vijay.kilari at gmail.com
Quoted 1 line

+ { "pstate", 4, offsetof(struct pt_regs, pstate)},

As pt_regs::pstate is a u64, we're only describing half of the field here (to match GDB's expectations). While we happen to get the half we're interested in on an LE system, on a BE system this will point at the zeroed half.

Yup, I think you're right. It's almost as if this hasn't been tested on a BE system.

Given that a large proportion of this CC list *do* actually care about BE, I'd like to see a tested-by from one of them before this gets merged. I'm pretty sure GDB has a testsuite which might be of some use.

Will

#7 lore raw

PATCH v5 2/4 AArch64: KGDB: Add Basic KGDB support

Quoted 13 lines · Will Deacon
Quoted 1 line · Mark Rutland

I think that there's a slight problem with this on BE systems.

[...]

Quoted 7 lines · vijay.kilari at gmail.com
Quoted 1 line

+ { "pstate", 4, offsetof(struct pt_regs, pstate)},

As pt_regs::pstate is a u64, we're only describing half of the field here (to match GDB's expectations). While we happen to get the half we're interested in on an LE system, on a BE system this will point at the zeroed half.

Quoted 6 lines

Yup, I think you're right. It's almost as if this hasn't been tested on a BE system.

Given that a large proportion of this CC list *do* actually care about BE, I'd like to see a tested-by from one of them before this gets merged. I'm pretty sure GDB has a testsuite which might be of some use.

Having said that, our ptrace interface (built around regsets) treats pstate as 64-bit, so we should do the same thing for kgdb and let GDB work out which bits it's interested in.

So: make pstate 8 bytes and test/fix GDB to deal with that (like it should do for userspace already).

Will

#8 lore raw

PATCH v5 2/4 AArch64: KGDB: Add Basic KGDB support

Quoted 21 lines · Will Deacon
Quoted 13 lines · Will Deacon
Quoted 1 line · Mark Rutland

I think that there's a slight problem with this on BE systems.

[...]

Quoted 7 lines · vijay.kilari at gmail.com
Quoted 1 line

+ { "pstate", 4, offsetof(struct pt_regs, pstate)},

As pt_regs::pstate is a u64, we're only describing half of the field here (to match GDB's expectations). While we happen to get the half we're interested in on an LE system, on a BE system this will point at the zeroed half.

Quoted 6 lines

Yup, I think you're right. It's almost as if this hasn't been tested on a BE system.

Given that a large proportion of this CC list *do* actually care about BE, I'd like to see a tested-by from one of them before this gets merged. I'm pretty sure GDB has a testsuite which might be of some use.

Quoted 7 lines

Having said that, our ptrace interface (built around regsets) treats pstate as 64-bit, so we should do the same thing for kgdb and let GDB work out which bits it's interested in.

So: make pstate 8 bytes and test/fix GDB to deal with that (like it should do for userspace already).

I have tested with BE & LE. it works fine except displaying 'pstate' contents in BE is wrong

If I change pstate offset as below, it works

#ifdef __AARCH64EB__
        { "pstate", 4, offsetof(struct pt_regs, pstate) + 4},

#else
{ "pstate", 4, offsetof(struct pt_regs, pstate)},
#endif

I am checking with tool chain guy to patch GDB to make pstate as 8 bytes. After that, I will re-send the patch series

Quoted 1 line

Will

#9 lore raw

PATCH v5 2/4 AArch64: KGDB: Add Basic KGDB support

Quoted 35 lines · Vijay Kilari
Quoted 21 lines · Will Deacon
Quoted 13 lines · Will Deacon
Quoted 1 line · Mark Rutland

I think that there's a slight problem with this on BE systems.

[...]

Quoted 7 lines · vijay.kilari at gmail.com
Quoted 1 line

+ { "pstate", 4, offsetof(struct pt_regs, pstate)},

As pt_regs::pstate is a u64, we're only describing half of the field here (to match GDB's expectations). While we happen to get the half we're interested in on an LE system, on a BE system this will point at the zeroed half.

Quoted 6 lines

Yup, I think you're right. It's almost as if this hasn't been tested on a BE system.

Given that a large proportion of this CC list *do* actually care about BE, I'd like to see a tested-by from one of them before this gets merged. I'm pretty sure GDB has a testsuite which might be of some use.

Quoted 7 lines

Having said that, our ptrace interface (built around regsets) treats pstate as 64-bit, so we should do the same thing for kgdb and let GDB work out which bits it's interested in.

So: make pstate 8 bytes and test/fix GDB to deal with that (like it should do for userspace already).

I have tested with BE & LE. it works fine except displaying 'pstate' contents in BE is wrong

If I change pstate offset as below, it works

Quoted 9 lines
#ifdef __AARCH64EB__
        { "pstate", 4, offsetof(struct pt_regs, pstate) + 4},

#else
{ "pstate", 4, offsetof(struct pt_regs, pstate)},
#endif

I am checking with tool chain guy to patch GDB to make pstate as 8 bytes. After that, I will re-send the patch series

Thanks to Andrew, GDB tool was patched here to interpret pstate as 8 bytes
https://sourceware.org/ml/gdb-patches/2013-12/msg00720.html

Quoted 1 line
Quoted 1 line

Will

#10 lore raw

PATCH v5 3/4 AArch64: KGDB: Add step debugging support

In reply to vijay.kilari at gmail.com

From: Vijaya Kumar K <[email protected]>

Add KGDB software step debugging support for EL1 debug in AArch64 mode.

KGDB registers step debug handler with debug monitor. On receiving 'step' command from GDB tool, target enables software step debugging and step address is updated in ELR.

Software Step debugging is disabled when 'continue' command is received

---
 arch/arm64/kernel/kgdb.c |   67 +++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 58 insertions(+), 9 deletions(-)
arch/arm64/kernel/kgdb.c +58 -9
index ec624bc..f10f2ba 100644
@@ -137,13 +137,26 @@ void kgdb_arch_set_pc(struct pt_regs *regs, unsigned long pc)
 
 static int compiled_break;
 
+static void kgdb_arch_update_addr(struct pt_regs *regs,
+				char *remcom_in_buffer)
+{
+	unsigned long addr;
+	char *ptr;
+
+	ptr = &remcom_in_buffer[1];
+	if (kgdb_hex2long(&ptr, &addr))
+		kgdb_arch_set_pc(regs, addr);
+	else if (compiled_break == 1)
+		kgdb_arch_set_pc(regs, regs->pc + 4);
+
+	compiled_break = 0;
+}
+
 int kgdb_arch_handle_exception(int exception_vector, int signo,
 			       int err_code, char *remcom_in_buffer,
 			       char *remcom_out_buffer,
 			       struct pt_regs *linux_regs)
 {
-	unsigned long addr;
-	char *ptr;
 	int err;
 
 	switch (remcom_in_buffer[0]) {
@@ -153,6 +166,8 @@ int kgdb_arch_handle_exception(int exception_vector, int signo,
 		 * Packet D (Detach), k (kill). No special handling
 		 * is required here
 		 */
+		atomic_set(&kgdb_cpu_doing_single_step, -1);
+		kgdb_single_step =  0;
 		err = 0;
 		break;
 	case 'c':
@@ -164,16 +179,39 @@ int kgdb_arch_handle_exception(int exception_vector, int signo,
 		 * to the next instruction else we will just breakpoint
 		 * over and over again.
 		 */
-		ptr = &remcom_in_buffer[1];
-		if (kgdb_hex2long(&ptr, &addr))
-			kgdb_arch_set_pc(linux_regs, addr);
-		else if (compiled_break == 1)
-			kgdb_arch_set_pc(linux_regs, linux_regs->pc + 4);
+		kgdb_arch_update_addr(linux_regs, remcom_in_buffer);
+		atomic_set(&kgdb_cpu_doing_single_step, -1);
+		kgdb_single_step =  0;
 
-		compiled_break = 0;
+		/*
+		 * Received continue command, disable single step
+		 */
+		if (kernel_active_single_step())
+			kernel_disable_single_step();
 
 		err = 0;
 		break;
+	case 's':
+		/*
+		 * Update step address value with address passed
+		 * with step packet.
+		 * On debug exception return PC is copied to ELR
+		 * So just update PC.
+		 * If no step address is passed, resume from the address
+		 * pointed by PC. Do not update PC
+		 */
+		kgdb_arch_update_addr(linux_regs, remcom_in_buffer);
+		atomic_set(&kgdb_cpu_doing_single_step, raw_smp_processor_id());
+		kgdb_single_step =  1;
+
+		/*
+		 * Enable single step handling
+		 */
+		if (!kernel_active_single_step())
+			kernel_enable_single_step(linux_regs);
+		err = 0;
+		break;
+
 	default:
 		err = -1;
 	}
@@ -194,6 +232,12 @@ static int kgdb_compiled_brk_fn(struct pt_regs *regs, unsigned int esr)
 	return 0;
 }
 
+static int kgdb_step_brk_fn(struct pt_regs *regs, unsigned int esr)
+{
+	kgdb_handle_exception(1, SIGTRAP, 0, regs);
+	return 0;
+}
+
 static struct break_hook kgdb_brkpt_hook = {
 	.esr_mask	= 0xffffffff,
 	.esr_val	= DBG_ESR_VAL_BRK(KGDB_DYN_DGB_BRK_IMM),
@@ -206,6 +250,10 @@ static struct break_hook kgdb_compiled_brkpt_hook = {
 	.fn		= kgdb_compiled_brk_fn
 };
 
+static struct step_hook kgdb_step_hook = {
+	.fn		= kgdb_step_brk_fn
+};
+
 static void kgdb_call_nmi_hook(void *ignored)
 {
 	kgdb_nmicallback(raw_smp_processor_id(), get_irq_regs());
@@ -259,7 +307,7 @@ int kgdb_arch_init(void)
 
 	register_break_hook(&kgdb_brkpt_hook);
 	register_break_hook(&kgdb_compiled_brkpt_hook);
-
+	register_step_hook(&kgdb_step_hook);
 	return 0;
 }
 
@@ -272,6 +320,7 @@ void kgdb_arch_exit(void)
 {
 	unregister_break_hook(&kgdb_brkpt_hook);
 	unregister_break_hook(&kgdb_compiled_brkpt_hook);
+	unregister_step_hook(&kgdb_step_hook);
 	unregister_die_notifier(&kgdb_notifier);
 }
 
Signature · 1 line
1.7.9.5
#11 lore raw

PATCH v5 4/4 KGDB: make kgdb_breakpoint() as noinline

In reply to vijay.kilari at gmail.com

From: Vijaya Kumar K <[email protected]>

The function kgdb_breakpoint() sets up break point at compile time by calling arch_kgdb_breakpoint(); Though this call is surrounded by wmb() barrier, the compile can still re-order the break point, because this scheduling barrier is not a code motion barrier in gcc.

Making kgdb_breakpoint() as noinline solves this problem of code reording around break point instruction and also avoids problem of being called as inline function from other places

More details about discussion on this can be found here
http://comments.gmane.org/gmane.linux.ports.arm.kernel/269732

---
 kernel/debug/debug_core.c |    2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
kernel/debug/debug_core.c +1 -1
index 7d2f35e..cf04798 100644
@@ -1034,7 +1034,7 @@ int dbg_io_get_char(void)
  * otherwise as a quick means to stop program execution and "break" into
  * the debugger.
  */
-void kgdb_breakpoint(void)
+noinline void kgdb_breakpoint(void)
 {
 	atomic_inc(&kgdb_setting_breakpoint);
 	wmb(); /* Sync point before breakpoint */
Signature · 1 line
1.7.9.5