sergiotarxz/nuttx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

support gdbstub use serial.

Browse Source 
we can use uart to debug nuttx,like debugger:

1. read/write memory
2. Use watchpoint,breakpoint,single step.
    use up_debugpoint api

3. Ctrl+c to stop, continue, or single step.
    hold uart send and receive

4. register a panic event, when crash or assert/panic, we use uart to
   debug.

Signed-off-by: anjiahao <anjiahao@xiaomi.com>
This commit is contained in:
anjiahao 2023-10-31 20:12:02 +08:00 committed by Xiang Xiao
parent a423d9b404
commit bf03bb557f
8 changed files with 582 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
drivers/serial/CMakeLists.txt
View File

@ -22,6 +22,10 @@
set(SRCS serial.c serial_io.c)
if(CONFIG_SERIAL_GDBSTUB)
list(APPEND SRCS serial_gdbstub.c)
endif()
if(CONFIG_UART_PL011)
list(APPEND SRCS serial_pl011.c)
endif()

12
drivers/serial/Kconfig
View File

@ -41,6 +41,18 @@ config SERIAL_CONSOLE
bool
default n
config SERIAL_GDBSTUB
bool "GDBSTUB Serial support"
depends on ARCH_HAVE_DEBUG
default n
config SERIAL_GDBSTUB_PATH
string "GDBSTUB Serial path"
depends on SERIAL_GDBSTUB
default "/dev/ttyS1"
---help---
The path to the serial device that will be used for GDB stub.
menuconfig UART_PL011
bool "PL011 Chip support"
default n

4
drivers/serial/Make.defs
View File

@ -22,6 +22,10 @@
CSRCS += serial.c serial_io.c
ifeq ($(CONFIG_SERIAL_GDBSTUB),y)
CSRCS += serial_gdbstub.c
endif
ifeq ($(CONFIG_UART_PL011),y)
CSRCS += serial_pl011.c
endif

7
drivers/serial/serial.c
View File

@ -1836,6 +1836,13 @@ int uart_register(FAR const char *path, FAR uart_dev_t *dev)
/* Register the serial driver */
#ifdef CONFIG_SERIAL_GDBSTUB
if (strcmp(path, CONFIG_SERIAL_GDBSTUB_PATH) == 0)
{
return uart_gdbstub_register(dev);
}
#endif
sinfo("Registering %s\n", path);
return register_driver(path, &g_serialops, 0666, dev);
}

202
drivers/serial/serial_gdbstub.c Normal file
View File

