You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@nuttx.apache.org by xi...@apache.org on 2023/07/14 17:57:18 UTC
[nuttx] 01/02: libs/libc:Support gdb rsp protocol
This is an automated email from the ASF dual-hosted git repository.
xiaoxiang pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/nuttx.git
commit b956495c5eb00396569133dddfdf28a05fe5a1de
Author: anjiahao <an...@xiaomi.com>
AuthorDate: Fri Jul 7 11:08:09 2023 +0800
libs/libc:Support gdb rsp protocol
you can debug nuttx through any transport layer (serial port, network etc.),
currently supports the following functions:
1. Read and write registers
2. Read and write memory
3. Switch thread and read stack information
Future support plans:
1. Support breakpoint, watch point (requires architecture support).
related information:
https://sourceware.org/gdb/onlinedocs/gdb/Remote-Protocol.html
Signed-off-by: anjiahao <an...@xiaomi.com>
---
include/nuttx/gdbstub.h | 113 +++
libs/libc/Kconfig | 1 +
libs/libc/Makefile | 1 +
libs/libc/gdbstub/Kconfig | 20 +
libs/libc/gdbstub/Make.defs | 32 +
libs/libc/gdbstub/lib_gdbstub.c | 1559 +++++++++++++++++++++++++++++++++++++++
6 files changed, 1726 insertions(+)
diff --git a/include/nuttx/gdbstub.h b/include/nuttx/gdbstub.h
new file mode 100644
index 0000000000..0772e6f049
--- /dev/null
+++ b/include/nuttx/gdbstub.h
@@ -0,0 +1,113 @@
+/****************************************************************************
+ * include/nuttx/gdbstub.h
+ *
+ * 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.
+ *
+ ****************************************************************************/
+
+#ifndef __INCLUDE_NUTTX_GDBSTUB_H
+#define __INCLUDE_NUTTX_GDBSTUB_H
+
+/****************************************************************************
+ * Included Files
+ ****************************************************************************/
+
+#include <stdlib.h>
+
+/****************************************************************************
+ * Type Definitions
+ ****************************************************************************/
+
+struct gdb_state_s;
+typedef CODE ssize_t (*gdb_send_func_t)(FAR void *priv, FAR void *buf,
+ size_t len);
+typedef CODE ssize_t (*gdb_recv_func_t)(FAR void *priv, FAR void *buf,
+ size_t len);
+
+typedef CODE int (*gdb_monitor_func_t)(FAR struct gdb_state_s *state,
+ FAR const char *cmd);
+
+/****************************************************************************
+ * Name: gdb_state_init
+ *
+ * Description:
+ * Initialize the GDB state structure.
+ *
+ * Input Parameters:
+ * send - The pointer to the send function.
+ * recv - The pointer to the receive function.
+ * monitor - The pointer to the monitor function.
+ * priv - The pointer to the private data.
+ *
+ * Returned Value:
+ * The pointer to the GDB state structure on success.
+ * NULL on failure.
+ *
+ ****************************************************************************/
+
+FAR struct gdb_state_s *gdb_state_init(gdb_send_func_t send,
+ gdb_recv_func_t recv,
+ gdb_monitor_func_t monitor,
+ FAR void *priv);
+
+/****************************************************************************
+ * Name: gdb_state_uninit
+ *
+ * Description:
+ * Uninitialize the GDB state structure.
+ *
+ * Input Parameters:
+ * state - The pointer to the GDB state structure.
+ *
+ ****************************************************************************/
+
+void gdb_state_uninit(FAR struct gdb_state_s *state);
+
+/****************************************************************************
+ * Name: gdb_console_message
+ *
+ * Description:
+ * Send a message to the GDB console (via O XX... packet).
+ *
+ * Input Parameters:
+ * state - The pointer to the GDB state structure.
+ *
+ * Returned Value:
+ * Zero on success.
+ * Negative value on error.
+ *
+ ****************************************************************************/
+
+int gdb_console_message(FAR struct gdb_state_s *state, FAR const char *msg);
+
+/****************************************************************************
+ * Name: gdb_process
+ *
+ * Description:
+ * Main debug loop. Handles commands.
+ *
+ * Input Parameters:
+ * state - The pointer to the GDB state structure.
+ *
+ * Returned Value:
+ * Zero if successful.
+ * Negative value on error.
+ *
+ ****************************************************************************/
+
+int gdb_process(FAR struct gdb_state_s *state);
+
+#endif /* __INCLUDE_NUTTX_GDBSTUB_H */
diff --git a/libs/libc/Kconfig b/libs/libc/Kconfig
index 1e26b3ee38..ac59bac040 100644
--- a/libs/libc/Kconfig
+++ b/libs/libc/Kconfig
@@ -14,6 +14,7 @@ source "libs/libc/string/Kconfig"
source "libs/libc/pthread/Kconfig"
source "libs/libc/dlfcn/Kconfig"
source "libs/libc/modlib/Kconfig"
+source "libs/libc/gdbstub/Kconfig"
source "libs/libc/grp/Kconfig"
source "libs/libc/pwd/Kconfig"
source "libs/libc/locale/Kconfig"
diff --git a/libs/libc/Makefile b/libs/libc/Makefile
index 40e87f58fb..b08dabe046 100644
--- a/libs/libc/Makefile
+++ b/libs/libc/Makefile
@@ -30,6 +30,7 @@ include dlfcn/Make.defs
include errno/Make.defs
include eventfd/Make.defs
include fixedmath/Make.defs
+include gdbstub/Make.defs
include grp/Make.defs
include hex2bin/Make.defs
include inttypes/Make.defs
diff --git a/libs/libc/gdbstub/Kconfig b/libs/libc/gdbstub/Kconfig
new file mode 100644
index 0000000000..faa91cdb90
--- /dev/null
+++ b/libs/libc/gdbstub/Kconfig
@@ -0,0 +1,20 @@
+#
+# For a description of the syntax of this configuration file,
+# see the file kconfig-language.txt in the NuttX tools repository.
+#
+
+config LIB_GDBSTUB
+ tristate "GDBSTUB"
+ depends on DEBUG_TCBINFO
+ ---help---
+ Enable support for gdbstub.
+
+if LIB_GDBSTUB
+
+config LIB_GDBSTUB_DEBUG
+ bool "Gdbstub Debug Info"
+ default n
+ ---help---
+ Add debug info to gdbstub
+
+endif
diff --git a/libs/libc/gdbstub/Make.defs b/libs/libc/gdbstub/Make.defs
new file mode 100644
index 0000000000..77c2180c80
--- /dev/null
+++ b/libs/libc/gdbstub/Make.defs
@@ -0,0 +1,32 @@
+############################################################################
+# libs/libc/gdbstub/Make.defs
+#
+# 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.
+#
+############################################################################
+
+ifeq ($(CONFIG_LIB_GDBSTUB),y)
+
+# Add the internal C files to the build
+
+CSRCS += lib_gdbstub.c
+
+# Add the userfs directory to the build
+
+DEPPATH += --dep-path gdbstub
+VPATH += :gdbstub
+
+endif
diff --git a/libs/libc/gdbstub/lib_gdbstub.c b/libs/libc/gdbstub/lib_gdbstub.c
new file mode 100644
index 0000000000..67b4dbb5ad
--- /dev/null
+++ b/libs/libc/gdbstub/lib_gdbstub.c
@@ -0,0 +1,1559 @@
+/****************************************************************************
+ * libs/libc/gdbstub/lib_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 <ctype.h>
+#include <stdint.h>
+#include <string.h>
+#include <stdio.h>
+#include <syslog.h>
+#include <sys/param.h>
+#include <sys/types.h>
+
+#include <nuttx/sched.h>
+#include <nuttx/gdbstub.h>
+
+/****************************************************************************
+ * Pre-processor Definitions
+ ****************************************************************************/
+
+#ifdef CONFIG_LIB_GDBSTUB_DEBUG
+# define GDB_DEBUG(...) syslog(LOG_DEBUG, ##__VA_ARGS__)
+# define GDB_ASSERT() __assert(__FILE__, __LINE__, 0)
+#else
+# define GDB_DEBUG(...)
+# define GDB_ASSERT() do {} while (0)
+#endif
+
+/****************************************************************************
+ * Private Types
+ ****************************************************************************/
+
+struct gdb_state_s
+{
+ gdb_send_func_t send; /* Send buffer to gdb */
+ gdb_recv_func_t recv; /* Recv buffer from gdb */
+ FAR void *priv; /* Private data for transport */
+ gdb_monitor_func_t monitor; /* Monitor will be called when gdb
+ * receive a monitor command
+ */
+ pid_t pid; /* Gdb current thread */
+ FAR char *pkt_next; /* Pointer to next byte in packet */
+ char pkt_buf[1024]; /* Packet buffer */
+ size_t pkt_len; /* Packet send and receive length */
+ uint8_t running_regs[XCPTCONTEXT_SIZE]; /* Registers of running thread */
+ size_t size; /* Size of registers */
+ uintptr_t registers[0]; /* Registers of other threads */
+};
+
+typedef CODE ssize_t (*gdb_format_func_t)(FAR void *buf, size_t buf_len,
+ FAR const void *data,
+ size_t data_len);
+
+/* Calculate remaining space in packet from ptr_next position. */
+
+#define gdb_remaining_len(state) ((state)->pkt_len - \
+ ((state)->pkt_next - (state)->pkt_buf))
+
+/****************************************************************************
+ * Private Data
+ ****************************************************************************/
+
+/****************************************************************************
+ * Private Functions Prototypes
+ ****************************************************************************/
+
+/* System functions, supported by all stubs */
+
+static int gdb_getchar(FAR struct gdb_state_s *state);
+static int gdb_putchar(FAR struct gdb_state_s *state, int ch);
+
+/* Packet functions */
+
+static int gdb_send_packet(FAR struct gdb_state_s *state);
+static int gdb_recv_packet(FAR struct gdb_state_s *state);
+static int gdb_checksum(FAR const char *buf, size_t len);
+static int gdb_recv_ack(FAR struct gdb_state_s *state);
+
+/* Data format */
+
+static ssize_t gdb_bin2hex(FAR void *buf, size_t buf_len,
+ FAR const void *data, size_t data_len);
+static ssize_t gdb_hex2bin(FAR void *buf, size_t buf_len,
+ FAR const void *data, size_t data_len);
+static ssize_t gdb_bin2bin(FAR void *buf, size_t buf_len,
+ FAR const void *data, size_t data_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);
+
+/* Command functions */
+
+static ssize_t gdb_get_memory(FAR struct gdb_state_s *state,
+ FAR void *buf, size_t buf_len,
+ uintptr_t addr, size_t len,
+ gdb_format_func_t format);
+static ssize_t gdb_put_memory(FAR struct gdb_state_s *state,
+ FAR const void *buf, size_t buf_len,
+ uintptr_t addr, size_t len,
+ gdb_format_func_t format);
+
+/****************************************************************************
+ * Private Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Packet buffer Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: gdb_expect_seperator
+ *
+ * Description:
+ * Check if the next byte in the packet is a seperator.
+ *
+ * Input Parameters:
+ * state - The pointer to the GDB state structure.
+ * c - The expected seperator.
+ *
+ * Returned Value:
+ * 0 on success, -EINVAL on error.
+ *
+ ****************************************************************************/
+
+static int gdb_expect_seperator(FAR struct gdb_state_s *state, char c)
+{
+ if (!state->pkt_next || *state->pkt_next != c)
+ {
+ return -EINVAL;
+ }
+ else
+ {
+ state->pkt_next++;
+ }
+
+ return 0;
+}
+
+/****************************************************************************
+ * Name: gdb_expect_integer
+ *
+ * Description:
+ * Parse an integer argument from the packet.
+ *
+ * Input Parameters:
+ * state - The pointer to the GDB state structure.
+ * arg - The parsed integer argument.
+ *
+ * Returned Value:
+ * 0 on success
+ *
+ ****************************************************************************/
+
+static int gdb_expect_integer(FAR struct gdb_state_s *state,
+ FAR uintptr_t *arg)
+{
+ size_t len = gdb_remaining_len(state);
+ char tmp = state->pkt_next[len];
+
+ state->pkt_next[len] = '\0';
+ *arg = strtoul(state->pkt_next, &state->pkt_next, 16);
+ state->pkt_next[len] = tmp;
+ return 0;
+}
+
+/****************************************************************************
+ * Name: gdb_expect_addr_lenth
+ *
+ * Description:
+ * Parse an address and length argument from the packet.
+ *
+ * Input Parameters:
+ * state - The pointer to the GDB state structure.
+ * addr - The parsed address.
+ * length - The parsed length.
+ *
+ * Returned Value:
+ * 0 on success, -EINVAL on error.
+ *
+ ****************************************************************************/
+
+static int gdb_expect_addr_lenth(FAR struct gdb_state_s *state,
+ FAR uintptr_t *addr, FAR size_t *length)
+{
+ int ret;
+
+ ret = gdb_expect_integer(state, addr);
+ if (ret < 0)
+ {
+ return ret;
+ }
+
+ ret = gdb_expect_seperator(state, ',');
+ if (ret < 0)
+ {
+ return ret;
+ }
+
+ return gdb_expect_integer(state, length);
+}
+
+/****************************************************************************
+ * Packet Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: gdb_putchar
+ *
+ * Description:
+ * Put a character to the GDB server.
+ *
+ * Input Parameters:
+ * state - The pointer to the GDB state structure.
+ * ch - The character to be sent.
+ *
+ * Returned Value:
+ * The character sent to the GDB server.
+ *
+ ****************************************************************************/
+
+static int gdb_putchar(FAR struct gdb_state_s *state, int ch)
+{
+ unsigned char tmp = ch & 0xff;
+ ssize_t ret;
+
+ ret = state->send(state->priv, &tmp, 1);
+ if (ret < 0)
+ {
+ return ret;
+ }
+
+ return tmp;
+}
+
+/****************************************************************************
+ * Name: gdb_getchar
+ *
+ * Description:
+ * Get a character from the GDB server.
+ *
+ * Input Parameters:
+ * state - The pointer to the GDB state structure.
+ *
+ * Returned Value:
+ * The character read from the GDB server.
+ *
+ ****************************************************************************/
+
+static int gdb_getchar(FAR struct gdb_state_s *state)
+{
+ unsigned char tmp;
+ ssize_t ret;
+
+ ret = state->recv(state->priv, &tmp, 1);
+ if (ret < 0)
+ {
+ return ret;
+ }
+
+ return tmp;
+}
+
+/****************************************************************************
+ * Name: gdb_send_packet
+ *
+ * Description:
+ * Transmits a packet of data.
+ * Packets are of the form: $<packet-data>#<checksum>
+ *
+ * Input Parameters:
+ * state - The pointer to the GDB state structure.
+ *
+ * Returned Value:
+ * 0 if the packet was transmitted and acknowledged.
+ * 1 if the packet was transmitted but not acknowledged.
+ * Negative value on error.
+ *
+ ****************************************************************************/
+
+static int gdb_send_packet(FAR struct gdb_state_s *state)
+{
+ unsigned char buf[3];
+ unsigned char csum;
+ int ret;
+
+ ret = gdb_putchar(state, '$'); /* Send packet start */
+ if (ret < 0)
+ {
+ return ret;
+ }
+
+#ifdef CONFIG_LIB_GDBSTUB_DEBUG
+ {
+ size_t p;
+ GDB_DEBUG("-> ");
+ for (p = 0; p < state->pkt_len; p++)
+ {
+ if (isprint(state->pkt_buf[p]))
+ {
+ GDB_DEBUG("%c", state->pkt_buf[p]);
+ }
+ else
+ {
+ GDB_DEBUG("\\x%02x", state->pkt_buf[p] & 0xff);
+ }
+ }
+
+ GDB_DEBUG("\n");
+ }
+#endif
+
+ /* Send packet data */
+
+ ret = state->send(state->priv, state->pkt_buf, state->pkt_len);
+ if (ret < 0)
+ {
+ return ret;
+ }
+
+ /* Send the checksum */
+
+ buf[0] = '#';
+ csum = gdb_checksum(state->pkt_buf, state->pkt_len);
+ ret = gdb_bin2hex(buf + 1, sizeof(buf) - 1, &csum, 1);
+ if (ret < 0)
+ {
+ return ret;
+ }
+
+ ret = state->send(state->priv, buf, sizeof(buf));
+ if (ret < 0)
+ {
+ return ret;
+ }
+
+ return gdb_recv_ack(state);
+}
+
+/****************************************************************************
+ * Name: gdb_recv_packet
+ *
+ * Description:
+ * Receives a packet of data, assuming a 7-bit clean connection.
+ *
+ * Input Parameters:
+ * state - The pointer to the GDB state structure.
+ *
+ * Returned Value:
+ * 0 if the packet was received.
+ * -EIO if the packet was not received.
+ * -EOVERFLOW if the packet was too long.
+ * Negative value on error.
+ *
+ ****************************************************************************/
+
+static int gdb_recv_packet(FAR struct gdb_state_s *state)
+{
+ unsigned char buf[2];
+ unsigned char csum;
+ int ret;
+
+ /* Wait for packet start */
+
+ do
+ {
+ while (1)
+ {
+ ret = gdb_getchar(state);
+ if (ret < 0)
+ {
+ return ret;
+ }
+ else if (ret == '$')
+ {
+ /* Detected start of packet. */
+
+ break;
+ }
+ }
+
+ /* Read until checksum */
+
+ state->pkt_len = 0;
+ while (1)
+ {
+ ret = gdb_getchar(state);
+ if (ret < 0) /* Error receiving character */
+ {
+ return ret;
+ }
+ else if (ret == '#') /* End of packet */
+ {
+ break;
+ }
+ else /* Check for space */
+ {
+ if (state->pkt_len >= sizeof(state->pkt_buf))
+ {
+ GDB_DEBUG("packet buffer overflow\n");
+ return -EOVERFLOW;
+ }
+
+ /* Store character and update checksum */
+
+ state->pkt_buf[state->pkt_len++] = (char)ret;
+ }
+ }
+ }
+ while (state->pkt_len == 0); /* Ignore empty packets */
+
+#ifdef CONFIG_LIB_GDBSTUB_DEBUG
+ {
+ size_t p;
+ GDB_DEBUG("<- ");
+ for (p = 0; p < state->pkt_len; p++)
+ {
+ if (isprint(state->pkt_buf[p]))
+ {
+ GDB_DEBUG("%c", state->pkt_buf[p]);
+ }
+ else
+ {
+ GDB_DEBUG("\\x%02x", state->pkt_buf[p] & 0xff);
+ }
+ }
+
+ GDB_DEBUG("\n");
+ }
+#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)
+ {
+ return ret;
+ }
+
+ if (csum != gdb_checksum(state->pkt_buf, state->pkt_len)) /* Verify */
+ {
+ GDB_DEBUG("received packet with bad checksum\n");
+ gdb_putchar(state, '-'); /* Send packet nack */
+ return -EIO;
+ }
+
+ gdb_putchar(state, '+'); /* Send packet ack */
+ state->pkt_next = state->pkt_buf;
+ return 0;
+}
+
+/****************************************************************************
+ * Name: gdb_checksum
+ *
+ * Description:
+ * Calculate 8-bit checksum of a buffer.
+ *
+ * Input Parameters:
+ * buf - The buffer to checksum.
+ *
+ * Returned Value:
+ * 8-bit checksum
+ *
+ ****************************************************************************/
+
+static int gdb_checksum(FAR const char *buf, size_t len)
+{
+ unsigned char csum = 0;
+
+ while (len--)
+ {
+ csum += *buf++;
+ }
+
+ return csum;
+}
+
+/****************************************************************************
+ * Name: gdb_recv_ack
+ *
+ * Description:
+ * Receive a packet acknowledgment.
+ *
+ * Input Parameters:
+ * state - The pointer to the GDB state structure.
+ *
+ * Returned Value:
+ * 0 if an ACK (+) was received
+ * 1 if a NACK (-) was received
+ * -EINVAL if a bad response was received
+ *
+ ****************************************************************************/
+
+static int gdb_recv_ack(FAR struct gdb_state_s *state)
+{
+ int response;
+
+ switch (response = gdb_getchar(state)) /* Wait for packet ack */
+ {
+ case '+': /* Packet acknowledged */
+ return 0;
+ case '-': /* Packet negative acknowledged */
+ return 1;
+ default: /* Bad response! */
+ GDB_DEBUG("received bad packet response: 0x%2x\n", response);
+ return -EINVAL;
+ }
+}
+
+/****************************************************************************
+ * Data Encoding/Decoding
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: gdb_bin2hex
+ *
+ * Description:
+ * Encode data to its hex-value representation in a buffer.
+ *
+ * Input Parameters:
+ * buf - The buffer to encode to.
+ * buf_len - The length of the buffer.
+ * data - The data to encode.
+ * data_len - The length of the data to encode.
+ *
+ * Returned Value:
+ * The number of bytes written to buf on success.
+ * -EOVERFLOW if the buffer is too small.
+ *
+ ****************************************************************************/
+
+static ssize_t gdb_bin2hex(FAR void *buf, size_t buf_len,
+ FAR const void *data, size_t data_len)
+{
+ FAR const char *in = data;
+ FAR char *out = buf;
+ size_t pos;
+
+ if (buf_len < data_len * 2)
+ {
+ return -EOVERFLOW; /* Buffer too small */
+ }
+
+ for (pos = 0; pos < data_len; pos++)
+ {
+ itoa(in[pos] >> 4 & 0xf, out++, 16);
+ itoa(in[pos] & 0xf, out++, 16);
+ }
+
+ return data_len * 2;
+}
+
+/****************************************************************************
+ * Name: gdb_hex2bin
+ *
+ * Description:
+ * Decode data from its hex-value representation to a buffer.
+ *
+ * Input Parameters:
+ * buf - The buffer containing the encoded data.
+ * buf_len - The length of the buffer.
+ * data - The buffer to store the decoded data.
+ * data_len - The length of the data to decode.
+ *
+ * Returned Value:
+ * The number of bytes written to data on success.
+ * -EOVERFLOW if the buffer is too small.
+ * Negative value on error.
+ *
+ ****************************************************************************/
+
+static int gdb_hex2bin(FAR void *buf, size_t buf_len,
+ FAR const void *data, size_t data_len)
+{
+ FAR const char *in = data;
+ FAR char *out = buf;
+ size_t pos;
+
+ if (buf_len * 2 < data_len)
+ {
+ return -EOVERFLOW; /* Buffer too small */
+ }
+
+ for (pos = 0; pos < data_len; pos += 2)
+ {
+ char ch[3] =
+ {
+ in[pos], in[pos + 1], 0
+ };
+
+ out[pos / 2] = strtoul(ch, NULL, 16); /* Decode high nibble */
+ if (out[pos / 2] == 0 && errno)
+ {
+ GDB_ASSERT();
+ return -errno; /* Buffer contained junk. */
+ }
+ }
+
+ return data_len / 2;
+}
+
+/****************************************************************************
+ * Name: gdb_bin2bin
+ *
+ * Description:
+ * Decode data from its bin-value representation to a buffer.
+ *
+ * Input Parameters:
+ * buf - The buffer containing the encoded data.
+ * buf_len - The length of the buffer.
+ * data - The buffer to store the decoded data.
+ * data_len - The length of the data to decode.
+ *
+ * Returned Value:
+ * The number of bytes written to data on success.
+ * -EOVERFLOW if the output buffer is too small.
+ * -EINVAL if the input buffer is invalid.
+ *
+ ****************************************************************************/
+
+static ssize_t gdb_bin2bin(FAR void *buf, size_t buf_len,
+ FAR const void *data, size_t data_len)
+{
+ FAR const char *in = data;
+ FAR char *out = buf;
+ size_t out_pos = 0;
+ size_t in_pos;
+
+ for (in_pos = 0; in_pos < data_len; in_pos++)
+ {
+ if (out_pos >= buf_len)
+ {
+ GDB_ASSERT();
+ return -EOVERFLOW; /* Output buffer overflow */
+ }
+
+ if (in[in_pos] == '}') /* The next byte is escaped! */
+ {
+ if (in_pos + 1 >= data_len)
+ {
+ /* There's an escape character, but no escaped character
+ * following the escape character.
+ */
+
+ GDB_ASSERT();
+ return -EINVAL;
+ }
+
+ in_pos++;
+ out[out_pos++] = in[in_pos] ^ 0x20;
+ }
+ else
+ {
+ out[out_pos++] = in[in_pos];
+ }
+ }
+
+ return out_pos;
+}
+
+/****************************************************************************
+ * Command Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: gdb_get_memory
+ *
+ * Description:
+ * Get data from memory.
+ *
+ * Input Parameters:
+ * state - The state structure.
+ * buf - The buffer to store the encoded data.
+ * buf_len - The length of the buffer.
+ * addr - The address to read from.
+ * len - The length of the data to read.
+ * format - The formatting function to use.
+ *
+ * Returned Value:
+ * The number of bytes written to buf on success.
+ * Negative value on error.
+ *
+ ****************************************************************************/
+
+static ssize_t gdb_get_memory(FAR struct gdb_state_s *state,
+ FAR void *buf, size_t buf_len,
+ uintptr_t addr, size_t len,
+ gdb_format_func_t format)
+{
+ return format(buf, buf_len, (FAR const void *)addr, len);
+}
+
+/****************************************************************************
+ * Name: gdb_put_memory
+ *
+ * Description:
+ * Put data from buf into memory.
+ *
+ * Input Parameters:
+ * state - The pointer to the GDB state structure.
+ * buf - The buffer containing the encoded data.
+ * buf_len - The length of the buffer.
+ * addr - The address to write to.
+ * len - The length of the data to write.
+ * format - The formatting function to use.
+ *
+ * Returned Value:
+ * The number of bytes written to addr on success.
+ * Negative value on error.
+ *
+ ****************************************************************************/
+
+static ssize_t gdb_put_memory(FAR struct gdb_state_s *state,
+ FAR const void *buf, size_t buf_len,
+ uintptr_t addr, size_t len,
+ gdb_format_func_t format)
+{
+ return format((FAR void *)addr, len, buf, buf_len);
+}
+
+/****************************************************************************
+ * Packet Creation Helpers
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: gdb_send_ok_packet
+ *
+ * Description:
+ * Send OK packet.
+ *
+ * Input Parameters:
+ * state - The pointer to the GDB state structure.
+ *
+ * Returned Value:
+ * Zero on success.
+ * Negative value on error.
+ *
+ ****************************************************************************/
+
+static int gdb_send_ok_packet(FAR struct gdb_state_s *state)
+{
+ state->pkt_buf[0] = 'O';
+ state->pkt_buf[1] = 'K';
+ state->pkt_len = 2;
+
+ 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
+ *
+ * Description:
+ * Send a error packet (E AA).
+ *
+ * Input Parameters:
+ * state - The pointer to the GDB state structure.
+ * error - The error to send.
+ *
+ * Returned Value:
+ * Zero on success.
+ * Negative value on error.
+ *
+ ****************************************************************************/
+
+static int gdb_send_error_packet(FAR struct gdb_state_s *state,
+ unsigned char error)
+{
+ int ret;
+
+ state->pkt_buf[0] = 'E';
+ ret = gdb_bin2hex(&state->pkt_buf[1], sizeof(state->pkt_buf) - 1,
+ &error, 1);
+ if (ret < 0)
+ {
+ return ret;
+ }
+
+ state->pkt_len = 1 + ret;
+ return gdb_send_packet(state);
+}
+
+/****************************************************************************
+ * Communication Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: gdb_get_registers
+ *
+ * Description:
+ * Get the registers of the specified task.
+ *
+ * Input Parameters:
+ * state - The pointer to the GDB state structure.
+ ****************************************************************************/
+
+static void gdb_get_registers(FAR struct gdb_state_s *state)
+{
+ FAR struct tcb_s *tcb = nxsched_get_tcb(state->pid);
+ FAR uint8_t *reg;
+ int i;
+
+ reg = (FAR uint8_t *)tcb->xcp.regs;
+ if (state->pid == getpid())
+ {
+ if (up_interrupt_context())
+ {
+ reg = (FAR uint8_t *)CURRENT_REGS;
+ }
+ else
+ {
+ up_saveusercontext(state->running_regs);
+ reg = state->running_regs;
+ }
+ }
+
+ for (i = 0; i < state->size / sizeof(uintptr_t); i++)
+ {
+ if (g_tcbinfo.reg_off.p[i] == UINT16_MAX)
+ {
+ state->registers[i] = 0;
+ }
+ else
+ {
+ state->registers[i] =
+ *(FAR uintptr_t *)(reg + g_tcbinfo.reg_off.p[i]);
+ }
+ }
+}
+
+/****************************************************************************
+ * Name: gdb_read_registers
+ *
+ * Description:
+ * Read Registers Command Format: g.
+ *
+ * Input Parameters:
+ * state - The pointer to the GDB state structure.
+ *
+ * Returned Value:
+ * Zero on success.
+ * Negative value on error.
+ *
+ * Note: Comand Format: g.
+ * Response Format: xxxxxxxxyyyyyyyyy...
+ ****************************************************************************/
+
+static int gdb_read_registers(FAR struct gdb_state_s *state)
+{
+ int ret;
+
+ gdb_get_registers(state);
+ ret = gdb_bin2hex(state->pkt_buf, sizeof(state->pkt_buf),
+ state->registers, state->size);
+ if (ret < 0)
+ {
+ return ret;
+ }
+
+ state->pkt_len = ret;
+ gdb_send_packet(state);
+
+ return 0;
+}
+
+/****************************************************************************
+ * Name: gdb_write_registers
+ *
+ * Description:
+ * Write Registers Command Format: G XX...
+ *
+ * Input Parameters:
+ * state - The pointer to the GDB state structure.
+ *
+ * Returned Value:
+ * Zero on success.
+ * Negative value on error.
+ *
+ * Note: This function is not really change the register values.
+ * Comand Format: Gxxxxxxxxyyyyyyyyy
+ * Response Format: OK
+ ****************************************************************************/
+
+static int gdb_write_registers(FAR struct gdb_state_s *state)
+{
+ int ret;
+
+ ret = gdb_hex2bin(state->registers, sizeof(state->registers),
+ state->pkt_buf + 1, state->pkt_len - 1);
+ if (ret < 0)
+ {
+ return ret;
+ }
+
+ gdb_send_ok_packet(state);
+ return 0;
+}
+
+/****************************************************************************
+ * Name: gdb_write_register
+ *
+ * Description:
+ * Write a Register Command Format: P n.
+ *
+ * Input Parameters:
+ * state - The pointer to the GDB state structure.
+ *
+ * Returned Value:
+ * Zero on success.
+ * Negative value on error.
+ *
+ * Note: Comand Format: Pn.
+ * Response Format: OK
+ ****************************************************************************/
+
+static int gdb_read_register(FAR struct gdb_state_s *state)
+{
+ uintptr_t addr;
+ int ret;
+
+ state->pkt_next++;
+ ret = gdb_expect_integer(state, &addr);
+ if (ret < 0)
+ {
+ return ret;
+ }
+
+ gdb_get_registers(state);
+ if (addr >= state->size)
+ {
+ return 0;
+ }
+
+ ret = gdb_bin2hex(state->pkt_buf, sizeof(state->pkt_buf),
+ &state->registers[addr], sizeof(state->registers[addr]));
+ if (ret < 0)
+ {
+ return ret;
+ }
+
+ state->pkt_len = ret;
+ gdb_send_packet(state);
+ return 0;
+}
+
+/****************************************************************************
+ * Name: gdb_read_memory
+ *
+ * Description:
+ * Read Memory Command Format: m addr,length
+ *
+ * Input Parameters:
+ * state - The pointer to the GDB state structure.
+ *
+ * Returned Value:
+ * The number of bytes read if successful.
+ * Negative value on error.
+ *
+ * Note: Comand Format: mAAAAAAAAA,LLLLLLLL
+ * Response Format: XXXXXXXXYYYYYYYYY...
+ ****************************************************************************/
+
+static int gdb_read_memory(FAR struct gdb_state_s *state)
+{
+ uintptr_t addr;
+ size_t length;
+ int ret;
+
+ state->pkt_next++;
+ ret = gdb_expect_addr_lenth(state, &addr, &length);
+ if (ret < 0)
+ {
+ return ret;
+ }
+
+ ret = gdb_get_memory(state, state->pkt_buf, sizeof(state->pkt_buf),
+ addr, length, gdb_bin2hex);
+ if (ret < 0)
+ {
+ return ret;
+ }
+
+ state->pkt_len = ret;
+ gdb_send_packet(state);
+
+ return ret;
+}
+
+/****************************************************************************
+ * Name: gdb_write_memory
+ *
+ * Description:
+ * Write Memory Command Format: M addr,length:XX..
+ *
+ * Input Parameters:
+ * state - The pointer to the GDB state structure.
+ *
+ * Returned Value:
+ * The number of bytes written if successful.
+ * Negative value on error.
+ *
+ * Note : Comand Format: MAAAAAAAAA,LLLLLLLL:XXXXXXXXX...
+ * Response Format: OK
+ ****************************************************************************/
+
+static int gdb_write_memory(FAR struct gdb_state_s *state)
+{
+ uintptr_t addr;
+ size_t length;
+ int ret;
+
+ state->pkt_next++;
+ ret = gdb_expect_addr_lenth(state, &addr, &length);
+ if (ret < 0)
+ {
+ return ret;
+ }
+
+ ret = gdb_put_memory(state, state->pkt_next, gdb_remaining_len(state),
+ addr, length, gdb_hex2bin);
+ if (ret < 0)
+ {
+ return ret;
+ }
+
+ gdb_send_ok_packet(state);
+ return ret;
+}
+
+/****************************************************************************
+ * Name: gdb_write_bin_memory
+ *
+ * Description:
+ * Write Memory (Binary) Command Format: X addr,length:XX..
+ *
+ * Input Parameters:
+ * state - The pointer to the GDB state structure.
+ *
+ * Returned Value:
+ * The number of bytes written if successful.
+ * Negative value on error.
+ *
+ * Note : Comand Format: XAAAAAAAAA,LLLLLLLL:XXXXXXXXX...
+ * Response Format: OK
+ ****************************************************************************/
+
+static int gdb_write_bin_memory(FAR struct gdb_state_s *state)
+{
+ uintptr_t addr;
+ size_t length;
+ int ret;
+
+ state->pkt_next++;
+ ret = gdb_expect_addr_lenth(state, &addr, &length);
+ if (ret < 0)
+ {
+ return ret;
+ }
+
+ ret = gdb_expect_seperator(state, ':');
+ if (ret < 0)
+ {
+ return ret;
+ }
+
+ ret = gdb_put_memory(state, state->pkt_next, gdb_remaining_len(state),
+ addr, length, gdb_bin2bin);
+ if (ret < 0)
+ {
+ return ret;
+ }
+
+ gdb_send_ok_packet(state);
+ return ret;
+}
+
+/****************************************************************************
+ * Name: gdb_get_thread
+ *
+ * Description:
+ * Get the all thread id.
+ *
+ * Input Parameters:
+ * state - The pointer to the GDB state structure.
+ *
+ ****************************************************************************/
+
+static void gdb_get_thread(FAR struct tcb_s *tcb, FAR void *arg)
+{
+ FAR struct gdb_state_s *state = arg;
+ int pid = tcb->pid;
+ size_t len;
+
+ len = sprintf(&state->pkt_buf[state->pkt_len], "%x,", pid);
+ state->pkt_len += len;
+}
+
+/****************************************************************************
+ * Name: gdb_query
+ *
+ * Description:
+ * The query packet is used by GDB to request information from the stub.
+ *
+ * Input Parameters:
+ * state - The pointer to the GDB state structure.
+ *
+ * Returned Value:
+ * 0 if successful.
+ * Negative value on error.
+ *
+ * Note : Comand Format: qSTRING
+ * STRING:is the query string.
+ ****************************************************************************/
+
+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 r_cmd[] = "Rcmd";
+
+ if (memcmp(&state->pkt_buf[1], fthread_info,
+ sizeof(fthread_info) - 1) == 0)
+ {
+ state->pkt_buf[0] = 'm';
+ state->pkt_len = 1;
+ nxsched_foreach(gdb_get_thread, state);
+ state->pkt_len--;
+ state->pkt_buf[state->pkt_len] = 0;
+ gdb_send_packet(state);
+ }
+ else if (memcmp(&state->pkt_buf[1], sthread_info,
+ sizeof(sthread_info) - 1) == 0)
+ {
+ state->pkt_buf[0] = 'l';
+ state->pkt_len = 1;
+ gdb_send_packet(state);
+ }
+ else if (memcmp(&state->pkt_buf[1], thread_extra_info,
+ sizeof(thread_extra_info) - 1) == 0)
+ {
+ FAR struct tcb_s *tcb;
+ char thread_state[32];
+ char thread_info[128];
+ uintptr_t pid;
+ int ret;
+
+ state->pkt_next += sizeof(thread_extra_info) + 1;
+ ret = gdb_expect_integer(state, &pid);
+ if (ret < 0)
+ {
+ return ret;
+ }
+
+ tcb = nxsched_get_tcb(pid);
+ if (tcb == NULL)
+ {
+ return -EINVAL;
+ }
+
+ nxsched_get_stateinfo(tcb, thread_state, sizeof(thread_state));
+#if CONFIG_TASK_NAME_SIZE > 0
+ snprintf(thread_info, sizeof(thread_info),
+ "Name: %s, State: %s, Priority: %d, Stack: %d",
+ tcb->name, thread_state, tcb->sched_priority,
+ tcb->adj_stack_size);
+#else
+ snprintf(thread_info, sizeof(thread_info),
+ "State: %s, Priority: %d, Stack: %d",
+ thread_state, tcb->sched_priority,
+ tcb->adj_stack_size);
+#endif
+
+ ret = gdb_bin2hex(state->pkt_buf, sizeof(state->pkt_buf),
+ thread_info, strlen(thread_info));
+
+ state->pkt_len = ret;
+ gdb_send_packet(state);
+ }
+ else if (state->monitor != NULL &&
+ memcmp(&state->pkt_buf[1], r_cmd, sizeof(r_cmd) - 1) == 0)
+ {
+ ssize_t len = state->pkt_len - sizeof(r_cmd) - 1; /* skip the 'Rcmd,' */
+ char cmd[128];
+ int ret;
+
+ len = gdb_hex2bin(cmd, len / 2,
+ &state->pkt_buf[sizeof(r_cmd) + 1], len);
+ if (len < 0)
+ {
+ return len;
+ }
+
+ cmd[len] = '\0';
+ ret = state->monitor(state, cmd);
+ if (ret < 0)
+ {
+ return ret;
+ }
+ else
+ {
+ gdb_send_ok_packet(state);
+ }
+ }
+ else
+ {
+ return -EPROTONOSUPPORT;
+ }
+
+ return 0;
+}
+
+/****************************************************************************
+ * Name: gdb_is_thread_active
+ *
+ * Description:
+ * The is thread active 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: T<id>
+ * id:is the thread id.
+ * Rsponse Format: OK
+ ****************************************************************************/
+
+static int gdb_is_thread_active(FAR struct gdb_state_s *state)
+{
+ FAR struct tcb_s *tcb;
+ uintptr_t pid;
+ int ret;
+
+ state->pkt_next++;
+ ret = gdb_expect_integer(state, &pid);
+ if (ret < 0)
+ {
+ return ret;
+ }
+
+ tcb = nxsched_get_tcb(pid);
+ if (tcb == NULL)
+ {
+ return -EINVAL;
+ }
+
+ state->pid = pid;
+ gdb_send_ok_packet(state);
+ return ret;
+}
+
+/****************************************************************************
+ * Name: gdb_thread_context
+ *
+ * Description:
+ * The thread context packet is used by GDB to request information from
+ * the stub.
+ *
+ * Input Parameters:
+ * state - The pointer to the GDB state structure.
+ *
+ * Returned Value:
+ * 0 if successful.
+ * Negative value on error.
+ *
+ * Note : Comand Format: Hc<id>
+ * Rsponse Format: OK
+ ****************************************************************************/
+
+static int gdb_thread_context(FAR struct gdb_state_s *state)
+{
+ FAR struct tcb_s *tcb;
+ uintptr_t pid;
+ int ret;
+
+ state->pkt_next += 2;
+ ret = gdb_expect_integer(state, &pid);
+ if (ret < 0)
+ {
+ return ret;
+ }
+
+ tcb = nxsched_get_tcb(pid);
+ if (tcb == NULL)
+ {
+ return -EINVAL;
+ }
+
+ state->pid = pid;
+ gdb_send_ok_packet(state);
+ return 0;
+}
+
+/****************************************************************************
+ * Name: gdb_send_stop
+ *
+ * Description:
+ * The stop packet is used by GDB to request information from the stub.
+ *
+ * Input Parameters:
+ * state - The pointer to the GDB state structure.
+ *
+ * Returned Value:
+ * 0 if successful.
+ * Negative value on error.
+ *
+ ****************************************************************************/
+
+static int gdb_send_stop(FAR struct gdb_state_s *state)
+{
+ return gdb_send_signal_packet(state, 0x00);
+}
+
+/****************************************************************************
+ * Public Data
+ ****************************************************************************/
+
+extern const struct tcbinfo_s g_tcbinfo;
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: gdb_state_init
+ *
+ * Description:
+ * Initialize the GDB state structure.
+ *
+ * Input Parameters:
+ * send - The pointer to the send function.
+ * recv - The pointer to the receive function.
+ * monitor - The pointer to the monitor_cmd function.
+ * priv - The pointer to the private data.
+ *
+ * Returned Value:
+ * The pointer to the GDB state structure on success.
+ * NULL on failure.
+ *
+ ****************************************************************************/
+
+FAR struct gdb_state_s *gdb_state_init(gdb_send_func_t send,
+ gdb_recv_func_t recv,
+ gdb_monitor_func_t monitor,
+ FAR void *priv)
+{
+ size_t size = g_tcbinfo.basic_num * sizeof(uintptr_t);
+ FAR struct gdb_state_s *state = lib_zalloc(sizeof(*state) + size);
+
+ if (state == NULL)
+ {
+ return NULL;
+ }
+
+ state->size = size;
+ state->send = send;
+ state->recv = recv;
+ state->priv = priv;
+ state->monitor = monitor;
+
+ return state;
+}
+
+/****************************************************************************
+ * Name: gdb_state_uninit
+ *
+ * Description:
+ * Uninitialize the GDB state structure.
+ *
+ * Input Parameters:
+ * state - The pointer to the GDB state structure.
+ *
+ ****************************************************************************/
+
+void gdb_state_uninit(FAR struct gdb_state_s *state)
+{
+ if (state != NULL)
+ {
+ lib_free(state);
+ }
+}
+
+/****************************************************************************
+ * Name: gdb_console_message
+ *
+ * Description:
+ * Send a message to the GDB console (via O XX... packet).
+ *
+ * Input Parameters:
+ * state - The pointer to the GDB state structure.
+ *
+ * Returned Value:
+ * Zero on success.
+ * Negative value on error.
+ *
+ ****************************************************************************/
+
+int gdb_console_message(FAR struct gdb_state_s *state, FAR const char *msg)
+{
+ ssize_t ret;
+
+ if (state == NULL || msg == NULL)
+ {
+ return -EINVAL;
+ }
+
+ state->pkt_buf[0] = 'O';
+ ret = gdb_bin2hex(&state->pkt_buf[1], sizeof(state->pkt_buf) - 1,
+ msg, strlen(msg));
+ if (ret < 0)
+ {
+ return ret;
+ }
+
+ state->pkt_len = 1 + ret;
+ return gdb_send_packet(state);
+}
+
+/****************************************************************************
+ * Name: gdb_process
+ *
+ * Description:
+ * Main debug loop. Handles commands.
+ *
+ * Input Parameters:
+ * state - The pointer to the GDB state structure.
+ *
+ * Returned Value:
+ * Zero if successful.
+ * Negative value on error.
+ *
+ ****************************************************************************/
+
+int gdb_process(FAR struct gdb_state_s *state)
+{
+ int ret;
+
+ while ((ret = gdb_recv_packet(state)) >= 0)
+ {
+ /* Handle one letter commands */
+
+ switch (state->pkt_buf[0])
+ {
+ case '?': /* gdbserial status */
+ ret = gdb_send_stop(state);
+ break;
+ case 'g': /* Read registers */
+ ret = gdb_read_registers(state);
+ break;
+ case 'G': /* Write registers */
+ ret = gdb_write_registers(state);
+ break;
+ case 'p': /* Read one register */
+ ret = gdb_read_register(state);
+ break;
+ case 'm': /* Read memory */
+ ret = gdb_read_memory(state);
+ break;
+ case 'M': /* Write memory */
+ ret = gdb_write_memory(state);
+ break;
+ case 'X': /* Write binary memory */
+ ret = gdb_write_bin_memory(state);
+ break;
+ case 'q': /* Query command */
+ ret = gdb_query(state);
+ break;
+ case 'T': /* Query thread */
+ ret = gdb_is_thread_active(state);
+ break;
+ case 'H': /* Thread related */
+ ret = gdb_thread_context(state);
+ break;
+ case 'k': /* Kill request */
+ ret = -ECONNRESET;
+ break;
+ default:
+ ret = -EPROTONOSUPPORT;
+ }
+
+ if (ret == -EPROTONOSUPPORT)
+ {
+ state->pkt_len = 0;
+ gdb_send_packet(state);
+ }
+ else if (ret == -ECONNRESET)
+ {
+ break;
+ }
+ else if (ret < 0)
+ {
+ gdb_send_error_packet(state, 0x00);
+ }
+ }
+
+ return ret;
+}