[PATCH 1/5] kgdb: remove unused HAVE_ARCH_KGDB_SHADOW_INFO config variable - Kernel

This is a discussion on [PATCH 1/5] kgdb: remove unused HAVE_ARCH_KGDB_SHADOW_INFO config variable - Kernel ; Remove HAVE_ARCH_KGDB_SHADOW_INFO because it does not exist anywhere in the kernel mainline sources Signed-off-by: Jason Wessel --- lib/Kconfig.kgdb | 3 --- 1 files changed, 0 insertions(+), 3 deletions(-) diff --git a/lib/Kconfig.kgdb b/lib/Kconfig.kgdb index a5d4b1d..2cfd272 100644 --- a/lib/Kconfig.kgdb +++ b/lib/Kconfig.kgdb @@ ...

+ Reply to Thread
Results 1 to 4 of 4

Thread: [PATCH 1/5] kgdb: remove unused HAVE_ARCH_KGDB_SHADOW_INFO config variable

  1. [PATCH 1/5] kgdb: remove unused HAVE_ARCH_KGDB_SHADOW_INFO config variable

    Remove HAVE_ARCH_KGDB_SHADOW_INFO because it does not
    exist anywhere in the kernel mainline sources

    Signed-off-by: Jason Wessel
    ---
    lib/Kconfig.kgdb | 3 ---
    1 files changed, 0 insertions(+), 3 deletions(-)

    diff --git a/lib/Kconfig.kgdb b/lib/Kconfig.kgdb
    index a5d4b1d..2cfd272 100644
    --- a/lib/Kconfig.kgdb
    +++ b/lib/Kconfig.kgdb
    @@ -1,7 +1,4 @@

    -config HAVE_ARCH_KGDB_SHADOW_INFO
    - bool
    -
    config HAVE_ARCH_KGDB
    bool

    --
    1.5.5.1

    --
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  2. [PATCH 5/5] kgdb: kgdboc console poll hooks for mpsc uart

    Add in console polling hooks for the mpsc uart for use with kgdb and
    kgdboc.

    Signed-off-by: Jason Wessel
    ---
    drivers/serial/mpsc.c | 148 ++++++++++++++++++++++++++++++++++++++++++++++++-
    1 files changed, 147 insertions(+), 1 deletions(-)

    diff --git a/drivers/serial/mpsc.c b/drivers/serial/mpsc.c
    index c9f53e7..61d3ade 100644
    --- a/drivers/serial/mpsc.c
    +++ b/drivers/serial/mpsc.c
    @@ -921,6 +921,10 @@ static int mpsc_make_ready(struct mpsc_port_info *pi)
    return 0;
    }

    +#ifdef CONFIG_CONSOLE_POLL
    +static int serial_polled;
    +#endif
    +
    /*
    ************************************************** ****************************
    *
    @@ -956,7 +960,12 @@ static int mpsc_rx_intr(struct mpsc_port_info *pi)
    while (!((cmdstat = be32_to_cpu(rxre->cmdstat))
    & SDMA_DESC_CMDSTAT_O)) {
    bytes_in = be16_to_cpu(rxre->bytecnt);
    -
    +#ifdef CONFIG_CONSOLE_POLL
    + if (unlikely(serial_polled)) {
    + serial_polled = 0;
    + return 0;
    + }
    +#endif
    /* Following use of tty struct directly is deprecated */
    if (unlikely(tty_buffer_request_room(tty, bytes_in)
    < bytes_in)) {
    @@ -1017,6 +1026,12 @@ static int mpsc_rx_intr(struct mpsc_port_info *pi)
    if (uart_handle_sysrq_char(&pi->port, *bp)) {
    bp++;
    bytes_in--;
    +#ifdef CONFIG_CONSOLE_POLL
    + if (unlikely(serial_polled)) {
    + serial_polled = 0;
    + return 0;
    + }
    +#endif
    goto next_frame;
    }

    @@ -1519,6 +1534,133 @@ static int mpsc_verify_port(struct uart_port *port, struct serial_struct *ser)

    return rc;
    }
    +#ifdef CONFIG_CONSOLE_POLL
    +/* Serial polling routines for writing and reading from the uart while
    + * in an interrupt or debug context.
    + */
    +
    +static char poll_buf[2048];
    +static int poll_ptr;
    +static int poll_cnt;
    +static void mpsc_put_poll_char(struct uart_port *port,
    + unsigned char c);
    +
    +static int mpsc_get_poll_char(struct uart_port *port)
    +{
    + struct mpsc_port_info *pi = (struct mpsc_port_info *)port;
    + struct mpsc_rx_desc *rxre;
    + u32 cmdstat, bytes_in, i;
    + u8 *bp;
    +
    + if (!serial_polled)
    + serial_polled = 1;
    +
    + pr_debug("mpsc_rx_intr[%d]: Handling Rx intr\n", pi->port.line);
    +
    + if (poll_cnt) {
    + poll_cnt--;
    + return poll_buf[poll_ptr++];
    + }
    + poll_ptr = 0;
    + poll_cnt = 0;
    +
    + while (poll_cnt == 0) {
    + rxre = (struct mpsc_rx_desc *)(pi->rxr +
    + (pi->rxr_posn*MPSC_RXRE_SIZE));
    + dma_cache_sync(pi->port.dev, (void *)rxre,
    + MPSC_RXRE_SIZE, DMA_FROM_DEVICE);
    +#if defined(CONFIG_PPC32) && !defined(CONFIG_NOT_COHERENT_CACHE)
    + if (pi->cache_mgmt) /* GT642[46]0 Res #COMM-2 */
    + invalidate_dcache_range((ulong)rxre,
    + (ulong)rxre + MPSC_RXRE_SIZE);
    +#endif
    + /*
    + * Loop through Rx descriptors handling ones that have
    + * been completed.
    + */
    + while (poll_cnt == 0 &&
    + !((cmdstat = be32_to_cpu(rxre->cmdstat)) &
    + SDMA_DESC_CMDSTAT_O)){
    + bytes_in = be16_to_cpu(rxre->bytecnt);
    + bp = pi->rxb + (pi->rxr_posn * MPSC_RXBE_SIZE);
    + dma_cache_sync(pi->port.dev, (void *) bp,
    + MPSC_RXBE_SIZE, DMA_FROM_DEVICE);
    +#if defined(CONFIG_PPC32) && !defined(CONFIG_NOT_COHERENT_CACHE)
    + if (pi->cache_mgmt) /* GT642[46]0 Res #COMM-2 */
    + invalidate_dcache_range((ulong)bp,
    + (ulong)bp + MPSC_RXBE_SIZE);
    +#endif
    + if ((unlikely(cmdstat & (SDMA_DESC_CMDSTAT_BR |
    + SDMA_DESC_CMDSTAT_FR | SDMA_DESC_CMDSTAT_OR))) &&
    + !(cmdstat & pi->port.ignore_status_mask)) {
    + poll_buf[poll_cnt] = *bp;
    + poll_cnt++;
    + } else {
    + for (i = 0; i < bytes_in; i++) {
    + poll_buf[poll_cnt] = *bp++;
    + poll_cnt++;
    + }
    + pi->port.icount.rx += bytes_in;
    + }
    + rxre->bytecnt = cpu_to_be16(0);
    + wmb();
    + rxre->cmdstat = cpu_to_be32(SDMA_DESC_CMDSTAT_O |
    + SDMA_DESC_CMDSTAT_EI |
    + SDMA_DESC_CMDSTAT_F |
    + SDMA_DESC_CMDSTAT_L);
    + wmb();
    + dma_cache_sync(pi->port.dev, (void *)rxre,
    + MPSC_RXRE_SIZE, DMA_BIDIRECTIONAL);
    +#if defined(CONFIG_PPC32) && !defined(CONFIG_NOT_COHERENT_CACHE)
    + if (pi->cache_mgmt) /* GT642[46]0 Res #COMM-2 */
    + flush_dcache_range((ulong)rxre,
    + (ulong)rxre + MPSC_RXRE_SIZE);
    +#endif
    +
    + /* Advance to next descriptor */
    + pi->rxr_posn = (pi->rxr_posn + 1) &
    + (MPSC_RXR_ENTRIES - 1);
    + rxre = (struct mpsc_rx_desc *)(pi->rxr +
    + (pi->rxr_posn * MPSC_RXRE_SIZE));
    + dma_cache_sync(pi->port.dev, (void *)rxre,
    + MPSC_RXRE_SIZE, DMA_FROM_DEVICE);
    +#if defined(CONFIG_PPC32) && !defined(CONFIG_NOT_COHERENT_CACHE)
    + if (pi->cache_mgmt) /* GT642[46]0 Res #COMM-2 */
    + invalidate_dcache_range((ulong)rxre,
    + (ulong)rxre + MPSC_RXRE_SIZE);
    +#endif
    + }
    +
    + /* Restart rx engine, if its stopped */
    + if ((readl(pi->sdma_base + SDMA_SDCM) & SDMA_SDCM_ERD) == 0)
    + mpsc_start_rx(pi);
    + }
    + if (poll_cnt) {
    + poll_cnt--;
    + return poll_buf[poll_ptr++];
    + }
    +
    + return 0;
    +}
    +
    +
    +static void mpsc_put_poll_char(struct uart_port *port,
    + unsigned char c)
    +{
    + struct mpsc_port_info *pi = (struct mpsc_port_info *)port;
    + u32 data;
    +
    + data = readl(pi->mpsc_base + MPSC_MPCR);
    + writeb(c, pi->mpsc_base + MPSC_CHR_1);
    + mb();
    + data = readl(pi->mpsc_base + MPSC_CHR_2);
    + data |= MPSC_CHR_2_TTCS;
    + writel(data, pi->mpsc_base + MPSC_CHR_2);
    + mb();
    +
    + while (readl(pi->mpsc_base + MPSC_CHR_2) & MPSC_CHR_2_TTCS);
    +}
    +#endif

    static struct uart_ops mpsc_pops = {
    .tx_empty = mpsc_tx_empty,
    @@ -1537,6 +1679,10 @@ static struct uart_ops mpsc_pops = {
    .request_port = mpsc_request_port,
    .config_port = mpsc_config_port,
    .verify_port = mpsc_verify_port,
    +#ifdef CONFIG_CONSOLE_POLL
    + .poll_get_char = mpsc_get_poll_char,
    + .poll_put_char = mpsc_put_poll_char,
    +#endif
    };

    /*
    --
    1.5.5.1

    --
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  3. [PATCH 4/5] kgdb: kgdboc console poll hooks for cpm uart

    Add in console polling hooks for the cpm uart for use with kgdb and
    kgdboc.

    Signed-off-by: Jason Wessel
    CC: galak@kernel.crashing.org
    ---
    drivers/serial/cpm_uart/cpm_uart_core.c | 95 ++++++++++++++++++++++++++++++-
    1 files changed, 94 insertions(+), 1 deletions(-)

    diff --git a/drivers/serial/cpm_uart/cpm_uart_core.c b/drivers/serial/cpm_uart/cpm_uart_core.c
    index 93e407e..1ff80de 100644
    --- a/drivers/serial/cpm_uart/cpm_uart_core.c
    +++ b/drivers/serial/cpm_uart/cpm_uart_core.c
    @@ -201,6 +201,10 @@ static void cpm_uart_int_tx(struct uart_port *port)
    cpm_uart_tx_pump(port);
    }

    +#ifdef CONFIG_CONSOLE_POLL
    +static int serial_polled;
    +#endif
    +
    /*
    * Receive characters
    */
    @@ -222,6 +226,12 @@ static void cpm_uart_int_rx(struct uart_port *port)
    */
    bdp = pinfo->rx_cur;
    for (; {
    +#ifdef CONFIG_CONSOLE_POLL
    + if (unlikely(serial_polled)) {
    + serial_polled = 0;
    + return;
    + }
    +#endif
    /* get status */
    status = in_be16(&bdp->cbd_sc);
    /* If this one is empty, return happy */
    @@ -253,7 +263,12 @@ static void cpm_uart_int_rx(struct uart_port *port)
    goto handle_error;
    if (uart_handle_sysrq_char(port, ch))
    continue;
    -
    +#ifdef CONFIG_CONSOLE_POLL
    + if (unlikely(serial_polled)) {
    + serial_polled = 0;
    + return;
    + }
    +#endif
    error_return:
    tty_insert_flip_char(tty, ch, flg);

    @@ -865,6 +880,80 @@ static void cpm_uart_config_port(struct uart_port *port, int flags)
    cpm_uart_request_port(port);
    }
    }
    +
    +#ifdef CONFIG_CONSOLE_POLL
    +/* Serial polling routines for writing and reading from the uart while
    + * in an interrupt or debug context.
    + */
    +
    +#define GDB_BUF_SIZE 512 /* power of 2, please */
    +
    +static char poll_buf[GDB_BUF_SIZE];
    +static char *pollp;
    +static int poll_chars;
    +
    +static int poll_wait_key(char *obuf, struct uart_cpm_port *pinfo)
    +{
    + u_char c, *cp;
    + volatile cbd_t *bdp;
    + int i;
    +
    + /* Get the address of the host memory buffer.
    + */
    + bdp = pinfo->rx_cur;
    + while (bdp->cbd_sc & BD_SC_EMPTY)
    + ;
    +
    + /* If the buffer address is in the CPM DPRAM, don't
    + * convert it.
    + */
    + cp = cpm2cpu_addr(bdp->cbd_bufaddr, pinfo);
    +
    + if (obuf) {
    + i = c = bdp->cbd_datlen;
    + while (i-- > 0)
    + *obuf++ = *cp++;
    + } else
    + c = *cp;
    + bdp->cbd_sc &= ~(BD_SC_BR | BD_SC_FR | BD_SC_PR | BD_SC_OV | BD_SC_ID);
    + bdp->cbd_sc |= BD_SC_EMPTY;
    +
    + if (bdp->cbd_sc & BD_SC_WRAP)
    + bdp = pinfo->rx_bd_base;
    + else
    + bdp++;
    + pinfo->rx_cur = (cbd_t *)bdp;
    +
    + return (int)c;
    +}
    +
    +static int cpm_get_poll_char(struct uart_port *port)
    +{
    + struct uart_cpm_port *pinfo = (struct uart_cpm_port *)port;
    +
    + if (!serial_polled) {
    + serial_polled = 1;
    + poll_chars = 0;
    + }
    + if (poll_chars <= 0) {
    + poll_chars = poll_wait_key(poll_buf, pinfo);
    + pollp = poll_buf;
    + }
    + poll_chars--;
    + return *pollp++;
    +}
    +
    +static void cpm_put_poll_char(struct uart_port *port,
    + unsigned char c)
    +{
    + struct uart_cpm_port *pinfo = (struct uart_cpm_port *)port;
    + static char ch[2];
    +
    + ch[0] = (char)c;
    + cpm_uart_early_write(pinfo->port.line, ch, 1);
    +}
    +#endif /* CONFIG_CONSOLE_POLL */
    +
    static struct uart_ops cpm_uart_pops = {
    .tx_empty = cpm_uart_tx_empty,
    .set_mctrl = cpm_uart_set_mctrl,
    @@ -882,6 +971,10 @@ static struct uart_ops cpm_uart_pops = {
    .request_port = cpm_uart_request_port,
    .config_port = cpm_uart_config_port,
    .verify_port = cpm_uart_verify_port,
    +#ifdef CONFIG_CONSOLE_POLL
    + .poll_get_char = cpm_get_poll_char,
    + .poll_put_char = cpm_put_poll_char,
    +#endif
    };

    struct uart_cpm_port cpm_uart_ports[UART_NR];
    --
    1.5.5.1

    --
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  4. [PATCH 2/5] kgdb: support for ARCH=arm

    This patch adds the ARCH=arm specific a kgdb backend, originally
    written by Deepak Saxena and George Davis
    . Geoff Levand ,
    Nicolas Pitre, Manish Lachwani, and Jason Wessel have contributed
    various fixups here as well.

    The KGDB patch makes one change to the core ARM architecture such that
    the traps are initialized early for use with the debugger or other
    subsystems.

    [ mingo@elte.hu: small cleanups. ]
    [ ben-linux@fluff.org: fixed early_trap_init ]

    Signed-off-by: Jason Wessel
    Acked-by: Deepak Saxena
    ---
    arch/arm/Kconfig | 1 +
    arch/arm/kernel/Makefile | 1 +
    arch/arm/kernel/kgdb.c | 201 ++++++++++++++++++++++++++++++++++++++++++++++
    arch/arm/kernel/setup.c | 2 +
    arch/arm/kernel/traps.c | 5 +
    include/asm-arm/kgdb.h | 104 ++++++++++++++++++++++++
    include/asm-arm/traps.h | 2 +
    7 files changed, 316 insertions(+), 0 deletions(-)
    create mode 100644 arch/arm/kernel/kgdb.c
    create mode 100644 include/asm-arm/kgdb.h

    diff --git a/arch/arm/Kconfig b/arch/arm/Kconfig
    index c7ad324..d048f68 100644
    --- a/arch/arm/Kconfig
    +++ b/arch/arm/Kconfig
    @@ -12,6 +12,7 @@ config ARM
    select RTC_LIB
    select SYS_SUPPORTS_APM_EMULATION
    select HAVE_OPROFILE
    + select HAVE_ARCH_KGDB
    select HAVE_KPROBES if (!XIP_KERNEL)
    select HAVE_KRETPROBES if (HAVE_KPROBES)
    select HAVE_FTRACE if (!XIP_KERNEL)
    diff --git a/arch/arm/kernel/Makefile b/arch/arm/kernel/Makefile
    index eb9092c..1d296fc 100644
    --- a/arch/arm/kernel/Makefile
    +++ b/arch/arm/kernel/Makefile
    @@ -28,6 +28,7 @@ obj-$(CONFIG_KPROBES) += kprobes.o kprobes-decode.o
    obj-$(CONFIG_ATAGS_PROC) += atags.o
    obj-$(CONFIG_OABI_COMPAT) += sys_oabi-compat.o
    obj-$(CONFIG_ARM_THUMBEE) += thumbee.o
    +obj-$(CONFIG_KGDB) += kgdb.o

    obj-$(CONFIG_CRUNCH) += crunch.o crunch-bits.o
    AFLAGS_crunch-bits.o := -Wa,-mcpu=ep9312
    diff --git a/arch/arm/kernel/kgdb.c b/arch/arm/kernel/kgdb.c
    new file mode 100644
    index 0000000..aaffaec
    --- /dev/null
    +++ b/arch/arm/kernel/kgdb.c
    @@ -0,0 +1,201 @@
    +/*
    + * arch/arm/kernel/kgdb.c
    + *
    + * ARM KGDB support
    + *
    + * Copyright (c) 2002-2004 MontaVista Software, Inc
    + * Copyright (c) 2008 Wind River Systems, Inc.
    + *
    + * Authors: George Davis
    + * Deepak Saxena
    + */
    +#include
    +#include
    +
    +/* Make a local copy of the registers passed into the handler (bletch) */
    +void pt_regs_to_gdb_regs(unsigned long *gdb_regs, struct pt_regs *kernel_regs)
    +{
    + int regno;
    +
    + /* Initialize all to zero. */
    + for (regno = 0; regno < GDB_MAX_REGS; regno++)
    + gdb_regs[regno] = 0;
    +
    + gdb_regs[_R0] = kernel_regs->ARM_r0;
    + gdb_regs[_R1] = kernel_regs->ARM_r1;
    + gdb_regs[_R2] = kernel_regs->ARM_r2;
    + gdb_regs[_R3] = kernel_regs->ARM_r3;
    + gdb_regs[_R4] = kernel_regs->ARM_r4;
    + gdb_regs[_R5] = kernel_regs->ARM_r5;
    + gdb_regs[_R6] = kernel_regs->ARM_r6;
    + gdb_regs[_R7] = kernel_regs->ARM_r7;
    + gdb_regs[_R8] = kernel_regs->ARM_r8;
    + gdb_regs[_R9] = kernel_regs->ARM_r9;
    + gdb_regs[_R10] = kernel_regs->ARM_r10;
    + gdb_regs[_FP] = kernel_regs->ARM_fp;
    + gdb_regs[_IP] = kernel_regs->ARM_ip;
    + gdb_regs[_SPT] = kernel_regs->ARM_sp;
    + gdb_regs[_LR] = kernel_regs->ARM_lr;
    + gdb_regs[_PC] = kernel_regs->ARM_pc;
    + gdb_regs[_CPSR] = kernel_regs->ARM_cpsr;
    +}
    +
    +/* Copy local gdb registers back to kgdb regs, for later copy to kernel */
    +void gdb_regs_to_pt_regs(unsigned long *gdb_regs, struct pt_regs *kernel_regs)
    +{
    + kernel_regs->ARM_r0 = gdb_regs[_R0];
    + kernel_regs->ARM_r1 = gdb_regs[_R1];
    + kernel_regs->ARM_r2 = gdb_regs[_R2];
    + kernel_regs->ARM_r3 = gdb_regs[_R3];
    + kernel_regs->ARM_r4 = gdb_regs[_R4];
    + kernel_regs->ARM_r5 = gdb_regs[_R5];
    + kernel_regs->ARM_r6 = gdb_regs[_R6];
    + kernel_regs->ARM_r7 = gdb_regs[_R7];
    + kernel_regs->ARM_r8 = gdb_regs[_R8];
    + kernel_regs->ARM_r9 = gdb_regs[_R9];
    + kernel_regs->ARM_r10 = gdb_regs[_R10];
    + kernel_regs->ARM_fp = gdb_regs[_FP];
    + kernel_regs->ARM_ip = gdb_regs[_IP];
    + kernel_regs->ARM_sp = gdb_regs[_SPT];
    + kernel_regs->ARM_lr = gdb_regs[_LR];
    + kernel_regs->ARM_pc = gdb_regs[_PC];
    + kernel_regs->ARM_cpsr = gdb_regs[_CPSR];
    +}
    +
    +void
    +sleeping_thread_to_gdb_regs(unsigned long *gdb_regs, struct task_struct *task)
    +{
    + struct pt_regs *thread_regs;
    + int regno;
    +
    + /* Just making sure... */
    + if (task == NULL)
    + return;
    +
    + /* Initialize to zero */
    + for (regno = 0; regno < GDB_MAX_REGS; regno++)
    + gdb_regs[regno] = 0;
    +
    + /* Otherwise, we have only some registers from switch_to() */
    + thread_regs = task_pt_regs(task);
    + gdb_regs[_R0] = thread_regs->ARM_r0;
    + gdb_regs[_R1] = thread_regs->ARM_r1;
    + gdb_regs[_R2] = thread_regs->ARM_r2;
    + gdb_regs[_R3] = thread_regs->ARM_r3;
    + gdb_regs[_R4] = thread_regs->ARM_r4;
    + gdb_regs[_R5] = thread_regs->ARM_r5;
    + gdb_regs[_R6] = thread_regs->ARM_r6;
    + gdb_regs[_R7] = thread_regs->ARM_r7;
    + gdb_regs[_R8] = thread_regs->ARM_r8;
    + gdb_regs[_R9] = thread_regs->ARM_r9;
    + gdb_regs[_R10] = thread_regs->ARM_r10;
    + gdb_regs[_FP] = thread_regs->ARM_fp;
    + gdb_regs[_IP] = thread_regs->ARM_ip;
    + gdb_regs[_SPT] = thread_regs->ARM_sp;
    + gdb_regs[_LR] = thread_regs->ARM_lr;
    + gdb_regs[_PC] = thread_regs->ARM_pc;
    + gdb_regs[_CPSR] = thread_regs->ARM_cpsr;
    +}
    +
    +static int compiled_break;
    +
    +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;
    +
    + switch (remcom_in_buffer[0]) {
    + case 'D':
    + case 'k':
    + case 'c':
    + kgdb_contthread = NULL;
    +
    + /*
    + * Try to read optional parameter, pc unchanged if no parm.
    + * If this was a compiled breakpoint, we need to move
    + * to the next instruction or we will just breakpoint
    + * over and over again.
    + */
    + ptr = &remcom_in_buffer[1];
    + if (kgdb_hex2long(&ptr, &addr))
    + linux_regs->ARM_pc = addr;
    + else if (compiled_break == 1)
    + linux_regs->ARM_pc += 4;
    +
    + compiled_break = 0;
    +
    + return 0;
    + }
    +
    + return -1;
    +}
    +
    +static int kgdb_brk_fn(struct pt_regs *regs, unsigned int instr)
    +{
    + kgdb_handle_exception(1, SIGTRAP, 0, regs);
    +
    + return 0;
    +}
    +
    +static int kgdb_compiled_brk_fn(struct pt_regs *regs, unsigned int instr)
    +{
    + compiled_break = 1;
    + kgdb_handle_exception(1, SIGTRAP, 0, regs);
    +
    + return 0;
    +}
    +
    +static struct undef_hook kgdb_brkpt_hook = {
    + .instr_mask = 0xffffffff,
    + .instr_val = KGDB_BREAKINST,
    + .fn = kgdb_brk_fn
    +};
    +
    +static struct undef_hook kgdb_compiled_brkpt_hook = {
    + .instr_mask = 0xffffffff,
    + .instr_val = KGDB_COMPILED_BREAK,
    + .fn = kgdb_compiled_brk_fn
    +};
    +
    +/**
    + * kgdb_arch_init - Perform any architecture specific initalization.
    + *
    + * This function will handle the initalization of any architecture
    + * specific callbacks.
    + */
    +int kgdb_arch_init(void)
    +{
    + register_undef_hook(&kgdb_brkpt_hook);
    + register_undef_hook(&kgdb_compiled_brkpt_hook);
    +
    + return 0;
    +}
    +
    +/**
    + * kgdb_arch_exit - Perform any architecture specific uninitalization.
    + *
    + * This function will handle the uninitalization of any architecture
    + * specific callbacks, for dynamic registration and unregistration.
    + */
    +void kgdb_arch_exit(void)
    +{
    + unregister_undef_hook(&kgdb_brkpt_hook);
    + unregister_undef_hook(&kgdb_compiled_brkpt_hook);
    +}
    +
    +/*
    + * Register our undef instruction hooks with ARM undef core.
    + * We regsiter a hook specifically looking for the KGB break inst
    + * and we handle the normal undef case within the do_undefinstr
    + * handler.
    + */
    +struct kgdb_arch arch_kgdb_ops = {
    +#ifndef __ARMEB__
    + .gdb_bpt_instr = {0xfe, 0xde, 0xff, 0xe7}
    +#else /* ! __ARMEB__ */
    + .gdb_bpt_instr = {0xe7, 0xff, 0xde, 0xfe}
    +#endif
    +};
    diff --git a/arch/arm/kernel/setup.c b/arch/arm/kernel/setup.c
    index b7b0720..38f0e79 100644
    --- a/arch/arm/kernel/setup.c
    +++ b/arch/arm/kernel/setup.c
    @@ -36,6 +36,7 @@
    #include
    #include
    #include
    +#include

    #include "compat.h"
    #include "atags.h"
    @@ -853,6 +854,7 @@ void __init setup_arch(char **cmdline_p)
    conswitchp = &dummy_con;
    #endif
    #endif
    + early_trap_init();
    }


    diff --git a/arch/arm/kernel/traps.c b/arch/arm/kernel/traps.c
    index 5595fdd..7277aef 100644
    --- a/arch/arm/kernel/traps.c
    +++ b/arch/arm/kernel/traps.c
    @@ -708,6 +708,11 @@ EXPORT_SYMBOL(abort);

    void __init trap_init(void)
    {
    + return;
    +}
    +
    +void __init early_trap_init(void)
    +{
    unsigned long vectors = CONFIG_VECTORS_BASE;
    extern char __stubs_start[], __stubs_end[];
    extern char __vectors_start[], __vectors_end[];
    diff --git a/include/asm-arm/kgdb.h b/include/asm-arm/kgdb.h
    new file mode 100644
    index 0000000..67af4b8
    --- /dev/null
    +++ b/include/asm-arm/kgdb.h
    @@ -0,0 +1,104 @@
    +/*
    + * ARM KGDB support
    + *
    + * Author: Deepak Saxena
    + *
    + * Copyright (C) 2002 MontaVista Software Inc.
    + *
    + */
    +
    +#ifndef __ARM_KGDB_H__
    +#define __ARM_KGDB_H__
    +
    +#include
    +
    +/*
    + * GDB assumes that we're a user process being debugged, so
    + * it will send us an SWI command to write into memory as the
    + * debug trap. When an SWI occurs, the next instruction addr is
    + * placed into R14_svc before jumping to the vector trap.
    + * This doesn't work for kernel debugging as we are already in SVC
    + * we would loose the kernel's LR, which is a bad thing. This
    + * is bad thing.
    + *
    + * By doing this as an undefined instruction trap, we force a mode
    + * switch from SVC to UND mode, allowing us to save full kernel state.
    + *
    + * We also define a KGDB_COMPILED_BREAK which can be used to compile
    + * in breakpoints. This is important for things like sysrq-G and for
    + * the initial breakpoint from trap_init().
    + *
    + * Note to ARM HW designers: Add real trap support like SH && PPC to
    + * make our lives much much simpler.
    + */
    +#define BREAK_INSTR_SIZE 4
    +#define GDB_BREAKINST 0xef9f0001
    +#define KGDB_BREAKINST 0xe7ffdefe
    +#define KGDB_COMPILED_BREAK 0xe7ffdeff
    +#define CACHE_FLUSH_IS_SAFE 1
    +
    +#ifndef __ASSEMBLY__
    +
    +static inline void arch_kgdb_breakpoint(void)
    +{
    + asm(".word 0xe7ffdeff");
    +}
    +
    +extern void kgdb_handle_bus_error(void);
    +extern int kgdb_fault_expected;
    +
    +#endif /* !__ASSEMBLY__ */
    +
    +/*
    + * From Kevin Hilman:
    + *
    + * gdb is expecting the following registers layout.
    + *
    + * r0-r15: 1 long word each
    + * f0-f7: unused, 3 long words each !!
    + * fps: unused, 1 long word
    + * cpsr: 1 long word
    + *
    + * Even though f0-f7 and fps are not used, they need to be
    + * present in the registers sent for correct processing in
    + * the host-side gdb.
    + *
    + * In particular, it is crucial that CPSR is in the right place,
    + * otherwise gdb will not be able to correctly interpret stepping over
    + * conditional branches.
    + */
    +#define _GP_REGS 16
    +#define _FP_REGS 8
    +#define _EXTRA_REGS 2
    +#define GDB_MAX_REGS (_GP_REGS + (_FP_REGS * 3) + _EXTRA_REGS)
    +
    +#define KGDB_MAX_NO_CPUS 1
    +#define BUFMAX 400
    +#define NUMREGBYTES (GDB_MAX_REGS << 2)
    +#define NUMCRITREGBYTES (32 << 2)
    +
    +#define _R0 0
    +#define _R1 1
    +#define _R2 2
    +#define _R3 3
    +#define _R4 4
    +#define _R5 5
    +#define _R6 6
    +#define _R7 7
    +#define _R8 8
    +#define _R9 9
    +#define _R10 10
    +#define _FP 11
    +#define _IP 12
    +#define _SPT 13
    +#define _LR 14
    +#define _PC 15
    +#define _CPSR (GDB_MAX_REGS - 1)
    +
    +/*
    + * So that we can denote the end of a frame for tracing,
    + * in the simple case:
    + */
    +#define CFI_END_FRAME(func) __CFI_END_FRAME(_PC, _SPT, func)
    +
    +#endif /* __ASM_KGDB_H__ */
    diff --git a/include/asm-arm/traps.h b/include/asm-arm/traps.h
    index f1541af..aa399ae 100644
    --- a/include/asm-arm/traps.h
    +++ b/include/asm-arm/traps.h
    @@ -24,4 +24,6 @@ static inline int in_exception_text(unsigned long ptr)
    ptr < (unsigned long)&__exception_text_end;
    }

    +extern void __init early_trap_init(void);
    +
    #endif
    --
    1.5.5.1

    --
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

+ Reply to Thread