@ -0,0 +1,202 @@
/****************************************************************************
* drivers/serial/serial_gdbstub.c
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership. The
* ASF licenses this file to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/serial/serial.h>
#include <nuttx/panic_notifier.h>
#include <nuttx/kmalloc.h>
#include <nuttx/gdbstub.h>
#include <nuttx/nuttx.h>
#include <string.h>
#include <debug.h>
/****************************************************************************
* Private Data
****************************************************************************/
struct uart_gdbstub_s
{
FAR struct uart_dev_s *dev;
FAR struct gdb_state_s *state;
FAR const struct uart_ops_s *org_ops;
struct uart_ops_s ops;
struct notifier_block nb;
};
static FAR struct uart_gdbstub_s *g_uart_gdbstub;
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Name: uart_gdbstub_panic_callback
*
* Description:
* This is panic callback for gdbstub, If a crash occurs,
* you can debug it through gdb
*
****************************************************************************/
static int uart_gdbstub_panic_callback(FAR struct notifier_block *nb,
unsigned long action, FAR void *data)
{
FAR struct uart_gdbstub_s *uart_gdbstub =
container_of(nb, struct uart_gdbstub_s, nb);
if (action != PANIC_KERNEL_FINAL)
{
return 0;
}
_alert("Enter panic gdbstub mode, plase use gdb connect to debug\n");
_alert("Please use gdb of the corresponding architecture to "
"connect to nuttx");
_alert("such as: arm-none-eabi-gdb nuttx -ex \"set "
"target-charset ASCII\" -ex \"target remote /dev/ttyUSB0\"\n");
gdb_console_message(uart_gdbstub->state, "Enter panic gdbstub mode!\n");
gdb_process(uart_gdbstub->state, GDBSTUB_STOPREASON_CTRLC, NULL);
return 0;
}
/****************************************************************************
* Name: uart_gdbstub_ctrlc
*
* Description:
* This is uart receive callback in interruption.
* The function is to accept the initial connection of Ctrl c and gdb.
*
****************************************************************************/
static int uart_gdbstub_ctrlc(FAR struct uart_dev_s *dev,
FAR unsigned int *status)
{
uart_disablerxint(dev);
gdb_process(g_uart_gdbstub->state, GDBSTUB_STOPREASON_CTRLC, NULL);
uart_enablerxint(dev);
return 0;
}
/****************************************************************************
* Name: uart_gdbstub_receive
*
* Description:
* This is gdbstub receive char function.
*
****************************************************************************/
static ssize_t uart_gdbstub_receive(FAR void *priv, FAR void *buf,
size_t len)
{
FAR struct uart_gdbstub_s *uart_gdbstub = priv;
FAR uart_dev_t *dev = uart_gdbstub->dev;
FAR char *ptr = buf;
unsigned int state;
size_t i = 0;
while (i < len)
{
if (uart_gdbstub->org_ops->rxavailable(dev))
{
ptr[i++] = g_uart_gdbstub->org_ops->receive(dev, &state);
}
}
return len;
}
/****************************************************************************
* Name: uart_gdbstub_send
*
* Description:
* This is gdbstub send char function.
*
****************************************************************************/
static ssize_t uart_gdbstub_send(FAR void *priv, FAR void *buf, size_t len)
{
FAR struct uart_gdbstub_s *uart_gdbstub = priv;
FAR uart_dev_t *dev = uart_gdbstub->dev;
size_t i = 0;
while (i < len)
{
if (uart_gdbstub->org_ops->txready(dev))
{
uart_gdbstub->org_ops->send(dev, ((FAR char *)buf)[i++]);
}
}
return len;
}
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: uart_gdbstub_register
*
* Description:
* Use the uart device to register gdbstub.
* gdbstub run with serial interrupt.
*
****************************************************************************/
int uart_gdbstub_register(FAR uart_dev_t *dev)
{
FAR struct uart_gdbstub_s *uart_gdbstub;
uart_gdbstub = kmm_malloc(sizeof(struct uart_gdbstub_s));
if (uart_gdbstub == NULL)
{
return -ENOMEM;
}
uart_gdbstub->state = gdb_state_init(uart_gdbstub_send,
uart_gdbstub_receive,
NULL, uart_gdbstub);
if (uart_gdbstub->state == NULL)
{
kmm_free(uart_gdbstub);
return -ENOMEM;
}
g_uart_gdbstub = uart_gdbstub;
memcpy(&uart_gdbstub->ops, dev->ops, sizeof(struct uart_ops_s));
uart_gdbstub->dev = dev;
uart_gdbstub->org_ops = dev->ops;
uart_gdbstub->ops.receive = uart_gdbstub_ctrlc;
dev->ops = &uart_gdbstub->ops;
uart_setup(dev);
uart_attach(dev);
uart_enablerxint(dev);
uart_gdbstub->nb.notifier_call = uart_gdbstub_panic_callback;
panic_notifier_chain_register(&uart_gdbstub->nb);
return 0;
}

15
include/nuttx/gdbstub.h
View File

@ -27,6 +27,18 @@
#include <stdlib.h>
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
#define GDBSTUB_STOPREASON_NONE 0x00
#define GDBSTUB_STOPREASON_WATCHPOINT_RO 0x01
#define GDBSTUB_STOPREASON_WATCHPOINT_WO 0x02
#define GDBSTUB_STOPREASON_WATCHPOINT_RW 0x03
#define GDBSTUB_STOPREASON_BREAKPOINT 0x04
#define GDBSTUB_STOPREASON_STEPPOINT 0x05
#define GDBSTUB_STOPREASON_CTRLC 0x06
/****************************************************************************
* Type Definitions
****************************************************************************/
@ -108,6 +120,7 @@ int gdb_console_message(FAR struct gdb_state_s *state, FAR const char *msg);
*
****************************************************************************/
int gdb_process(FAR struct gdb_state_s *state);
int gdb_process(FAR struct gdb_state_s *state, int stopreason,
FAR void *stopaddr);
#endif /* __INCLUDE_NUTTX_GDBSTUB_H */

13
include/nuttx/serial/serial.h
View File

@ -522,6 +522,19 @@ void uart_reset_sem(FAR uart_dev_t *dev);
int uart_check_special(FAR uart_dev_t *dev, const char *buf, size_t size);
#endif
/****************************************************************************
* Name: uart_gdbstub_register
*
* Description:
* Use the uart device to register gdbstub.
* gdbstub run with serial interrupt.
*
****************************************************************************/
#ifdef CONFIG_SERIAL_GDBSTUB
int uart_gdbstub_register(FAR uart_dev_t *dev);
#endif
#undef EXTERN
#if defined(__cplusplus)
}

372
libs/libc/gdbstub/lib_gdbstub.c
View File

