[PATCH] cpukit: Add libdebugger, a remote debugger agent for GDB.
Chris Johns
chrisj at rtems.org
Fri Nov 25 04:14:07 UTC 2016
---
cpukit/Makefile.am | 9 +
cpukit/configure.ac | 12 +
cpukit/libdebugger/Makefile.am | 23 +
cpukit/libdebugger/preinstall.am | 9 +
cpukit/libdebugger/rtems-debugger-arm.c | 1193 ++++++++++++++
cpukit/libdebugger/rtems-debugger-block.c | 73 +
cpukit/libdebugger/rtems-debugger-block.h | 75 +
cpukit/libdebugger/rtems-debugger-cmd.c | 208 +++
cpukit/libdebugger/rtems-debugger-i386.c | 421 +++++
cpukit/libdebugger/rtems-debugger-remote-tcp.c | 342 ++++
cpukit/libdebugger/rtems-debugger-remote-tcp.h | 47 +
cpukit/libdebugger/rtems-debugger-remote.c | 68 +
cpukit/libdebugger/rtems-debugger-remote.h | 71 +
cpukit/libdebugger/rtems-debugger-server.c | 1993 ++++++++++++++++++++++++
cpukit/libdebugger/rtems-debugger-server.h | 204 +++
cpukit/libdebugger/rtems-debugger-target.c | 400 +++++
cpukit/libdebugger/rtems-debugger-target.h | 237 +++
cpukit/libdebugger/rtems-debugger-threads.c | 577 +++++++
cpukit/libdebugger/rtems-debugger-threads.h | 272 ++++
cpukit/libdebugger/rtems-debugger.h | 81 +
cpukit/preinstall.am | 18 +
cpukit/wrapup/Makefile.am | 4 +
testsuites/libtests/Makefile.am | 4 +
testsuites/libtests/configure.ac | 12 +
testsuites/libtests/debugger01/Makefile.am | 21 +
testsuites/libtests/debugger01/debugger01.doc | 18 +
testsuites/libtests/debugger01/debugger01.scn | 188 +++
testsuites/libtests/debugger01/init.c | 53 +
testsuites/libtests/debugger01/remote.c | 321 ++++
testsuites/libtests/debugger01/system.h | 37 +
testsuites/libtests/debugger01/tasks.c | 104 ++
31 files changed, 7095 insertions(+)
create mode 100644 cpukit/libdebugger/Makefile.am
create mode 100644 cpukit/libdebugger/preinstall.am
create mode 100644 cpukit/libdebugger/rtems-debugger-arm.c
create mode 100644 cpukit/libdebugger/rtems-debugger-block.c
create mode 100644 cpukit/libdebugger/rtems-debugger-block.h
create mode 100644 cpukit/libdebugger/rtems-debugger-cmd.c
create mode 100644 cpukit/libdebugger/rtems-debugger-i386.c
create mode 100644 cpukit/libdebugger/rtems-debugger-remote-tcp.c
create mode 100644 cpukit/libdebugger/rtems-debugger-remote-tcp.h
create mode 100644 cpukit/libdebugger/rtems-debugger-remote.c
create mode 100644 cpukit/libdebugger/rtems-debugger-remote.h
create mode 100644 cpukit/libdebugger/rtems-debugger-server.c
create mode 100644 cpukit/libdebugger/rtems-debugger-server.h
create mode 100644 cpukit/libdebugger/rtems-debugger-target.c
create mode 100644 cpukit/libdebugger/rtems-debugger-target.h
create mode 100644 cpukit/libdebugger/rtems-debugger-threads.c
create mode 100644 cpukit/libdebugger/rtems-debugger-threads.h
create mode 100644 cpukit/libdebugger/rtems-debugger.h
create mode 100644 testsuites/libtests/debugger01/Makefile.am
create mode 100644 testsuites/libtests/debugger01/debugger01.doc
create mode 100644 testsuites/libtests/debugger01/debugger01.scn
create mode 100644 testsuites/libtests/debugger01/init.c
create mode 100644 testsuites/libtests/debugger01/remote.c
create mode 100644 testsuites/libtests/debugger01/system.h
create mode 100644 testsuites/libtests/debugger01/tasks.c
diff --git a/cpukit/Makefile.am b/cpukit/Makefile.am
index 6ca5e16..73bf35d 100644
--- a/cpukit/Makefile.am
+++ b/cpukit/Makefile.am
@@ -18,6 +18,7 @@ SUBDIRS += libmd
SUBDIRS += libgnat
SUBDIRS += libdl
SUBDIRS += libstdthreads
+SUBDIRS += libdebugger
SUBDIRS += wrapup
SUBDIRS += zlib
@@ -99,6 +100,14 @@ include_rtems_rtl_HEADERS += libdl/rtl-indirect-ptr.h libdl/rtl-sym.h libdl/rtl-
include_rtems_rtl_HEADERS += libdl/rap.h libdl/rap-shell.h
endif
+if LIBDEBUGGER
+include_rtems_HEADERS += libdebugger/rtems-debugger.h
+include_rtems_debuggerdir = $(includedir)/rtems/debugger
+include_rtems_debugger_HEADERS =
+include_rtems_debugger_HEADERS += libdebugger/rtems-debugger-server.h
+include_rtems_debugger_HEADERS += libdebugger/rtems-debugger-remote.h
+endif
+
include_rtems_HEADERS += include/rtems/bspIo.h
include_rtems_HEADERS += include/rtems/print.h
include_rtems_HEADERS += include/rtems/printer.h
diff --git a/cpukit/configure.ac b/cpukit/configure.ac
index 136630b..02f4759 100644
--- a/cpukit/configure.ac
+++ b/cpukit/configure.ac
@@ -395,6 +395,17 @@ esac
AM_CONDITIONAL(LIBDL,[test x"$HAVE_LIBDL" = x"yes"])
AC_MSG_RESULT([$HAVE_LIBDL])
+# Filter debugger to only build for architectures that have a target backend
+AC_MSG_CHECKING([whether CPU supports libdebugger])
+case $RTEMS_CPU in
+ arm | i386)
+ HAVE_LIBDEBUGGER=yes ;;
+ *)
+ HAVE_LIBDEBUGGER=no ;;
+esac
+AM_CONDITIONAL(LIBDEBUGGER,[test x"$HAVE_LIBDEBUGGER" = x"yes"])
+AC_MSG_RESULT([$HAVE_LIBDEBUGGER])
+
AC_MSG_CHECKING([whether CPU supports SHA])
case $RTEMS_CPU in
m32c)
@@ -473,6 +484,7 @@ libi2c/Makefile
libmd/Makefile
libdl/Makefile
libstdthreads/Makefile
+libdebugger/Makefile
zlib/Makefile
ftpd/Makefile
telnetd/Makefile
diff --git a/cpukit/libdebugger/Makefile.am b/cpukit/libdebugger/Makefile.am
new file mode 100644
index 0000000..72a8944
--- /dev/null
+++ b/cpukit/libdebugger/Makefile.am
@@ -0,0 +1,23 @@
+if LIBDEBUGGER
+
+include $(top_srcdir)/automake/compile.am
+
+noinst_LIBRARIES = libdebugger.a
+libdebugger_a_SOURCES = \
+ rtems-debugger-block.c \
+ rtems-debugger-cmd.c \
+ rtems-debugger-remote.c \
+ rtems-debugger-server.c \
+ rtems-debugger-target.c \
+ rtems-debugger-threads.c \
+ rtems-debugger- at RTEMS_CPU@.c
+
+if LIBNETWORKING
+libdebugger_a_SOURCES += \
+ rtems-debugger-remote-tcp.c
+endif
+
+endif
+
+include $(srcdir)/preinstall.am
+include $(top_srcdir)/automake/local.am
diff --git a/cpukit/libdebugger/preinstall.am b/cpukit/libdebugger/preinstall.am
new file mode 100644
index 0000000..695eb30
--- /dev/null
+++ b/cpukit/libdebugger/preinstall.am
@@ -0,0 +1,9 @@
+## Automatically generated by ampolish3 - Do not edit
+
+if AMPOLISH3
+$(srcdir)/preinstall.am: Makefile.am
+ $(AMPOLISH3) $(srcdir)/Makefile.am > $(srcdir)/preinstall.am
+endif
+
+if LIBDEBUGGER
+endif
diff --git a/cpukit/libdebugger/rtems-debugger-arm.c b/cpukit/libdebugger/rtems-debugger-arm.c
new file mode 100644
index 0000000..945dc9c
--- /dev/null
+++ b/cpukit/libdebugger/rtems-debugger-arm.c
@@ -0,0 +1,1193 @@
+/*
+ * Copyright (c) 2016 Chris Johns <chrisj at rtems.org>. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#define TARGET_DEBUG 0
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <errno.h>
+#include <inttypes.h>
+#include <stdlib.h>
+
+#include <rtems.h>
+#include <rtems/score/threadimpl.h>
+
+#include <libcpu/arm-cp15.h>
+#include <bsp/linker-symbols.h>
+
+#include "rtems-debugger-target.h"
+#include "rtems-debugger-threads.h"
+
+#if TARGET_DEBUG
+#include <rtems/bspIo.h>
+#endif
+
+/*
+ * The ARM has 2 interrupt bits.
+ */
+#define CPSR_IRQ_DISABLE 0x80 /* IIQ disabled when 1 */
+#define CPSR_FIQ_DISABLE 0x40 /* FIQ disabled when 1 */
+#define CPSR_INTS_MASK (CPSR_IRQ_DISABLE | CPSR_FIQ_DISABLE)
+
+/*
+ * Software breakpoint block size.
+ */
+#define RTEMS_DEBUGGER_SWBREAK_NUM 64
+
+/*
+ * Number of registers.
+ */
+#define RTEMS_DEBUGGER_NUMREGS 26
+
+/*
+ * Number of bytes per register.
+ */
+#define RTEMS_DEBUGGER_REGBYTES 4
+
+/*
+ * Number of bytes of registers.
+ */
+#define RTEMS_DEBUGGER_NUMREGBYTES \
+ (RTEMS_DEBUGGER_NUMREGS * RTEMS_DEBUGGER_REGBYTES)
+
+/*
+ * Debugger registers layout.
+ */
+#define REG_R0 0
+#define REG_R1 1
+#define REG_R2 2
+#define REG_R3 3
+#define REG_R4 4
+#define REG_R5 5
+#define REG_R6 6
+#define REG_R7 7
+#define REG_R8 8
+#define REG_R9 9
+#define REG_R10 10
+#define REG_R11 11
+#define REG_R12 12
+#define REG_SP 13
+#define REG_LR 14
+#define REG_PC 15
+#define REG_CPSR 25
+
+/**
+ * The various status registers.
+ */
+#if defined(ARM_MULTILIB_ARCH_V4)
+ #define FRAME_SR frame->register_cpsr
+#elif defined(ARM_MULTILIB_ARCH_V7M)
+ #define FRAME_SR frame->register_xpsr
+#else
+ #error ARM architecture is not supported.
+#endif
+
+/**
+ * The breakpoint.
+ */
+#ifdef __thumb__
+ static const uint8_t breakpoint[2] = { 0x55, 0xbe };
+#else
+ static const uint8_t breakpoint[4] = { 0x75, 0xe0a, 0x20, 0xe1 };
+#endif
+
+/**
+ * Target lock.
+ */
+RTEMS_INTERRUPT_LOCK_DEFINE(static, target_lock, "target_lock")
+
+/**
+ * The init value for the text section.
+ */
+static uint32_t text_section_flags;
+
+/**
+ * Is a session active?
+ */
+static bool debug_session_active;
+
+/*
+ * ARM debug hardware.
+ */
+static int debug_version;
+static int debug_revision;;
+static int hw_breakpoints;
+static int hw_watchpoints;
+
+/**
+ * Hardware break and watch points.
+ */
+typedef struct
+{
+ bool enabled;
+ bool loaded;
+ void* address;
+ size_t length;
+ CPU_Exception_frame* frame;
+ uint32_t control;
+ uint32_t value;
+} arm_debug_hwbreak;
+
+#define ARM_HW_BREAKPOINT_MAX (16)
+#define ARM_HW_WATCHPOINT_MAX (16)
+
+/*
+ * Types of break points. Only the 2 we use listed.
+ */
+#define ARM_HW_BP_UNLINKED_INSTR_MATCH (0x00)
+#define ARM_HW_BP_UNLINKED_INSTR_MISMATCH (0x04)
+
+/*
+ * Privilege levels.
+ */
+#define ARM_HW_BP_PRIV_PL0_SUP_SYS (0x00)
+#define ARM_HW_BP_PRIV_PL1_ONLY (0x01)
+#define ARM_HW_BP_PRIV_PL0_ONLY (0x02)
+#define ARM_HW_BP_PRIV_ALL_MODES (0x03)
+
+static arm_debug_hwbreak hw_breaks[ARM_HW_BREAKPOINT_MAX];
+//static arm_debug_hwbreak hw_watches[ARM_HW_WATCHPOINT_MAX];
+
+#if TARGET_DEBUG
+static void target_printk(const char* format, ...) RTEMS_PRINTFLIKE(1, 2);
+static void
+target_printk(const char* format, ...)
+{
+ va_list ap;
+ va_start(ap, format);
+ vprintk(format, ap);
+ va_end(ap);
+}
+static const char*
+mode_label(int mode)
+{
+ switch (mode) {
+ case 0x10:
+ return "USR";
+ case 0x11:
+ return "FIQ";
+ case 0x12:
+ return "IRQ";
+ case 0x13:
+ return "SVC";
+ case 0x16:
+ return "MON";
+ case 0x17:
+ return "ABT";
+ case 0x1a:
+ return "HYP";
+ case 0x1b:
+ return "UND";
+ case 0x1f:
+ return "SYS";
+ }
+ return "---";
+}
+#else
+#define target_printk(_fmt, ...)
+#define mode_labels(_m) NULL
+#endif
+
+/*
+ * Read and write a CP14 register.
+ *
+ * The software debug event registers are not easy to program because there are
+ * up to 32 registers and the instructions have to assembler for each of the 32
+ * registers, you cannot program it. This means there is a switch table to do
+ * this.
+ */
+#define ARM_CP14_INSTR(_opc, _val, _CRn, _CRm, _opc2) \
+ #_opc " p14, 0, %[" #_val "], c" #_CRn ", c" #_CRm ", " #_opc2 "\n"
+
+#define ARM_CP14_WRITE(_val, _CRn, _CRm, _opc2) \
+ do { \
+ ARM_SWITCH_REGISTERS; \
+ asm volatile( \
+ ARM_SWITCH_TO_ARM \
+ ARM_CP14_INSTR(mcr, val, _CRn, _CRm, _opc2) \
+ ARM_SWITCH_BACK \
+ : ARM_SWITCH_OUTPUT : [val] "r" (_val)); \
+ } while (0)
+
+#define ARM_CP14_READ(_val, _CRn, _CRm, _opc2) \
+ do { \
+ ARM_SWITCH_REGISTERS; \
+ asm volatile( \
+ ARM_SWITCH_TO_ARM \
+ ARM_CP14_INSTR(mrc, val, _CRn, _CRm, _opc2) \
+ ARM_SWITCH_BACK \
+ : [val] "=&r" (_val) ARM_SWITCH_ADDITIONAL_OUTPUT); \
+ } while (0)
+
+static int
+arm_debug_probe(rtems_debugger_target* target)
+{
+ #define ID_VALUE(_i, _h, _l) ((_i >> _l) & ((1 << ((_h - _l) + 1)) -1))
+ uint32_t val;
+ const char const* vl = "[Invalid version]";
+ const char const* labels[] = {
+ "ARMv6 [v6]",
+ "ARMv6 [v6.1]",
+ "ARMv7 [v7, all CP14 registers]",
+ "ARMv7 [v7, baseline CP14 registers]",
+ "ARMv7 [v7.1]"
+ };
+ ARM_CP14_READ(val, 0, 0, 0);
+ debug_version = ID_VALUE(val, 19, 16);
+ if (debug_version < 1 || debug_version > 5) {
+ rtems_debugger_printf("rtems-db: arm debug: (v%d.%d) not supported\n",
+ debug_version, debug_revision);
+ errno = EIO;
+ return -1;
+ }
+ vl = labels[debug_version - 1];
+ debug_revision = ID_VALUE(val, 3, 0);
+ hw_breakpoints = ID_VALUE(val, 27, 24);
+ hw_watchpoints = ID_VALUE(val, 31, 28);
+ rtems_debugger_printf("rtems-db: arm debug: (v%d.%d) %s breakpoints:%d watchpoints:%d\n",
+ debug_version, debug_revision, vl,
+ hw_breakpoints, hw_watchpoints);
+ ARM_CP14_READ(val, 0, 1, 0);
+ if ((val & (1 << 15)) == 0) {
+ switch (debug_version) {
+ case 1:
+ case 2:
+ ARM_CP14_WRITE(val | (1 << 15), 0, 1, 0);
+ break;
+ case 3:
+ case 4:
+ case 5:
+ default:
+ ARM_CP14_WRITE(val | (1 << 15), 0, 2, 2);
+ break;
+ }
+ ARM_CP14_READ(val, 0, 1, 0);
+ if ((val & (1 << 15)) == 0) {
+ rtems_debugger_printf("rtems-db: arm debug: cannot enter monitor mode\n");
+ errno = EIO;
+ return -1;
+ }
+ }
+ return 0;
+}
+
+static inline void
+arm_debug_break_setup(arm_debug_hwbreak* bp,
+ uint32_t address,
+ uint32_t type,
+ uint32_t byte_address_select,
+ uint32_t privilege)
+{
+ bp->control = (((type & 0xf) << 20) |
+ ((byte_address_select & 0xf) << 5) |
+ ((privilege & 0x3) << 1) | 1);
+ bp->value = (intptr_t) address;
+}
+
+static void
+arm_debug_break_write_control(int bp, uint32_t control)
+{
+ switch (bp) {
+ case 0:
+ ARM_CP14_WRITE(control, 0, 0, 5);
+ break;
+ case 1:
+ ARM_CP14_WRITE(control, 0, 1, 5);
+ break;
+ case 2:
+ ARM_CP14_WRITE(control, 0, 2, 5);
+ break;
+ case 3:
+ ARM_CP14_WRITE(control, 0, 3, 5);
+ break;
+ case 4:
+ ARM_CP14_WRITE(control, 0, 4, 5);
+ break;
+ case 5:
+ ARM_CP14_WRITE(control, 0, 5, 5);
+ break;
+ case 6:
+ ARM_CP14_WRITE(control, 0, 6, 5);
+ break;
+ case 7:
+ ARM_CP14_WRITE(control, 0, 7, 5);
+ break;
+ case 8:
+ ARM_CP14_WRITE(control, 0, 8, 5);
+ break;
+ case 9:
+ ARM_CP14_WRITE(control, 0, 9, 5);
+ break;
+ case 10:
+ ARM_CP14_WRITE(control, 0, 10, 5);
+ break;
+ case 11:
+ ARM_CP14_WRITE(control, 0, 11, 5);
+ break;
+ case 12:
+ ARM_CP14_WRITE(control, 0, 12, 5);
+ break;
+ case 13:
+ ARM_CP14_WRITE(control, 0, 13, 5);
+ break;
+ case 14:
+ ARM_CP14_WRITE(control, 0, 14, 5);
+ break;
+ case 15:
+ ARM_CP14_WRITE(control, 0, 15, 5);
+ break;
+ }
+}
+
+static void
+arm_debug_break_write_value(int bp, uint32_t value)
+{
+ switch (bp) {
+ case 0:
+ ARM_CP14_WRITE(value, 0, 0, 4);
+ break;
+ case 1:
+ ARM_CP14_WRITE(value, 0, 1, 4);
+ break;
+ case 2:
+ ARM_CP14_WRITE(value, 0, 2, 4);
+ break;
+ case 3:
+ ARM_CP14_WRITE(value, 0, 3, 4);
+ break;
+ case 4:
+ ARM_CP14_WRITE(value, 0, 4, 4);
+ break;
+ case 5:
+ ARM_CP14_WRITE(value, 0, 5, 4);
+ break;
+ case 6:
+ ARM_CP14_WRITE(value, 0, 6, 4);
+ break;
+ case 7:
+ ARM_CP14_WRITE(value, 0, 7, 4);
+ break;
+ case 8:
+ ARM_CP14_WRITE(value, 0, 8, 4);
+ break;
+ case 9:
+ ARM_CP14_WRITE(value, 0, 9, 4);
+ break;
+ case 10:
+ ARM_CP14_WRITE(value, 0, 10, 4);
+ break;
+ case 11:
+ ARM_CP14_WRITE(value, 0, 11, 4);
+ break;
+ case 12:
+ ARM_CP14_WRITE(value, 0, 12, 4);
+ break;
+ case 13:
+ ARM_CP14_WRITE(value, 0, 13, 4);
+ break;
+ case 14:
+ ARM_CP14_WRITE(value, 0, 14, 4);
+ break;
+ case 15:
+ ARM_CP14_WRITE(value, 0, 15, 4);
+ break;
+ }
+}
+
+static void
+arm_debug_break_clear(void)
+{
+ arm_debug_hwbreak* bp = &hw_breaks[0];
+ int i;
+ for (i = 0; i < hw_breakpoints; ++i, ++bp) {
+ bp->enabled = false;
+ bp->loaded = false;
+ }
+}
+
+static void
+arm_debug_break_load(void)
+{
+ arm_debug_hwbreak* bp = &hw_breaks[0];
+ int i;
+ for (i = 0; i < hw_breakpoints; ++i, ++bp) {
+ if (bp->enabled && !bp->loaded) {
+ bp->loaded = true;
+ target_printk("]]} hwbp: %i: v:%08lx c:%08lx l:%08x\n",
+ i, bp->value, bp->control, bp->length);
+ arm_debug_break_write_value(i, bp->value);
+ arm_debug_break_write_control(i, bp->control);
+ }
+ }
+}
+
+static void
+arm_debug_break_unload(void)
+{
+ arm_debug_hwbreak* bp = &hw_breaks[0];
+ int i;
+ for (i = 0; i < hw_breakpoints; ++i, ++bp) {
+ bp->loaded = false;
+ arm_debug_break_write_control(i, 0);
+ }
+}
+
+#if NOT_USED_BUT_KEEPING
+static size_t
+arm_debug_break_length(void* pc)
+{
+ arm_debug_hwbreak* bp = &hw_breaks[0];
+ int i;
+
+ for (i = 0; i < hw_breakpoints; ++i, ++bp) {
+ if (bp->enabled && bp->address == pc) {
+ return bp->length;
+ }
+ }
+ return sizeof(DB_UINT);
+}
+#endif
+
+int
+rtems_debugger_target_configure(rtems_debugger_target* target)
+{
+ target->capabilities = (RTEMS_DEBUGGER_TARGET_CAP_SWBREAK);
+ target->reg_num = RTEMS_DEBUGGER_NUMREGS;
+ target->reg_size = sizeof(uint32_t);
+ target->breakpoint = &breakpoint[0];
+ target->breakpoint_size = sizeof(breakpoint);
+ return arm_debug_probe(target);
+}
+
+static void
+target_exception(CPU_Exception_frame* frame)
+{
+#if TARGET_DEBUG
+ uint32_t ifsr = arm_cp15_get_instruction_fault_status();
+#endif
+
+ target_printk("[} frame = %08lx sig=%d vector=%x ifsr=%08lx pra=%08x\n",
+ (uint32_t) frame,
+ rtems_debugger_target_exception_to_signal(frame),
+ frame->vector, ifsr, (intptr_t) frame->register_pc);
+
+ if ((FRAME_SR & (1 << 5)) == 0)
+ frame->register_pc = (void*) ((intptr_t) frame->register_pc - 8);
+ else
+ frame->register_pc = (void*) ((intptr_t) frame->register_pc - 4);
+
+ target_printk("[} R0 = %08" PRIx32 " R1 = %08" PRIx32 \
+ " R2 = %08" PRIx32 " R3 = %08" PRIx32 "\n",
+ frame->register_r0, frame->register_r1,
+ frame->register_r2, frame->register_r3);
+ target_printk("[} R4 = %08" PRIx32 " R5 = %08" PRIx32 \
+ " R6 = %08" PRIx32 " R7 = %08" PRIx32 "\n",
+ frame->register_r4, frame->register_r5,
+ frame->register_r6, frame->register_r7);
+ target_printk("[} R8 = %08" PRIx32 " R9 = %08" PRIx32 \
+ " R10 = %08" PRIx32 " R11 = %08" PRIx32 "\n",
+ frame->register_r8, frame->register_r9,
+ frame->register_r10, frame->register_r11);
+ target_printk("[} R12 = %08" PRIx32 " SP = %08" PRIx32 \
+ " LR = %08" PRIxPTR " PC = %08" PRIxPTR "\n", \
+ frame->register_r12, frame->register_sp,
+ (intptr_t) frame->register_lr, (intptr_t) frame->register_pc);
+ target_printk("[} CPSR = %08" PRIx32 " %c%c%c%c%c%c%c%c%c%c%c" \
+ " GE:%" PRIx32 " IT:%02" PRIx32 " M:%" PRIx32 " %s\n",
+ FRAME_SR,
+ (FRAME_SR & (1 << 31)) != 0 ? 'N' : '-',
+ (FRAME_SR & (1 << 30)) != 0 ? 'Z' : '-',
+ (FRAME_SR & (1 << 29)) != 0 ? 'C' : '-',
+ (FRAME_SR & (1 << 28)) != 0 ? 'V' : '-',
+ (FRAME_SR & (1 << 27)) != 0 ? 'Q' : '-',
+ (FRAME_SR & (1 << 24)) != 0 ? 'J' : '-',
+ (FRAME_SR & (1 << 9)) != 0 ? 'E' : '-',
+ (FRAME_SR & (1 << 8)) != 0 ? 'A' : '-',
+ (FRAME_SR & (1 << 7)) != 0 ? 'I' : '-',
+ (FRAME_SR & (1 << 6)) != 0 ? 'F' : '-',
+ (FRAME_SR & (1 << 5)) != 0 ? 'T' : '-',
+ ((FRAME_SR >> (25 - 5)) & (0x3 << 5)) | ((FRAME_SR >> 10) & 0x1f),
+ (FRAME_SR >> 16) & 0xf,
+ FRAME_SR & 0x1f, mode_label(FRAME_SR & 0x1f));
+
+ arm_debug_break_clear();
+
+ if (!debug_session_active)
+ _ARM_Exception_default(frame);
+
+ switch (rtems_debugger_target_exception(frame)) {
+ case rtems_debugger_target_exc_consumed:
+ default:
+ break;
+ case rtems_debugger_target_exc_step:
+ FRAME_SR |= CPSR_INTS_MASK;
+ break;
+ case rtems_debugger_target_exc_cascade:
+ target_printk("rtems-db: unhandled exception: cascading\n");
+ _ARM_Exception_default(frame);
+ break;
+ }
+
+ target_printk("[} resuming frame = %08lx PC = %08" PRIxPTR " CPSR = %08" PRIx32 "\n",
+ (uint32_t) frame, (intptr_t) frame->register_pc, FRAME_SR);
+}
+
+/**
+ * If thumb build of code switch the asm to thumb as required.
+ */
+#ifdef __thumb__
+ #define ASM_ARM_MODE ".align 2\nbx pc\n.arm\n"
+ #define ASM_THUMB_MODE "add %[arm_switch_reg], pc, #1\nbx %[arm_switch_reg]\n.thumb\n"
+ #define ARM_SWITCH_REG uint32_t arm_switch_reg
+#else
+ #define ASM_ARM_MODE
+ #define ASM_THUMB_MODE
+ #define ARM_SWITCH_REG
+#endif
+
+/**
+ * Exception stack frame size.
+ *
+ * The size is the exception stack frame plus the CPSR from the exception. We
+ * save the CPSR and restore it when we exit the exception.
+ */
+#define EXCEPTION_FRAME_SIZE (sizeof(CPU_Exception_frame) + sizeof(uint32_t))
+
+/**
+ * Exception stack frame FPU offsets and sizes.
+ */
+#define EXCEPTION_FRAME_FPU_SIZE ARM_VFP_CONTEXT_SIZE
+#define EXCEPTION_FRAME_FPU_OFFSET ARM_EXCEPTION_FRAME_VFP_CONTEXT_OFFSET
+
+/**
+ * Exception entry.
+ *
+ * We have switched from svc (or even user) to an exception mode. Save the
+ * current CPSR and create an exception frame on the exception's stack and then
+ * copy it to the thread's stack. Switch back to the thread's context and mode
+ * to handle the exception to avoid any stack checks thinking the stack is
+ * blown. This lets the thread be suspended.
+ *
+ * The entry is in two parts, the exception mode entry and the trhead mode
+ * entry. This lets us disable any hardware breakpoint support. We need to do
+ * this because it is enabled in PL0 mode.
+ *
+ * Note, the code currently assumes cp15 has been set up to match the
+ * instruction set being used.
+ */
+#define EXCEPTION_ENTRY_EXC() \
+ __asm__ volatile( \
+ ASM_ARM_MODE \
+ "sub sp, %[frame_size]\n" /* alloc the frame and CPSR */ \
+ "stm sp, {r0-r12}\n" /* store r0-r12 */ \
+ "sub sp, #4\n" \
+ "str lr, [sp]\n" /* save the link reg */ \
+ ASM_THUMB_MODE \
+ : [arm_switch_reg] "=&r" (arm_switch_reg) \
+ : [frame_size] "i" (EXCEPTION_FRAME_SIZE) \
+ : "memory")
+
+/*
+ * FPU entry. Conditionally D16 or D32 support.
+ */
+#ifdef ARM_MULTILIB_VFP
+#ifdef ARM_MULTILIB_VFP_D32
+#define FPU_ENTRY_VFP_D32 \
+ "vstmia r5!, {d16-d31}\n"
+#else /* ARM_MULTILIB_VFP_D32 */
+#define FPU_ENTRY_VFP_D32 \
+ "mov r3, #0\n" \
+ "mov r4, #0\n" \
+ "adds r6, r5, #128\n" \
+ "3:\n" \
+ "stmia r5!, {r3-r4}\n" \
+ "cmp r5, r6\n" \
+ "bne 3b\n"
+#endif /* ARM_MULTILIB_VFP_D32 */
+#define EXCEPTION_ENTRY_FPU(frame_fpu_size) \
+ "sub sp, %[frame_fpu_size]\n" /* size includes alignment size */ \
+ "add r5, sp, #4\n" /* up to align down */ \
+ "bic r5, r5, #7\n" /* align the FPU frame */ \
+ "str r5, [r2]\n" /* store the FPU frame pointer */ \
+ "vmrs r3, FPEXC\n" \
+ "vmrs r4, FPSCR\n" \
+ "stmia r5!, {r3-r4}\n" \
+ "vstmia r5!, {d0-d15}\n" \
+ FPU_ENTRY_VFP_D32
+#else /* ARM_MULTILIB_VFP */
+#define EXCEPTION_ENTRY_FPU(frame_fpu_size)
+#endif /* ARM_MULTILIB_VFP */
+
+#define EXCEPTION_ENTRY_THREAD(_frame) \
+ __asm__ volatile( \
+ ASM_ARM_MODE \
+ "ldr lr, [sp]\n" /* recover the link reg */ \
+ "add sp, #4\n" \
+ "add r0, sp, %[r0_r12_size]\n" /* get the sp in the frame */ \
+ "mrs r1, spsr\n" /* get the saved sr */ \
+ "mov r6, r1\n" /* stash it for later */ \
+ "bic r1, r1, %[psr_t]\n" /* clear thumb mode, not sure? */ \
+ "orr r1, r1, %[psr_i]\n" /* mask irqs */ \
+ "mrs r2, cpsr\n" /* get the current sr */ \
+ "str r2, [sp, %[frame_cpsr]]\n" /* save for exc return */ \
+ "msr cpsr, r1\n" /* switch to user mode */ \
+ "mov r3, sp\n" /* get the stack pointer */ \
+ "mov r4, lr\n" /* get the link reg */ \
+ "msr cpsr, r2\n" /* back to exc mode */ \
+ "mov r5, lr\n" /* get the PRA */ \
+ "stm r0, {r3-r6}\n" /* save into the frame */ \
+ "sub r4, r3, %[frame_size]\n" /* destination address */ \
+ "mov r6, r4\n" /* save the frame */ \
+ "sub r4, #1\n" /* one before the start */ \
+ "add r3, #1\n" /* one past the end */ \
+ "sub r5, sp, #1\n" /* source address */ \
+ "1:\n" \
+ "ldrb r0, [r5, #1]!\n" /* get a byte */ \
+ "strb r0, [r4, #1]!\n" /* put the byte */ \
+ "cmp r3, r4\n" /* the end? */ \
+ "bne 1b\n" \
+ "add sp, %[frame_size]\n" /* free the frame and CPSR */ \
+ "mrs r1, spsr\n" /* get the thread's saved sr */ \
+ "orr r2, r1, %[psr_i]\n" /* mask irqs */ \
+ "msr cpsr, r2\n" /* switch back to the thread's context */ \
+ "sub sp, %[frame_size]\n" /* alloc in the thread stack */ \
+ "mov %[o_frame], sp\n" /* save the frame */ \
+ "add r2, sp, %[o_frame_fpu]\n" /* get the FPU offset */ \
+ "mov r3, #0\n" \
+ "str r3, [r2]\n" /* clear the FPU frame pointer */ \
+ EXCEPTION_ENTRY_FPU(frame_fpu_size) \
+ "msr cpsr, r1\n" /* restore the irq mask */ \
+ ASM_THUMB_MODE \
+ : [arm_switch_reg] "=&r" (arm_switch_reg), \
+ [o_frame] "=r" (_frame) \
+ : [psr_t] "i" (ARM_PSR_T), \
+ [psr_i] "i" (ARM_PSR_I), \
+ [r0_r12_size] "i" (13 * sizeof(uint32_t)), \
+ [frame_cpsr] "i" (EXCEPTION_FRAME_SIZE - sizeof(uint32_t)), \
+ [frame_size] "i" (EXCEPTION_FRAME_SIZE), \
+ [o_frame_fpu] "i" (EXCEPTION_FRAME_FPU_OFFSET), \
+ [frame_fpu_size] "i" (EXCEPTION_FRAME_FPU_SIZE + 4) \
+ : "r0", "r1", "r2", "r3", "r4", "r5", "r6", "memory")
+
+/*
+ * FPU exit. Conditionally D16 or D32 support.
+ */
+#ifdef ARM_MULTILIB_VFP
+#ifdef ARM_MULTILIB_VFP_D32
+#define FPU_EXIT_VFP_D32 \
+ "vldmia r0, {d16-d31}\n"
+#else /* ARM_MULTILIB_VFP_D32 */
+#define FPU_EXIT_VFP_D32
+#endif /* ARM_MULTILIB_VFP_D32 */
+#define EXCEPTION_EXIT_FPU(frame_fpu_size) \
+ "ldmia r0!, {r1-r2}\n" \
+ "vldmia r0!, {d0-d15}\n" \
+ FPU_EXIT_VFP_D32 \
+ "vmsr FPEXC, r1\n" \
+ "vmsr FPSCR, r2\n" \
+ "add sp, %[frame_fpu_size]\n" /* size includes alignment size */
+#else /* ARM_MULTILIB_VFP */
+#define EXCEPTION_EXIT_FPU(frame_fpu_size)
+#endif /* ARM_MULTILIB_VFP */
+
+/**
+ * Exception exit.
+ *
+ * The thread is to be resumed so we are still in the thread's mode. Copy the
+ * exception frame from the thread's stack back to the exception's stack and
+ * restore the thread's context before returning from the exception to the
+ * thread.
+ *
+ * Note, the code currently assumes cp15 has been set up to match the
+ * instruction set being used.
+ */
+#define EXCEPTION_EXIT_THREAD(_frame) \
+ __asm__ volatile( \
+ ASM_ARM_MODE \
+ "mov r0, %[i_frame]\n" /* get the frame */ \
+ "ldr r0, [r0, %[frame_fpu]]\n" /* recover FPU frame pointer */ \
+ EXCEPTION_EXIT_FPU(frame_fpu_size) \
+ "ldr r2, [sp, %[frame_cpsr]]\n" /* recover exc CPSR from thread */ \
+ "mov r0, sp\n" /* get the thread frame pointer */ \
+ "msr cpsr, r2\n" /* switch back to the exc's context */ \
+ "add r3, sp, #1\n" /* get the end */ \
+ "sub sp, %[frame_size]\n" /* alloc the frame */ \
+ "sub r4, sp, #1\n" /* destination address */ \
+ "sub r5, r0, #1\n" /* source address */ \
+ "1:\n" \
+ "ldrb r1, [r5, #1]!\n" /* get a byte */ \
+ "strb r1, [r4, #1]!\n" /* put the byte */ \
+ "cmp r3, r4\n" /* the end? */ \
+ "bne 1b\n" \
+ "add r1, r0, %[r0_r12_size]\n" /* get the sp in the frame */ \
+ "ldm r1, {r3-r6}\n" /* recover from the frame */ \
+ "orr r1, r6, %[psr_i]\n" /* get the thread's psr and mask irqs */ \
+ "msr cpsr, r1\n" /* switch to user mode */ \
+ "mov sp, r3\n" /* set the stack pointer */ \
+ "mov lr, r4\n" /* set the link reg */ \
+ "msr cpsr, r2\n" /* switch back to the exc's context */ \
+ "msr spsr, r6\n" /* set the thread's CPSR */ \
+ "sub sp, #4\n" \
+ "mov lr, r5\n" /* get the PC */ \
+ "str lr, [sp]\n" /* save the link reg */ \
+ ASM_THUMB_MODE \
+ : [arm_switch_reg] "=&r" (arm_switch_reg) \
+ : [psr_i] "i" (ARM_PSR_I), \
+ [r0_r12_size] "i" (13 * sizeof(uint32_t)), \
+ [frame_cpsr] "i" (EXCEPTION_FRAME_SIZE - sizeof(uint32_t)), \
+ [frame_size] "i" (EXCEPTION_FRAME_SIZE), \
+ [frame_fpu] "i" (EXCEPTION_FRAME_FPU_OFFSET), \
+ [frame_fpu_size] "i" (EXCEPTION_FRAME_FPU_SIZE + 4), \
+ [i_frame] "r" (_frame) \
+ : "r0", "r1", "r2", "r3", "r4", "r5", "r6", "memory")
+
+#define EXCEPTION_EXIT_EXC() \
+ __asm__ volatile( \
+ ASM_ARM_MODE \
+ "ldr lr, [sp]\n" /* recover the link reg */ \
+ "add sp, #4\n" \
+ "ldm sp, {r0-r12}\n" /* restore the trhead's context */ \
+ "add sp, %[frame_size]\n" /* free the frame */ \
+ "subs pc, lr, #0\n" /* return from the exc */ \
+ : \
+ : [frame_size] "i" (EXCEPTION_FRAME_SIZE) \
+ : "memory")
+
+
+static void __attribute__((naked))
+target_exception_undefined_instruction(void)
+{
+ CPU_Exception_frame* frame;
+ ARM_SWITCH_REG;
+ EXCEPTION_ENTRY_EXC();
+ arm_debug_break_unload();
+ EXCEPTION_ENTRY_THREAD(frame);
+ frame->vector = 1;
+ target_exception(frame);
+ EXCEPTION_EXIT_THREAD(frame);
+ arm_debug_break_load();
+ EXCEPTION_EXIT_EXC();
+}
+
+static void __attribute__((naked))
+target_exception_supervisor_call(void)
+{
+ CPU_Exception_frame* frame;
+ ARM_SWITCH_REG;
+ /*
+ * The PC offset needs to be review so we move past a svc instruction. This
+ * can then used as a user breakpoint. The issue is this exception is used by
+ * the BKPT instruction in the prefetch abort handler to signal a TRAP.
+ */
+ EXCEPTION_ENTRY_EXC();
+ arm_debug_break_unload();
+ EXCEPTION_ENTRY_THREAD(frame);
+ frame->vector = 2;
+ target_exception(frame);
+ EXCEPTION_EXIT_THREAD(frame);
+ arm_debug_break_load();
+ EXCEPTION_EXIT_EXC();
+}
+
+static void __attribute__((naked))
+target_exception_prefetch_abort(void)
+{
+ CPU_Exception_frame* frame;
+ ARM_SWITCH_REG;
+ EXCEPTION_ENTRY_EXC();
+ arm_debug_break_unload();
+ EXCEPTION_ENTRY_THREAD(frame);
+ if ((arm_cp15_get_instruction_fault_status() & 0x1f) == 0x02)
+ frame->vector = 2;
+ else
+ frame->vector = 3;
+ target_exception(frame);
+ EXCEPTION_EXIT_THREAD(frame);
+ arm_debug_break_load();
+ EXCEPTION_EXIT_EXC();
+}
+
+static void __attribute__((naked))
+target_exception_data_abort(void)
+{
+ CPU_Exception_frame* frame;
+ ARM_SWITCH_REG;
+ EXCEPTION_ENTRY_EXC();
+ arm_debug_break_unload();
+ EXCEPTION_ENTRY_THREAD(frame);
+ frame->vector = 4;
+ target_exception(frame);
+ EXCEPTION_EXIT_THREAD(frame);
+ arm_debug_break_load();
+ EXCEPTION_EXIT_EXC();
+}
+
+int
+rtems_debugger_target_enable(void)
+{
+ rtems_interrupt_lock_context lock_context;
+ void* text_begin;
+ void* text_end;
+ debug_session_active = true;
+ text_begin = &bsp_section_text_begin[0];
+ text_end = &bsp_section_text_end[0];
+ rtems_interrupt_lock_acquire(&target_lock, &lock_context);
+ arm_debug_break_unload();
+ arm_debug_break_clear();
+ text_section_flags =
+ arm_cp15_set_translation_table_entries(text_begin,
+ text_end,
+ ARMV7_MMU_DATA_READ_WRITE_CACHED);
+ arm_cp15_set_exception_handler(ARM_EXCEPTION_UNDEF,
+ target_exception_undefined_instruction);
+ arm_cp15_set_exception_handler(ARM_EXCEPTION_SWI,
+ target_exception_supervisor_call);
+ arm_cp15_set_exception_handler(ARM_EXCEPTION_PREF_ABORT,
+ target_exception_prefetch_abort);
+ arm_cp15_set_exception_handler(ARM_EXCEPTION_DATA_ABORT,
+ target_exception_data_abort);
+ rtems_interrupt_lock_release(&target_lock, &lock_context);
+ return 0;
+}
+
+int
+rtems_debugger_target_disable(void)
+{
+ rtems_interrupt_lock_context lock_context;
+#if DOES_NOT_WORK
+ void* text_begin;
+ void* text_end;
+#endif
+ rtems_interrupt_lock_acquire(&target_lock, &lock_context);
+ debug_session_active = false;
+#if DOES_NOT_WORK
+ text_begin = &bsp_section_text_begin[0];
+ text_end = &bsp_section_text_end[0];
+ arm_cp15_set_translation_table_entries(text_begin,
+ text_end,
+ text_section_flags);
+#endif
+ rtems_interrupt_lock_release(&target_lock, &lock_context);
+ return 0;
+}
+
+int
+rtems_debugger_target_read_regs(rtems_debugger_thread* thread)
+{
+ if (!rtems_debugger_thread_flag(thread,
+ RTEMS_DEBUGGER_THREAD_FLAG_REG_VALID)) {
+ static const uint32_t good_address = (uint32_t) &good_address;
+ uint32_t* regs = &thread->registers[0];
+ int i;
+
+ for (i = 0; i < RTEMS_DEBUGGER_NUMREGS; ++i)
+ regs[i] = (uint32_t) &good_address;
+
+ if (thread->frame) {
+ CPU_Exception_frame* frame = thread->frame;
+
+ /*
+ * Assume interrupts are not masked and if masked set them to the saved
+ * value.
+ */
+ FRAME_SR &= ~CPSR_INTS_MASK;
+
+ if (rtems_debugger_thread_flag(thread,
+ RTEMS_DEBUGGER_THREAD_FLAG_INTS_DISABLED)) {
+ FRAME_SR |=
+ (thread->flags >> RTEMS_DEBUGGER_THREAD_FLAG_TARGET_BASE) & CPSR_INTS_MASK;
+ thread->flags = ~RTEMS_DEBUGGER_THREAD_FLAG_INTS_DISABLED;
+ }
+
+ regs[REG_R0] = frame->register_r0;
+ regs[REG_R1] = frame->register_r1;
+ regs[REG_R2] = frame->register_r2;
+ regs[REG_R3] = frame->register_r3;
+ regs[REG_R4] = frame->register_r4;
+ regs[REG_R5] = frame->register_r5;
+ regs[REG_R6] = frame->register_r6;
+ regs[REG_R7] = frame->register_r7;
+ regs[REG_R8] = frame->register_r8;
+ regs[REG_R9] = frame->register_r9;
+ regs[REG_R10] = frame->register_r10;
+ regs[REG_R11] = frame->register_r11;
+ regs[REG_R12] = frame->register_r12;
+ regs[REG_SP] = frame->register_sp;
+ regs[REG_LR] = (uint32_t) frame->register_lr;
+ regs[REG_PC] = (uint32_t) frame->register_pc;
+ regs[REG_CPSR] = FRAME_SR;
+ /*
+ * Get the signal from the frame.
+ */
+ thread->signal = rtems_debugger_target_exception_to_signal(frame);
+ }
+ else {
+#if defined(ARM_MULTILIB_ARCH_V4)
+ regs[REG_R4] = thread->tcb->Registers.register_r4;
+ regs[REG_R5] = thread->tcb->Registers.register_r5;
+ regs[REG_R6] = thread->tcb->Registers.register_r6;
+ regs[REG_R7] = thread->tcb->Registers.register_r7;
+ regs[REG_R8] = thread->tcb->Registers.register_r8;
+ regs[REG_R9] = thread->tcb->Registers.register_r9;
+ regs[REG_R10] = thread->tcb->Registers.register_r10;
+ regs[REG_R11] = thread->tcb->Registers.register_fp;
+ regs[REG_LR] = (intptr_t) thread->tcb->Registers.register_lr;
+ regs[REG_PC] = (intptr_t) thread->tcb->Registers.register_lr;
+ regs[REG_SP] = (intptr_t) thread->tcb->Registers.register_sp;
+#elif defined(ARM_MULTILIB_ARCH_V7M)
+ regs[REG_R4] = thread->tcb->Registers.register_r4;
+ regs[REG_R5] = thread->tcb->Registers.register_r5;
+ regs[REG_R6] = thread->tcb->Registers.register_r6;
+ regs[REG_R7] = thread->tcb->Registers.register_r7;
+ regs[REG_R8] = thread->tcb->Registers.register_r8;
+ regs[REG_R9] = thread->tcb->Registers.register_r9;
+ regs[REG_R10] = thread->tcb->Registers.register_r10;
+ regs[REG_R11] = thread->tcb->Registers.register_r11;
+ regs[REG_LR] = (intptr_t) thread->tcb->Registers.register_lr;
+ regs[REG_PC] = (intptr_t) thread->tcb->Registers.register_lr;
+ regs[REG_SP] = (intptr_t) thread->tcb->Registers.register_sp;
+#endif
+ /*
+ * Blocked threads have no signal.
+ */
+ thread->signal = 0;
+ }
+
+ thread->flags |= RTEMS_DEBUGGER_THREAD_FLAG_REG_VALID;
+ thread->flags &= ~RTEMS_DEBUGGER_THREAD_FLAG_REG_DIRTY;
+ }
+
+ return 0;
+}
+
+int
+rtems_debugger_target_write_regs(rtems_debugger_thread* thread)
+{
+ if (rtems_debugger_thread_flag(thread,
+ RTEMS_DEBUGGER_THREAD_FLAG_REG_DIRTY)) {
+ uint32_t* regs = &thread->registers[0];
+
+ /*
+ * Only write to debugger controlled threads. Do not touch the registers
+ * for threads blocked in the context switcher.
+ */
+ if (rtems_debugger_thread_flag(thread,
+ RTEMS_DEBUGGER_THREAD_FLAG_DEBUGGING)) {
+ CPU_Exception_frame* frame = thread->frame;
+ frame->register_r0 = regs[REG_R0];
+ frame->register_r1 = regs[REG_R1];
+ frame->register_r2 = regs[REG_R2];
+ frame->register_r3 = regs[REG_R3];
+ frame->register_r4 = regs[REG_R4];
+ frame->register_r5 = regs[REG_R5];
+ frame->register_r6 = regs[REG_R6];
+ frame->register_r7 = regs[REG_R7];
+ frame->register_r8 = regs[REG_R8];
+ frame->register_r9 = regs[REG_R9];
+ frame->register_r10 = regs[REG_R10];
+ frame->register_r11 = regs[REG_R11];
+ frame->register_r12 = regs[REG_R12];
+ frame->register_sp = regs[REG_SP];
+ frame->register_lr = (void*) regs[REG_LR];
+ frame->register_pc = (void*) regs[REG_PC];
+ FRAME_SR = regs[REG_CPSR];
+ }
+ thread->flags &= ~RTEMS_DEBUGGER_THREAD_FLAG_REG_DIRTY;
+ }
+ return 0;
+}
+
+DB_UINT
+rtems_debugger_target_reg_pc(rtems_debugger_thread* thread)
+{
+ int r;
+ r = rtems_debugger_target_read_regs(thread);
+ if (r >= 0) {
+ uint32_t* regs = &thread->registers[0];
+ return regs[REG_PC];
+ }
+ return 0;
+}
+
+DB_UINT
+rtems_debugger_target_frame_pc(CPU_Exception_frame* frame)
+{
+ return (DB_UINT) frame->register_pc;
+}
+
+DB_UINT
+rtems_debugger_target_reg_sp(rtems_debugger_thread* thread)
+{
+ int r;
+ r = rtems_debugger_target_read_regs(thread);
+ if (r >= 0) {
+ uint32_t* regs = &thread->registers[0];
+ return regs[REG_SP];
+ }
+ return 0;
+}
+
+DB_UINT
+rtems_debugger_target_tcb_sp(rtems_debugger_thread* thread)
+{
+ return (DB_UINT) thread->tcb->Registers.register_sp;
+}
+
+int
+rtems_debugger_target_thread_stepping(rtems_debugger_thread* thread)
+{
+ if (rtems_debugger_thread_flag(thread,
+ (RTEMS_DEBUGGER_THREAD_FLAG_STEP |
+ RTEMS_DEBUGGER_THREAD_FLAG_STEPPING))) {
+ /*
+ * Single stepping and range stepping uses hardware debug breakpoint
+ * 0. This is reserved for single stepping.
+ */
+ CPU_Exception_frame* frame = thread->frame;
+ arm_debug_hwbreak* bp = &hw_breaks[0];
+ int i;
+ for (i = 0; i < hw_breakpoints; ++i, ++bp) {
+ if (!bp->enabled) {
+ const uint32_t addr = (intptr_t) frame->register_pc;
+ const bool thumb = (FRAME_SR & (1 << 5)) != 0 ? true : false;
+ uint32_t bas;
+
+ bp->enabled = true;
+ bp->loaded = false;
+ bp->address = frame->register_pc;
+ bp->frame = frame;
+ bp->length = sizeof(uint32_t);
+
+ if (thumb) {
+ uint16_t instr = *((uint16_t*) frame->register_pc);
+ switch (instr & 0xf800) {
+ case 0xe800:
+ case 0xf000:
+ case 0xf800:
+ break;
+ default:
+ bp->length = sizeof(uint16_t);
+ break;
+ }
+ }
+
+ /*
+ * See table C3-2 Effect of byte address selection on Breakpoint
+ * generation and "Instruction address comparisoin programming
+ * examples.
+ */
+ if (thumb) {
+ if ((addr & (1 << 1)) == 0) {
+ bas = 0x3; /* b0011 */
+ }
+ else {
+ bas = 0xc; /* b1100 */
+ }
+ }
+ else {
+ bas = 0xf; /* b1111 */
+ }
+
+ arm_debug_break_setup(bp,
+ addr & ~0x3,
+ ARM_HW_BP_UNLINKED_INSTR_MISMATCH,
+ bas,
+ ARM_HW_BP_PRIV_PL0_SUP_SYS);
+
+ /*
+ * Save the interrupt state before stepping if set.
+ */
+ if ((FRAME_SR & CPSR_INTS_MASK) != 0) {
+ uint32_t int_state;
+ int_state =
+ (frame->register_cpsr & CPSR_INTS_MASK) << RTEMS_DEBUGGER_THREAD_FLAG_TARGET_BASE;
+ thread->flags |= RTEMS_DEBUGGER_THREAD_FLAG_INTS_DISABLED | int_state;
+ }
+ /*
+ * Mask the interrupt when stepping.
+ */
+ FRAME_SR |= CPSR_INTS_MASK;
+ break;
+ }
+ }
+ }
+ return 0;
+}
+
+int
+rtems_debugger_target_exception_to_signal(CPU_Exception_frame* frame)
+{
+ int sig = RTEMS_DEBUGGER_SIGNAL_HUP;
+ switch (frame->vector) {
+ case ARM_EXCEPTION_RESET:
+ case ARM_EXCEPTION_SWI:
+ sig = RTEMS_DEBUGGER_SIGNAL_TRAP;
+ break;
+ case ARM_EXCEPTION_UNDEF:
+ sig = RTEMS_DEBUGGER_SIGNAL_ILL;
+ break;
+ case ARM_EXCEPTION_FIQ:
+ sig = RTEMS_DEBUGGER_SIGNAL_FPE;
+ break;
+ case ARM_EXCEPTION_PREF_ABORT:
+ case ARM_EXCEPTION_DATA_ABORT:
+ sig = RTEMS_DEBUGGER_SIGNAL_SEGV;
+ break;
+ case ARM_EXCEPTION_RESERVED:
+ case ARM_EXCEPTION_IRQ:
+ sig = RTEMS_DEBUGGER_SIGNAL_BUS;
+ break;
+ default:
+ break;
+ }
+ return sig;
+}
+
+int
+rtems_debugger_target_hwbreak_control(rtems_debugger_target_watchpoint wp,
+ bool insert,
+ DB_UINT addr,
+ DB_UINT kind)
+{
+ /*
+ * To do.
+ */
+ return 0;
+}
+
+int
+rtems_debugger_target_cache_sync(rtems_debugger_target_swbreak* swbreak)
+{
+ /*
+ * Flush the data cache and invalidate the instruction cache.
+ */
+ rtems_cache_flush_multiple_data_lines(swbreak->address,
+ sizeof(breakpoint));
+ rtems_cache_invalidate_multiple_instruction_lines(swbreak->address,
+ sizeof(breakpoint));
+ return 0;
+}
diff --git a/cpukit/libdebugger/rtems-debugger-block.c b/cpukit/libdebugger/rtems-debugger-block.c
new file mode 100644
index 0000000..918e321
--- /dev/null
+++ b/cpukit/libdebugger/rtems-debugger-block.c
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2016 Chris Johns <chrisj at rtems.org>. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <errno.h>
+#include <stdlib.h>
+
+#include "rtems-debugger-block.h"
+
+int
+rtems_debugger_block_create(rtems_debugger_block* block,
+ size_t step,
+ size_t size)
+{
+ int r = 0;
+ block->level = 0;
+ block->step = step;
+ block->count = step;
+ block->size = size;
+ block->block = calloc(block->count, block->size);
+ if (block->block == NULL)
+ errno = ENOMEM;
+ return r;
+}
+
+int
+rtems_debugger_block_destroy(rtems_debugger_block* block)
+{
+ free(block->block);
+ block->block = NULL;
+ block->level = 0;
+ block->count = 0;
+ block->size = 0;
+ return 0;
+}
+
+int
+rtems_debugger_block_resize(rtems_debugger_block* block)
+{
+ int r = 0;
+ if (block->level >= block->count) {
+ block->count += block->step;
+ block->block = realloc(block->block, block->count * block->size);
+ if (block->block == NULL) {
+ block->level = 0;
+ block->count = 0;
+ errno = ENOMEM;
+ r = -1;
+ }
+ }
+ return r;
+}
diff --git a/cpukit/libdebugger/rtems-debugger-block.h b/cpukit/libdebugger/rtems-debugger-block.h
new file mode 100644
index 0000000..c1c7fab
--- /dev/null
+++ b/cpukit/libdebugger/rtems-debugger-block.h
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2016 Chris Johns <chrisj at rtems.org>. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/*
+ * Debugger for RTEMS.
+ */
+
+#ifndef _RTEMS_DEBUGGER_BLOCK_h
+#define _RTEMS_DEBUGGER_BLOCK_h
+
+#include <rtems/rtems-debugger.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/**
+ * DB server block manages a block of re-sizable memory. The block only
+ * grows. As more threads enter the system the block becomes the peak and then
+ * sits at that level.
+ */
+typedef struct rtems_debugger_block
+{
+ void* block; /**< The block of memory. */
+ size_t step; /**< The step size the block is increased by. */
+ size_t size; /**< The size of the elements in the block. */
+ size_t count; /**< The number of elements in the block. */
+ size_t level; /**< The usage level in the block. */
+} rtems_debugger_block;
+
+/**
+ * Create a block.
+ */
+extern int rtems_debugger_block_create(rtems_debugger_block* block,
+ size_t step,
+ size_t size);
+
+/**
+ * Destroy a block.
+ */
+extern int rtems_debugger_block_destroy(rtems_debugger_block* block);
+
+/**
+ * Resize a block.
+ */
+extern int rtems_debugger_block_resize(rtems_debugger_block* block);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif
diff --git a/cpukit/libdebugger/rtems-debugger-cmd.c b/cpukit/libdebugger/rtems-debugger-cmd.c
new file mode 100644
index 0000000..e292065
--- /dev/null
+++ b/cpukit/libdebugger/rtems-debugger-cmd.c
@@ -0,0 +1,208 @@
+/*
+ * Copyright (c) 2016 Chris Johns <chrisj at rtems.org>. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <errno.h>
+#include <inttypes.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#define __need_getopt_newlib
+#include <getopt.h>
+
+#include <rtems.h>
+#include <rtems/printer.h>
+#include <rtems/shell.h>
+
+#include <rtems/rtems-debugger.h>
+
+/*
+ * Debugger command for the RTEMS shell.
+ */
+
+static int rtems_shell_main_debugger(int argc, char *argv[])
+{
+ if (argc == 1) {
+ printf("RTEMS debugger is %srunning\n", rtems_debugger_running() ? "" : "not ");
+ return 0;
+ }
+
+ if (strcasecmp(argv[1], "start") == 0) {
+ rtems_printer printer;
+ const char* remote = "tcp";
+ const char* device = "1122";
+ int timeout = RTEMS_DEBUGGER_TIMEOUT;
+ rtems_task_priority priority = 1;
+ bool verbose = false;
+ struct getopt_data data;
+ char* end;
+ int r;
+
+ if (rtems_debugger_running()) {
+ printf("error: debugger already running.\n");
+ return 1;
+ }
+
+ memset(&data, 0, sizeof(data));
+
+ rtems_print_printer_fprintf(&printer, stdout);
+
+ argv += 1;
+ argc -= 1;
+
+ while (true) {
+ int c;
+
+ c = getopt_r(argc, argv, "vR:d:t:P:l:", &data);
+ if (c == -1)
+ break;
+
+ switch (c) {
+ case 'v':
+ verbose = true;
+ break;
+ case 'R':
+ remote = data.optarg;
+ break;
+ case 'd':
+ device = data.optarg;
+ break;
+ case 't':
+ timeout = strtoul(data.optarg, &end, 10);
+ if (timeout == 0 || *end != '\0') {
+ printf("error: invalid timeout: %s\n", data.optarg);
+ return 1;
+ }
+ break;
+ case 'P':
+ priority = strtoul(data.optarg, &end, 10);
+ if (priority == 0 || *end != '\0') {
+ printf("error: invalid priority: %s\n", data.optarg);
+ return 1;
+ }
+ break;
+ case 'l':
+ if (strcasecmp(data.optarg, "stdout") == 0)
+ rtems_print_printer_fprintf(&printer, stdout);
+ else if (strcasecmp(data.optarg, "stderr") == 0)
+ rtems_print_printer_fprintf(&printer, stderr);
+ else if (strcasecmp(data.optarg, "kernel") == 0)
+ rtems_print_printer_printk(&printer);
+ else {
+ printf("error: unknown printer (stdout, stderr, kernel): %s\n", data.optarg);
+ return 1;
+ }
+ break;
+ default:
+ case '?':
+ if (data.optarg != NULL)
+ printf("error: unknown option: %s\n", data.optarg);
+ else
+ printf("error: invalid start command\n");
+ return 1;
+ }
+ }
+
+ printf("RTEMS Debugger start: remote=%s device=%s priority=%" PRIu32 "\n",
+ remote, device, priority);
+
+ r = rtems_debugger_start(remote, device, timeout, priority, &printer);
+ if (r < 0) {
+ printf("debugger start failed\n");
+ return 1;
+ }
+
+ rtems_debugger_set_verbose(verbose);
+ }
+ else if (strcasecmp(argv[1], "stop") == 0) {
+ int r;
+
+ if (!rtems_debugger_running()) {
+ printf("error: debugger not running.\n");
+ return 1;
+ }
+
+ r = rtems_debugger_stop();
+ if (r < 0) {
+ printf("debugger stop failed\n");
+ return 1;
+ }
+ }
+ else if (strcasecmp(argv[1], "remote-debug") == 0) {
+ int r;
+
+ if (!rtems_debugger_running()) {
+ printf("error: debugger not running.\n");
+ return 1;
+ }
+
+ if (argc == 3 && strcasecmp(argv[2], "on") == 0) {
+ r = rtems_debugger_remote_debug(true);
+ if (r < 0) {
+ printf("debugger remote-debug on failed\n");
+ return 1;
+ }
+ }
+ else if (argc == 3 && strcasecmp(argv[2], "off") == 0) {
+ r = rtems_debugger_remote_debug(false);
+ if (r < 0) {
+ printf("debugger remote-debug off failed\n");
+ return 1;
+ }
+ }
+ else {
+ printf("debugger remote-debug: not on or off\n");
+ return 1;
+ }
+ }
+ else if (strcasecmp(argv[1], "help") == 0) {
+ printf("debugger [start/stop/help] ...\n" \
+ " start -v -R remote -d device -t secs -P priority -l [stdout,stderr,kernel]\n" \
+ " stop\n" \
+ " remote-debug <on/off>\n" \
+ " help\n");
+ }
+ else {
+ printf("error: unknown command: %s\n", argv[1]);
+ return 1;
+ }
+
+ return 0;
+}
+
+rtems_shell_cmd_t rtems_shell_DEBUGGER_Command = {
+ "debugger", /* name */
+ "debugger [start/stop] [options ...]", /* usage */
+ "misc", /* topic */
+ rtems_shell_main_debugger, /* command */
+ NULL, /* alias */
+ NULL, /* next */
+ 0755,
+ 0,
+ 0
+};
diff --git a/cpukit/libdebugger/rtems-debugger-i386.c b/cpukit/libdebugger/rtems-debugger-i386.c
new file mode 100644
index 0000000..901ba85
--- /dev/null
+++ b/cpukit/libdebugger/rtems-debugger-i386.c
@@ -0,0 +1,421 @@
+/*
+ * Copyright (c) 2016 Chris Johns <chrisj at rtems.org>. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#define TARGET_DEBUG 1
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <errno.h>
+#include <inttypes.h>
+#include <stdlib.h>
+
+#include <rtems.h>
+#include <rtems/score/threadimpl.h>
+
+#include "rtems-debugger-target.h"
+#include "rtems-debugger-threads.h"
+
+/*
+ * Hardware breakpoints. Limited by hardware
+ */
+#define RTEMS_DEBUGGER_HWBREAK_NUM 4
+
+/*
+ * Number of registers.
+ */
+#define RTEMS_DEBUGGER_NUMREGS 16
+
+/*
+ * Number of bytes per register.
+ */
+#define RTEMS_DEBUGGER_REGBYTES 4
+
+/*
+ * Number of bytes of registers.
+ */
+#define RTEMS_DEBUGGER_NUMREGBYTES \
+ (RTEMS_DEBUGGER_NUMREGS * RTEMS_DEBUGGER_REGBYTES)
+
+/*
+ * Debugger registers layout.
+ */
+#define REG_EAX 0
+#define REG_ECX 1
+#define REG_EDX 2
+#define REG_EBX 3
+#define REG_ESP 4
+#define REG_EBP 5
+#define REG_ESI 6
+#define REG_EDI 7
+#define REG_PC 8
+#define REG_EIP REG_PC
+#define REG_PS 9
+#define REG_EFLAGS REG_PS
+#define REG_CS 10
+#define REG_SS 11
+#define REG_DS 12
+#define REG_ES 13
+#define REG_FS 14
+#define REG_GS 15
+
+/**
+ * The int 3 opcode.
+ */
+#define TARGET_BKPT 0xcc
+
+static const uint8_t breakpoint[1] = { TARGET_BKPT };
+
+/*
+ * Get a copy of a register.
+ */
+#define GET_REG(_r, _v) asm volatile("pushl %%" #_r "; popl %0" : "=rm" (_v))
+
+/*
+ * Get a copy of a segment register.
+ */
+#define GET_SEG_REG(_r, _v) \
+ do { \
+ int _i; \
+ GET_REG(_r, _i); \
+ _v = _i & 0xffff; \
+ } while (0)
+
+/**
+ * Target lock.
+ */
+RTEMS_INTERRUPT_LOCK_DEFINE(static, target_lock, "target_lock")
+
+/**
+ * The orginal exception handler.
+ */
+static void (*orig_currentExcHandler)(CPU_Exception_frame* frame);
+
+#if TARGET_DEBUG
+#include <rtems/bspIo.h>
+static void target_printk(const char* format, ...) RTEMS_PRINTFLIKE(1, 2);
+static void
+target_printk(const char* format, ...)
+{
+ va_list ap;
+ va_start(ap, format);
+ vprintk(format, ap);
+ va_end(ap);
+}
+#else
+#define target_printk(_fmt, ...)
+#endif
+
+#if TODO
+/**
+ * Target description.
+ */
+static const char* const target_xml =
+"<?xml version=\"1.0\"> \
+ <!DOCTYPE target SYSTEM \"gdb-target.dtd\"> \
+ <target version=\"1.0\"> \
+ <architecture>i386</architecture> \
+ <xi:include href=\"32bit-core.xml\"/> \
+ <xi:include href=\"32bit-sse.xml\"/> \
+</target>";
+#endif
+
+int
+rtems_debugger_target_configure(rtems_debugger_target* target)
+{
+ target->capabilities = (RTEMS_DEBUGGER_TARGET_CAP_SWBREAK);
+ target->reg_num = RTEMS_DEBUGGER_NUMREGS;
+ target->reg_size = sizeof(uint32_t);
+ target->breakpoint = &breakpoint[0];
+ target->breakpoint_size = sizeof(breakpoint);
+ return 0;
+}
+
+static void
+target_exception(CPU_Exception_frame* frame)
+{
+ target_printk("[} frame = %08lx sig=%d (%lx)\n",
+ (uint32_t) frame,
+ rtems_debugger_target_exception_to_signal(frame),
+ frame->idtIndex);
+ target_printk("[} EAX = %" PRIx32 " EBX = %" PRIx32 \
+ " ECX = %" PRIx32 " EDX = %" PRIx32 "\n",
+ frame->eax, frame->ebx, frame->ecx, frame->edx);
+ target_printk("[} ESI = %" PRIx32 " EDI = %" PRIx32 \
+ " EBP = %" PRIx32 " ESP = %" PRIx32 "\n",
+ frame->esi, frame->edi, frame->ebp, frame->esp0);
+ target_printk("[} EIP = %" PRIx32"\n", frame->eip);
+
+ frame->eflags &= ~EFLAGS_TRAP;
+
+ switch (rtems_debugger_target_exception(frame)) {
+ case rtems_debugger_target_exc_consumed:
+ default:
+ break;
+ case rtems_debugger_target_exc_step:
+ frame->eflags |= EFLAGS_TRAP;
+ break;
+ case rtems_debugger_target_exc_cascade:
+ orig_currentExcHandler(frame);
+ break;
+ }
+}
+
+int
+rtems_debugger_target_enable(void)
+{
+ rtems_interrupt_lock_context lock_context;
+ rtems_interrupt_lock_acquire(&target_lock, &lock_context);
+ if (orig_currentExcHandler == NULL) {
+ orig_currentExcHandler = _currentExcHandler;
+ _currentExcHandler = target_exception;
+ }
+ rtems_interrupt_lock_release(&target_lock, &lock_context);
+ return 0;
+}
+
+int
+rtems_debugger_target_disable(void)
+{
+ rtems_interrupt_lock_context lock_context;
+ rtems_interrupt_lock_acquire(&target_lock, &lock_context);
+ if (orig_currentExcHandler != NULL)
+ _currentExcHandler = orig_currentExcHandler;
+ rtems_interrupt_lock_release(&target_lock, &lock_context);
+ return 0;
+}
+
+int
+rtems_debugger_target_read_regs(rtems_debugger_thread* thread)
+{
+ if (!rtems_debugger_thread_flag(thread,
+ RTEMS_DEBUGGER_THREAD_FLAG_REG_VALID)) {
+ uint32_t* regs = &thread->registers[0];
+ size_t i;
+
+ for (i = 0; i < rtems_debugger_target_reg_num(); ++i)
+ regs[i] = 0xdeaddead;
+
+ if (thread->frame) {
+ CPU_Exception_frame* frame = thread->frame;
+ regs[REG_EAX] = frame->eax;
+ regs[REG_ECX] = frame->ecx;
+ regs[REG_EDX] = frame->edx;
+ regs[REG_EBX] = frame->ebx;
+ regs[REG_ESP] = frame->esp0;
+ regs[REG_EBP] = frame->ebp;
+ regs[REG_ESI] = frame->esi;
+ regs[REG_EDI] = frame->edi;
+ regs[REG_EIP] = frame->eip;
+ regs[REG_EFLAGS] = frame->eflags;
+ regs[REG_CS] = frame->cs;
+
+ /*
+ * Get the signal from the frame.
+ */
+ thread->signal = rtems_debugger_target_exception_to_signal(frame);
+ }
+ else {
+ regs[REG_EBX] = thread->tcb->Registers.ebx;
+ regs[REG_ESI] = thread->tcb->Registers.esi;
+ regs[REG_EDI] = thread->tcb->Registers.edi;
+ regs[REG_EFLAGS] = thread->tcb->Registers.eflags;
+ regs[REG_ESP] = (intptr_t) thread->tcb->Registers.esp;
+ regs[REG_EBP] = (intptr_t) thread->tcb->Registers.ebp;
+ regs[REG_EIP] = *((DB_UINT*) thread->tcb->Registers.esp);
+ regs[REG_EAX] = (intptr_t) thread;
+
+ GET_SEG_REG(CS, regs[REG_CS]);
+
+ /*
+ * Blocked threads have no signal.
+ */
+ thread->signal = 0;
+ }
+
+ GET_SEG_REG(SS, regs[REG_SS]);
+ GET_SEG_REG(DS, regs[REG_DS]);
+ GET_SEG_REG(ES, regs[REG_ES]);
+ GET_SEG_REG(FS, regs[REG_FS]);
+ GET_SEG_REG(GS, regs[REG_GS]);
+
+ thread->flags |= RTEMS_DEBUGGER_THREAD_FLAG_REG_VALID;
+ thread->flags &= ~RTEMS_DEBUGGER_THREAD_FLAG_REG_DIRTY;
+ }
+
+ return 0;
+}
+
+int
+rtems_debugger_target_write_regs(rtems_debugger_thread* thread)
+{
+ if (rtems_debugger_thread_flag(thread,
+ RTEMS_DEBUGGER_THREAD_FLAG_REG_DIRTY)) {
+ uint32_t* regs = &thread->registers[0];
+
+ /*
+ * Only write to debugger controlled threads. Do not touch the registers
+ * for threads blocked in the context switcher.
+ */
+ if (rtems_debugger_thread_flag(thread,
+ RTEMS_DEBUGGER_THREAD_FLAG_DEBUGGING)) {
+ CPU_Exception_frame* frame = thread->frame;
+ frame->eax = regs[REG_EAX];
+ frame->ecx = regs[REG_ECX];
+ frame->edx = regs[REG_EDX];
+ frame->ebx = regs[REG_EBX];
+ frame->esp0 = regs[REG_ESP];
+ frame->ebp = regs[REG_EBP];
+ frame->esi = regs[REG_ESI];
+ frame->edi = regs[REG_EDI];
+ frame->eip = regs[REG_EIP];
+ frame->eflags = regs[REG_EFLAGS];
+ frame->cs = regs[REG_CS];
+ }
+ thread->flags &= ~RTEMS_DEBUGGER_THREAD_FLAG_REG_DIRTY;
+ }
+ return 0;
+}
+
+DB_UINT
+rtems_debugger_target_reg_pc(rtems_debugger_thread* thread)
+{
+ int r;
+ r = rtems_debugger_target_read_regs(thread);
+ if (r >= 0) {
+ uint32_t* regs = &thread->registers[0];
+ return regs[REG_EIP];
+ }
+ return 0;
+}
+
+DB_UINT
+rtems_debugger_target_frame_pc(CPU_Exception_frame* frame)
+{
+ return (DB_UINT) frame->eip;
+}
+
+DB_UINT
+rtems_debugger_target_reg_sp(rtems_debugger_thread* thread)
+{
+ int r;
+ r = rtems_debugger_target_read_regs(thread);
+ if (r >= 0) {
+ uint32_t* regs = &thread->registers[0];
+ return regs[REG_ESP];
+ }
+ return 0;
+}
+
+DB_UINT
+rtems_debugger_target_tcb_sp(rtems_debugger_thread* thread)
+{
+ return (DB_UINT) thread->tcb->Registers.esp;
+}
+
+int
+rtems_debugger_target_thread_stepping(rtems_debugger_thread* thread)
+{
+ if (rtems_debugger_thread_flag(thread,
+ (RTEMS_DEBUGGER_THREAD_FLAG_STEP |
+ RTEMS_DEBUGGER_THREAD_FLAG_STEPPING))) {
+ CPU_Exception_frame* frame = thread->frame;
+ /*
+ * Single step instructions with interrupts masked to avoid stepping into
+ * an interrupt handler.
+ */
+ if ((frame->eflags & EFLAGS_INTR_ENABLE) == 0)
+ thread->flags |= RTEMS_DEBUGGER_THREAD_FLAG_INTS_DISABLED;
+ else
+ frame->eflags &= ~EFLAGS_INTR_ENABLE;
+ frame->eflags |= EFLAGS_TRAP;
+ }
+ return 0;
+}
+
+int
+rtems_debugger_target_exception_to_signal(CPU_Exception_frame* frame)
+{
+ int sig = RTEMS_DEBUGGER_SIGNAL_HUP;
+ switch (frame->idtIndex) {
+ case 1: /* debug exception */
+ case 3: /* breakpoint int3 */
+ sig = RTEMS_DEBUGGER_SIGNAL_TRAP;
+ break;
+ case 4: /* int overflow */
+ case 5: /* out-of-bounds */
+ sig = RTEMS_DEBUGGER_SIGNAL_URG;
+ break;
+ case 6: /* invalid opcode */
+ sig = RTEMS_DEBUGGER_SIGNAL_ILL;
+ break;
+ case 8: /* double fault */
+ case 16: /* fp error */
+ sig = RTEMS_DEBUGGER_SIGNAL_EMT;
+ break;
+ case 0: /* divide by zero */
+ case 7: /* FPU not avail. */
+ sig = RTEMS_DEBUGGER_SIGNAL_FPE;
+ break;
+ case 9: /* i387 seg overr. */
+ case 10: /* Invalid TSS */
+ case 11: /* seg. not pres. */
+ case 12: /* stack except. */
+ case 13: /* general prot. */
+ case 14: /* page fault */
+ case 17: /* alignment check */
+ sig = RTEMS_DEBUGGER_SIGNAL_SEGV;
+ break;
+ case 2: /* NMI */
+ case 18: /* machine check */
+ sig = RTEMS_DEBUGGER_SIGNAL_BUS;
+ break;
+ default:
+ break;
+ }
+ return sig;
+}
+
+int
+rtems_debugger_target_hwbreak_control(rtems_debugger_target_watchpoint wp,
+ bool insert,
+ DB_UINT addr,
+ DB_UINT kind)
+{
+ /*
+ * To do.
+ */
+ return 0;
+}
+
+int
+rtems_debugger_target_cache_sync(rtems_debugger_target_swbreak* swbreak)
+{
+ /*
+ * Nothing to do on an i386.
+ */
+ return 0;
+}
diff --git a/cpukit/libdebugger/rtems-debugger-remote-tcp.c b/cpukit/libdebugger/rtems-debugger-remote-tcp.c
new file mode 100644
index 0000000..ded51d6
--- /dev/null
+++ b/cpukit/libdebugger/rtems-debugger-remote-tcp.c
@@ -0,0 +1,342 @@
+/*
+ * Copyright (c) 2016 Chris Johns <chrisj at rtems.org>. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <errno.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+
+#include <rtems/rtems-debugger.h>
+#include <rtems/debugger/rtems-debugger-server.h>
+#include <rtems/debugger/rtems-debugger-remote.h>
+
+#include "rtems-debugger-remote-tcp.h"
+
+/**
+ * Debugger default server port. 'RT' as ASCII.
+ */
+#define RTEMS_DB_PORT_DEFAULT (8284)
+
+/**
+ * TCP Remote data.
+ */
+typedef struct
+{
+ int fd;
+ int port;
+} rtems_debugger_remote_tcp;
+
+static rtems_debugger_remote_tcp*
+tcp_remote(rtems_debugger_remote* remote)
+{
+ rtems_debugger_remote_tcp* tcp = NULL;
+ rtems_debugger_lock();
+ if (remote != NULL && remote->data != NULL)
+ tcp = (rtems_debugger_remote_tcp*) remote->data;
+ rtems_debugger_unlock();
+ return tcp;
+}
+
+static int
+tcp_remote_begin(rtems_debugger_remote* remote, const char* device)
+{
+ rtems_debugger_remote_tcp* tcp;
+ int port;
+ char* end;
+
+ rtems_debugger_lock();
+
+ /*
+ * Parse the port number.
+ */
+ port = strtoul(device, &end, 10);
+ if (port == 0 || *end != '\0') {
+ rtems_debugger_printf("error: rtems-db: tcp remote: invalid port: %s\n", device);
+ return -1;
+ }
+
+ tcp = malloc(sizeof(rtems_debugger_remote_tcp));
+ if (tcp == NULL) {
+ errno = ENOMEM;
+ return -1;
+ }
+
+ remote->data = tcp;
+
+ tcp->fd = -1;
+ tcp->port = port;
+
+ rtems_debugger_unlock();
+
+ return 0;
+}
+
+static int
+tcp_remote_end(rtems_debugger_remote* remote)
+{
+ rtems_debugger_lock();
+
+ if (remote != NULL && remote->data != NULL) {
+ rtems_debugger_remote_tcp* tcp = (rtems_debugger_remote_tcp*) remote->data;
+ if (tcp != NULL) {
+ if (tcp->fd >= 0)
+ close(tcp->fd);
+ free(tcp);
+ remote->data = NULL;
+ }
+ }
+
+ rtems_debugger_unlock();
+
+ return 0;
+}
+
+static int
+tcp_remote_connect(rtems_debugger_remote* remote)
+{
+ int ld;
+ struct sockaddr_in addr;
+ socklen_t opt;
+ socklen_t len;
+ bool running;
+ struct timeval timeout;
+ rtems_debugger_remote_tcp* tcp = tcp_remote(remote);
+ int r;
+
+ if (rtems_debugger_verbose())
+ rtems_debugger_printf("error: rtems-db: tcp remote: connect\n");
+
+ ld = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
+ if (ld < 0) {
+ rtems_debugger_printf("error: rtems-db: tcp remote: socket: (%d) %s\n",
+ errno, strerror(errno));
+ return -1;
+ }
+
+ opt = 1;
+ r = setsockopt(ld,
+ SOL_SOCKET,
+ SO_REUSEADDR,
+ (char *) &opt,
+ sizeof(opt));
+ if (r < 0) {
+ close(ld);
+ rtems_debugger_printf("error: rtems-db: tcp remote: setsocket: reuseaddr: (%d) %s\n",
+ errno, strerror(errno));
+ return -1;
+ }
+
+ addr.sin_family = PF_INET;
+ addr.sin_port = htons(tcp->port);
+ addr.sin_addr.s_addr = INADDR_ANY;
+
+ r = bind(ld, (struct sockaddr *) &addr, sizeof(addr));
+ if (r < 0) {
+ close(ld);
+ rtems_debugger_printf("error: rtems-db: tcp remote: bind: (%d) %s\n",
+ errno, strerror(errno));
+ return -1;
+ }
+
+ /*
+ * Backlog of 1 connection.
+ */
+ r = listen(ld, 1);
+ if (r < 0) {
+ close(ld);
+ rtems_debugger_printf("error: rtems-db: tcp remote: listen: (%d) %s\n",
+ errno, strerror(errno));
+ return -1;
+ }
+
+ /*
+ * Use a random port if the port is 0.
+ */
+ if (tcp->port == 0) {
+ len = sizeof(addr);
+ r = getsockname(ld, (struct sockaddr *) &addr, &len);
+ if (r < 0 || len < sizeof(addr)) {
+ close(ld);
+ rtems_debugger_printf("error: rtems-db: tcp remote: getsockname: (%d) %s\n",
+ errno, strerror(errno));
+ return -1;
+ }
+ tcp->port = ntohs(addr.sin_port);
+ }
+
+ rtems_debugger_printf("rtems-db: tcp remote: listing on port: %d\n",
+ tcp->port);
+
+ len = sizeof(addr);
+ tcp->fd = accept(ld, (struct sockaddr *) &addr, &len);
+
+ running = rtems_debugger_server_running();
+
+ close(ld);
+
+ if (tcp->fd < 0) {
+ /*
+ * EBADF means the socket has been closed, ignore it.
+ */
+ if (errno != EBADF)
+ rtems_debugger_printf("error: rtems-db: accept: (%d) %s\n",
+ errno, strerror(errno));
+ return -1;
+ }
+
+ if (!running) {
+ close(tcp->fd);
+ errno = EIO;
+ return -1;
+ }
+
+ opt = 1;
+ r = setsockopt(tcp->fd,
+ SOL_SOCKET, SO_KEEPALIVE,
+ (char*) &opt,
+ sizeof(opt));
+ if (r < 0) {
+ int errno_ = errno;
+ close(tcp->fd);
+ rtems_debugger_printf("error: rtems-db: tcp remote: set keepalive: (%d) %s\n",
+ errno, strerror(errno));
+ errno = errno_;
+ return -1;
+ }
+
+ opt = 1;
+ r = setsockopt(tcp->fd,
+ IPPROTO_TCP, TCP_NODELAY,
+ (char*) &opt, sizeof(opt));
+ if (r < 0) {
+ int errno_ = errno;
+ close(tcp->fd);
+ rtems_debugger_printf("error: rtems-db: tcp remote: set no-delay: (%d) %s\n",
+ errno, strerror(errno));
+ errno = errno_;
+ return -1;
+ }
+
+ timeout.tv_sec = rtems_debugger->timeout;
+ timeout.tv_usec = 0;
+
+ r = setsockopt(tcp->fd,
+ SOL_SOCKET, SO_RCVTIMEO,
+ (char*) &timeout, sizeof(timeout));
+ if (r < 0) {
+ int errno_ = errno;
+ close(tcp->fd);
+ rtems_debugger_printf("error: rtems-db: tcp remote: set rcv-timeout: (%d) %s\n",
+ errno, strerror(errno));
+ errno = errno_;
+ return -1;
+ }
+
+ rtems_debugger_printf("rtems-db: tcp remote: connect host: %s\n",
+ inet_ntoa(addr.sin_addr));
+
+ return 0;
+}
+
+static int
+tcp_remote_disconnect(rtems_debugger_remote* remote)
+{
+ rtems_debugger_remote_tcp* tcp;
+
+ rtems_debugger_lock();
+
+ rtems_debugger_printf("rtems-db: tcp remote: disconnect host\n");
+
+ tcp = (rtems_debugger_remote_tcp*) remote->data;
+ close(tcp->fd);
+
+ rtems_debugger_unlock();
+
+ return 0;
+}
+
+static bool
+tcp_remote_isconnected(rtems_debugger_remote* remote)
+{
+ rtems_debugger_remote_tcp* tcp = tcp_remote(remote);
+ return tcp != NULL && tcp->fd >= 0;
+}
+
+static ssize_t
+tcp_remote_receive(rtems_debugger_remote* remote,
+ void* buf,
+ size_t nbytes)
+{
+ rtems_debugger_remote_tcp* tcp = tcp_remote(remote);
+ ssize_t len;
+ if (tcp != NULL) {
+ len = read(tcp->fd, buf, nbytes);
+ }
+ else {
+ errno = EIO;
+ len = -1;
+ }
+ return len;
+}
+
+static ssize_t
+tcp_remote_send(rtems_debugger_remote* remote,
+ const void* buf,
+ size_t nbytes)
+{
+ rtems_debugger_remote_tcp* tcp = tcp_remote(remote);
+ ssize_t len;
+ if (tcp != NULL) {
+ len = write(tcp->fd, buf, nbytes);
+ }
+ else {
+ errno = EIO;
+ len = -1;
+ }
+ return len;
+}
+
+static rtems_debugger_remote remote_tcp =
+{
+ .name = "tcp",
+ .begin = tcp_remote_begin,
+ .end = tcp_remote_end,
+ .connect = tcp_remote_connect,
+ .disconnect = tcp_remote_disconnect,
+ .isconnected = tcp_remote_isconnected,
+ .read = tcp_remote_receive,
+ .write = tcp_remote_send
+};
+
+int
+rtems_debugger_register_tcp_remote(void)
+{
+ return rtems_debugger_remote_register(&remote_tcp);
+}
diff --git a/cpukit/libdebugger/rtems-debugger-remote-tcp.h b/cpukit/libdebugger/rtems-debugger-remote-tcp.h
new file mode 100644
index 0000000..d9d7fee
--- /dev/null
+++ b/cpukit/libdebugger/rtems-debugger-remote-tcp.h
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2016 Chris Johns <chrisj at rtems.org>. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/*
+ * Debugger for RTEMS.
+ */
+
+#ifndef _RTEMS_DEBUGGER_REMOTE_TCP_h
+#define _RTEMS_DEBUGGER_REMOTE_TCP_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/**
+ * Register a remote with the server.
+ */
+int rtems_debugger_register_tcp_remote(void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif
diff --git a/cpukit/libdebugger/rtems-debugger-remote.c b/cpukit/libdebugger/rtems-debugger-remote.c
new file mode 100644
index 0000000..f9a104d
--- /dev/null
+++ b/cpukit/libdebugger/rtems-debugger-remote.c
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2016 Chris Johns <chrisj at rtems.org>. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <errno.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include <rtems/rtems-debugger.h>
+#include <rtems/debugger/rtems-debugger-server.h>
+#include <rtems/debugger/rtems-debugger-remote.h>
+
+static rtems_debugger_remote* remotes[4];
+
+int
+rtems_debugger_remote_register(rtems_debugger_remote* remote)
+{
+ size_t r;
+ if (remote->begin == NULL || remote->end == NULL ||
+ remote->connect == NULL || remote->disconnect == NULL ||
+ remote->isconnected == NULL ||
+ remote->read == NULL || remote->write == NULL) {
+ errno = EINVAL;
+ return -1;
+ }
+ for (r = 0; r < RTEMS_DEBUGGER_NUMOF(remotes); ++r) {
+ if (remotes[r] == NULL) {
+ remotes[r] = remote;
+ return 0;
+ }
+ }
+ errno = ENOSPC;
+ return -1;
+}
+
+rtems_debugger_remote*
+rtems_debugger_remote_find(const char* name)
+{
+ size_t r;
+ for (r = 0; r < RTEMS_DEBUGGER_NUMOF(remotes); ++r) {
+ if (remotes[r] != NULL) {
+ if (strcasecmp(name, remotes[r]->name) == 0)
+ return remotes[r];
+ }
+ }
+ return NULL;
+}
diff --git a/cpukit/libdebugger/rtems-debugger-remote.h b/cpukit/libdebugger/rtems-debugger-remote.h
new file mode 100644
index 0000000..3ea2b14
--- /dev/null
+++ b/cpukit/libdebugger/rtems-debugger-remote.h
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2016 Chris Johns <chrisj at rtems.org>. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/*
+ * Debugger for RTEMS.
+ */
+
+#ifndef _RTEMS_DEBUGGER_REMOTE_h
+#define _RTEMS_DEBUGGER_REMOTE_h
+
+#include <rtems/rtems-debugger.h>
+#include <rtems/debugger/rtems-debugger-server.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/**
+ * Debugger remote.
+ */
+struct rtems_debugger_remote
+{
+ const char* name;
+ int (*begin)(rtems_debugger_remote* remote, const char* device);
+ int (*end)(rtems_debugger_remote* remote);
+ int (*connect)(rtems_debugger_remote* remote);
+ int (*disconnect)(rtems_debugger_remote* remote);
+ bool (*isconnected)(rtems_debugger_remote* remote);
+ ssize_t (*read)(rtems_debugger_remote* remote, void* buf, size_t nbytes);
+ ssize_t (*write)(rtems_debugger_remote* remote, const void* buf, size_t nbytes);
+ void* data;
+};
+
+/**
+ * Register a remote with the server.
+ */
+int rtems_debugger_remote_register(rtems_debugger_remote* remote);
+
+/**
+ * Find a remote by name.
+ */
+rtems_debugger_remote* rtems_debugger_remote_find(const char* name);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif
diff --git a/cpukit/libdebugger/rtems-debugger-server.c b/cpukit/libdebugger/rtems-debugger-server.c
new file mode 100644
index 0000000..8c20cf6
--- /dev/null
+++ b/cpukit/libdebugger/rtems-debugger-server.c
@@ -0,0 +1,1993 @@
+/*
+ * Copyright (c) 2016 Chris Johns <chrisj at rtems.org>. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <errno.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include <rtems/rtems-debugger.h>
+#include <rtems/debugger/rtems-debugger-server.h>
+#include <rtems/debugger/rtems-debugger-remote.h>
+
+#include "rtems-debugger-target.h"
+#include "rtems-debugger-threads.h"
+
+/*
+ * GDB Debugger Remote Server for RTEMS.
+ */
+
+/*
+ * Hack to void including bsp.h. The reset needs a better API.
+ */
+extern void bsp_reset(void);
+
+/*
+ * Command lookup table.
+ */
+typedef int (*rtems_debugger_command)(uint8_t* buffer, int size);
+
+typedef struct rtems_debugger_packet
+{
+ const char const* label;
+ rtems_debugger_command command;
+} rtems_debugger_packet;
+
+/**
+ * Common error strings.
+ */
+static const char const* r_OK = "OK";
+static const char const* r_E01 = "E01";
+
+/*
+ * Global Debugger.
+ *
+ * The server instance is allocated on the heap so memory is only used then the
+ * server is running. A global is used because:
+ *
+ * 1. There can only be a single instance at once.
+ * 2. The backend's need access to the data and holding pointers in the TCB
+ * for each thread is mess.
+ * 3. The code is smaller and faster.
+ */
+rtems_debugger_server* rtems_debugger;
+
+int
+rtems_debugger_printf(const char* format, ...)
+{
+ int len;
+ va_list ap;
+ va_start(ap, format);
+ len = rtems_vprintf(&rtems_debugger->printer, format, ap);
+ va_end(ap);
+ return len;
+}
+
+bool
+rtems_debugger_verbose(void)
+{
+ return rtems_debugger_server_flag(RTEMS_DEBUGGER_FLAG_VERBOSE);
+}
+
+static inline int
+hex_decode(uint8_t ch)
+{
+ int i;
+ if (ch >= '0' && ch <= '9')
+ i = (int) (ch - '0');
+ else if (ch >= 'a' && ch <= 'f')
+ i = (int) (ch - 'a') + 10;
+ else if (ch >= 'A' && ch <= 'F')
+ i = (int) (ch - 'A') + 10;
+ else
+ i = -1;
+ return i;
+}
+
+static inline uint8_t
+hex_encode(int val)
+{
+ return "0123456789abcdef"[val & 0xf];
+}
+
+static inline DB_UINT
+hex_decode_uint(const uint8_t* data)
+{
+ DB_UINT ui = 0;
+ size_t i;
+ if (data[0] == '-') {
+ if (data[1] == '1')
+ ui = (DB_UINT) -1;
+ }
+ else {
+ for (i = 0; i < (sizeof(ui) * 2); ++i) {
+ int v = hex_decode(data[i]);
+ if (v < 0)
+ break;
+ ui = (ui << 4) | v;
+ }
+ }
+ return ui;
+}
+
+static inline int
+hex_decode_int(const uint8_t* data)
+{
+ return (int) hex_decode_uint(data);
+}
+
+static bool
+thread_id_decode(const char* data, DB_UINT* pid, DB_UINT* tid)
+{
+ bool is_extended = false;
+ if (*data == 'p') {
+ is_extended = true;
+ ++data;
+ }
+ *pid = *tid = hex_decode_uint((const uint8_t*) data);
+ if (is_extended) {
+ const char* stop = strchr(data, '.');
+ if (stop != NULL) {
+ *tid = hex_decode_uint((const uint8_t*) stop + 1);
+ }
+ }
+ return is_extended;
+}
+
+static inline bool
+check_pid(DB_UINT pid)
+{
+ return pid == 0|| rtems_debugger->pid == (pid_t) pid;
+}
+
+int
+rtems_debugger_lock(void)
+{
+ if (rtems_debugger->lock != 0) {
+ rtems_status_code sc;
+ sc = rtems_semaphore_obtain(rtems_debugger->lock, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
+ if (sc != RTEMS_SUCCESSFUL) {
+ rtems_debugger_printf("error: rtems-db: lock: %s\n",
+ rtems_status_text(sc));
+ return -1;
+ }
+ }
+ return 0;
+}
+
+int
+rtems_debugger_unlock(void)
+{
+ if (rtems_debugger->lock != 0) {
+ rtems_status_code sc;
+ sc = rtems_semaphore_release(rtems_debugger->lock);
+ if (sc != RTEMS_SUCCESSFUL) {
+ rtems_debugger_printf("error: rtems-db: unlock: %s\n",
+ rtems_status_text(sc));
+ return -1;
+ }
+ }
+ return 0;
+}
+
+static int
+rtems_debugger_lock_create(void)
+{
+ #define LOCK_ATTRIBUTES \
+ RTEMS_PRIORITY | RTEMS_INHERIT_PRIORITY | RTEMS_BINARY_SEMAPHORE
+ rtems_status_code sc;
+ sc = rtems_semaphore_create(rtems_build_name('G', 'D', 'B', 's'),
+ 1,
+ LOCK_ATTRIBUTES,
+ 0,
+ &rtems_debugger->lock);
+ if (sc != RTEMS_SUCCESSFUL) {
+ rtems_debugger_printf("error: rtems-db: sema create: %s\n",
+ rtems_status_text(sc));
+ errno = EIO;
+ return -1;
+ }
+ return 0;
+}
+
+static int
+rtems_debugger_lock_destroy(void)
+{
+ rtems_debugger_lock();
+ if (rtems_debugger->lock != 0) {
+ rtems_status_code sc;
+ rtems_semaphore_release(rtems_debugger->lock);
+ sc = rtems_semaphore_delete(rtems_debugger->lock);
+ rtems_debugger->lock = 0;
+ if (sc != RTEMS_SUCCESSFUL) {
+ rtems_debugger_printf("error: rtems-db: sema delete: %s\n",
+ rtems_status_text(sc));
+ return -1;
+ }
+ }
+ return 0;
+}
+
+static int
+rtems_debugger_task_create(const char* name,
+ rtems_task_priority priority,
+ size_t stack_size,
+ rtems_task_entry entry_point,
+ rtems_task_argument argument,
+ rtems_id* id)
+{
+ rtems_name tname;
+ rtems_status_code sc;
+
+ tname = rtems_build_name(name[0], name[1], name[2], name[3]);
+
+ sc = rtems_task_create (tname,
+ priority,
+ stack_size,
+ RTEMS_FLOATING_POINT | RTEMS_LOCAL,
+ RTEMS_PREEMPT | RTEMS_NO_ASR,
+ id);
+ if (sc != RTEMS_SUCCESSFUL) {
+ *id = 0;
+ rtems_debugger_printf("error: rtems-db: thread create: %s: %s\n",
+ name, rtems_status_text(sc));
+ errno = EIO;
+ return -1;
+ }
+
+ sc = rtems_task_start(*id, entry_point, argument);
+ if (sc != RTEMS_SUCCESSFUL) {
+ rtems_debugger_printf("error: rtems-db: thread start: %s: %s\n",
+ name, rtems_status_text(sc));
+ rtems_task_delete(*id);
+ *id = 0;
+ errno = EIO;
+ return -1;
+ }
+
+ return 0;
+}
+
+static int
+rtems_debugger_task_destroy(const char* name,
+ rtems_id id,
+ volatile bool* finished,
+ int timeout)
+{
+ while (timeout) {
+ bool has_finished;
+ rtems_debugger_lock();
+ has_finished = *finished;
+ rtems_debugger_unlock();
+
+ if (has_finished)
+ break;
+
+ usleep(RTEMS_DEBUGGER_POLL_WAIT);
+ if (timeout < RTEMS_DEBUGGER_POLL_WAIT)
+ timeout = 0;
+ else
+ timeout -= RTEMS_DEBUGGER_POLL_WAIT;
+ }
+
+ if (timeout == 0) {
+ rtems_debugger_printf("rtems-db: %s not stopping, killing\n", name);
+ rtems_task_delete(id);
+ }
+ return 0;
+}
+
+bool
+rtems_debugger_server_running(void)
+{
+ bool running;
+ rtems_debugger_lock();
+ running = rtems_debugger->server_running;
+ rtems_debugger_unlock();
+ return running;
+}
+
+rtems_debugger_remote*
+rtems_debugger_remote_handle(void)
+{
+ rtems_debugger_remote* remote;
+ rtems_debugger_lock();
+ remote = rtems_debugger->remote;
+ rtems_debugger_unlock();
+ return remote;
+}
+
+bool
+rtems_debugger_connected(void)
+{
+ bool isconnected = false;
+ rtems_debugger_lock();
+ if (rtems_debugger->remote != NULL)
+ isconnected = rtems_debugger->remote->isconnected(rtems_debugger->remote);
+ rtems_debugger_unlock();
+ return isconnected;
+}
+
+bool
+rtems_debugger_server_events_running(void)
+{
+ bool running;
+ rtems_debugger_lock();
+ running = rtems_debugger->events_running;
+ rtems_debugger_unlock();
+ return running;
+}
+
+int
+rtems_debugger_server_events_wake(void)
+{
+ rtems_status_code sc;
+ int r = 0;
+ sc = rtems_event_send(rtems_debugger->events_task, RTEMS_EVENT_1);
+ if (sc != RTEMS_SUCCESSFUL) {
+ rtems_debugger_printf("error: rtems-db: event send: %s\n",
+ rtems_status_text(sc));
+ errno = EIO;
+ r = -1;
+ }
+ return r;
+}
+
+static int
+rtems_debugger_server_events_wait(void)
+{
+ rtems_event_set out = 0;
+ rtems_status_code sc;
+ int r = 0;
+ rtems_debugger_unlock();
+ while (true) {
+ sc = rtems_event_receive(RTEMS_EVENT_1,
+ RTEMS_EVENT_ALL | RTEMS_WAIT,
+ RTEMS_NO_TIMEOUT,
+ &out);
+ if (sc != RTEMS_SUCCESSFUL) {
+ rtems_debugger_printf("error: rtems-db: event receive: %s\n",
+ rtems_status_text(sc));
+ errno = EIO;
+ r = -1;
+ break;
+ }
+ if (out == RTEMS_EVENT_1)
+ break;
+ }
+ rtems_debugger_lock();
+ return r;
+}
+
+static int
+rtems_debugger_remote_connect(void)
+{
+ rtems_debugger_remote* remote = rtems_debugger_remote_handle();
+ if (remote == NULL) {
+ errno = EIO;
+ return -1;
+ }
+ if (!remote->isconnected(remote))
+ return remote->connect(remote);
+}
+
+static int
+rtems_debugger_remote_disconnect(void)
+{
+ rtems_debugger_remote* remote = rtems_debugger_remote_handle();
+ if (remote == NULL) {
+ errno = EIO;
+ return -1;
+ }
+ if (remote->isconnected(remote))
+ return remote->disconnect(remote);
+}
+
+static int
+rtems_debugger_remote_receive(uint8_t* buffer, size_t size)
+{
+ rtems_debugger_remote* remote = rtems_debugger_remote_handle();
+ ssize_t len = remote->read(remote, buffer, size);
+ if (len < 0 && errno != EAGAIN)
+ rtems_debugger_printf("rtems-db: read: (%d) %s\n",
+ errno, strerror(errno));
+ return (int) len;
+}
+
+static int
+rtems_debugger_remote_send(void)
+{
+ const uint8_t* buffer = rtems_debugger->output;
+ ssize_t size = rtems_debugger->output_level;
+
+ if (rtems_debugger->output_level > RTEMS_DEBUGGER_BUFFER_SIZE) {
+ rtems_debugger_printf("rtems-db: write too big: %d\n",
+ (int) rtems_debugger->output_level);
+ return -1;
+ }
+
+ if (rtems_debugger->remote_debug) {
+ size_t i = 0;
+ rtems_debugger_printf("rtems-db: put:%4zu: ", rtems_debugger->output_level);
+ while (i < rtems_debugger->output_level)
+ rtems_debugger_printf("%c", (char) rtems_debugger->output[i++]);
+ rtems_debugger_printf("\n");
+ }
+
+ while (size) {
+ rtems_debugger_remote* remote = rtems_debugger_remote_handle();
+ ssize_t w;
+ if (remote == NULL) {
+ errno = EIO;
+ return -1;
+ }
+ w = remote->write(remote, buffer, size);
+ if (w < 0 && errno != EINTR) {
+ rtems_debugger_printf("rtems-db: write: (%d) %s\n",
+ errno, strerror(errno));
+ break;
+ }
+ else {
+ size -= w;
+ buffer += w;
+ }
+ }
+
+ return (int) rtems_debugger->output_level;
+}
+
+static int
+rtems_debugger_remote_send_ack(void)
+{
+ rtems_debugger->output[0] = '+';
+ rtems_debugger->output_level = 1;
+ return rtems_debugger_remote_send();
+}
+
+static int
+rtems_debugger_remote_send_nack(void)
+{
+ rtems_debugger->output[0] = '-';
+ rtems_debugger->output_level = 1;
+ return rtems_debugger_remote_send();
+}
+
+static int
+rtems_debugger_remote_packet_in(void)
+{
+ uint8_t buf[256];
+ uint8_t state;
+ int in = 0;
+ uint8_t csum = 0;
+ uint8_t rx_csum = 0;
+ bool junk = false;
+ bool escaped = false;
+ bool remote_debug_header = true;
+
+ /*
+ * States:
+ * 'H' : Looking for the start character '$', '-' or '+'.
+ * 'P' : Looking for the checksum character '#' else buffer data.
+ * '1' : Looking for the first checksum character.
+ * '2' : Looking for the second checksum character.
+ * 'F' : Finished.
+ */
+
+ state = 'H';
+
+ while (state != 'F') {
+ int r;
+ int i;
+
+ rtems_debugger_unlock();
+
+ r = rtems_debugger_remote_receive(buf, sizeof(buf));
+
+ rtems_debugger_lock();
+
+ if (r <= 0) {
+ /*
+ * Timeout?
+ */
+ if (r < 0 && errno == EAGAIN) {
+ if (rtems_debugger->ack_pending) {
+ rtems_debugger_remote_send();
+ }
+ continue;
+ }
+ if (r == 0)
+ rtems_debugger_printf("rtems-db: remote disconnected\n");
+ return -1;
+ }
+
+ i = 0;
+
+ while (i < r) {
+ uint8_t c = buf[i++];
+
+ if (rtems_debugger->remote_debug && remote_debug_header) {
+ rtems_debugger_printf("rtems-db: get:%4d: ", r);
+ remote_debug_header = false;
+ }
+
+ if (rtems_debugger->remote_debug)
+ rtems_debugger_printf("%c", c);
+
+ switch (state) {
+ case 'H':
+ switch (c) {
+ case '+':
+ if (rtems_debugger->remote_debug) {
+ rtems_debugger_printf(" [[ACK%s]]\n",
+ rtems_debugger->ack_pending ? "" : "?");
+ remote_debug_header = true;
+ }
+ rtems_debugger->ack_pending = false;
+ break;
+ case '-':
+ if (rtems_debugger->remote_debug) {
+ rtems_debugger_printf(" [[NACK]]\n");
+ remote_debug_header = true;
+ }
+ /*
+ * Resend.
+ */
+ rtems_debugger_remote_send();
+ break;
+ case '$':
+ state = 'P';
+ csum = 0;
+ in = 0;
+ if (junk && rtems_debugger->remote_debug) {
+ rtems_debugger_printf("\b [[junk dropped]]\nrtems-db: get: : $");
+ remote_debug_header = false;
+ }
+ break;
+ case '\x3':
+ if (rtems_debugger->remote_debug)
+ rtems_debugger_printf("^C [[BREAK]]\n");
+ rtems_debugger->ack_pending = false;
+ rtems_debugger->input[0] = '^';
+ rtems_debugger->input[1] = 'C';
+ rtems_debugger->input[2] = '\0';
+ return 2;
+ default:
+ junk = true;
+ break;
+ }
+ break;
+ case 'P':
+ if (c == '{' && !escaped) {
+ escaped = true;
+ }
+ else if (c == '$' && !escaped) {
+ csum = 0;
+ in = 0;
+ if (rtems_debugger->remote_debug) {
+ rtems_debugger_printf("\n");
+ remote_debug_header = true;
+ }
+ }
+ else if (c == '#' && !escaped) {
+ rtems_debugger->input[in] = '\0';
+ rx_csum = 0;
+ state = '1';
+ }
+ else {
+ if (in >= (RTEMS_DEBUGGER_BUFFER_SIZE - 1)) {
+ rtems_debugger_printf("rtems-db: input buffer overflow\n");
+ return -1;
+ }
+ csum += c;
+ rtems_debugger->input[in++] = c;
+ }
+ break;
+ case '1':
+ rx_csum = (rx_csum << 4) | (uint8_t) hex_decode(c);
+ state = '2';
+ break;
+ case '2':
+ rx_csum = (rx_csum << 4) | (uint8_t) hex_decode(c);
+ if (csum == rx_csum) {
+ state = 'F';
+ if (rtems_debugger->remote_debug)
+ rtems_debugger_printf("\n");
+ rtems_debugger_remote_send_ack();
+ }
+ else {
+ if (rtems_debugger->remote_debug) {
+ rtems_debugger_printf(" [[invalid checksum]]\n");
+ remote_debug_header = true;
+ rtems_debugger_remote_send_nack();
+ }
+ state = 'H';
+ }
+ break;
+ case 'F':
+ if (rtems_debugger->remote_debug)
+ rtems_debugger_printf(" [[extra data: 0x%02x]]", (int) c);
+ break;
+ default:
+ rtems_debugger_printf("rtems-db: bad state\n");
+ rtems_debugger_remote_send_nack();
+ return -1;
+ }
+ }
+ }
+
+ return in;
+}
+
+static int
+rtems_debugger_remote_packet_in_hex(uint8_t* addr,
+ const char* data,
+ size_t size)
+{
+ size_t i;
+ for (i = 0; i < size; ++i) {
+ *addr = (hex_decode(*data++) << 4);
+ *addr++ |= hex_decode(*data++);
+ }
+ return 0;
+}
+
+#if KEEP_INCASE
+static void
+remote_packet_out_rewind(size_t size)
+{
+ size_t i = 0;
+ while (rtems_debugger->output_level > 0 && i < size) {
+ if (rtems_debugger->output_level > 1) {
+ if (rtems_debugger->output[rtems_debugger->output_level - 1] == '}') {
+ --rtems_debugger->output_level;
+ }
+ }
+ --rtems_debugger->output_level;
+ --i;
+ }
+}
+#endif
+
+static int
+remote_packet_out_append_buffer(const char* buffer, size_t size)
+{
+ size_t ol = rtems_debugger->output_level;
+ size_t i = 0;
+ while (i < size) {
+ char c = buffer[i++];
+ if (c == '#' || c == '$') {
+ if (rtems_debugger->output_level >= (RTEMS_DEBUGGER_BUFFER_SIZE - 1)) {
+ rtems_debugger->output_level = ol;
+ rtems_debugger_printf("rtems-db: output overflow\n");
+ return -1;
+ }
+ rtems_debugger->output[rtems_debugger->output_level++] = '}';
+ c ^= 0x20;
+ }
+ if (rtems_debugger->output_level >= (RTEMS_DEBUGGER_BUFFER_SIZE - 1)) {
+ rtems_debugger->output_level = ol;
+ rtems_debugger_printf("rtems-db: output overflow\n");
+ return -1;
+ }
+ rtems_debugger->output[rtems_debugger->output_level++] = c;
+ }
+ return 0;
+}
+
+static int
+remote_packet_out_append_hex(const uint8_t* data, size_t size)
+{
+ size_t ol = rtems_debugger->output_level;
+ size_t i = 0;
+ while (i < size) {
+ uint8_t byte = data[i++];
+ if (rtems_debugger->output_level >= (RTEMS_DEBUGGER_BUFFER_SIZE - 2)) {
+ rtems_debugger->output_level = ol;
+ rtems_debugger_printf("rtems-db: output overflow\n");
+ return -1;
+ }
+ rtems_debugger->output[rtems_debugger->output_level++] = hex_encode(byte >> 4);
+ rtems_debugger->output[rtems_debugger->output_level++] = hex_encode(byte);
+ }
+ return 0;
+}
+
+static int
+remote_packet_out_append_str(const char* str)
+{
+ return remote_packet_out_append_buffer(str, strlen(str));
+}
+
+static int
+remote_packet_out_append_vprintf(const char* fmt, va_list ap)
+{
+ int len;
+ char buffer[64];
+ len = vsnprintf(buffer, sizeof(buffer), fmt, ap);
+ return remote_packet_out_append_buffer(buffer, len);
+}
+
+static int
+remote_packet_out_append(const char* fmt, ...)
+{
+ va_list ap;
+ int r;
+ va_start(ap, fmt);
+ r = remote_packet_out_append_vprintf(fmt, ap);
+ va_end(ap);
+ return r;
+}
+
+static void
+remote_packet_out_reset(void)
+{
+ rtems_debugger->output_level = 1;
+ rtems_debugger->output[0] = '$';
+}
+
+static int
+remote_packet_out_buffer(const char* buffer, size_t size)
+{
+ remote_packet_out_reset();
+ return remote_packet_out_append_buffer(buffer, size);
+}
+
+static int
+remote_packet_out_str(const char* str)
+{
+ remote_packet_out_reset();
+ return remote_packet_out_append_buffer(str, strlen(str));
+}
+
+static int
+remote_packet_out(const char* fmt, ...)
+{
+ va_list ap;
+ int r;
+ va_start(ap, fmt);
+ remote_packet_out_reset();
+ r = remote_packet_out_append_vprintf(fmt, ap);
+ va_end(ap);
+ return r;
+}
+
+static int
+remote_packet_out_send(void)
+{
+ uint8_t csum = 0;
+ size_t i = 1;
+
+ if (rtems_debugger->output_level >= (RTEMS_DEBUGGER_BUFFER_SIZE - 3)) {
+ rtems_debugger_printf("rtems-db: output overflow\n");
+ return -1;
+ }
+
+ while (i < rtems_debugger->output_level) {
+ csum += rtems_debugger->output[i++];
+ }
+
+ rtems_debugger->output[rtems_debugger->output_level++] = '#';
+ rtems_debugger->output[rtems_debugger->output_level++] = hex_encode((csum >> 4) & 0xf);
+ rtems_debugger->output[rtems_debugger->output_level++] = hex_encode(csum & 0xf);
+
+ rtems_debugger->ack_pending = true;;
+
+ return rtems_debugger_remote_send();
+}
+
+static int
+remote_packet_dispatch(const rtems_debugger_packet* packet,
+ size_t packets,
+ uint8_t* buffer,
+ int size)
+{
+ const rtems_debugger_packet* p;
+ size_t i;
+ int r = -1;
+ for (i = 0, p = &packet[0]; i < packets; ++i, ++p) {
+ if (strncmp(p->label,
+ (const char*) &buffer[0],
+ strlen(p->label)) == 0) {
+ r = p->command(buffer, size);
+ break;
+ }
+ }
+ if (r < 0) {
+ remote_packet_out_buffer("", 0);
+ remote_packet_out_send();
+ }
+ return 0;
+}
+
+static int
+remote_detach(uint8_t* buffer, int size)
+{
+ remote_packet_out_str(r_OK);
+ remote_packet_out_send();
+ rtems_debugger_remote_disconnect();
+ return 0;
+}
+
+static int
+remote_ut_features(uint8_t* buffer, int size)
+{
+ return -1;
+}
+
+static int
+remote_ut_osdata(uint8_t* buffer, int size)
+{
+ return -1;
+}
+
+static const rtems_debugger_packet uninterpreted_transfer[] = {
+ { .label = "qXfer:features",
+ .command = remote_ut_features },
+ { .label = "qXfer:osdata",
+ .command = remote_ut_osdata },
+};
+
+#define REMOTE_UNINTERPRETED_TRANSFERS \
+ RTEMS_DEBUGGER_NUMOF(uninterpreted_transfer)
+
+static int
+remote_gq_uninterpreted_transfer(uint8_t* buffer, int size)
+{
+ return remote_packet_dispatch(uninterpreted_transfer,
+ REMOTE_UNINTERPRETED_TRANSFERS,
+ buffer, size);
+}
+
+static int
+remote_gq_thread_info_subsequent(uint8_t* buffer, int size)
+{
+ rtems_debugger_threads* threads = rtems_debugger->threads;
+ if (threads->next >= threads->current.level)
+ remote_packet_out_str("l");
+ else {
+ rtems_debugger_thread* current;
+ const char* format = "p%d.%08lx";
+ current = rtems_debugger_thread_current(threads);
+ remote_packet_out_str("m");
+ while (threads->next < threads->current.level) {
+ int r;
+ r = remote_packet_out_append(format,
+ rtems_debugger->pid,
+ current[threads->next].id);
+ if (r < 0)
+ break;
+ format = ",p%d.%08lx";
+ ++threads->next;
+ }
+ }
+ remote_packet_out_send();
+ return 0;
+}
+
+static int
+remote_gq_thread_info_first(uint8_t* buffer, int size)
+{
+ rtems_debugger->threads->next = 0;
+ return remote_gq_thread_info_subsequent(buffer, size);
+}
+
+static int
+remote_gq_thread_extra_info(uint8_t* buffer, int size)
+{
+ const char* comma;
+ remote_packet_out_reset();
+ comma = strchr((const char*) buffer, ',');
+ if (comma != NULL) {
+ DB_UINT pid = 0;
+ DB_UINT tid = 0;
+ bool extended;
+ extended = thread_id_decode(comma + 1, &pid, &tid);
+ if (!extended || (extended && check_pid(pid))) {
+ int r;
+ r = rtems_debugger_thread_find_index(tid);
+ if (r >= 0) {
+ rtems_debugger_threads* threads = rtems_debugger->threads;
+ rtems_debugger_thread* current;
+ rtems_debugger_thread* thread;
+ char buf[128];
+ char str[32];
+ size_t l;
+ current = rtems_debugger_thread_current(threads);
+ thread = ¤t[r];
+ l = snprintf(buf, sizeof(buf),
+ "%4s (%08lx), ", thread->name, thread->id);
+ remote_packet_out_append_hex((const uint8_t*) buf, l);
+ l = snprintf(buf, sizeof(buf),
+ "priority(c:%3d r:%3d), ",
+ rtems_debugger_thread_current_priority(thread),
+ rtems_debugger_thread_real_priority(thread));
+ remote_packet_out_append_hex((const uint8_t*) buf, l);
+ l = snprintf(buf, sizeof(buf),
+ "stack(s:%6lu a:%p), ",
+ rtems_debugger_thread_stack_size(thread),
+ rtems_debugger_thread_stack_area(thread));
+ remote_packet_out_append_hex((const uint8_t*) buf, l);
+ rtems_debugger_thread_state_str(thread, str, sizeof(str));
+ l = snprintf(buf, sizeof(buf), "state(%s)", str);
+ remote_packet_out_append_hex((const uint8_t*) buf, l);
+ }
+ }
+ }
+ remote_packet_out_send();
+ return 0;
+}
+
+static int
+remote_gq_supported(uint8_t* buffer, int size)
+{
+ uint32_t capabilities = rtems_debugger_target_capabilities();
+ const char* p;
+ bool swbreak = false;
+ bool hwbreak = false;
+ bool vCont = false;
+ bool no_resumed = false;
+ bool multiprocess = false;
+ remote_packet_out("qSupported:PacketSize=%d;QNonStop-",
+ RTEMS_DEBUGGER_BUFFER_SIZE);
+ p = strchr((const char*) buffer, ':');
+ if (p != NULL)
+ ++p;
+ while (p != NULL && p != '\0') {
+ bool echo = false;
+ char* sc;
+ sc = strchr(p, ';');
+ if (sc != NULL) {
+ *sc++ = '\0';
+ }
+ if (strcmp(p, "swbreak+") == 0 &&
+ !swbreak && (capabilities & RTEMS_DEBUGGER_TARGET_CAP_SWBREAK) != 0) {
+ swbreak = true;
+ echo = true;
+ }
+ if (strcmp(p, "hwbreak+") == 0 &&
+ !hwbreak && (capabilities & RTEMS_DEBUGGER_TARGET_CAP_HWBREAK) != 0) {
+ hwbreak = true;
+ echo = true;
+ }
+ if (!vCont && strcmp(p, "vContSupported+") == 0) {
+ rtems_debugger->flags |= RTEMS_DEBUGGER_FLAG_VCONT;
+ vCont = true;
+ echo = true;
+ }
+ if (!no_resumed && strcmp(p, "no-resumed+") == 0) {
+ no_resumed = true;
+ echo = true;
+ }
+ if (!multiprocess && strcmp(p, "multiprocess+") == 0) {
+ rtems_debugger->flags |= RTEMS_DEBUGGER_FLAG_MULTIPROCESS;
+ multiprocess = true;
+ echo = true;
+ }
+
+ if (echo) {
+ remote_packet_out_append_str(";");
+ remote_packet_out_append_str(p);
+ }
+ else if (strncmp(p, "xmlRegisters", sizeof("xmlRegisters") - 1) == 0) {
+ /* ignore */
+ }
+ else {
+ remote_packet_out_append_str(";");
+ remote_packet_out_append_buffer(p, strlen(p) - 1);
+ remote_packet_out_append_str("-");
+ }
+ p = sc;
+ }
+ if (!swbreak && (capabilities & RTEMS_DEBUGGER_TARGET_CAP_SWBREAK) != 0) {
+ remote_packet_out_append_str("swbreak+;");
+ }
+ if (!hwbreak && (capabilities & RTEMS_DEBUGGER_TARGET_CAP_HWBREAK) != 0) {
+ remote_packet_out_append_str("hwbreak+;");
+ }
+ if (!vCont) {
+ remote_packet_out_append_str("vContSupported+;");
+ }
+ if (!no_resumed) {
+ remote_packet_out_append_str("no-resumed+;");
+ }
+ if (!multiprocess) {
+ remote_packet_out_append_str("multiprocess+;");
+ }
+ remote_packet_out_send();
+ return 0;
+}
+
+static int
+remote_gq_attached(uint8_t* buffer, int size)
+{
+ const char const* response = "1";
+ const char* colon = strchr((const char*) buffer, ':');
+ if (colon != NULL) {
+ DB_UINT pid = hex_decode_uint((const uint8_t*) colon + 1);
+ if ((pid_t) pid != rtems_debugger->pid)
+ response = r_E01;
+ }
+ remote_packet_out_str(response);
+ remote_packet_out_send();
+ return 0;
+}
+
+static const rtems_debugger_packet general_query[] = {
+ { .label = "qfThreadInfo",
+ .command = remote_gq_thread_info_first },
+ { .label = "qsThreadInfo",
+ .command = remote_gq_thread_info_subsequent },
+ { .label = "qThreadExtraInfo",
+ .command = remote_gq_thread_extra_info },
+ { .label = "qSupported",
+ .command = remote_gq_supported },
+ { .label = "qAttached",
+ .command = remote_gq_attached },
+ { .label = "qXfer",
+ .command = remote_gq_uninterpreted_transfer },
+};
+
+#define REMOTE_GENERAL_QUERIES RTEMS_DEBUGGER_NUMOF(general_query)
+
+static int
+remote_general_query(uint8_t* buffer, int size)
+{
+ return remote_packet_dispatch(general_query, REMOTE_GENERAL_QUERIES,
+ buffer, size);
+}
+
+static int
+remote_gs_non_stop(uint8_t* buffer, int size)
+{
+ const char const* response = r_E01;
+ char* p = strchr((char*) buffer, ':');
+ if (p != NULL) {
+ ++p;
+ response = r_OK;
+ if (*p == '0') {
+ rtems_debugger->flags &= ~RTEMS_DEBUGGER_FLAG_NON_STOP;
+ }
+ else if (*p == '1') {
+ rtems_debugger->flags |= RTEMS_DEBUGGER_FLAG_NON_STOP;
+ }
+ else
+ response = r_E01;
+ }
+ remote_packet_out_str(response);
+ remote_packet_out_send();
+ return 0;
+}
+
+static const rtems_debugger_packet general_set[] = {
+ { .label = "QNonStop",
+ .command = remote_gs_non_stop },
+};
+
+#define REMOTE_GENERAL_SETS RTEMS_DEBUGGER_NUMOF(general_set)
+
+static int
+remote_general_set(uint8_t* buffer, int size)
+{
+ return remote_packet_dispatch(general_set, REMOTE_GENERAL_SETS,
+ buffer, size);
+}
+
+static int
+remote_v_stopped(uint8_t* buffer, int size)
+{
+ rtems_debugger_threads* threads = rtems_debugger->threads;
+ if (threads->next >= threads->stopped.level)
+ remote_packet_out_str(r_OK);
+ else {
+ rtems_id* stopped;
+ remote_packet_out("T%02x", rtems_debugger->signal);
+ stopped = rtems_debugger_thread_stopped(threads);
+ while (threads->next < threads->stopped.level) {
+ int r;
+ r = remote_packet_out_append("thread:p%d.%08lx;",
+ rtems_debugger->pid,
+ stopped[threads->next]);
+ if (r < 0)
+ break;
+ ++threads->next;
+ }
+ }
+ remote_packet_out_send();
+ return 0;
+}
+
+static int
+remote_stop_reason(uint8_t* buffer, int size)
+{
+ rtems_debugger->threads->next = 0;
+ return remote_v_stopped(buffer, size);
+}
+
+static int
+remote_v_continue(uint8_t* buffer, int size)
+{
+ buffer += 5;
+
+ if (buffer[0] == '?') {
+ /*
+ * You need to supply 'c' and 'C' or GDB says vCont is not supported. As
+ * Sammy-J says "Silly GDB".
+ */
+ remote_packet_out_str("vCont;c;C;s;r;");
+ }
+ else {
+ const char* semi = (const char*) &buffer[0];
+ bool resume = false;
+ bool ok = true;
+ while (ok && semi != NULL) {
+ const char* colon = strchr(semi + 1, ':');
+ const char action = *(semi + 1);
+ DB_UINT pid = 0;
+ DB_UINT tid = 0;
+ bool extended;
+ if (colon != NULL) {
+ int r = -1;
+ extended = thread_id_decode(colon + 1, &pid, &tid);
+ if (extended || check_pid(pid)) {
+ rtems_debugger_threads* threads = rtems_debugger->threads;
+ rtems_debugger_thread* thread = NULL;
+ int index = 0;
+ if (tid != (DB_UINT) -1) {
+ rtems_debugger_thread* current;
+ current = rtems_debugger_thread_current(threads);
+ index = rtems_debugger_thread_find_index(tid);
+ if (index >= 0)
+ thread = ¤t[index];
+ }
+ switch (action) {
+ case 'c':
+ case 'C':
+ if (tid == (DB_UINT) -1) {
+ r = rtems_debugger_thread_continue_all();
+ }
+ else if (thread != NULL) {
+ r = rtems_debugger_thread_continue(thread);
+ }
+ if (r == 0)
+ resume = true;
+ break;
+ case 's':
+ if (thread != NULL) {
+ r = rtems_debugger_thread_step(thread);
+ if (r == 0)
+ resume = true;
+ }
+ break;
+ case 'r':
+ /*
+ * Range to step around inside: `r start,end`.
+ */
+ if (thread != NULL) {
+ const char* comma;
+ comma = strchr(semi + 2, ',');
+ if (comma != NULL) {
+ DB_UINT start;
+ DB_UINT end;
+ start = hex_decode_uint((const uint8_t*) semi + 2);
+ end = hex_decode_uint((const uint8_t*) comma + 1);
+ r = rtems_debugger_thread_stepping(thread, start, end);
+ if (r == 0)
+ resume = true;
+ }
+ else {
+ ok = false;
+ }
+ }
+ break;
+ default:
+ ok = false;
+ break;
+ }
+ if (r < 0)
+ ok = false;
+ }
+ }
+ else {
+ ok = false;
+ }
+ semi = strchr(semi + 1, ';');
+ }
+
+ if (ok)
+ remote_packet_out_str(r_OK);
+ else
+ remote_packet_out_str(r_E01);
+
+ if (resume)
+ rtems_debugger_thread_system_resume(false);
+ }
+
+ remote_packet_out_send();
+
+ return 0;
+}
+
+static int
+remote_v_kill(uint8_t* buffer, int size)
+{
+ rtems_debugger->flags |= RTEMS_DEBUGGER_FLAG_RESET;
+ return remote_detach(buffer, size);
+}
+
+static const rtems_debugger_packet v_packets[] = {
+ { .label = "vCont",
+ .command = remote_v_continue },
+ { .label = "vStopped",
+ .command = remote_v_stopped },
+ { .label = "vKill",
+ .command = remote_v_kill },
+};
+
+#define REMOTE_V_PACKETS RTEMS_DEBUGGER_NUMOF(v_packets)
+
+static int
+remote_v_packets(uint8_t* buffer, int size)
+{
+ return remote_packet_dispatch(v_packets, REMOTE_V_PACKETS,
+ buffer, size);
+}
+
+static int
+remote_thread_select(uint8_t* buffer, int size)
+{
+ const char const* response = r_OK;
+ int* index = NULL;
+
+ if (buffer[1] == 'g')
+ index = &rtems_debugger->threads->selector_gen;
+ else if (buffer[1] == 'c')
+ index = &rtems_debugger->threads->selector_cont;
+ else
+ response = r_E01;
+
+ if (index != NULL) {
+ DB_UINT pid = 0;
+ DB_UINT tid = 0;
+ bool extended;
+ extended = thread_id_decode((const char*) &buffer[2], &pid, &tid);
+ if (extended && !check_pid(pid)) {
+ response = r_E01;
+ }
+ else {
+ if (tid == 0 || tid == (DB_UINT) -1)
+ *index = (int) tid;
+ else {
+ int r;
+ r = rtems_debugger_thread_find_index(tid);
+ if (r < 0) {
+ response = r_E01;
+ *index = -1;
+ }
+ else
+ *index = r;
+ }
+ }
+ }
+
+ remote_packet_out_str(response);
+ remote_packet_out_send();
+ return 0;
+}
+
+static int
+remote_thread_alive(uint8_t* buffer, int size)
+{
+ const char const* response = r_E01;
+ DB_UINT pid = 0;
+ DB_UINT tid = 0;
+ bool extended;
+ extended = thread_id_decode((const char*) &buffer[1], &pid, &tid);
+ if (!extended || (extended && check_pid(pid))) {
+ int r;
+ r = rtems_debugger_thread_find_index(tid);
+ if (r >= 0)
+ response = r_OK;
+ }
+ remote_packet_out_str(response);
+ remote_packet_out_send();
+ return 0;
+}
+
+static int
+remote_argc_argv(uint8_t* buffer, int size)
+{
+ return -1;
+}
+
+static int
+remote_continue_at(uint8_t* buffer, int size)
+{
+ if (!rtems_debugger_server_flag(RTEMS_DEBUGGER_FLAG_VCONT)) {
+ char* vCont_c = "vCont;c:p1.-1";
+ return remote_v_continue((uint8_t*) vCont_c, strlen(vCont_c));
+ }
+ return -1;
+}
+
+static int
+remote_read_general_regs(uint8_t* buffer, int size)
+{
+ rtems_debugger_threads* threads = rtems_debugger->threads;
+ bool ok = false;
+ int r;
+ if (threads->selector_gen >= 0 &&
+ threads->selector_gen < (int) threads->current.level) {
+ rtems_debugger_thread* current;
+ rtems_debugger_thread* thread;
+ current = rtems_debugger_thread_current(threads);
+ thread = ¤t[threads->selector_gen];
+ r = rtems_debugger_target_read_regs(thread);
+ if (r >= 0) {
+ remote_packet_out_reset();
+ r = remote_packet_out_append_hex((const uint8_t*) &thread->registers[0],
+ rtems_debugger_target_reg_size());
+ if (r >= 0)
+ ok = true;
+ }
+ }
+ if (!ok)
+ remote_packet_out_str(r_E01);
+ remote_packet_out_send();
+ return 0;
+}
+
+static int
+remote_write_general_regs(uint8_t* buffer, int size)
+{
+ rtems_debugger_threads* threads = rtems_debugger->threads;
+ size_t reg_size = rtems_debugger_target_reg_size();
+ bool ok = false;
+ int r;
+ if (threads->selector_gen >= 0 &&
+ threads->selector_gen < (int) threads->current.level &&
+ ((size - 1) / 2) == (int) reg_size) {
+ rtems_debugger_thread* current;
+ rtems_debugger_thread* thread;
+ current = rtems_debugger_thread_current(threads);
+ thread = ¤t[threads->selector_gen];
+ r = rtems_debugger_target_read_regs(thread);
+ if (r >= 0) {
+ r = rtems_debugger_remote_packet_in_hex((uint8_t*) &thread->registers[0],
+ (const char*) &buffer[1],
+ reg_size);
+ if (r >= 0) {
+ thread->flags |= RTEMS_DEBUGGER_THREAD_FLAG_REG_DIRTY;
+ ok = true;
+ }
+ }
+ }
+ if (!ok)
+ remote_packet_out_str(r_E01);
+ remote_packet_out_send();
+ return 0;
+}
+
+static int
+remote_read_reg(uint8_t* buffer, int size)
+{
+ rtems_debugger_threads* threads = rtems_debugger->threads;
+ bool ok = false;
+ int r;
+ if (threads->selector_gen >= 0
+ && threads->selector_gen < (int) threads->current.level) {
+ size_t reg = hex_decode_int(&buffer[1]);
+ if (reg < rtems_debugger_target_reg_num()) {
+ rtems_debugger_thread* current;
+ rtems_debugger_thread* thread;
+ current = rtems_debugger_thread_current(threads);
+ thread = ¤t[threads->selector_gen];
+ r = rtems_debugger_target_read_regs(thread);
+ if (r >= 0) {
+ const uint8_t* addr = (const uint8_t*) &thread->registers[reg];
+ remote_packet_out_reset();
+ r = remote_packet_out_append_hex(addr, sizeof(thread->registers[0]));
+ if (r >= 0)
+ ok = true;
+ }
+ }
+ }
+ if (!ok)
+ remote_packet_out_str(r_E01);
+ remote_packet_out_send();
+ return 0;
+}
+
+static int
+remote_write_reg(uint8_t* buffer, int size)
+{
+ rtems_debugger_threads* threads = rtems_debugger->threads;
+ const char const* response = r_E01;
+ if (threads->selector_gen >= 0
+ && threads->selector_gen < (int) threads->current.level) {
+ const char* equals;
+ equals = strchr((const char*) buffer, '=');
+ if (equals != NULL) {
+ size_t reg = hex_decode_int(&buffer[1]);
+ if (reg < rtems_debugger_target_reg_num()) {
+ rtems_debugger_thread* current;
+ rtems_debugger_thread* thread;
+ int r;
+ current = rtems_debugger_thread_current(threads);
+ thread = ¤t[threads->selector_gen];
+ r = rtems_debugger_target_read_regs(thread);
+ if (r >= 0) {
+ uint8_t* addr = (uint8_t*) &thread->registers[reg];
+ r = rtems_debugger_remote_packet_in_hex(addr,
+ equals + 1,
+ sizeof(thread->registers[reg]));
+ if (r == 0) {
+ thread->flags |= RTEMS_DEBUGGER_THREAD_FLAG_REG_DIRTY;
+ response = r_OK;
+ }
+ }
+ }
+ }
+ }
+ remote_packet_out_str(response);
+ remote_packet_out_send();
+ return 0;
+}
+
+static int
+remote_read_memory(uint8_t* buffer, int size)
+{
+ const char* comma;
+ comma = strchr((const char*) buffer, ',');
+ if (comma == NULL)
+ remote_packet_out_str(r_E01);
+ else {
+ DB_UINT addr;
+ DB_UINT length;
+ int r;
+ addr = hex_decode_uint(&buffer[1]);
+ length = hex_decode_uint((const uint8_t*) comma + 1);
+ remote_packet_out_reset();
+ r = rtems_debugger_target_start_memory_access();
+ if (r == 0) {
+ /*
+ * There should be specific target access for 8, 16, 32 and 64 bit reads.
+ */
+ r = remote_packet_out_append_hex((const uint8_t*) addr, length);
+ }
+ rtems_debugger_target_end_memory_access();
+ if (r < 0)
+ remote_packet_out_str(r_E01);
+ }
+ remote_packet_out_send();
+ return 0;
+}
+
+static int
+remote_write_memory(uint8_t* buffer, int size)
+{
+ const char const* response = r_E01;
+ const char* comma;
+ const char* colon;
+ comma = strchr((const char*) buffer, ',');
+ colon = strchr((const char*) buffer, ':');
+ if (comma != NULL && colon != NULL) {
+ DB_UINT addr;
+ DB_UINT length;
+ int r;
+ addr = hex_decode_uint(&buffer[1]);
+ length = hex_decode_uint((const uint8_t*) comma + 1);
+ r = rtems_debugger_target_start_memory_access();
+ if (r == 0) {
+ r = rtems_debugger_remote_packet_in_hex((uint8_t*) addr,
+ colon + 1,
+ length);
+ }
+ rtems_debugger_target_end_memory_access();
+ if (r == 0)
+ response = r_OK;
+ }
+ remote_packet_out_str(response);
+ remote_packet_out_send();
+ return 0;
+}
+
+static int
+remote_single_step(uint8_t* buffer, int size)
+{
+ if (!rtems_debugger_server_flag(RTEMS_DEBUGGER_FLAG_VCONT)) {
+ rtems_debugger_threads* threads = rtems_debugger->threads;
+ if (threads != NULL && rtems_debugger_thread_current(threads) != NULL) {
+ rtems_debugger_thread* current;
+ char vCont_s[32];
+ current = rtems_debugger_thread_current(threads);
+ snprintf(vCont_s, sizeof(vCont_s), "vCont;s:p1.%08lx;c:p1.-1",
+ current[threads->selector_cont].id);
+ return remote_v_continue((uint8_t*) vCont_s, strlen(vCont_s));
+ }
+ remote_packet_out_str(r_E01);
+ remote_packet_out_send();
+ return 0;
+ }
+ return -1;
+}
+
+static int
+remote_breakpoints(bool insert, uint8_t* buffer, int size)
+{
+ const char* comma1;
+ int r = -1;
+ comma1 = strchr((const char*) buffer, ',');
+ if (comma1 != NULL) {
+ const char* comma2;
+ comma2 = strchr(comma1 + 1, ',');
+ if (comma2 != NULL) {
+ uint32_t capabilities;
+ DB_UINT addr;
+ DB_UINT kind;
+ addr = hex_decode_uint((const uint8_t*) comma1 + 1);
+ kind = hex_decode_uint((const uint8_t*)comma2 + 1);
+ capabilities = rtems_debugger_target_capabilities();
+ switch (buffer[1]) {
+ case '0':
+ if ((capabilities & RTEMS_DEBUGGER_TARGET_CAP_SWBREAK) != 0) {
+ r = rtems_debugger_target_swbreak_control(insert, addr, kind);
+ }
+ break;
+ case '1': /* execute */
+ case '2': /* write */
+ case '3': /* read */
+ case '4': /* access */
+ if ((capabilities & RTEMS_DEBUGGER_TARGET_CAP_HWWATCH) != 0) {
+ rtems_debugger_target_watchpoint type;
+ switch (buffer[1]) {
+ case '1':
+ type = rtems_debugger_target_hw_execute;
+ break;
+ case '2':
+ type = rtems_debugger_target_hw_write;
+ break;
+ case '3':
+ type = rtems_debugger_target_hw_read;
+ break;
+ case '4':
+ default:
+ type = rtems_debugger_target_hw_read_write;
+ break;
+ }
+ r = rtems_debugger_target_hwbreak_control(type, insert, addr, kind);
+ }
+ break;
+ default:
+ break;
+ }
+ }
+ }
+ remote_packet_out_str(r < 0 ? r_E01 : r_OK);
+ remote_packet_out_send();
+ return 0;
+}
+
+static int
+remote_insert_breakpoint(uint8_t* buffer, int size)
+{
+ return remote_breakpoints(true, buffer, size);
+}
+
+static int
+remote_remove_breakpoint(uint8_t* buffer, int size)
+{
+ return remote_breakpoints(false, buffer, size);
+}
+
+static int
+remote_break(uint8_t* buffer, int size)
+{
+ int r;
+ r = rtems_debugger_thread_system_suspend();
+ if (r < 0) {
+ rtems_debugger_printf("error: rtems-db: suspend all on break\n");
+ }
+ return remote_stop_reason(buffer, size);
+}
+
+static const rtems_debugger_packet packets[] = {
+ { .label = "q",
+ .command = remote_general_query },
+ { .label = "Q",
+ .command = remote_general_set },
+ { .label = "v",
+ .command = remote_v_packets },
+ { .label = "H",
+ .command = remote_thread_select },
+ { .label = "T",
+ .command = remote_thread_alive },
+ { .label = "?",
+ .command = remote_stop_reason },
+ { .label = "A",
+ .command = remote_argc_argv },
+ { .label = "c",
+ .command = remote_continue_at },
+ { .label = "g",
+ .command = remote_read_general_regs },
+ { .label = "G",
+ .command = remote_write_general_regs },
+ { .label = "p",
+ .command = remote_read_reg },
+ { .label = "P",
+ .command = remote_write_reg },
+ { .label = "m",
+ .command = remote_read_memory },
+ { .label = "M",
+ .command = remote_write_memory },
+ { .label = "s",
+ .command = remote_single_step },
+ { .label = "Z",
+ .command = remote_insert_breakpoint },
+ { .label = "z",
+ .command = remote_remove_breakpoint },
+ { .label = "D",
+ .command = remote_detach },
+ { .label = "k",
+ .command = remote_v_kill },
+ { .label = "r",
+ .command = remote_v_kill },
+ { .label = "R",
+ .command = remote_v_kill },
+ { .label = "^C",
+ .command = remote_break },
+};
+
+#define REMOTE_PACKETS RTEMS_DEBUGGER_NUMOF(packets)
+
+static int
+remote_packets(uint8_t* buffer, size_t size)
+{
+ return remote_packet_dispatch(packets, REMOTE_PACKETS,
+ buffer, size);
+}
+
+static void
+rtems_debugger_events(rtems_task_argument arg)
+{
+ int r;
+
+ if (rtems_debugger_verbose())
+ rtems_debugger_printf("rtems-db: events running\n");
+
+ /*
+ * Hold the lock until the thread blocks waiting for an event.
+ */
+ rtems_debugger_lock();
+
+ rtems_debugger_target_enable();
+
+ while (rtems_debugger_server_events_running()) {
+ r = rtems_debugger_server_events_wait();
+ if (r < 0)
+ break;
+ if (!rtems_debugger_server_events_running())
+ break;
+ r = rtems_debugger_thread_system_suspend();
+ if (r < 0)
+ break;
+ r = remote_stop_reason(NULL, 0);
+ if (r < 0)
+ break;
+ }
+
+ if (r < 0)
+ rtems_debugger_printf("rtems-db: error in events\n");
+
+ rtems_debugger_target_disable();
+
+ rtems_debugger->events_running = false;
+ rtems_debugger->events_finished = true;
+
+ rtems_debugger_unlock();
+
+ if (rtems_debugger_verbose())
+ rtems_debugger_printf("rtems-db: events finishing\n");
+
+ rtems_task_delete(RTEMS_SELF);
+}
+
+static int
+rtems_debugger_session(void)
+{
+ int r;
+ int rr;
+
+ if (rtems_debugger_verbose())
+ rtems_debugger_printf("rtems-db: remote running\n");
+
+ /*
+ * Hold the lock until the thread blocks on the remote input.
+ */
+ rtems_debugger_lock();
+
+ r = rtems_debugger_target_create();
+ if (r < 0) {
+ rtems_debugger_thread_destroy();
+ rtems_debugger_unlock();
+ return r;
+ }
+
+ r = rtems_debugger_thread_create();
+ if (r < 0) {
+ rtems_debugger_unlock();
+ return r;
+ }
+
+ rtems_debugger->events_running = true;
+ rtems_debugger->events_finished = false;
+
+ r = rtems_debugger_task_create("DBSe",
+ rtems_debugger->priority,
+ RTEMS_DEBUGGER_STACKSIZE,
+ rtems_debugger_events,
+ 0,
+ &rtems_debugger->events_task);
+ if (r < 0) {
+ rtems_debugger_target_destroy();
+ rtems_debugger_thread_destroy();
+ rtems_debugger_unlock();
+ return r;
+ }
+
+ while (rtems_debugger_server_running() &&
+ rtems_debugger_connected()) {
+ r = rtems_debugger_remote_packet_in();
+ if (r < 0)
+ break;
+ if (r > 0) {
+ remote_packets(&rtems_debugger->input[0], r);
+ }
+ }
+
+ rtems_debugger->events_running = false;
+ rtems_debugger_server_events_wake();
+
+ rtems_debugger_unlock();
+
+ rr = rtems_debugger_task_destroy("DBSe",
+ rtems_debugger->events_task,
+ &rtems_debugger->events_finished,
+ RTEMS_DEBUGGER_TIMEOUT_STOP);
+ if (rr < 0 && r == 0)
+ r = rr;
+
+ rtems_debugger_lock();
+
+ rr = rtems_debugger_target_destroy();
+ if (rr < 0 && r == 0)
+ r = rr;
+
+ rr = rtems_debugger_thread_destroy();
+ if (rr < 0 && r == 0)
+ r = rr;
+
+ if (rtems_debugger_server_flag(RTEMS_DEBUGGER_FLAG_RESET)) {
+ rtems_debugger_printf("rtems-db: shutdown\n");
+ rtems_fatal_error_occurred(1122);
+ }
+
+ rtems_debugger->flags = 0;
+ rtems_debugger->ack_pending = false;
+
+ rtems_debugger_unlock();
+
+ if (rtems_debugger_verbose())
+ rtems_debugger_printf("rtems-db: remote finishing\n");
+
+ return r;
+}
+
+static int
+rtems_debugger_create(const char* remote,
+ const char* device,
+ rtems_task_priority priority,
+ int timeout,
+ const rtems_printer* printer)
+{
+ int r;
+
+ if (rtems_debugger != NULL) {
+ rtems_printf(printer, "error: rtems-db: create: already active\n");
+ errno = EEXIST;
+ return -1;
+ }
+
+ rtems_debugger = malloc(sizeof(rtems_debugger_server));
+ if (rtems_debugger == NULL) {
+ rtems_printf(printer, "error: rtems-db: create: no memory\n");
+ errno = ENOMEM;
+ return -1;
+ }
+
+ memset(rtems_debugger, 0, sizeof(rtems_debugger_server));
+
+ /*
+ * These do not change with a session.
+ */
+ rtems_debugger->priority = priority;
+ rtems_debugger->timeout = timeout;
+ rtems_debugger->printer = *printer;
+ rtems_debugger->pid = getpid();
+ rtems_debugger->remote_debug = false;
+
+ rtems_debugger->remote = rtems_debugger_remote_find(remote);
+ if (rtems_debugger->remote== NULL) {
+ rtems_printf(printer, "error: rtems-db: remote not found: %s\n", remote);
+ free(rtems_debugger);
+ rtems_debugger = NULL;
+ return -1;
+ }
+
+ r = rtems_debugger->remote->begin(rtems_debugger->remote, device);
+ if (r < 0) {
+ rtems_printf(printer, "error: rtems-db: remote begin: %s: %s\n",
+ rtems_debugger->remote->name, strerror(errno));
+ free(rtems_debugger);
+ rtems_debugger = NULL;
+ }
+
+ /*
+ * Reset at the end of the session.
+ */
+ rtems_debugger->flags = 0;
+ rtems_debugger->ack_pending = false;
+
+ r = rtems_debugger_lock_create();
+ if (r < 0) {
+ free(rtems_debugger);
+ rtems_debugger = NULL;
+ return -1;
+ }
+
+ return 0;
+}
+
+static int
+rtems_debugger_destroy(void)
+{
+ int r;
+ int rr;
+
+ rtems_debugger_lock();
+ rtems_debugger->server_running = false;
+ rtems_debugger_unlock();
+
+ r = rtems_debugger_remote_disconnect();
+
+ rr = rtems_debugger->remote->end(rtems_debugger->remote);
+ if (rr < 0 && r == 0)
+ r = rr;
+
+ rr = rtems_debugger_task_destroy("DBSr",
+ rtems_debugger->server_task,
+ &rtems_debugger->server_finished,
+ RTEMS_DEBUGGER_TIMEOUT_STOP);
+ if (rr < 0 && r == 0)
+ r = rr;
+
+ rr = rtems_debugger_lock_destroy();
+ if (rr < 0 && r == 0)
+ r = rr;
+
+ free(rtems_debugger);
+ rtems_debugger = NULL;
+
+ return r;
+}
+
+static void
+rtems_debugger_main(rtems_task_argument arg)
+{
+ int r;
+
+ rtems_debugger_printf("rtems-db: remote running\n");
+
+ while (rtems_debugger_server_running()) {
+ r = rtems_debugger_remote_connect();
+ if (r < 0)
+ break;
+ rtems_debugger_session();
+ rtems_debugger_remote_disconnect();
+ }
+
+ rtems_debugger_printf("rtems-db: remote finishing\n");
+
+ rtems_debugger_lock();
+ rtems_debugger->server_running = false;
+ rtems_debugger->server_finished = true;
+ rtems_debugger_unlock();
+
+ rtems_task_delete(RTEMS_SELF);
+}
+
+int
+rtems_debugger_start(const char* remote,
+ const char* device,
+ int timeout,
+ rtems_task_priority priority,
+ const rtems_printer* printer)
+{
+ int r;
+
+ r = rtems_debugger_create(remote, device, priority, timeout, printer);
+ if (r < 0)
+ return -1;
+
+ rtems_debugger_lock();
+ rtems_debugger->server_running = true;
+ rtems_debugger->server_finished = false;
+ rtems_debugger_unlock();
+
+ r = rtems_debugger_task_create("DBSs",
+ priority,
+ RTEMS_DEBUGGER_STACKSIZE,
+ rtems_debugger_main,
+ 0,
+ &rtems_debugger->server_task);
+ if (r < 0) {
+ rtems_debugger_destroy();
+ return -1;
+ }
+
+ return 0;
+}
+
+int
+rtems_debugger_stop(void)
+{
+ return rtems_debugger_destroy();
+}
+
+bool
+rtems_debugger_running(void)
+{
+ return rtems_debugger != NULL;
+}
+
+void
+rtems_debugger_set_verbose(bool on)
+{
+ if (rtems_debugger_running()) {
+ if (on)
+ rtems_debugger->flags |= RTEMS_DEBUGGER_FLAG_VERBOSE;
+ else
+ rtems_debugger->flags &= ~RTEMS_DEBUGGER_FLAG_VERBOSE;
+ }
+}
+
+int
+rtems_debugger_remote_debug(bool state)
+{
+ rtems_debugger_lock();
+ rtems_debugger->remote_debug = state;
+ rtems_debugger_printf("rtems-db: remote-debug is %s\n",
+ rtems_debugger->remote_debug ? "on" : "off");
+ rtems_debugger_unlock();
+ return 0;
+}
diff --git a/cpukit/libdebugger/rtems-debugger-server.h b/cpukit/libdebugger/rtems-debugger-server.h
new file mode 100644
index 0000000..0941933
--- /dev/null
+++ b/cpukit/libdebugger/rtems-debugger-server.h
@@ -0,0 +1,204 @@
+/*
+ * Copyright (c) 2016 Chris Johns <chrisj at rtems.org>. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/*
+ * Debugger for RTEMS.
+ */
+
+#ifndef _RTEMS_DEBUGGER_SERVER_h
+#define _RTEMS_DEBUGGER_SERVER_h
+
+#include <rtems.h>
+#include <rtems/printer.h>
+
+#include <rtems/rtems-debugger.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/**
+ * Debugger NUMOF macro.
+ */
+#define RTEMS_DEBUGGER_NUMOF(_d) (sizeof(_d) / sizeof(_d[0]))
+
+/**
+ * Machine specific size. Here for 64bit support.
+ */
+#define DB_UINT uint32_t
+
+/*
+ * Debugger signals.
+ */
+#define RTEMS_DEBUGGER_SIGNAL_HUP 1 /* Hangup */
+#define RTEMS_DEBUGGER_SIGNAL_INT 2 /* Interrupt */
+#define RTEMS_DEBUGGER_SIGNAL_QUIT 3 /* Quit */
+#define RTEMS_DEBUGGER_SIGNAL_ILL 4 /* Illegal instruction */
+#define RTEMS_DEBUGGER_SIGNAL_TRAP 5 /* Trace/breakpoint trap */
+#define RTEMS_DEBUGGER_SIGNAL_ABRT 6 /* Aborted */
+#define RTEMS_DEBUGGER_SIGNAL_EMT 7 /* Emulation trap */
+#define RTEMS_DEBUGGER_SIGNAL_FPE 8 /* Arithmetic exception */
+#define RTEMS_DEBUGGER_SIGNAL_KILL 9 /* Killed */
+#define RTEMS_DEBUGGER_SIGNAL_BUS 10 /* Bus error */
+#define RTEMS_DEBUGGER_SIGNAL_SEGV 11 /* Segmentation fault */
+#define RTEMS_DEBUGGER_SIGNAL_SYS 12 /* Bad system call */
+#define RTEMS_DEBUGGER_SIGNAL_PIPE 13 /* Broken pipe */
+#define RTEMS_DEBUGGER_SIGNAL_ALRM 14 /* Alarm clock */
+#define RTEMS_DEBUGGER_SIGNAL_TERM 15 /* Terminated */
+#define RTEMS_DEBUGGER_SIGNAL_URG 16 /* Urgent I/O condition */
+#define RTEMS_DEBUGGER_SIGNAL_STOP 17 /* Stopped (signal) */
+#define RTEMS_DEBUGGER_SIGNAL_TSTP 18 /* Stopped (user) */
+#define RTEMS_DEBUGGER_SIGNAL_CONT 19 /* Continued */
+
+/**
+ * Timeout period for the Debugger task to stop in usecs.
+ */
+#define RTEMS_DEBUGGER_TIMEOUT_STOP (5 * 1000 * 1000)
+
+/**
+ * Debugger poll wait timeout in usecs.
+ */
+#define RTEMS_DEBUGGER_POLL_WAIT (10000)
+
+/**
+ * Debugger task stack size.
+ */
+#define RTEMS_DEBUGGER_STACKSIZE (16 * 1024)
+
+/**
+ * Debugger output buffer size.
+ */
+#define RTEMS_DEBUGGER_BUFFER_SIZE (4 * 1024)
+
+/**
+ * Debugger flags.
+ */
+#define RTEMS_DEBUGGER_FLAG_VERBOSE (1 << 0)
+#define RTEMS_DEBUGGER_FLAG_RESET (1 << 1)
+#define RTEMS_DEBUGGER_FLAG_NON_STOP (1 << 2)
+#define RTEMS_DEBUGGER_FLAG_VCONT (1 << 3)
+#define RTEMS_DEBUGGER_FLAG_MULTIPROCESS (1 << 4)
+
+/**
+ * Forward decl for the threads and targets.
+ */
+typedef struct rtems_debugger_remote rtems_debugger_remote;
+typedef struct rtems_debugger_threads rtems_debugger_threads;
+typedef struct rtems_debugger_target rtems_debugger_target;
+
+/**
+ * Debugger data.
+ */
+typedef struct
+{
+ int port;
+ int timeout;
+ rtems_task_priority priority;
+ rtems_id lock;
+ rtems_id lock_output;
+ rtems_debugger_remote* remote;
+ rtems_id server_task;
+ volatile bool server_running;
+ volatile bool server_finished;
+ rtems_id events_task;
+ volatile bool events_running;
+ volatile bool events_finished;
+ rtems_printer printer;
+ uint32_t flags;
+ pid_t pid;
+ bool remote_debug;
+ bool ack_pending;
+ size_t output_level;
+ uint8_t input[RTEMS_DEBUGGER_BUFFER_SIZE];
+ uint8_t output[RTEMS_DEBUGGER_BUFFER_SIZE];
+ rtems_debugger_threads* threads;
+ int signal;
+ rtems_debugger_target* target;
+} rtems_debugger_server;
+
+/**
+ * Debugger global variable.
+ */
+extern rtems_debugger_server* rtems_debugger;
+
+/**
+ * Debug server printer.
+ */
+extern int rtems_debugger_printf(const char* format, ...) RTEMS_PRINTFLIKE(1, 2);
+
+/**
+ * Lock the Debugger.
+ */
+extern int rtems_debugger_lock(void);
+
+/**
+ * Unlock the Debugger.
+ */
+extern int rtems_debugger_unlock(void);
+
+/**
+ * Is the server still running?
+ */
+bool rtems_debugger_server_running(void);
+
+/**
+ * Get the remote handle from the debugger.
+ */
+rtems_debugger_remote* rtems_debugger_remote_handle(void);
+
+/**
+ * Is the debugger connected?
+ */
+bool rtems_debugger_connected(void);
+
+/**
+ * Is the debugger events thread runnins?
+ */
+bool rtems_debugger_server_events_running(void);
+
+/**
+ * Wake events thread in the debug server.
+ */
+extern int rtems_debugger_server_events_wake(void);
+
+/**
+ * Check if verbose is on.
+ */
+extern bool rtems_debugger_verbose(void);
+
+/**
+ * Check a flag.
+ */
+static inline bool rtems_debugger_server_flag(uint32_t mask)
+{
+ return (rtems_debugger->flags & mask) != 0;
+}
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif
diff --git a/cpukit/libdebugger/rtems-debugger-target.c b/cpukit/libdebugger/rtems-debugger-target.c
new file mode 100644
index 0000000..cd15654
--- /dev/null
+++ b/cpukit/libdebugger/rtems-debugger-target.c
@@ -0,0 +1,400 @@
+/*
+ * Copyright (c) 2016 Chris Johns <chrisj at rtems.org>. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#define TARGET_DEBUG 0
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <errno.h>
+#include <inttypes.h>
+#include <stdlib.h>
+
+#include <rtems.h>
+#include <rtems/score/threadimpl.h>
+
+#include "rtems-debugger-target.h"
+#include "rtems-debugger-threads.h"
+
+/**
+ * Frame signature.
+ */
+#define TARGET_FRAME_MAGIC_NUM (2)
+#define TARGET_FRAME_MAGIC 0xdeadbeef, 0xb2107016
+static const uint32_t
+ frame_magic[TARGET_FRAME_MAGIC_NUM] = { TARGET_FRAME_MAGIC };
+
+#if TARGET_DEBUG
+#include <rtems/bspIo.h>
+static void target_printk(const char* format, ...) RTEMS_PRINTFLIKE(1, 2);
+static void
+target_printk(const char* format, ...)
+{
+ va_list ap;
+ va_start(ap, format);
+ vprintk(format, ap);
+ va_end(ap);
+}
+#else
+#define target_printk(_fmt, ...)
+#endif
+
+int
+rtems_debugger_target_create(void)
+{
+ if (rtems_debugger->target == NULL) {
+ rtems_debugger_target* target;
+ int r;
+
+ target = calloc(1, sizeof(rtems_debugger_target));
+ if (target == NULL) {
+ errno = ENOMEM;
+ return -1;
+ }
+
+ r = rtems_debugger_target_configure(target);
+ if (r < 0) {
+ free(target);
+ return -1;
+ }
+
+ if (target->breakpoint_size > RTEMS_DEBUGGER_TARGET_SWBREAK_MAX_SIZE) {
+ free(target);
+ rtems_debugger_printf("error: rtems-db: target: breakpoint size too big\n");
+ return -1;
+ }
+
+ r = rtems_debugger_block_create(&target->swbreaks,
+ RTEMS_DEBUGGER_TARGET_SWBREAK_NUM,
+ sizeof(rtems_debugger_target_swbreak));
+ if (r < 0) {
+ free(target);
+ return -1;
+ }
+
+ rtems_debugger->target = target;
+ }
+
+ return 0;
+}
+
+int
+rtems_debugger_target_destroy(void)
+{
+ if (rtems_debugger->target != NULL) {
+ rtems_debugger_target* target = rtems_debugger->target;
+ rtems_debugger_target_swbreak_remove();
+ rtems_debugger_target_disable();
+ rtems_debugger_block_destroy(&target->swbreaks);
+ free(target);
+ rtems_debugger->target = NULL;
+ }
+ return 0;
+}
+
+uint32_t
+rtems_debugger_target_capabilities(void)
+{
+ if (rtems_debugger->target != NULL)
+
+ return rtems_debugger->target->capabilities;
+ return 0;
+}
+
+size_t
+rtems_debugger_target_reg_num(void)
+{
+ if (rtems_debugger->target != NULL)
+ return rtems_debugger->target->reg_num;
+ return 0;
+}
+
+size_t
+rtems_debugger_target_reg_size(void)
+{
+ if (rtems_debugger->target != NULL)
+ return rtems_debugger->target->reg_num * rtems_debugger->target->reg_size;
+ return 0;
+}
+
+int
+rtems_debugger_target_swbreak_control(bool insert, DB_UINT addr, DB_UINT kind)
+{
+ rtems_debugger_target* target = rtems_debugger->target;
+ rtems_debugger_target_swbreak* swbreaks = target->swbreaks.block;
+ size_t swbreak_size;
+ uint8_t* loc = (void*) addr;
+ size_t i;
+ int r;
+
+ if (target == NULL || swbreaks == NULL || kind != target->breakpoint_size) {
+ errno = EIO;
+ return -1;
+ }
+
+ swbreak_size =
+ sizeof(rtems_debugger_target_swbreak) + target->breakpoint_size;
+
+ for (i = 0; i < target->swbreaks.level; ++i) {
+ if (loc == swbreaks[i].address) {
+ size_t remaining;
+ if (!insert) {
+ --target->swbreaks.level;
+ remaining = (target->swbreaks.level - i) * swbreak_size;
+ memmove(&swbreaks[i], &swbreaks[i + 1], remaining);
+ }
+ return 0;
+ }
+ }
+
+ if (!insert)
+ return 0;
+
+ r = rtems_debugger_block_resize(&target->swbreaks);
+ if (r < 0)
+ return -1;
+
+ swbreaks = target->swbreaks.block;
+
+ swbreaks[target->swbreaks.level].address = loc;
+ if (target->breakpoint_size > 4)
+ memcpy(&swbreaks[target->swbreaks.level].contents[0],
+ loc,
+ target->breakpoint_size);
+ else {
+ uint8_t* contents = &swbreaks[target->swbreaks.level].contents[0];
+ switch (target->breakpoint_size) {
+ case 4:
+ contents[3] = loc[3];
+ case 3:
+ contents[2] = loc[2];
+ case 2:
+ contents[1] = loc[1];
+ case 1:
+ contents[0] = loc[0];
+ break;
+ }
+ }
+ ++target->swbreaks.level;
+
+ return 0;
+}
+
+int
+rtems_debugger_target_swbreak_insert(void)
+{
+ rtems_debugger_target* target = rtems_debugger->target;
+ int r = -1;
+ if (target != NULL && target->swbreaks.block != NULL) {
+ rtems_debugger_target_swbreak* swbreaks = target->swbreaks.block;
+ size_t i;
+ r = 0;
+ for (i = 0; i < target->swbreaks.level; ++i) {
+ uint8_t* loc = swbreaks[i].address;
+ if (rtems_debugger_verbose())
+ rtems_debugger_printf("rtems-db: bp: in: %p\n", swbreaks[i].address);
+ if (target->breakpoint_size > 4)
+ memcpy(loc, &target->breakpoint[0], target->breakpoint_size);
+ else {
+ switch (target->breakpoint_size) {
+ case 4:
+ loc[3] = target->breakpoint[3];
+ case 3:
+ loc[2] = target->breakpoint[2];
+ case 2:
+ loc[1] = target->breakpoint[1];
+ case 1:
+ loc[0] = target->breakpoint[0];
+ break;
+ }
+ }
+ r = rtems_debugger_target_cache_sync(&swbreaks[i]);
+ }
+ }
+ return r;
+}
+
+int
+rtems_debugger_target_swbreak_remove(void)
+{
+ rtems_debugger_target* target = rtems_debugger->target;
+ int r = -1;
+ if (target != NULL && target->swbreaks.block != NULL) {
+ rtems_debugger_target* target = rtems_debugger->target;
+ rtems_debugger_target_swbreak* swbreaks = target->swbreaks.block;
+ size_t i;
+ r = 0;
+ for (i = 0; i < target->swbreaks.level; ++i) {
+ uint8_t* loc = swbreaks[i].address;
+ uint8_t* contents = &swbreaks[i].contents[0];
+ if (rtems_debugger_verbose())
+ rtems_debugger_printf("rtems-db: bp: out: %p\n", swbreaks[i].address);
+ if (target->breakpoint_size > 4)
+ memcpy(loc, contents, target->breakpoint_size);
+ else {
+ switch (target->breakpoint_size) {
+ case 4:
+ loc[3] = contents[3];
+ case 3:
+ loc[2] = contents[2];
+ case 2:
+ loc[1] = contents[1];
+ case 1:
+ loc[0] = contents[0];
+ break;
+ }
+ }
+ r = rtems_debugger_target_cache_sync(&swbreaks[i]);
+ }
+ }
+ return r;
+}
+
+rtems_debugger_target_exc_action
+rtems_debugger_target_exception(CPU_Exception_frame* frame)
+{
+ volatile const uint32_t magic[3] = {
+ (uint32_t) frame, TARGET_FRAME_MAGIC
+ };
+
+ (void) magic;
+
+ if (!rtems_interrupt_is_in_progress()) {
+ rtems_debugger_threads* threads = rtems_debugger->threads;
+ Thread_Control* thread = _Thread_Executing;
+ rtems_id* excludes;
+ const rtems_id tid = thread->Object.id;
+ DB_UINT pc;
+ const rtems_debugger_thread_stepper* stepper;
+ size_t i;
+
+ target_printk("[} tid:%08" PRIx32 ": thread:%08" PRIxPTR
+ " frame:%08" PRIxPTR "\n",
+ tid, (intptr_t) thread, (intptr_t) frame);
+
+ /*
+ * If the thread is the debugger recover.
+ */
+ if (tid == rtems_debugger->server_task) {
+ if (rtems_debugger->target->memory_access) {
+ target_printk("[} server access fault\n");
+ rtems_debugger->target->memory_access = true;
+ longjmp(rtems_debugger->target->access_return, -1);
+ }
+ target_printk("[} server exception\n");
+ return rtems_debugger_target_exc_cascade;
+ }
+
+ /*
+ * See if the thread is excluded.
+ */
+ excludes = rtems_debugger_thread_excludes(threads);
+ for (i = 0; i < threads->excludes.level; ++i) {
+ if (tid == excludes[i]) {
+ /*
+ * We do nothing with this condition and cascade the exception.
+ *
+ * @todo: if this is a hwbreak carry on, if this is a swbreak replace
+ * the contents of the instruction, step then return the
+ * swbreak's contents.
+ */
+ target_printk("[} tid:%08lx: excluded\n", tid);
+ return rtems_debugger_target_exc_cascade;
+ }
+ }
+
+ /*
+ * See if the thread is inside the stepping a range.
+ */
+ pc = rtems_debugger_target_frame_pc(frame);
+ stepper = rtems_debugger_thread_is_stepping(tid, pc);
+ if (stepper != NULL) {
+ stepper->thread->frame = frame;
+ rtems_debugger_target_thread_stepping(stepper->thread);
+ target_printk("[} tid:%08lx: stepping\n", tid);
+ return rtems_debugger_target_exc_step;
+ }
+
+ target_printk("[} tid:%08lx: suspending\n", tid);
+
+ /*
+ * Tag the thread as being debugged, wake the debug server's event thread,
+ * then suspend this thread.
+ */
+ _Thread_Set_state(thread, STATES_DEBUGGER);
+ rtems_debugger_server_events_wake();
+ rtems_task_suspend(tid);
+
+ target_printk("[} tid:%08lx: resuming\n", tid);
+
+ return rtems_debugger_target_exc_consumed;
+ }
+
+ target_printk("[} cascade, in interrupt\n");
+
+ return rtems_debugger_target_exc_cascade;
+}
+
+int
+rtems_debugger_target_set_exception_frame(rtems_debugger_thread* thread)
+{
+ int r = 0;
+ thread->frame = NULL;
+ thread->flags &= ~RTEMS_DEBUGGER_THREAD_FLAG_DEBUGGING;
+ if ((thread->tcb->current_state & STATES_DEBUGGER) != 0) {
+ CPU_Exception_frame* frame = NULL;
+ DB_UINT* sp;
+ int i;
+ sp = (DB_UINT*) rtems_debugger_target_tcb_sp(thread);
+ for (i = 0; i < 128; ++i) {
+ if (sp[i] == frame_magic[0] && sp[i + 1] == frame_magic[1]) {
+ frame = (CPU_Exception_frame*) sp[i + 2];
+ break;
+ }
+ }
+ _Thread_Clear_state(thread->tcb, STATES_DEBUGGER);
+ thread->frame = frame;
+ if (frame != NULL)
+ thread->flags |= RTEMS_DEBUGGER_THREAD_FLAG_DEBUGGING;
+ else
+ r = -1;
+ }
+ return r;
+}
+
+int
+rtems_debugger_target_start_memory_access(void)
+{
+ rtems_debugger_target* target = rtems_debugger->target;
+ target->memory_access = true;
+ return setjmp(target->access_return);
+}
+
+void
+rtems_debugger_target_end_memory_access(void)
+{
+ rtems_debugger->target->memory_access = false;
+}
diff --git a/cpukit/libdebugger/rtems-debugger-target.h b/cpukit/libdebugger/rtems-debugger-target.h
new file mode 100644
index 0000000..82230e8
--- /dev/null
+++ b/cpukit/libdebugger/rtems-debugger-target.h
@@ -0,0 +1,237 @@
+/*
+ * Copyright (c) 2016 Chris Johns <chrisj at rtems.org>. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/*
+ * Debugger for RTEMS.
+ */
+
+#ifndef _RTEMS_DEBUGGER_TARGET_h
+#define _RTEMS_DEBUGGER_TARGET_h
+
+#include <setjmp.h>
+
+#include <rtems/rtems-debugger.h>
+
+#include "rtems-debugger-threads.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/*
+ * Software breakpoint block size.
+ */
+#define RTEMS_DEBUGGER_TARGET_SWBREAK_NUM 64
+
+/**
+ * Target capabilities mask.
+ */
+#define RTEMS_DEBUGGER_TARGET_CAP_SWBREAK (1 << 0)
+#define RTEMS_DEBUGGER_TARGET_CAP_HWBREAK (1 << 1)
+#define RTEMS_DEBUGGER_TARGET_CAP_HWWATCH (1 << 2)
+
+/**
+ * Types of hardware breakpoints.
+ */
+typedef enum rtems_debugger_target_watchpoint
+{
+ rtems_debugger_target_hw_read,
+ rtems_debugger_target_hw_write,
+ rtems_debugger_target_hw_read_write,
+ rtems_debugger_target_hw_execute
+} rtems_debugger_target_watchpoint;
+
+/**
+ * Target exception actions.
+ */
+typedef enum rtems_debugger_target_exc_action
+{
+ rtems_debugger_target_exc_consumed, /*<< The exception has been consumed. */
+ rtems_debugger_target_exc_cascade, /*<< Cascade to a previous handler. */
+ rtems_debugger_target_exc_step, /*<< Step an instruction. */
+} rtems_debugger_target_exc_action;
+
+/**
+ * Memory breakpoint. We use thumb mode BKPT which is 2 bytes.
+ */
+#define RTEMS_DEBUGGER_TARGET_SWBREAK_MAX_SIZE (4)
+typedef struct rtems_debugger_target_swbreak {
+ void* address;
+ uint8_t contents[RTEMS_DEBUGGER_TARGET_SWBREAK_MAX_SIZE];
+} rtems_debugger_target_swbreak;
+
+/**
+ * The target data.
+ */
+typedef struct rtems_debugger_target {
+ int capabilities; /*<< The capabilities to report. */
+ size_t reg_num; /*<< The number of registers. */
+ size_t reg_size; /*<< The size of a register. */
+ const uint8_t* breakpoint; /*<< The breakpoint instruction(s). */
+ size_t breakpoint_size; /*<< The breakpoint size. */
+ rtems_debugger_block swbreaks; /*<< The software breakpoint block. */
+ bool memory_access; /*<< Accessing target memory. */
+ jmp_buf access_return; /*<< Return from an access fault. */
+} rtems_debugger_target;
+
+/**
+ * Create the target.
+ */
+extern int rtems_debugger_target_create(void);
+
+/**
+ * Destroy the target.
+ */
+extern int rtems_debugger_target_destroy(void);
+
+/**
+ * Configure the target. This is architecture specific.
+ */
+extern int rtems_debugger_target_configure(rtems_debugger_target* target);
+
+/**
+ * Enable the target.
+ */
+extern int rtems_debugger_target_enable(void);
+
+/**
+ * Disable the target.
+ */
+extern int rtems_debugger_target_disable(void);
+
+/**
+ * Return the capabilities mask for the target.
+ */
+extern uint32_t rtems_debugger_target_capabilities(void);
+
+/**
+ * Return the number of regisers.
+ */
+extern size_t rtems_debugger_target_reg_num(void);
+
+/**
+ * Return the size of the regisers in bytes.
+ */
+extern size_t rtems_debugger_target_reg_size(void);
+
+/**
+ * Read the regosters.
+ */
+extern int rtems_debugger_target_read_regs(rtems_debugger_thread* thread);
+
+/**
+ * Write the regosters.
+ */
+extern int rtems_debugger_target_write_regs(rtems_debugger_thread* thread);
+
+/**
+ * Return the thread's program counter (PC).
+ */
+extern DB_UINT rtems_debugger_target_reg_pc(rtems_debugger_thread* thread);
+
+/**
+ * Return the frame's program counter (PC).
+ */
+extern DB_UINT rtems_debugger_target_frame_pc(CPU_Exception_frame* frame);
+
+/**
+ * Return the thread's stack pointer (SP).
+ */
+extern DB_UINT rtems_debugger_target_reg_sp(rtems_debugger_thread* thread);
+
+/**
+ * Return the thread's TCB stack pointer (SP).
+ */
+extern DB_UINT rtems_debugger_target_tcb_sp(rtems_debugger_thread* thread);
+
+/**
+ * The thread is stepping. Setup the thread to step an instruction.
+ */
+extern int rtems_debugger_target_thread_stepping(rtems_debugger_thread* thread);
+
+/**
+ * Return the signal for the exception.
+ */
+extern int rtems_debugger_target_exception_to_signal(CPU_Exception_frame* frame);
+
+/**
+ * Software breakpoints. These are also referred to as memory breakpoints.
+ */
+extern int rtems_debugger_target_swbreak_control(bool insert,
+ DB_UINT addr,
+ DB_UINT kind);
+
+/**
+ * Insert software breakpoints into the memory.
+ */
+extern int rtems_debugger_target_swbreak_insert(void);
+
+/**
+ * Remove software breakpoints from the memory.
+ */
+extern int rtems_debugger_target_swbreak_remove(void);
+
+/**
+ * Hardware breakpoints.
+ */
+extern int rtems_debugger_target_hwbreak_control(rtems_debugger_target_watchpoint type,
+ bool insert,
+ DB_UINT addr,
+ DB_UINT kind);
+
+/**
+ * Target exception processor.
+ */
+extern rtems_debugger_target_exc_action
+rtems_debugger_target_exception(CPU_Exception_frame* frame);
+
+/**
+ * Set the thread's exception stack frame pointer.
+ */
+extern int rtems_debugger_target_set_exception_frame(rtems_debugger_thread* thread);
+
+/**
+ * Target instruction cache sync. This depends on the target but it normally
+ * means a data cache flush and an instruction cache invalidate.
+ */
+extern int rtems_debugger_target_cache_sync(rtems_debugger_target_swbreak* swbreak);
+
+/**
+ * Start a target memory access. If 0 is return the access can proceed and if
+ * -1 is return the access has failed.
+ */
+extern int rtems_debugger_target_start_memory_access(void);
+
+/**
+ * End a target memory access.
+ */
+extern void rtems_debugger_target_end_memory_access(void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif
diff --git a/cpukit/libdebugger/rtems-debugger-threads.c b/cpukit/libdebugger/rtems-debugger-threads.c
new file mode 100644
index 0000000..89c1b9e
--- /dev/null
+++ b/cpukit/libdebugger/rtems-debugger-threads.c
@@ -0,0 +1,577 @@
+/*
+ * Copyright (c) 2016 Chris Johns <chrisj at rtems.org>. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <errno.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include <rtems.h>
+#include <rtems/score/statesimpl.h>
+#include <rtems/score/threadimpl.h>
+
+#include <rtems/debugger/rtems-debugger-server.h>
+
+#include "rtems-debugger-target.h"
+#include "rtems-debugger-threads.h"
+
+static const char const* excludes_defaults[] =
+{
+ "TIME",
+ "_BSD",
+ "IRQS",
+ "DBSs",
+ "DBSe",
+};
+
+static void
+rtems_debugger_thread_free(rtems_debugger_threads* threads)
+{
+ rtems_debugger_block_destroy(&threads->current);
+ rtems_debugger_block_destroy(&threads->registers);
+ rtems_debugger_block_destroy(&threads->excludes);
+ rtems_debugger_block_destroy(&threads->stopped);
+ rtems_debugger_block_destroy(&threads->steppers);
+ threads->next = 0;
+}
+
+int
+rtems_debugger_thread_create(void)
+{
+ rtems_debugger_threads* threads;
+ int r;
+
+ threads = calloc(1, sizeof(rtems_debugger_threads));
+ if (threads == NULL) {
+ errno = ENOMEM;
+ rtems_debugger_printf("error: rtems-db: thread: threads alloc: (%d) %s\n",
+ errno, strerror(errno));
+ return -1;
+ }
+
+ r = rtems_debugger_block_create(&threads->current,
+ RTEMS_DEBUGGER_THREAD_BLOCK_SIZE,
+ sizeof(rtems_debugger_thread));
+ if (r < 0) {
+ rtems_debugger_thread_free(threads);
+ free(threads);
+ rtems_debugger_printf("error: rtems-db: thread: current alloc: (%d) %s\n",
+ errno, strerror(errno));
+ return -1;
+ }
+
+ r = rtems_debugger_block_create(&threads->registers,
+ RTEMS_DEBUGGER_THREAD_BLOCK_SIZE,
+ rtems_debugger_target_reg_size());
+ if (r < 0) {
+ rtems_debugger_thread_free(threads);
+ free(threads);
+ rtems_debugger_printf("error: rtems-db: thread: registers alloc: (%d) %s\n",
+ errno, strerror(errno));
+ return -1;
+ }
+
+ r = rtems_debugger_block_create(&threads->excludes,
+ RTEMS_DEBUGGER_THREAD_BLOCK_SIZE,
+ sizeof(rtems_id));
+ if (r < 0) {
+ rtems_debugger_thread_free(threads);
+ free(threads);
+ rtems_debugger_printf("error: rtems-db: thread: exlcudes alloc: (%d) %s\n",
+ errno, strerror(errno));
+ return -1;
+ }
+
+ r = rtems_debugger_block_create(&threads->stopped,
+ RTEMS_DEBUGGER_THREAD_BLOCK_SIZE,
+ sizeof(rtems_id));
+ if (r < 0) {
+ rtems_debugger_thread_free(threads);
+ free(threads);
+ rtems_debugger_printf("error: rtems-db: thread: stopped alloc: (%d) %s\n",
+ errno, strerror(errno));
+ return -1;
+ }
+
+ r = rtems_debugger_block_create(&threads->steppers,
+ RTEMS_DEBUGGER_THREAD_BLOCK_SIZE,
+ sizeof(rtems_debugger_thread_stepper));
+ if (r < 0) {
+ rtems_debugger_thread_free(threads);
+ free(threads);
+ rtems_debugger_printf("error: rtems-db: thread: steppers alloc: (%d) %s\n",
+ errno, strerror(errno));
+ return -1;
+ }
+
+ rtems_debugger->threads = threads;
+
+ return rtems_debugger_thread_system_suspend();
+}
+
+int
+rtems_debugger_thread_destroy(void)
+{
+ rtems_debugger_threads* threads = rtems_debugger->threads;
+ rtems_debugger_thread_system_resume(true);
+ rtems_debugger_thread_free(threads);
+ free(threads);
+ rtems_debugger->threads = NULL;
+ return 0;
+}
+
+int
+rtems_debugger_thread_find_index(rtems_id id)
+{
+ rtems_debugger_threads* threads = rtems_debugger->threads;
+ rtems_debugger_thread* current = rtems_debugger_thread_current(threads);
+ int r = -1;
+ if (threads != NULL) {
+ size_t i;
+ for (i = 0; i < threads->current.level; ++i) {
+ if (id == 0 || current[i].id == id) {
+ r = i;
+ break;
+ }
+ }
+ }
+ return r;
+}
+
+static bool
+snapshot_thread(rtems_tcb* tcb, void* arg)
+{
+ rtems_debugger_threads* threads = rtems_debugger->threads;
+ rtems_id id = tcb->Object.id;
+ char name[RTEMS_DEBUGGER_THREAD_NAME_SIZE];
+ bool exclude = false;
+ size_t i;
+
+ /*
+ * The only time the threads pointer is NULL is a realloc error so we stop
+ * processing threads. There is no way to stop the iterator.
+ */
+ if (rtems_debugger_thread_current(threads) == NULL)
+ return true;
+
+ /*
+ * Filter the threads.
+ */
+ switch (rtems_object_id_get_api(id)) {
+ case OBJECTS_NO_API:
+ case OBJECTS_INTERNAL_API:
+ exclude = true;
+ break;
+ default:
+ rtems_object_get_name(id, sizeof(name), (char*) &name[0]);
+ for (i = 0; i < RTEMS_DEBUGGER_NUMOF(excludes_defaults); ++i) {
+ if (strcmp(excludes_defaults[i], name) == 0) {
+ exclude = true;
+ break;
+ }
+ }
+ break;
+ }
+
+ if (exclude) {
+ rtems_id* excludes;
+ int r;
+ r = rtems_debugger_block_resize(&threads->excludes);
+ if (r < 0) {
+ rtems_debugger_thread_free(threads);
+ return true;
+ }
+ excludes = rtems_debugger_thread_excludes(threads);
+ excludes[threads->excludes.level++] = id;
+ }
+ else {
+ rtems_debugger_thread* current;
+ DB_UINT* registers;
+ rtems_debugger_thread* thread;
+ int r;
+
+ r = rtems_debugger_block_resize(&threads->current);
+ if (r < 0) {
+ rtems_debugger_thread_free(threads);
+ return true;
+ }
+ r = rtems_debugger_block_resize(&threads->registers);
+ if (r < 0) {
+ rtems_debugger_thread_free(threads);
+ return true;
+ }
+
+ current = rtems_debugger_thread_current(threads);
+ registers = rtems_debugger_thread_registers(threads);
+
+ thread = ¤t[threads->current.level++];
+ thread->registers =
+ ®isters[threads->registers.level++ * rtems_debugger_target_reg_num()];
+
+ thread->tcb = tcb;
+ thread->id = id;
+ thread->flags = 0;
+ thread->signal = 0;
+ thread->frame = NULL;
+ memcpy((void*) &thread->name[0], &name[0], sizeof(thread->name));
+
+ /*
+ * See if there is a valid exception stack frame and if the thread is being
+ * debugged.
+ */
+ r = rtems_debugger_target_set_exception_frame(thread);
+ if (r < 0) {
+ rtems_debugger_printf("error: rtems-db: thread: snap: %08lx: not valid frame\n",
+ id);
+ }
+
+ /*
+ * Read the target registers into the thread register array.
+ */
+ rtems_debugger_target_read_regs(thread);
+
+ /*
+ * Debugger threads are stopped for breakpoint, segv or other errors have
+ * the RTEMS_DEBUGGER_THREAD_FLAG_DEBUGGING set.
+ */
+ if (rtems_debugger_thread_flag(thread,
+ RTEMS_DEBUGGER_THREAD_FLAG_DEBUGGING)) {
+ rtems_id* stopped;
+ r = rtems_debugger_block_resize(&threads->stopped);
+ if (r < 0) {
+ rtems_debugger_thread_free(threads);
+ return true;
+ }
+ stopped = rtems_debugger_thread_stopped(threads);
+ stopped[threads->stopped.level++] = id;
+ }
+ else {
+ rtems_status_code sc;
+ sc = rtems_task_suspend(id);
+ if (sc != RTEMS_SUCCESSFUL && sc != RTEMS_ALREADY_SUSPENDED) {
+ rtems_debugger_printf("error: rtems-db: thread: suspend: %08lx: %s\n",
+ id, rtems_status_text(sc));
+ r = -1;
+ }
+ }
+
+ if (rtems_debugger_server_flag(RTEMS_DEBUGGER_FLAG_VERBOSE))
+ rtems_debugger_printf("rtems-db: sys: thd: %08lx: signal: %d\n",
+ id, thread->signal);
+
+ /*
+ * Pick up the first non-zero signal.
+ */
+ if (rtems_debugger->signal == 0) {
+ rtems_debugger->signal = thread->signal;
+ }
+ }
+
+ return false;
+}
+
+int
+rtems_debugger_thread_system_suspend(void)
+{
+ rtems_debugger_threads* threads = rtems_debugger->threads;
+ int r = -1;
+ if (threads != NULL && rtems_debugger_thread_current(threads) != NULL) {
+ if (rtems_debugger_verbose())
+ rtems_debugger_printf("rtems-db: sys: : suspending\n");
+ r = rtems_debugger_target_swbreak_remove();
+ if (r == 0) {
+ rtems_debugger_thread* current;
+ threads->current.level = 0;
+ threads->registers.level = 0;
+ threads->stopped.level = 0;
+ threads->excludes.level = 0;
+ threads->steppers.level = 0;
+ rtems_task_iterate(snapshot_thread, NULL);
+ current = rtems_debugger_thread_current(threads);
+ if (current == NULL) {
+ rtems_debugger_printf("error: rtems-db: thread: snapshot: (%d) %s\n",
+ errno, strerror(errno));
+ r = -1;
+ }
+ else {
+ rtems_id* stopped;
+ /*
+ * If there are no stopped threads pick the first one in the current
+ * table and return that.
+ */
+ threads->selector_gen = 0;
+ threads->selector_cont = 0;
+ stopped = rtems_debugger_thread_stopped(threads);
+ if (threads->stopped.level == 0 && threads->current.level > 0) {
+ stopped[threads->stopped.level++] = current[0].id;
+ }
+ if (threads->stopped.level > 0) {
+ threads->selector_gen =
+ rtems_debugger_thread_find_index(stopped[0]);
+ if (threads->selector_gen < 0)
+ threads->selector_gen = 0;
+ }
+ }
+ }
+ else {
+ errno = EIO;
+ }
+ }
+ return r;
+}
+
+int
+rtems_debugger_thread_system_resume(bool detaching)
+{
+ rtems_debugger_threads* threads = rtems_debugger->threads;
+ rtems_debugger_thread* current;
+ int r = 0;
+ current = rtems_debugger_thread_current(threads);
+ if (threads != NULL && current != NULL) {
+ size_t i;
+ if (rtems_debugger_verbose())
+ rtems_debugger_printf("rtems-db: sys: : resuming\n");
+ if (!detaching)
+ r = rtems_debugger_target_swbreak_insert();
+ if (r == 0) {
+ for (i = 0; i < threads->current.level; ++i) {
+ rtems_debugger_thread* thread = ¤t[i];
+ rtems_status_code sc;
+ int rr;
+ /*
+ * Check if resuming, which is continuing, a step, or stepping a range.
+ */
+ if (detaching ||
+ rtems_debugger_thread_flag(thread,
+ RTEMS_DEBUGGER_THREAD_FLAG_RESUME)) {
+ if (!detaching) {
+ rr = rtems_debugger_target_write_regs(thread);
+ if (rr < 0 && r == 0)
+ r = rr;
+ if (rtems_debugger_thread_flag(thread,
+ RTEMS_DEBUGGER_THREAD_FLAG_STEP_INSTR)) {
+ rr = rtems_debugger_target_thread_stepping(thread);
+ if (rr < 0 && r == 0)
+ r = rr;
+ }
+ }
+ sc = rtems_task_resume(thread->id);
+ if (sc != RTEMS_SUCCESSFUL) {
+ rtems_debugger_printf("error: rtems-db: thread: resume: %08lx: %s\n",
+ thread->id, rtems_status_text(sc));
+ }
+ thread->flags &= ~(RTEMS_DEBUGGER_THREAD_FLAG_CONTINUE |
+ RTEMS_DEBUGGER_THREAD_FLAG_STEP);
+ thread->signal = 0;
+ }
+ }
+ /*
+ * Excludes are not cleared so the exception handler can find the
+ * excluded thread.
+ */
+ threads->current.level = 0;
+ threads->registers.level = 0;
+ threads->stopped.level = 0;
+ }
+ else {
+ r = -1;
+ errno = EIO;
+ }
+ }
+ return r;
+}
+
+int
+rtems_debugger_thread_continue(rtems_debugger_thread* thread)
+{
+ thread->flags |= RTEMS_DEBUGGER_THREAD_FLAG_CONTINUE;
+ return 0;
+}
+
+int
+rtems_debugger_thread_continue_all(void)
+{
+ rtems_debugger_threads* threads = rtems_debugger->threads;
+ rtems_debugger_thread* current;
+ int r = 0;
+ current = rtems_debugger_thread_current(threads);
+ if (threads != NULL && current != NULL) {
+ size_t i;
+ for (i = 0; i < threads->current.level; ++i) {
+ rtems_debugger_thread* thread = ¤t[i];
+ int r;
+ r = rtems_debugger_thread_continue(thread);
+ if (r < 0)
+ break;
+ }
+ }
+ else {
+ r = -1;
+ errno = EIO;
+ }
+ return r;
+}
+
+int
+rtems_debugger_thread_step(rtems_debugger_thread* thread)
+{
+ thread->flags |= RTEMS_DEBUGGER_THREAD_FLAG_STEP;
+ return 0;
+}
+
+int
+rtems_debugger_thread_stepping(rtems_debugger_thread* thread,
+ DB_UINT start,
+ DB_UINT end)
+{
+ /* add lock */
+ rtems_debugger_threads* threads = rtems_debugger->threads;
+ rtems_debugger_thread_stepper* stepper;
+ int r;
+ /*
+ * The resize will automatically extend the block when we are full. The
+ * steppers are cleared in suspend by setting the level to 0.
+ */
+ r = rtems_debugger_block_resize(&threads->steppers);
+ if (r < 0) {
+ rtems_debugger_thread_free(threads);
+ return -1;
+ }
+ stepper = rtems_debugger_thread_steppers(threads);
+ stepper = &stepper[threads->steppers.level];
+ stepper->thread = thread;
+ stepper->start = start;
+ stepper->end = end;
+ threads->steppers.level++;
+ thread->flags |= RTEMS_DEBUGGER_THREAD_FLAG_STEPPING;
+ return 0;
+}
+
+const rtems_debugger_thread_stepper*
+rtems_debugger_thread_is_stepping(rtems_id id, DB_UINT pc)
+{
+ /* add lock */
+ rtems_debugger_threads* threads = rtems_debugger->threads;
+ rtems_debugger_thread_stepper* stepper;
+ size_t i;
+ stepper = rtems_debugger_thread_steppers(threads);
+ for (i = 0; i < threads->steppers.level; ++i, ++stepper) {
+ if (stepper->thread->id == id) {
+ if (pc == stepper->start || (pc > stepper->start && pc < stepper->end))
+ return stepper;
+ break;
+ }
+ }
+ return NULL;
+}
+
+int
+rtems_debugger_thread_current_priority(rtems_debugger_thread* thread)
+{
+ return _Thread_Get_priority(thread->tcb);
+}
+
+int
+rtems_debugger_thread_real_priority(rtems_debugger_thread* thread)
+{
+ return thread->tcb->Real_priority.priority;
+}
+
+int
+rtems_debugger_thread_state(rtems_debugger_thread* thread)
+{
+ return thread->tcb->current_state;
+}
+
+int
+rtems_debugger_thread_state_str(rtems_debugger_thread* thread,
+ char* buffer,
+ size_t size)
+{
+ struct mapper {
+ const char const* label;
+ DB_UINT mask;
+ };
+ const struct mapper map[] = {
+ { "DELAY", STATES_DELAYING },
+ { "DORM", STATES_DORMANT },
+ { "LIFE", STATES_LIFE_IS_CHANGING },
+ { "SUSP", STATES_SUSPENDED },
+ { "Wbar", STATES_WAITING_FOR_BARRIER },
+ { "Wbuf", STATES_WAITING_FOR_BUFFER },
+ { "Wcvar", STATES_WAITING_FOR_CONDITION_VARIABLE },
+ { "Wevnt", STATES_WAITING_FOR_EVENT },
+ { "Wisig", STATES_INTERRUPTIBLE_BY_SIGNAL },
+ { "Wjatx", STATES_WAITING_FOR_JOIN_AT_EXIT },
+ { "Wjoin", STATES_WAITING_FOR_JOIN },
+ { "Wmsg" , STATES_WAITING_FOR_MESSAGE },
+ { "Wmutex", STATES_WAITING_FOR_MUTEX },
+ { "WRATE", STATES_WAITING_FOR_PERIOD },
+ { "Wrpc", STATES_WAITING_FOR_RPC_REPLY },
+ { "Wrwlk", STATES_WAITING_FOR_RWLOCK },
+ { "Wseg", STATES_WAITING_FOR_SEGMENT },
+ { "Wsem", STATES_WAITING_FOR_SEMAPHORE },
+ { "Wsig", STATES_WAITING_FOR_SIGNAL },
+ { "Wslcnd", STATES_WAITING_FOR_SYS_LOCK_CONDITION },
+ { "Wslftx", STATES_WAITING_FOR_SYS_LOCK_FUTEX },
+ { "Wslmtx", STATES_WAITING_FOR_SYS_LOCK_MUTEX },
+ { "Wslsem", STATES_WAITING_FOR_SYS_LOCK_SEMAPHORE },
+ { "Wsysev", STATES_WAITING_FOR_SYSTEM_EVENT },
+ { "Wtime", STATES_WAITING_FOR_TIME },
+ { "Wwkup", STATES_WAITING_FOR_BSD_WAKEUP },
+ { "ZOMBI", STATES_ZOMBIE },
+ };
+ DB_UINT state = thread->tcb->current_state;
+ if (state == STATES_READY) {
+ strcpy(buffer, "READY");
+ }
+ else {
+ char* start = buffer;
+ size_t i;
+ buffer[0] = '\0';
+ buffer[size - 1] = '\0';
+ for (i = 0; size > 0 && i < RTEMS_DEBUGGER_NUMOF(map); ++i) {
+ if ((map[i].mask & state) != 0) {
+ size_t l = snprintf(buffer, size - 1, "%s ", map[i].label);
+ buffer += l;
+ size -= l;
+ }
+ }
+ if (buffer != start)
+ *(buffer - 1) = '\0';
+ }
+ return 0;
+}
+
+unsigned long
+rtems_debugger_thread_stack_size(rtems_debugger_thread* thread)
+{
+ return thread->tcb->Start.Initial_stack.size;
+}
+
+void*
+rtems_debugger_thread_stack_area(rtems_debugger_thread* thread)
+{
+ return thread->tcb->Start.Initial_stack.area;
+}
diff --git a/cpukit/libdebugger/rtems-debugger-threads.h b/cpukit/libdebugger/rtems-debugger-threads.h
new file mode 100644
index 0000000..563b402
--- /dev/null
+++ b/cpukit/libdebugger/rtems-debugger-threads.h
@@ -0,0 +1,272 @@
+/*
+ * Copyright (c) 2016 Chris Johns <chrisj at rtems.org>. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/*
+ * Debugger for RTEMS.
+ */
+
+#ifndef _RTEMS_DEBUGGER_THREADS_h
+#define _RTEMS_DEBUGGER_THREADS_h
+
+#include <rtems/debugger/rtems-debugger-server.h>
+
+#include "rtems-debugger-block.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/**
+ * Debugger thread name size, fixed size. ASCIIZ format.
+ */
+#define RTEMS_DEBUGGER_THREAD_NAME_SIZE (5)
+
+/**
+ * Debugger thread allocation block size.
+ */
+#define RTEMS_DEBUGGER_THREAD_BLOCK_SIZE (32)
+
+/**
+ * Debugger thread flags.
+ */
+#define RTEMS_DEBUGGER_THREAD_FLAG_DEBUGGING (1 << 0)
+#define RTEMS_DEBUGGER_THREAD_FLAG_REG_VALID (1 << 1)
+#define RTEMS_DEBUGGER_THREAD_FLAG_REG_DIRTY (1 << 2)
+#define RTEMS_DEBUGGER_THREAD_FLAG_CONTINUE (1 << 3)
+#define RTEMS_DEBUGGER_THREAD_FLAG_STEP (1 << 4)
+#define RTEMS_DEBUGGER_THREAD_FLAG_STEPPING (1 << 5)
+#define RTEMS_DEBUGGER_THREAD_FLAG_INTS_DISABLED (1 << 6)
+/* Target specific flags for use by the target backend. */
+#define RTEMS_DEBUGGER_THREAD_FLAG_TARGET_BASE (24)
+#define RTEMS_DEBUGGER_THREAD_FLAG_TARGET_MASK (0xff << RTEMS_DEBUGGER_THREAD_FLAG_TARGET_BASE)
+
+/**
+ * Resume this thread.
+ */
+#define RTEMS_DEBUGGER_THREAD_FLAG_RESUME \
+ (RTEMS_DEBUGGER_THREAD_FLAG_CONTINUE | \
+ RTEMS_DEBUGGER_THREAD_FLAG_STEP | \
+ RTEMS_DEBUGGER_THREAD_FLAG_STEPPING)
+
+/**
+ * Step an instruction.
+ */
+#define RTEMS_DEBUGGER_THREAD_FLAG_STEP_INSTR \
+ (RTEMS_DEBUGGER_THREAD_FLAG_STEP | \
+ RTEMS_DEBUGGER_THREAD_FLAG_STEPPING)
+
+/**
+ * Debugger thread.
+ */
+typedef struct rtems_debugger_thread
+{
+ uint32_t flags;
+ const char name[RTEMS_DEBUGGER_THREAD_NAME_SIZE];
+ Thread_Control* tcb;
+ rtems_id id;
+ int cpu;
+ DB_UINT* registers;
+ int signal;
+ void* frame;
+} rtems_debugger_thread;
+
+/**
+ * Debugger stepping thread. This is a thread that steps while inside an
+ * address range.
+ */
+typedef struct rtems_debugger_thread_stepper
+{
+ rtems_debugger_thread* thread;
+ DB_UINT start;
+ DB_UINT end;
+} rtems_debugger_thread_stepper;
+
+/**
+ * Debugger thread control.
+ */
+struct rtems_debugger_threads
+{
+ rtems_debugger_block current; /**< The threads currently available. */
+ rtems_debugger_block registers; /**< The threads that have stopped. */
+ rtems_debugger_block excludes; /**< The threads we cannot touch. */
+ rtems_debugger_block stopped; /**< The threads that have stopped. */
+ rtems_debugger_block steppers; /**< The threads that are stepping. */
+ size_t next; /**< An iterator. */
+ int selector_gen; /**< General thread selector. */
+ int selector_cont; /**< Continue thread selector. */
+};
+
+/**
+ * Create the thread support.
+ */
+extern int rtems_debugger_thread_create(void);
+
+/**
+ * Destroy the thread support.
+ */
+extern int rtems_debugger_thread_destroy(void);
+
+/**
+ * Find the index in the thread table for the ID.
+ */
+extern int rtems_debugger_thread_find_index(rtems_id id);
+
+/**
+ * Suspend the system.
+ */
+extern int rtems_debugger_thread_system_suspend(void);
+
+/**
+ * Resume the system.
+ */
+extern int rtems_debugger_thread_system_resume(bool detaching);
+
+/**
+ * Continue all threads.
+ */
+extern int rtems_debugger_thread_continue_all(void);
+
+/**
+ * Continue a thread.
+ */
+extern int rtems_debugger_thread_continue(rtems_debugger_thread* thread);
+
+/**
+ * Step a thread.
+ */
+extern int rtems_debugger_thread_step(rtems_debugger_thread* thread);
+
+/**
+ * Thread is stepping so record the details.
+ */
+extern int rtems_debugger_thread_stepping(rtems_debugger_thread* thread,
+ DB_UINT start,
+ DB_UINT end);
+
+/**
+ * Thread's PC in the stepping range? Returns the stepper is in range else
+ * NULL.
+ */
+extern const rtems_debugger_thread_stepper*
+rtems_debugger_thread_is_stepping(rtems_id id, DB_UINT pc);
+
+/**
+ * Return the thread's current priority/
+ */
+extern int rtems_debugger_thread_current_priority(rtems_debugger_thread* thread);
+
+/**
+ * Return the thread's real priority.
+ */
+extern int rtems_debugger_thread_real_priority(rtems_debugger_thread* thread);
+
+/**
+ * Return the thread's state.
+ */
+extern int rtems_debugger_thread_state(rtems_debugger_thread* thread);
+
+/**
+ * Return the thread's state.
+ */
+//extern bool rtems_debugger_thread_state_debugger(rtems_debugger_thread* thread);
+
+/**
+ * Return a string of the thread's state.
+ */
+extern int rtems_debugger_thread_state_str(rtems_debugger_thread* thread,
+ char* buffer,
+ size_t size);
+
+/**
+ * Return the thread's stack size.
+ */
+extern unsigned long rtems_debugger_thread_stack_size(rtems_debugger_thread* thread);
+
+/**
+ * Return the thread's stack area address.
+ */
+extern void* rtems_debugger_thread_stack_area(rtems_debugger_thread* thread);
+
+/**
+ * Check a thread's flag and return true if any of the bits in the mask are
+ * set.
+ */
+static inline bool
+rtems_debugger_thread_flag(rtems_debugger_thread* thread,
+ uint32_t mask)
+{
+ return (thread->flags & mask) != 0;
+}
+
+/**
+ * Get the current threads.
+ */
+static inline rtems_debugger_thread*
+rtems_debugger_thread_current(rtems_debugger_threads* threads)
+{
+ return threads->current.block;
+}
+
+/**
+ * Get the registers.
+ */
+static inline DB_UINT*
+rtems_debugger_thread_registers(rtems_debugger_threads* threads)
+{
+ return threads->registers.block;
+}
+
+/**
+ * Get the excludes.
+ */
+static inline rtems_id*
+rtems_debugger_thread_excludes(rtems_debugger_threads* threads)
+{
+ return threads->excludes.block;
+}
+
+/**
+ * Get the stopped.
+ */
+static inline rtems_id*
+rtems_debugger_thread_stopped(rtems_debugger_threads* threads)
+{
+ return threads->stopped.block;
+}
+
+/**
+ * Get the steppers.
+ */
+static inline rtems_debugger_thread_stepper*
+rtems_debugger_thread_steppers(rtems_debugger_threads* threads)
+{
+ return threads->steppers.block;
+}
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif
diff --git a/cpukit/libdebugger/rtems-debugger.h b/cpukit/libdebugger/rtems-debugger.h
new file mode 100644
index 0000000..1fc8b3d
--- /dev/null
+++ b/cpukit/libdebugger/rtems-debugger.h
@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2016 Chris Johns <chrisj at rtems.org>. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/*
+ * Debugger for RTEMS.
+ */
+
+#ifndef _RTEMS_DEBUGGER_h
+#define _RTEMS_DEBUGGER_h
+
+#include <stdbool.h>
+
+#include <rtems.h>
+#include <rtems/printer.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/**
+ * Timeout period for an ack
+ */
+#define RTEMS_DEBUGGER_TIMEOUT (3)
+
+/**
+ * Start the Debugger.
+ */
+extern int rtems_debugger_start(const char* remote,
+ const char* device,
+ int timeout,
+ rtems_task_priority priority,
+ const rtems_printer* printer);
+
+/**
+ * Stop the Debugger.
+ */
+extern int rtems_debugger_stop(void);
+
+/**
+ * Is the Debugger running?.
+ */
+extern bool rtems_debugger_running(void);
+
+/**
+ * Verbose control.
+ */
+extern void rtems_debugger_set_verbose(bool on);
+
+/**
+ * Control remote debug printing.
+ */
+extern int rtems_debugger_remote_debug(bool state);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif
diff --git a/cpukit/preinstall.am b/cpukit/preinstall.am
index 9514390..f4b6529 100644
--- a/cpukit/preinstall.am
+++ b/cpukit/preinstall.am
@@ -233,6 +233,24 @@ $(PROJECT_INCLUDE)/rtems/rtl/rap-shell.h: libdl/rap-shell.h $(PROJECT_INCLUDE)/r
$(INSTALL_DATA) $< $(PROJECT_INCLUDE)/rtems/rtl/rap-shell.h
PREINSTALL_FILES += $(PROJECT_INCLUDE)/rtems/rtl/rap-shell.h
endif
+if LIBDEBUGGER
+$(PROJECT_INCLUDE)/rtems/rtems-debugger.h: libdebugger/rtems-debugger.h $(PROJECT_INCLUDE)/rtems/$(dirstamp)
+ $(INSTALL_DATA) $< $(PROJECT_INCLUDE)/rtems/rtems-debugger.h
+PREINSTALL_FILES += $(PROJECT_INCLUDE)/rtems/rtems-debugger.h
+
+$(PROJECT_INCLUDE)/rtems/debugger/$(dirstamp):
+ @$(MKDIR_P) $(PROJECT_INCLUDE)/rtems/debugger
+ @: > $(PROJECT_INCLUDE)/rtems/debugger/$(dirstamp)
+PREINSTALL_DIRS += $(PROJECT_INCLUDE)/rtems/debugger/$(dirstamp)
+
+$(PROJECT_INCLUDE)/rtems/debugger/rtems-debugger-server.h: libdebugger/rtems-debugger-server.h $(PROJECT_INCLUDE)/rtems/debugger/$(dirstamp)
+ $(INSTALL_DATA) $< $(PROJECT_INCLUDE)/rtems/debugger/rtems-debugger-server.h
+PREINSTALL_FILES += $(PROJECT_INCLUDE)/rtems/debugger/rtems-debugger-server.h
+
+$(PROJECT_INCLUDE)/rtems/debugger/rtems-debugger-remote.h: libdebugger/rtems-debugger-remote.h $(PROJECT_INCLUDE)/rtems/debugger/$(dirstamp)
+ $(INSTALL_DATA) $< $(PROJECT_INCLUDE)/rtems/debugger/rtems-debugger-remote.h
+PREINSTALL_FILES += $(PROJECT_INCLUDE)/rtems/debugger/rtems-debugger-remote.h
+endif
$(PROJECT_INCLUDE)/rtems/bspIo.h: include/rtems/bspIo.h $(PROJECT_INCLUDE)/rtems/$(dirstamp)
$(INSTALL_DATA) $< $(PROJECT_INCLUDE)/rtems/bspIo.h
PREINSTALL_FILES += $(PROJECT_INCLUDE)/rtems/bspIo.h
diff --git a/cpukit/wrapup/Makefile.am b/cpukit/wrapup/Makefile.am
index 768a903..47ffd24 100644
--- a/cpukit/wrapup/Makefile.am
+++ b/cpukit/wrapup/Makefile.am
@@ -95,6 +95,10 @@ if LIBDL
TMP_LIBS += ../libdl/libdl.a
endif
+if LIBDEBUGGER
+TMP_LIBS += ../libdebugger/libdebugger.a
+endif
+
librtemscpu.a: $(TMP_LIBS)
rm -f $@
$(MKDIR_P) $(ARCH)
diff --git a/testsuites/libtests/Makefile.am b/testsuites/libtests/Makefile.am
index c00916a..9ff4394 100644
--- a/testsuites/libtests/Makefile.am
+++ b/testsuites/libtests/Makefile.am
@@ -53,5 +53,9 @@ _SUBDIRS += dl04 dl05
endif
endif
+if DEBUGGERTESTS
+_SUBDIRS += debugger01
+endif
+
include $(top_srcdir)/../automake/test-subdirs.am
include $(top_srcdir)/../automake/local.am
diff --git a/testsuites/libtests/configure.ac b/testsuites/libtests/configure.ac
index 430c509..8e74b3e 100644
--- a/testsuites/libtests/configure.ac
+++ b/testsuites/libtests/configure.ac
@@ -80,6 +80,17 @@ AS_IF([test x"$TEST_LIBDL" = x"yes"],[
AM_CONDITIONAL(DLTESTS,[test x"$TEST_LIBDL" = x"yes"])
+# Must match the list in cpukit.
+AC_MSG_CHECKING([whether CPU supports libdebugger])
+case $RTEMS_CPU in
+ arm | i386)
+ TEST_LIBDEBUGGER=yes ;;
+ *)
+ TEST_LIBDEBUGGER=no ;;
+esac
+AC_MSG_RESULT([$TEST_LIBDEBUGGER])
+AM_CONDITIONAL(DEBUGGERTESTS,[test x"$TEST_LIBDEBUGGER" = x"yes"])
+
# Explicitly list all Makefiles here
AC_CONFIG_FILES([Makefile
networking01/Makefile
@@ -169,5 +180,6 @@ math/Makefile
mathf/Makefile
mathl/Makefile
complex/Makefile
+debugger01/Makefile
])
AC_OUTPUT
diff --git a/testsuites/libtests/debugger01/Makefile.am b/testsuites/libtests/debugger01/Makefile.am
new file mode 100644
index 0000000..d0bf0f8
--- /dev/null
+++ b/testsuites/libtests/debugger01/Makefile.am
@@ -0,0 +1,21 @@
+
+rtems_tests_PROGRAMS = debugger01
+debugger01_SOURCES = init.c remote.c system.h
+
+dist_rtems_tests_DATA = debugger01.scn
+
+include $(RTEMS_ROOT)/make/custom/@RTEMS_BSP at .cfg
+include $(top_srcdir)/../automake/compile.am
+include $(top_srcdir)/../automake/leaf.am
+
+
+AM_CPPFLAGS += -I$(top_srcdir)/../support/include
+
+LINK_OBJS = $(debugger01_OBJECTS)
+LINK_LIBS = $(debugger01_LDLIBS)
+
+debugger01$(EXEEXT): $(debugger01_OBJECTS) $(debugger01_DEPENDENCIES)
+ @rm -f debugger01$(EXEEXT)
+ $(make-exe)
+
+include $(top_srcdir)/../automake/local.am
diff --git a/testsuites/libtests/debugger01/debugger01.doc b/testsuites/libtests/debugger01/debugger01.doc
new file mode 100644
index 0000000..2cdd48b
--- /dev/null
+++ b/testsuites/libtests/debugger01/debugger01.doc
@@ -0,0 +1,18 @@
+# Copyright (c) 2016 Chris Johns <chrisj at rtems.org>
+#
+# The license and distribution terms for this file may be
+# found in the file LICENSE in this distribution or at
+# http://www.rtems.org/license/LICENSE.
+#
+
+This file describes the directives and concepts tested by this test set.
+
+test set name: debugger01
+
+directives:
+
+ rtems_debugger_start
+
+concepts:
+
++ Starts a debugging session with the test remote backend.
diff --git a/testsuites/libtests/debugger01/debugger01.scn b/testsuites/libtests/debugger01/debugger01.scn
new file mode 100644
index 0000000..6db1679
--- /dev/null
+++ b/testsuites/libtests/debugger01/debugger01.scn
@@ -0,0 +1,188 @@
+
+*** BEGIN OF TEST DEBUGGER01 ***
+error: rtems-db: remote not found: test
+error: rtems-db: test remote: begin
+rtems-db: remote-debug is on
+rtems-db: remote running
+rtems-db: test remote: isconnected: not-connected
+error: rtems-db: test remote: connect
+rtems-db: remote running
+rtems-db: arm debug: (v3.0) ARMv7 [v7, all CP14 registers] breakpoints:5
+watchpoints:3
+rtems-db: sys: : suspending
+rtems-db: sys: thd: 0a010001: signal: 0
+rtems-db: test remote: isconnected: connected
+ remote: rx: message=0 length=1
+ remote: rx: +
+rtems-db: get: 1: + [[ACK?]]
+ remote: rx: message=1 length=5
+ remote: rx: xxxxx
+ remote: rx: message=2 length=5
+ remote: rx: $x#aa
+rtems-db: get: 5: xxxxx [[junk dropped]]
+rtems-db: get: : $x#aa [[invalid checksum]]
+rtems-db: put: 1: -
+ remote: tx: message=0 length=1
+ remote: tx: -
+ remote: rx: message=3 length=141
+ remote: rx: $qSupported:multiprocess+;swbreak+;hwbreak+;qRelocInsn+;fork-events+;vfork-events+;exec-events+;vContSupported+;QThreadEvents+;no-resumed+#df
+rtems-db: get: 141: [[junk dropped]]
+rtems-db: get: : $qSupported:multiprocess+;swbreak+;hwbreak+;qRelocInsn+;fork-events+;vfork-events+;exec-events+;vContSupported+;QThreadEvents+;no-resumed+#df
+rtems-db: put: 1: +
+ remote: tx: message=1 length=1
+ remote: tx: +
+rtems-db: put: 167: $qSupported:PacketSize=4096;QNonStop-;multiprocess+;swbreak+;hwbreak-;qRelocInsn-;fork-events-;vfork-events-;exec-events-;vContSupported+;QThreadEvents-;no-resumed+#b3
+ remote: tx: message=2 length=167
+ remote: tx: $qSupported:PacketSize=4096;QNonStop-;multiprocess+;swbreak+;hwbreak-;qRelocInsn-;fork-events-;vfork-events-;exec-events-;vContSupported+;QThreadEvents-;no-resumed+#b3
+rtems-db: test remote: isconnected: connected
+ remote: rx: message=4 length=19
+ remote: rx: $vMustReplyEmpty#3a
+rtems-db: get: 19: $vMustReplyEmpty#3a
+rtems-db: put: 1: +
+ remote: tx: message=3 length=1
+ remote: tx: +
+rtems-db: put: 4: $#00
+ remote: tx: message=4 length=4
+ remote: tx: $#00
+rtems-db: test remote: isconnected: connected
+ remote: rx: message=5 length=1
+ remote: rx: +
+rtems-db: get: 1: + [[ACK]]
+ remote: rx: message=6 length=10
+ remote: rx: $Hgp0.0#ad
+rtems-db: get: 10: $Hgp0.0#ad
+rtems-db: put: 1: +
+ remote: tx: message=5 length=1
+ remote: tx: +
+rtems-db: put: 6: $OK#9a
+ remote: tx: message=6 length=6
+ remote: tx: $OK#9a
+rtems-db: test remote: isconnected: connected
+ remote: rx: message=7 length=1
+ remote: rx: +
+rtems-db: get: 1: + [[ACK]]
+ remote: rx: message=8 length=12
+ remote: rx: $qTStatus#49
+rtems-db: get: 12: $qTStatus#49
+rtems-db: put: 1: +
+ remote: tx: message=7 length=1
+ remote: tx: +
+rtems-db: put: 4: $#00
+ remote: tx: message=8 length=4
+ remote: tx: $#00
+rtems-db: test remote: isconnected: connected
+ remote: rx: message=9 length=1
+ remote: rx: +
+rtems-db: get: 1: + [[ACK]]
+ remote: rx: message=10 length=5
+ remote: rx: $?#3f
+rtems-db: get: 5: $?#3f
+rtems-db: put: 1: +
+ remote: tx: message=9 length=1
+ remote: tx: +
+rtems-db: put: 26: $T00thread:p1.0a010001;#23
+ remote: tx: message=10 length=26
+ remote: tx: $T00thread:p1.0a010001;#23
+rtems-db: test remote: isconnected: connected
+ remote: rx: message=11 length=1
+ remote: rx: +
+rtems-db: get: 1: + [[ACK]]
+ remote: rx: message=12 length=16
+ remote: rx: $qfThreadInfo#bb
+rtems-db: get: 16: $qfThreadInfo#bb
+rtems-db: put: 1: +
+ remote: tx: message=11 length=1
+ remote: tx: +
+rtems-db: put: 16: $mp1.0a010001#ef
+ remote: tx: message=12 length=2
+ remote: tx: $mp1.0a010001#ef
+rtems-db: test remote: isconnected: connected
+ remote: rx: message=13 length=1
+ remote: rx: +
+rtems-db: get: 1: + [[ACK]]
+ remote: rx: message=14 length=16
+ remote: rx: $qsThreadInfo#c8
+rtems-db: get: 16: $qsThreadInfo#c8
+rtems-db: put: 1: +
+ remote: tx: message=13 length=1
+ remote: tx: +
+rtems-db: put: 5: $l#6c
+ remote: tx: message=14 length=5
+ remote: tx: $l#6c
+rtems-db: test remote: isconnected: connected
+ remote: rx: message=15 length=1
+ remote: rx: -
+rtems-db: get: 1: - [[NACK]]
+rtems-db: put: 5: $l#6c
+ remote: tx: message=15 length=5
+ remote: tx: $l#6c
+ remote: rx: message=16 length=1
+ remote: rx: +
+rtems-db: get: 1: + [[ACK]]
+ remote: rx: message=17 length=15
+ remote: rx: $qAttached:1#fa
+rtems-db: get: 15: $qAttached:1#fa
+rtems-db: put: 1: +
+ remote: tx: message=16 length=1
+ remote: tx: +
+rtems-db: put: 5: $1#31
+ remote: tx: message=17 length=5
+ remote: tx: $1#31
+rtems-db: test remote: isconnected: connected
+ remote: rx: message=18 length=1
+ remote: rx: +
+rtems-db: get: 1: + [[ACK]]
+ remote: rx: message=19 length=8
+ remote: rx: $Hc-1#09
+rtems-db: get: 8: $Hc-1#09
+rtems-db: put: 1: +
+ remote: tx: message=18 length=1
+ remote: tx: +
+rtems-db: put: 6: $OK#9a
+ remote: tx: message=19 length=6
+ remote: tx: $OK#9a
+rtems-db: test remote: isconnected: connected
+ remote: rx: message=20 length=1
+ remote: rx: +
+rtems-db: get: 1: + [[ACK]]
+ remote: rx: message=21 length=12
+ remote: rx: $qOffsets#4b
+rtems-db: get: 12: $qOffsets#4b
+rtems-db: put: 1: +
+ remote: tx: message=20 length=1
+ remote: tx: +
+rtems-db: put: 4: $#00
+ remote: tx: message=21 length=4
+ remote: tx: $#00
+rtems-db: test remote: isconnected: connected
+ remote: rx: message=22 length=1
+ remote: rx: +
+rtems-db: get: 1: + [[ACK]]
+ remote: rx: message=23 length=6
+ remote: rx: $g#67+
+rtems-db: get: 6: $g#67
+rtems-db: put: 1: +
+ remote: tx: message=22 length=1
+ remote: tx: +
++ [[extra data: 0x2b]]rtems-db: put: 212: $cc381200cc381200cc381200cc3812004c162000a83f2000704520004c16200040362000481620000000000020ee1100cc38120028a2200089dc100089dc1000cc381200cc381200cc381200cc381200cc381200cc381200cc381200cc381200cc381200cc381200#95
+ remote: tx: message=23 length=2
+ remote: tx: $cc381200cc381200cc381200cc3812004c162000a83f2000704520004c16200040362000481620000000000020ee1100cc38120028a2200089dc100089dc1000cc381200cc381200cc381200cc381200cc381200cc381200cc381200cc381200cc381200cc381200#95
+rtems-db: test remote: isconnected: connected
+ remote: rx: message=24 length=7
+ remote: rx: $D;1#b0
+rtems-db: get: 7: $D;1#b0
+rtems-db: put: 1: +
+ remote: tx: message=24 length=1
+ remote: tx: +
+rtems-db: put: 6: $OK#9a
+ remote: tx: message=25 length=6
+ remote: tx: $OK#9a
+rtems-db: test remote: isconnected: connected
+rtems-db: test remote: disconnect host
+rtems-db: test remote: isconnected: not-connected
+rtems-db: events running
+rtems-db: events finishing
+rtems-db: sys: : resuming
+rtems-db: test remote: isconnected: not-connected
+rtems-db: test remote: isconnected: not-connected
+*** END OF TEST DEBUGGER01 ***
diff --git a/testsuites/libtests/debugger01/init.c b/testsuites/libtests/debugger01/init.c
new file mode 100644
index 0000000..e243d42
--- /dev/null
+++ b/testsuites/libtests/debugger01/init.c
@@ -0,0 +1,53 @@
+/*
+ * Debugger test.
+ *
+ * Copyright (c) 2016 Chris Johns (chrisj at rtems.org)
+ *
+ * The license and distribution terms for this file may be
+ * found in the file LICENSE in this distribution or at
+ * http://www.rtems.org/license/LICENSE.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#define CONFIGURE_INIT
+#include "system.h"
+
+#include "tmacros.h"
+
+#include <rtems/rtems-debugger.h>
+
+#include "system.h"
+
+static void test(void)
+{
+ rtems_printer printer;
+
+ rtems_print_printer_fprintf(&printer, stdout);
+ rtems_test_assert(rtems_debugger_start("test", "something",
+ 3, 10, &printer) < 0);
+ rtems_test_assert(rtems_debugger_register_test_remote() == 0);
+ rtems_test_assert(rtems_debugger_start("test", "something",
+ 3, 10, &printer) == 0);
+ rtems_debugger_set_verbose(true);
+ rtems_test_assert(rtems_debugger_remote_debug(true) == 0);
+
+ /*
+ * This thread is suspended when the debugger is active until the debugger
+ * disconnects.
+ */
+ sleep(1);
+}
+
+const char rtems_test_name[] = "DEBUGGER01";
+
+rtems_task Init(rtems_task_argument argument)
+{
+ TEST_BEGIN();
+
+ test();
+
+ TEST_END();
+}
diff --git a/testsuites/libtests/debugger01/remote.c b/testsuites/libtests/debugger01/remote.c
new file mode 100644
index 0000000..1c8c4d0
--- /dev/null
+++ b/testsuites/libtests/debugger01/remote.c
@@ -0,0 +1,321 @@
+/*
+ * Debugger test remote.
+ *
+ * Copyright (c) 2016 Chris Johns (chrisj at rtems.org)
+ *
+ * The license and distribution terms for this file may be
+ * found in the file LICENSE in this distribution or at
+ * http://www.rtems.org/license/LICENSE.
+ */
+
+#ifdef HAVE_CONFIG_H
+ #include "config.h"
+#endif
+
+#include "tmacros.h"
+
+#include <errno.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include <rtems/rtems-debugger.h>
+#include <rtems/debugger/rtems-debugger-server.h>
+#include <rtems/debugger/rtems-debugger-remote.h>
+
+#include "system.h"
+
+/**
+ * Remote data.
+ */
+typedef struct
+{
+ int connect_count;
+ bool connected;
+ size_t out;
+ size_t in;
+} rtems_debugger_remote_test;
+
+static const char* out[] =
+{
+ "+",
+ "xxxxx",
+ "$x#aa",
+
+ "$qSupported:multiprocess+;swbreak+;hwbreak+;qRelocInsn+;fork-events+;"
+ "vfork-events+;exec-events+;vContSupported+;QThreadEvents+;no-resumed+#df",
+
+ "$vMustReplyEmpty#3a",
+ "+",
+
+ "$Hgp0.0#ad",
+ "+",
+
+ "$qTStatus#49",
+ "+",
+
+ "$?#3f",
+ "+",
+
+ "$qfThreadInfo#bb",
+ "+",
+
+ "$qsThreadInfo#c8",
+ "-",
+ "+",
+
+ "$qAttached:1#fa",
+ "+",
+
+ "$Hc-1#09",
+ "+",
+
+ "$qOffsets#4b",
+ "+",
+
+ "$g#67"
+ "+",
+
+ "$D;1#b0",
+ "+"
+};
+
+static const char* in[] =
+{
+ /* 0 */
+ "-",
+
+ /* 1 */
+ "+",
+ "$qSupported:PacketSize=4096;QNonStop-;multiprocess+;swbreak+;hwbreak-;"
+ "qRelocInsn-;fork-events-;vfork-events-;exec-events-;vContSupported+;"
+ "QThreadEvents-;no-resumed+#b3",
+
+ /* 3 */
+ "+",
+ "$#00",
+
+ /* 5 */
+ "+",
+ "$OK#9a",
+
+ /* 7 */
+ "+",
+ "$#00",
+
+ /* 9 */
+ "+",
+ "$T00thread:p1.0a010001;#23",
+
+ /* 11 */
+ "+",
+ "**",
+
+ /* 13 */
+ "+",
+ "$l#6c",
+ "$l#6c",
+
+ /* 16 */
+ "+",
+ "$1#31",
+
+ /* 18 */
+ "+",
+ "$OK#9a",
+
+ /* 20 */
+ "+",
+ "$#00",
+
+ /* 22 */
+ "+",
+ "**",
+
+ "+",
+ "$OK#9a"
+};
+
+static int
+test_remote_begin(rtems_debugger_remote* remote, const char* device)
+{
+ rtems_debugger_remote_test* test;
+
+ rtems_debugger_printf("error: rtems-db: test remote: begin\n");
+
+ rtems_debugger_lock();
+
+ /*
+ * Check the device.
+ */
+ rtems_test_assert(strcmp(device, "something") == 0);
+
+ test = malloc(sizeof(rtems_debugger_remote_test));
+ rtems_test_assert(test != NULL);
+
+ remote->data = test;
+
+ test->connect_count = 0;
+ test->connected = false;
+ test->out = 0;
+ test->in = 0;
+
+ rtems_debugger_unlock();
+
+ return 0;
+}
+
+static int
+test_remote_end(rtems_debugger_remote* remote)
+{
+ rtems_debugger_remote_test* test;
+
+ rtems_debugger_printf("error: rtems-db: test remote: end\n");
+
+ rtems_debugger_lock();
+
+ rtems_test_assert(remote != NULL);
+ rtems_test_assert(remote->data != NULL);
+ test = (rtems_debugger_remote_test*) remote->data;
+
+ test->connected = false;
+
+ free(test);
+
+ rtems_debugger_unlock();
+
+ return 0;
+}
+
+static int
+test_remote_connect(rtems_debugger_remote* remote)
+{
+ rtems_debugger_remote_test* test;
+
+ rtems_test_assert(remote != NULL);
+ rtems_test_assert(remote->data != NULL);
+ test = (rtems_debugger_remote_test*) remote->data;
+
+ if (test->connect_count > 0) {
+ rtems_event_set out = 0;
+ rtems_test_assert(rtems_event_receive(RTEMS_EVENT_1,
+ RTEMS_EVENT_ALL | RTEMS_WAIT,
+ RTEMS_NO_TIMEOUT,
+ &out) == RTEMS_SUCCESSFUL);
+ }
+
+ rtems_debugger_printf("error: rtems-db: test remote: connect\n");
+
+ ++test->connect_count;
+ test->connected = true;
+ test->out = 0;
+ test->in = 0;
+
+ return 0;
+}
+
+static int
+test_remote_disconnect(rtems_debugger_remote* remote)
+{
+ rtems_debugger_remote_test* test;
+
+ rtems_test_assert(remote != NULL);
+ rtems_test_assert(remote->data != NULL);
+ test = (rtems_debugger_remote_test*) remote->data;
+
+ rtems_debugger_printf("rtems-db: test remote: disconnect host\n");
+
+ rtems_debugger_lock();
+
+ rtems_test_assert(test->connected == true);
+
+ test->connected = false;
+
+ rtems_debugger_unlock();
+
+ return 0;
+}
+
+static bool
+test_remote_isconnected(rtems_debugger_remote* remote)
+{
+ rtems_debugger_remote_test* test;
+ bool isconnected;
+ rtems_test_assert(remote != NULL);
+ rtems_test_assert(remote->data != NULL);
+ test = (rtems_debugger_remote_test*) remote->data;
+ isconnected = test != NULL && test->connected;
+ rtems_debugger_printf("rtems-db: test remote: isconnected: %s\n",
+ isconnected ? "connected" : "not-connected");
+ return isconnected;
+}
+
+static void
+test_remote_print(const char* label, const char* buf, size_t size)
+{
+ printf(" remote: %s: ", label);
+ while (size-- > 0) {
+ printf("%c", *buf++);
+ }
+ printf("\n");
+}
+
+static ssize_t
+test_remote_receive(rtems_debugger_remote* remote,
+ void* buf,
+ size_t nbytes)
+{
+ rtems_debugger_remote_test* test;
+ size_t len;
+ rtems_test_assert(remote != NULL);
+ rtems_test_assert(remote->data != NULL);
+ test = (rtems_debugger_remote_test*) remote->data;
+ rtems_test_assert(test->out < RTEMS_DEBUGGER_NUMOF(out));
+ len = strlen(out[test->out]);
+ printf(" remote: rx: message=%zu length=%zu\n", test->out, len);
+ test_remote_print("rx", out[test->out], len);
+ rtems_test_assert(len < nbytes);
+ memcpy(buf, out[test->out++], len);
+ return len;
+}
+
+static ssize_t
+test_remote_send(rtems_debugger_remote* remote,
+ const void* buf,
+ size_t nbytes)
+{
+ rtems_debugger_remote_test* test;
+ size_t len;
+ bool no_match;
+ rtems_test_assert(remote != NULL);
+ rtems_test_assert(remote->data != NULL);
+ test = (rtems_debugger_remote_test*) remote->data;
+ rtems_test_assert(test->in < RTEMS_DEBUGGER_NUMOF(in));
+ len = strlen(in[test->in]);
+ no_match = len == 2 && strcmp(in[test->in], "**") == 0;
+ printf(" remote: tx: message=%zu length=%zu\n", test->in, len);
+ if (!no_match)
+ rtems_test_assert(len == nbytes);
+ test_remote_print("tx", buf, nbytes);
+ if (!no_match)
+ rtems_test_assert(memcmp(buf, in[test->in], nbytes) == 0);
+ test->in++;
+ return nbytes;
+}
+
+static rtems_debugger_remote remote_test =
+{
+ .name = "test",
+ .begin = test_remote_begin,
+ .end = test_remote_end,
+ .connect = test_remote_connect,
+ .disconnect = test_remote_disconnect,
+ .isconnected = test_remote_isconnected,
+ .read = test_remote_receive,
+ .write = test_remote_send
+};
+
+int
+rtems_debugger_register_test_remote(void)
+{
+ return rtems_debugger_remote_register(&remote_test);
+}
diff --git a/testsuites/libtests/debugger01/system.h b/testsuites/libtests/debugger01/system.h
new file mode 100644
index 0000000..c38283c
--- /dev/null
+++ b/testsuites/libtests/debugger01/system.h
@@ -0,0 +1,37 @@
+/* system.h
+ *
+ * This include file contains information that is included in every
+ * function in the test set.
+ *
+ * COPYRIGHT (c) 1989-1999.
+ * On-Line Applications Research Corporation (OAR).
+ *
+ * The license and distribution terms for this file may be
+ * found in the file LICENSE in this distribution or at
+ * http://www.rtems.org/license/LICENSE.
+ */
+
+#include <bsp.h>
+#include <tmacros.h>
+
+/* functions */
+
+rtems_task Init(rtems_task_argument argument);
+
+int rtems_debugger_register_test_remote(void);
+void test_wake(void);
+
+/* configuration information */
+
+#define CONFIGURE_APPLICATION_NEEDS_CONSOLE_DRIVER
+#define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER
+
+#define CONFIGURE_MAXIMUM_USER_EXTENSIONS 1
+#define CONFIGURE_MAXIMUM_TASKS 10
+#define CONFIGURE_MAXIMUM_SEMAPHORES 10
+
+#define CONFIGURE_RTEMS_INIT_TASKS_TABLE
+
+#include <rtems/confdefs.h>
+
+/* end of include file */
diff --git a/testsuites/libtests/debugger01/tasks.c b/testsuites/libtests/debugger01/tasks.c
new file mode 100644
index 0000000..969d816
--- /dev/null
+++ b/testsuites/libtests/debugger01/tasks.c
@@ -0,0 +1,104 @@
+/* Task_1
+ *
+ * This test serves as a test task. It verifies timeslicing activities
+ * and tswitch extension processing.
+ *
+ * Input parameters:
+ * argument - task argument
+ *
+ * Output parameters: NONE
+ *
+ * COPYRIGHT (c) 1989-1999.
+ * On-Line Applications Research Corporation (OAR).
+ *
+ * The license and distribution terms for this file may be
+ * found in the file LICENSE in this distribution or at
+ * http://www.rtems.org/license/LICENSE.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "system.h"
+
+rtems_task Task_1(
+ rtems_task_argument argument
+)
+{
+ uint32_t seconds;
+ uint32_t old_seconds;
+ rtems_mode previous_mode;
+ rtems_time_of_day time;
+ rtems_status_code status;
+ uint32_t start_time;
+ uint32_t end_time;
+
+ puts( "TA1 - rtems_task_suspend - on Task 2" );
+ status = rtems_task_suspend( Task_id[ 2 ] );
+ directive_failed( status, "rtems_task_suspend of TA2" );
+
+ puts( "TA1 - rtems_task_suspend - on Task 3" );
+ status = rtems_task_suspend( Task_id[ 3 ] );
+ directive_failed( status, "rtems_task_suspend of TA3" );
+
+ status = rtems_clock_get_seconds_since_epoch( &start_time );
+ directive_failed( status, "rtems_clock_get_seconds_since_epoch" );
+
+ puts( "TA1 - killing time" );
+
+ for ( ; ; ) {
+ status = rtems_clock_get_seconds_since_epoch( &end_time );
+ directive_failed( status, "rtems_clock_get_seconds_since_epoch" );
+
+ if ( end_time > (start_time + 2) )
+ break;
+ }
+
+ puts( "TA1 - rtems_task_resume - on Task 2" );
+ status = rtems_task_resume( Task_id[ 2 ] );
+ directive_failed( status, "rtems_task_resume of TA2" );
+
+ puts( "TA1 - rtems_task_resume - on Task 3" );
+ status = rtems_task_resume( Task_id[ 3 ] );
+ directive_failed( status, "rtems_task_resume of TA3" );
+
+ while ( FOREVER ) {
+ if ( Run_count[ 1 ] == 3 ) {
+ puts( "TA1 - rtems_task_mode - change mode to NO RTEMS_PREEMPT" );
+
+ status = rtems_task_mode(
+ RTEMS_NO_PREEMPT,
+ RTEMS_PREEMPT_MASK,
+ &previous_mode
+ );
+ directive_failed( status, "rtems_task_mode" );
+
+ status = rtems_clock_get_tod( &time );
+ directive_failed( status, "rtems_clock_get_tod" );
+
+ old_seconds = time.second;
+
+ for ( seconds = 0 ; seconds < 6 ; ) {
+ status = rtems_clock_get_tod( &time );
+ directive_failed( status, "rtems_clock_get_tod" );
+
+ if ( time.second != old_seconds ) {
+ old_seconds = time.second;
+ seconds++;
+ print_time( "TA1 - ", &time, "\n" );
+ }
+ }
+
+ puts( "TA1 - rtems_task_mode - change mode to RTEMS_PREEMPT" );
+ status = rtems_task_mode(
+ RTEMS_PREEMPT,
+ RTEMS_PREEMPT_MASK,
+ &previous_mode
+ );
+ directive_failed( status, "rtems_task_mode" );
+
+ while ( FOREVER );
+ }
+ }
+}
--
2.9.0
More information about the devel
mailing list