@ -30,7 +30,9 @@
#include <sys/param.h>
#include <sys/types.h>
#include <nuttx/arch.h>
#include <nuttx/sched.h>
#include <nuttx/ascii.h>
#include <nuttx/gdbstub.h>
/****************************************************************************
@ -57,6 +59,8 @@ struct gdb_state_s
gdb_monitor_func_t monitor; /* Monitor will be called when gdb
* receive a monitor command
*/
int last_stopreason; /* Last stop reason */
FAR void *last_stopaddr; /* Last stop address */
pid_t pid; /* Gdb current thread */
FAR char *pkt_next; /* Pointer to next byte in packet */
char pkt_buf[1024]; /* Packet buffer */
@ -107,8 +111,6 @@ static ssize_t gdb_bin2bin(FAR void *buf, size_t buf_len,
/* Packet creation helpers */
static int gdb_send_ok_packet(FAR struct gdb_state_s *state);
static int gdb_send_signal_packet(FAR struct gdb_state_s *state,
unsigned char signal);
static int gdb_send_error_packet(FAR struct gdb_state_s *state,
unsigned char error);
@ -400,6 +402,12 @@ static int gdb_recv_packet(FAR struct gdb_state_s *state)
break;
}
else if (ret == ASCII_ETX)
{
state->pkt_buf[0] = ASCII_ETX;
state->pkt_len = 1;
return 0;
}
}
/* Read until checksum */
@ -432,6 +440,12 @@ static int gdb_recv_packet(FAR struct gdb_state_s *state)
}
while (state->pkt_len == 0); /* Ignore empty packets */
ret = state->recv(state->priv, buf, 2); /* Receive the checksum */
if (ret < 0)
{
return ret;
}
#ifdef CONFIG_LIB_GDBSTUB_DEBUG
{
size_t p;
@ -452,12 +466,6 @@ static int gdb_recv_packet(FAR struct gdb_state_s *state)
}
#endif
ret = state->recv(state->priv, buf, 2); /* Receive the checksum */
if (ret < 0)
{
return ret;
}
ret = gdb_hex2bin(&csum, 1, buf, 2);
if (ret < 0)
{
@ -773,39 +781,6 @@ static int gdb_send_ok_packet(FAR struct gdb_state_s *state)
return gdb_send_packet(state);
}
/****************************************************************************
* Name: gdb_send_signal_packet
*
* Description:
* Send a signal packet (S AA).
*
* Input Parameters:
* state - The pointer to the GDB state structure.
* signal - The signal to send.
*
* Returned Value:
* Zero on success.
* Negative value on error.
*
****************************************************************************/
static int gdb_send_signal_packet(FAR struct gdb_state_s *state,
unsigned char signal)
{
int ret;
state->pkt_buf[0] = 'S';
ret = gdb_bin2hex(&state->pkt_buf[1], sizeof(state->pkt_buf) - 1,
&signal, 1);
if (ret < 0)
{
return ret;
}
state->pkt_len = 1 + ret;
return gdb_send_packet(state);
}
/****************************************************************************
* Name: gdb_send_error_packet
*
@ -1176,6 +1151,7 @@ static int gdb_query(FAR struct gdb_state_s *state)
static const char thread_extra_info[] = "ThreadExtraInfo";
static const char fthread_info[] = "fThreadInfo";
static const char sthread_info[] = "sThreadInfo";
static const char supported_info[] = "Supported";
static const char r_cmd[] = "Rcmd";
if (memcmp(&state->pkt_buf[1], fthread_info,
@ -1195,6 +1171,20 @@ static int gdb_query(FAR struct gdb_state_s *state)
state->pkt_len = 1;
gdb_send_packet(state);
}
else if (memcmp(&state->pkt_buf[1], supported_info,
sizeof(supported_info) - 1) == 0)
{
#ifdef CONFIG_ARCH_HAVE_DEBUG
state->pkt_len = sprintf(state->pkt_buf,
"hwbreak+;PacketSize=%x",
sizeof(state->pkt_buf));
#else
state->pkt_len = sprintf(state->pkt_buf,
"PacketSize=%x",
sizeof(state->pkt_buf));
#endif
gdb_send_packet(state);
}
else if (memcmp(&state->pkt_buf[1], thread_extra_info,
sizeof(thread_extra_info) - 1) == 0)
{
@ -1325,7 +1315,7 @@ static int gdb_is_thread_active(FAR struct gdb_state_s *state)
* 0 if successful.
* Negative value on error.
*
* Note : Comand Format: Hc<id>
* Note : Comand Format: Hg<id>
* Rsponse Format: OK
****************************************************************************/
@ -1335,6 +1325,11 @@ static int gdb_thread_context(FAR struct gdb_state_s *state)
uintptr_t pid;
int ret;
if (state->pkt_buf[1] != 'g')
{
return -EINVAL;
}
state->pkt_next += 2;
ret = gdb_expect_integer(state, &pid);
if (ret < 0)
@ -1370,13 +1365,260 @@ static int gdb_thread_context(FAR struct gdb_state_s *state)
* 0 if successful.
* Negative value on error.
*
* Note : Rsponse Format: T AA n1:r1;n2:r2;...
* The program received signal number AA
* n is thread id in current.
* r is stop reason.
*
****************************************************************************/
static int gdb_send_stop(FAR struct gdb_state_s *state)
static int gdb_send_stop(FAR struct gdb_state_s *state, int stopreason,
FAR void *stopaddr)
{
return gdb_send_signal_packet(state, 0x00);
int ret;
state->pid = _SCHED_GETTID();
retry:
switch (stopreason)
{
case GDBSTUB_STOPREASON_WATCHPOINT_RO:
ret = sprintf(state->pkt_buf, "T05thread:%x;rwatch:%" PRIxPTR ";",
state->pid + 1, (uintptr_t)stopaddr);
break;
case GDBSTUB_STOPREASON_WATCHPOINT_WO:
ret = sprintf(state->pkt_buf, "T05thread:%x;awatch:%" PRIxPTR ";",
state->pid + 1, (uintptr_t)stopaddr);
break;
case GDBSTUB_STOPREASON_WATCHPOINT_RW:
ret = sprintf(state->pkt_buf, "T05thread:%x;watch:%" PRIxPTR ";",
state->pid + 1, (uintptr_t)stopaddr);
break;
case GDBSTUB_STOPREASON_BREAKPOINT:
ret = sprintf(state->pkt_buf, "T05thread:%x;hwbreak:;",
state->pid + 1);
break;
case GDBSTUB_STOPREASON_STEPPOINT:
if (state->last_stopreason == GDBSTUB_STOPREASON_WATCHPOINT_RW ||
state->last_stopreason == GDBSTUB_STOPREASON_WATCHPOINT_WO)
{
stopreason = state->last_stopreason;
stopaddr = state->last_stopaddr;
goto retry;
}
case GDBSTUB_STOPREASON_CTRLC:
default:
ret = sprintf(state->pkt_buf, "T05thread:%d;", state->pid + 1);
}
if (ret < 0)
{
return ret;
}
state->pkt_len = ret;
return gdb_send_packet(state);
}
#ifdef CONFIG_ARCH_HAVE_DEBUG
/****************************************************************************
* Name: gdbstub_debugpoint_callback
*
* Description:
* The debugpoint callback is used by GDB to request.
*
****************************************************************************/
static void gdbstub_debugpoint_callback(int type, FAR void *addr,
size_t size, FAR void *arg)
{
int stopreason;
switch (type)
{
case DEBUGPOINT_BREAKPOINT:
stopreason = GDBSTUB_STOPREASON_BREAKPOINT;
break;
case DEBUGPOINT_WATCHPOINT_RO:
stopreason = GDBSTUB_STOPREASON_WATCHPOINT_RO;
break;
case DEBUGPOINT_WATCHPOINT_WO:
stopreason = GDBSTUB_STOPREASON_WATCHPOINT_WO;
break;
case DEBUGPOINT_WATCHPOINT_RW:
stopreason = GDBSTUB_STOPREASON_WATCHPOINT_RW;
break;
case DEBUGPOINT_STEPPOINT:
stopreason = GDBSTUB_STOPREASON_STEPPOINT;
up_debugpoint_remove(DEBUGPOINT_STEPPOINT, NULL, 0);
break;
default:
return;
}
gdb_process(arg, stopreason, addr);
}
/****************************************************************************
* Name: gdb_debugpoint
*
* Description:
* The debugpoint packet is used by GDB to request information from
*
* Input Parameters:
* state - The pointer to the GDB state structure.
* enable - Enable or disable debugpoint.
*
* Returned Value:
* 0 if successful.
* Negative value on error.
*
* Note : Comand Format: Z/z type,addr,length
* Rsponse Format: OK
* Z is set breakpoint.
* z is clear breakpoint.
* type: 0 is software breakpoint.
* 1 is hardware breakpoint.
* 2 is write watchpoint.
* 3 is read watchpoint.
* 4 is read/write watchpoint.
* length: is the length of watchpoint.
* if is breakpoint, length is instruction type.
*
****************************************************************************/
static int gdb_debugpoint(FAR struct gdb_state_s *state, bool enable)
{
uintptr_t type;
uintptr_t addr;
uintptr_t size;
int ret;
state->pkt_next += 1;
ret = gdb_expect_integer(state, &type);
if (ret < 0)
{
return ret;
}
ret = gdb_expect_seperator(state, ',');
if (ret < 0)
{
return ret;
}
ret = gdb_expect_integer(state, &addr);
if (ret < 0)
{
return ret;
}
ret = gdb_expect_seperator(state, ',');
if (ret < 0)
{
return ret;
}
ret = gdb_expect_integer(state, &size);
if (ret < 0)
{
return ret;
}
switch (type)
{
case 0: /* just use hardware break */
case 1:
type = DEBUGPOINT_BREAKPOINT;
break;
case 2:
type = DEBUGPOINT_WATCHPOINT_WO;
break;
case 3:
type = DEBUGPOINT_WATCHPOINT_RO;
break;
case 4:
type = DEBUGPOINT_WATCHPOINT_RW;
break;
default:
return -EPROTONOSUPPORT;
}
if (enable)
{
ret = up_debugpoint_add(type, (FAR void *)addr, size,
gdbstub_debugpoint_callback, state);
}
else
{
ret = up_debugpoint_remove(type, (FAR void *)addr, size);
}
if (ret < 0)
{
return ret;
}
return gdb_send_ok_packet(state);
}
/****************************************************************************
* Name: gdb_step
*
* Description:
* The handle step packet is used by GDB to request information from
*
* Input Parameters:
* state - The pointer to the GDB state structure.
*
* Returned Value:
* 0 if successful.
* Negative value on error.
*
* Note : Comand Format: s
* Rsponse Format: OK
*
****************************************************************************/
static int gdb_step(FAR struct gdb_state_s *state)
{
int ret = up_debugpoint_add(DEBUGPOINT_STEPPOINT, NULL, 0,
gdbstub_debugpoint_callback, state);
if (ret < 0)
{
return ret;
}
return gdb_send_ok_packet(state);
}
/****************************************************************************
* Name: gdb_continue
*
* Description:
* The handle continue packet is used by GDB to request information from
*
* Input Parameters:
* state - The pointer to the GDB state structure.
*
* Returned Value:
* 0 if successful.
* Negative value on error.
*
* Note : Comand Format: c
* Rsponse Format: OK
*
****************************************************************************/
static int gdb_continue(FAR struct gdb_state_s *state)
{
return gdb_send_ok_packet(state);
}
#endif
/****************************************************************************
* Public Data
****************************************************************************/
@ -1497,10 +1739,16 @@ int gdb_console_message(FAR struct gdb_state_s *state, FAR const char *msg)
*
****************************************************************************/
int gdb_process(FAR struct gdb_state_s *state)
int gdb_process(FAR struct gdb_state_s *state, int stopreason,
FAR void *stopaddr)
{
int ret;
if (stopreason != GDBSTUB_STOPREASON_NONE)
{
gdb_send_stop(state, stopreason, stopaddr);
}
while ((ret = gdb_recv_packet(state)) >= 0)
{
/* Handle one letter commands */
@ -1508,7 +1756,7 @@ int gdb_process(FAR struct gdb_state_s *state)
switch (state->pkt_buf[0])
{
case '?': /* gdbserial status */
ret = gdb_send_stop(state);
ret = gdb_send_stop(state, stopreason, stopaddr);
break;
case 'g': /* Read registers */
ret = gdb_read_registers(state);
@ -1540,6 +1788,33 @@ int gdb_process(FAR struct gdb_state_s *state)
case 'k': /* Kill request */
ret = -ECONNRESET;
break;
case ASCII_ETX: /* Ctrl C */
ret = gdb_send_ok_packet(state);
break;
#ifdef CONFIG_ARCH_HAVE_DEBUG
case 'Z': /* Insert breakpoint/watchpoint */
ret = gdb_debugpoint(state, true);
break;
case 'z': /* Remove breakpoint/watchpoint */
ret = gdb_debugpoint(state, false);
break;
case 's': /* Single step */
ret = gdb_step(state);
if (ret < 0)
{
break;
}
goto out;
case 'c': /* Continue */
ret = gdb_continue(state);
if (ret < 0)
{
break;
}
goto out;
#endif
default:
ret = -EPROTONOSUPPORT;
}
@ -1559,6 +1834,11 @@ int gdb_process(FAR struct gdb_state_s *state)
}
}
#ifdef CONFIG_ARCH_HAVE_DEBUG
out:
#endif
state->last_stopreason = stopreason;
state->last_stopaddr = stopaddr;
return ret;
}