interesting
/
riscv-openocd
mirror of https://github.com/riscv/riscv-openocd.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
riscv-openocd/src/rtos/eCos.c

1225 lines
45 KiB
C
Raw Blame History

// SPDX-License-Identifier: GPL-2.0-or-later
/***************************************************************************
***************************************************************************/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <helper/time_support.h>
#include <jtag/jtag.h>
#include "target/target.h"
#include "target/armv7m.h"
#include "rtos.h"
#include "helper/log.h"
#include "helper/types.h"
#include "helper/bits.h"
#include "rtos_standard_stackings.h"
#include "rtos_ecos_stackings.h"
#include "server/gdb_server.h"
/* Unfortunately for the moment we are limited to returning the hardwired
* register count (ARMV7M_NUM_CORE_REGS for Cortex-M) since the openocd RTOS
* support does not yet support accessing all per-thread "stacked"
* registers. e.g. For Cortex-M under eCos we have a per-thread BASEPRI, and for
* all eCos targets we may have per-thread VFP/FPU register state.
*
* So, for the moment, we continue to use the hardwired limit for the depth of
* the returned register description vector. The current openocd
* rtos_standard_stackings.c just provides the main core regs for the Cortex_M*
* targets regardless of whether FPU is present/enabled.
*
* However, this code is written with the expectation that we may eventually be
* able to provide more register information ("m-system" and "vfp" for example)
* and also with the expectation of supporting different register sets being
* returned depending on the per-thread Cortex-M eCos contex_m for
* example. Hence the fact that the eCos_stack_layout_*() functions below allow
* for the stack context descriptor vector to be returned by those calls
* allowing for eventual support where this code will potentially cache
* different sets of register descriptors for the different shapes of contexts
* in a *single* application/binary run-time.
*
* TODO: Extend openocd generic RTOS support to allow thread-specific system and
* FPU register state to be returned. */
struct ecos_params;
static bool ecos_detect_rtos(struct target *target);
static int ecos_create(struct target *target);
static int ecos_update_threads(struct rtos *rtos);
static int ecos_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, struct rtos_reg **reg_list, int *num_regs);
static int ecos_get_symbol_list_to_lookup(struct symbol_table_elem *symbol_list[]);
static int ecos_stack_layout_cortexm(struct rtos *rtos, struct ecos_params *param,
int64_t stack_ptr, const struct rtos_register_stacking **si);
static int ecos_stack_layout_arm(struct rtos *rtos, struct ecos_params *param,
int64_t stack_ptr, const struct rtos_register_stacking **si);
/* The current eCos thread IDentifier uses 0 as an unused (not a valid thread
* ID) value. Currently the unique_id field is 16-bits, but the eCos SMP support
* convention is that only 12-bits of the ID will be used. This
* ECOS_MAX_THREAD_COUNT manifest is provided to limit the potential for
* interpreting stale/inconsistent thread list state when the debug host scans
* the thread list before the target RTOS has completed its initialisation. This
* support will need to revisited when eCos is re-engineered to support more
* than 16 CPU SMP setups. */
#define ECOS_MAX_THREAD_COUNT (4095)
struct ecos_thread_state {
int value;
const char *desc;
};
/* The status is actually a logical-OR bitmask of states: */
enum ecos_thread_state_flags {
RUNNING = 0, /* explicit no-bits-set value */
SLEEPING = BIT(0),
COUNTSLEEP = BIT(1),
SUSPENDED = BIT(2),
CREATING = BIT(3),
EXITED = BIT(4),
SLEEPSET = (SLEEPING | COUNTSLEEP)
};
/* Cyg_Thread:: reason codes for wake and sleep fields: */
static const struct ecos_thread_state ecos_thread_reasons[] = {
{ 0, "NONE" }, /* normally indicates "not yet started" */
{ 1, "WAIT" }, /* wait with no timeout */
{ 2, "DELAY" }, /* simple time delay */
{ 3, "TIMEOUT" }, /* wait with timeout *or* timeout expired */
{ 4, "BREAK" }, /* forced break out of sleep */
{ 5, "DESTRUCT" }, /* wait on object being destroyed */
{ 6, "EXIT" }, /* forced termination */
{ 7, "DONE" } /* wait/delay completed */
};
static const char * const target_cortex_m[] = {
"cortex_m",
"hla_target",
NULL
};
static const char * const target_arm[] = {
"cortex_a",
"arm7tdmi",
"arm720t",
"arm9tdmi",
"arm920t",
"arm926ejs",
"arm946e",
"arm966e",
"arm11",
NULL
};
/* Since individual eCos application configurations may have different thread
* object structure layouts depending on the actual build-time enabled features
* we provide support for applications built containing the relevant symbolic
* support to match the actual application binary being debugged, rather than
* relying on a set of default/fixed (and potentially incorrect)
* offsets. However, for backwards compatibility, we do *NOT* enforce the
* requirement for the common extra helper symbols to be present to allow the
* fallback to the simple fixed CM3 model to avoid affecting existing users of
* older eCos worlds. Similarly we need to provide support for per-thread
* register context offsets, as well as for per-application-configurations,
* since some targets can have different stacked state on a per-thread basis
* (e.g. "cortex_m"). This is why the stacking_info is now set at run-time
* rather than being fixed. */
struct ecos_params {
const char * const *target_names; /* NULL terminated list of targets */
int (*target_stack_layout)(struct rtos *rtos, struct ecos_params *param,
int64_t stack_ptr, const struct rtos_register_stacking **si);
bool flush_common;
unsigned char pointer_width;
unsigned char uid_width;
unsigned char state_width;
unsigned int thread_stack_offset;
unsigned int thread_name_offset;
unsigned int thread_state_offset;
unsigned int thread_next_offset;
unsigned int thread_uniqueid_offset;
const struct rtos_register_stacking *stacking_info;
};
/* As mentioned above we provide default offset values for the "cortex_m"
* targets for backwards compatibility with older eCos application builds and
* previous users of this RTOS specific support that do not have the
* configuration specific offsets provided in the symbol table. The support for
* other targets (e.g. "cortex_a") we do expect the application to provide the
* required symbolic information. We do not populate the stacking_info reference
* until we have had a chance to interrogate the symbol table. */
static struct ecos_params ecos_params_list[] = {
{
.target_names = target_cortex_m,
.pointer_width = 4,
.uid_width = 2,
.state_width = 4,
.thread_stack_offset = 0x0c,
.thread_name_offset = 0x9c,
.thread_state_offset = 0x3c,
.thread_next_offset = 0xa0,
.thread_uniqueid_offset = 0x4c,
.target_stack_layout = ecos_stack_layout_cortexm,
.stacking_info = NULL
},
{
.target_names = target_arm,
.pointer_width = 0,
.uid_width = 0,
.state_width = 0,
.thread_stack_offset = 0,
.thread_name_offset = 0,
.thread_state_offset = 0,
.thread_next_offset = 0,
.thread_uniqueid_offset = 0,
.target_stack_layout = ecos_stack_layout_arm,
.stacking_info = NULL
}
};
#define ECOS_NUM_PARAMS ARRAY_SIZE(ecos_params_list)
/* To eventually allow for more than just the ARMV7M_NUM_CORE_REGS to be
* returned by the Cortex-M support, and to avoid run-time lookups we manually
* maintain our own mapping for the supplied stack register vector entries. This
* enum needs to match the rtos_ecos_regoff_cortexm[] vector. Admittedly the
* initial indices just match the corresponding ARMV7M_R* definitions, but after
* the base registers the ARMV7M_* number space does not match the vector we
* wish to populate in this eCos support code. */
enum ecos_reglist_cortexm {
ECOS_REGLIST_R0 = 0,
ECOS_REGLIST_R1,
ECOS_REGLIST_R2,
ECOS_REGLIST_R3,
ECOS_REGLIST_R4,
ECOS_REGLIST_R5,
ECOS_REGLIST_R6,
ECOS_REGLIST_R7,
ECOS_REGLIST_R8,
ECOS_REGLIST_R9,
ECOS_REGLIST_R10,
ECOS_REGLIST_R11,
ECOS_REGLIST_R12,
ECOS_REGLIST_R13,
ECOS_REGLIST_R14,
ECOS_REGLIST_PC,
ECOS_REGLIST_XPSR, /* ARMV7M_NUM_CORE_REGS */
ECOS_REGLIST_BASEPRI,
ECOS_REGLIST_FPSCR, /* Following for FPU contexts */
ECOS_REGLIST_D0,
ECOS_REGLIST_D1,
ECOS_REGLIST_D2,
ECOS_REGLIST_D3,
ECOS_REGLIST_D4,
ECOS_REGLIST_D5,
ECOS_REGLIST_D6,
ECOS_REGLIST_D7,
ECOS_REGLIST_D8,
ECOS_REGLIST_D9,
ECOS_REGLIST_D10,
ECOS_REGLIST_D11,
ECOS_REGLIST_D12,
ECOS_REGLIST_D13,
ECOS_REGLIST_D14,
ECOS_REGLIST_D15
};
#define ECOS_CORTEXM_BASE_NUMREGS (ARMV7M_NUM_CORE_REGS)
/* NOTE: The offsets in this vector are overwritten by the architecture specific
* layout functions depending on the specific application configuration. The
* ordering of this vector MUST match eCos_reglist. */
static struct stack_register_offset rtos_ecos_regoff_cortexm[] = {
{ ARMV7M_R0, -1, 32 }, /* r0 */
{ ARMV7M_R1, -1, 32 }, /* r1 */
{ ARMV7M_R2, -1, 32 }, /* r2 */
{ ARMV7M_R3, -1, 32 }, /* r3 */
{ ARMV7M_R4, -1, 32 }, /* r4 */
{ ARMV7M_R5, -1, 32 }, /* r5 */
{ ARMV7M_R6, -1, 32 }, /* r6 */
{ ARMV7M_R7, -1, 32 }, /* r7 */
{ ARMV7M_R8, -1, 32 }, /* r8 */
{ ARMV7M_R9, -1, 32 }, /* r9 */
{ ARMV7M_R10, -1, 32 }, /* r10 */
{ ARMV7M_R11, -1, 32 }, /* r11 */
{ ARMV7M_R12, -1, 32 }, /* r12 */
{ ARMV7M_R13, -1, 32 }, /* sp */
{ ARMV7M_R14, -1, 32 }, /* lr */
{ ARMV7M_PC, -1, 32 }, /* pc */
{ ARMV7M_XPSR, -1, 32 }, /* xPSR */
{ ARMV7M_BASEPRI, -1, 32 }, /* BASEPRI */
{ ARMV7M_FPSCR, -1, 32 }, /* FPSCR */
{ ARMV7M_D0, -1, 64 }, /* D0 (S0/S1) */
{ ARMV7M_D1, -1, 64 }, /* D1 (S2/S3) */
{ ARMV7M_D2, -1, 64 }, /* D2 (S4/S5) */
{ ARMV7M_D3, -1, 64 }, /* D3 (S6/S7) */
{ ARMV7M_D4, -1, 64 }, /* D4 (S8/S9) */
{ ARMV7M_D5, -1, 64 }, /* D5 (S10/S11) */
{ ARMV7M_D6, -1, 64 }, /* D6 (S12/S13) */
{ ARMV7M_D7, -1, 64 }, /* D7 (S14/S15) */
{ ARMV7M_D8, -1, 64 }, /* D8 (S16/S17) */
{ ARMV7M_D9, -1, 64 }, /* D9 (S18/S19) */
{ ARMV7M_D10, -1, 64 }, /* D10 (S20/S21) */
{ ARMV7M_D11, -1, 64 }, /* D11 (S22/S23) */
{ ARMV7M_D12, -1, 64 }, /* D12 (S24/S25) */
{ ARMV7M_D13, -1, 64 }, /* D13 (S26/S27) */
{ ARMV7M_D14, -1, 64 }, /* D14 (S28/S29) */
{ ARMV7M_D15, -1, 64 }, /* D15 (S30/S31) */
};
static struct stack_register_offset rtos_ecos_regoff_arm[] = {
{ 0, -1, 32 }, /* r0 */
{ 1, -1, 32 }, /* r1 */
{ 2, -1, 32 }, /* r2 */
{ 3, -1, 32 }, /* r3 */
{ 4, -1, 32 }, /* r4 */
{ 5, -1, 32 }, /* r5 */
{ 6, -1, 32 }, /* r6 */
{ 7, -1, 32 }, /* r7 */
{ 8, -1, 32 }, /* r8 */
{ 9, -1, 32 }, /* r9 */
{ 10, -1, 32 }, /* r10 */
{ 11, -1, 32 }, /* r11 (fp) */
{ 12, -1, 32 }, /* r12 (ip) */
{ 13, -1, 32 }, /* sp (r13) */
{ 14, -1, 32 }, /* lr (r14) */
{ 15, -1, 32 }, /* pc (r15) */
{ 16, -1, 32 }, /* xPSR */
};
static struct rtos_register_stacking rtos_ecos_stacking = {
.stack_registers_size = 0,
.stack_growth_direction = -1,
.num_output_registers = 0,
.calculate_process_stack = NULL, /* stack_alignment */
.register_offsets = NULL
};
/* To avoid the run-time cost of matching explicit symbol names we push the
* lookup offsets to this *manually* maintained enumeration which must match the
* ecos_symbol_list[] order below. */
enum ecos_symbol_values {
ECOS_VAL_THREAD_LIST = 0,
ECOS_VAL_CURRENT_THREAD_PTR,
ECOS_VAL_COMMON_THREAD_NEXT_OFF,
ECOS_VAL_COMMON_THREAD_NEXT_SIZE,
ECOS_VAL_COMMON_THREAD_STATE_OFF,
ECOS_VAL_COMMON_THREAD_STATE_SIZE,
ECOS_VAL_COMMON_THREAD_SLEEP_OFF,
ECOS_VAL_COMMON_THREAD_SLEEP_SIZE,
ECOS_VAL_COMMON_THREAD_WAKE_OFF,
ECOS_VAL_COMMON_THREAD_WAKE_SIZE,
ECOS_VAL_COMMON_THREAD_ID_OFF,
ECOS_VAL_COMMON_THREAD_ID_SIZE,
ECOS_VAL_COMMON_THREAD_NAME_OFF,
ECOS_VAL_COMMON_THREAD_NAME_SIZE,
ECOS_VAL_COMMON_THREAD_PRI_OFF,
ECOS_VAL_COMMON_THREAD_PRI_SIZE,
ECOS_VAL_COMMON_THREAD_STACK_OFF,
ECOS_VAL_COMMON_THREAD_STACK_SIZE,
ECOS_VAL_CORTEXM_THREAD_SAVED,
ECOS_VAL_CORTEXM_CTX_THREAD_SIZE,
ECOS_VAL_CORTEXM_CTX_TYPE_OFF,
ECOS_VAL_CORTEXM_CTX_TYPE_SIZE,
ECOS_VAL_CORTEXM_CTX_BASEPRI_OFF,
ECOS_VAL_CORTEXM_CTX_BASEPRI_SIZE,
ECOS_VAL_CORTEXM_CTX_SP_OFF,
ECOS_VAL_CORTEXM_CTX_SP_SIZE,
ECOS_VAL_CORTEXM_CTX_REG_OFF,
ECOS_VAL_CORTEXM_CTX_REG_SIZE,
ECOS_VAL_CORTEXM_CTX_PC_OFF,
ECOS_VAL_CORTEXM_CTX_PC_SIZE,
ECOS_VAL_CORTEXM_VAL_EXCEPTION,
ECOS_VAL_CORTEXM_VAL_THREAD,
ECOS_VAL_CORTEXM_VAL_INTERRUPT,
ECOS_VAL_CORTEXM_VAL_FPU,
ECOS_VAL_CORTEXM_CTX_FPSCR_OFF,
ECOS_VAL_CORTEXM_CTX_FPSCR_SIZE,
ECOS_VAL_CORTEXM_CTX_S_OFF,
ECOS_VAL_CORTEXM_CTX_S_SIZE,
ECOS_VAL_ARM_REGSIZE,
ECOS_VAL_ARM_CTX_R0_OFF,
ECOS_VAL_ARM_CTX_R1_OFF,
ECOS_VAL_ARM_CTX_R2_OFF,
ECOS_VAL_ARM_CTX_R3_OFF,
ECOS_VAL_ARM_CTX_R4_OFF,
ECOS_VAL_ARM_CTX_R5_OFF,
ECOS_VAL_ARM_CTX_R6_OFF,
ECOS_VAL_ARM_CTX_R7_OFF,
ECOS_VAL_ARM_CTX_R8_OFF,
ECOS_VAL_ARM_CTX_R9_OFF,
ECOS_VAL_ARM_CTX_R10_OFF,
ECOS_VAL_ARM_CTX_FP_OFF,
ECOS_VAL_ARM_CTX_IP_OFF,
ECOS_VAL_ARM_CTX_SP_OFF,
ECOS_VAL_ARM_CTX_LR_OFF,
ECOS_VAL_ARM_CTX_PC_OFF,
ECOS_VAL_ARM_CTX_CPSR_OFF,
ECOS_VAL_ARM_FPUSIZE,
ECOS_VAL_ARM_CTX_FPSCR_OFF,
ECOS_VAL_ARM_SCOUNT,
ECOS_VAL_ARM_CTX_SVEC_OFF,
ECOS_VAL_ARM_VFPCOUNT,
ECOS_VAL_ARM_CTX_VFPVEC_OFF
};
struct symbols {
const char *name;
const char * const *target_names; /* non-NULL when for a specific architecture */
bool optional;
};
#define ECOSSYM(_n, _o, _t) { .name = _n, .optional = (_o), .target_names = _t }
/* Some of offset/size helper symbols are common to all eCos
* targets. Unfortunately, for historical reasons, some information is in
* architecture specific namespaces leading to some duplication and a larger
* vector below. */
static const struct symbols ecos_symbol_list[] = {
ECOSSYM("Cyg_Thread::thread_list", false, NULL),
ECOSSYM("Cyg_Scheduler_Base::current_thread", false, NULL),
/* Following symbols *are* required for generic application-specific
* configuration support, but we mark as optional for backwards
* compatibility with the previous fixed Cortex-M3 only RTOS plugin
* implementation. */
ECOSSYM("__ecospro_syminfo.off.cyg_thread.list_next", true, NULL),
ECOSSYM("__ecospro_syminfo.size.cyg_thread.list_next", true, NULL),
ECOSSYM("__ecospro_syminfo.off.cyg_thread.state", true, NULL),
ECOSSYM("__ecospro_syminfo.size.cyg_thread.state", true, NULL),
ECOSSYM("__ecospro_syminfo.off.cyg_thread.sleep_reason", true, NULL),
ECOSSYM("__ecospro_syminfo.size.cyg_thread.sleep_reason", true, NULL),
ECOSSYM("__ecospro_syminfo.off.cyg_thread.wake_reason", true, NULL),
ECOSSYM("__ecospro_syminfo.size.cyg_thread.wake_reason", true, NULL),
ECOSSYM("__ecospro_syminfo.off.cyg_thread.unique_id", true, NULL),
ECOSSYM("__ecospro_syminfo.size.cyg_thread.unique_id", true, NULL),
ECOSSYM("__ecospro_syminfo.off.cyg_thread.name", true, NULL),
ECOSSYM("__ecospro_syminfo.size.cyg_thread.name", true, NULL),
ECOSSYM("__ecospro_syminfo.off.cyg_thread.priority", true, NULL),
ECOSSYM("__ecospro_syminfo.size.cyg_thread.priority", true, NULL),
ECOSSYM("__ecospro_syminfo.off.cyg_thread.stack_ptr", true, NULL),
ECOSSYM("__ecospro_syminfo.size.cyg_thread.stack_ptr", true, NULL),
/* optional Cortex-M: */
ECOSSYM("__ecospro_syminfo.cortexm.thread.saved", true, target_cortex_m),
ECOSSYM("__ecospro_syminfo.size.HAL_SavedRegisters.Thread", true, target_cortex_m),
ECOSSYM("__ecospro_syminfo.off.HAL_SavedRegisters.u.thread.type", true, target_cortex_m),
ECOSSYM("__ecospro_syminfo.size.HAL_SavedRegisters.u.thread.type", true, target_cortex_m),
ECOSSYM("__ecospro_syminfo.off.HAL_SavedRegisters.u.thread.basepri", true, target_cortex_m),
ECOSSYM("__ecospro_syminfo.size.HAL_SavedRegisters.u.thread.basepri", true, target_cortex_m),
ECOSSYM("__ecospro_syminfo.off.HAL_SavedRegisters.u.thread.sp", true, target_cortex_m),
ECOSSYM("__ecospro_syminfo.size.HAL_SavedRegisters.u.thread.sp", true, target_cortex_m),
ECOSSYM("__ecospro_syminfo.off.HAL_SavedRegisters.u.thread.r", true, target_cortex_m),
ECOSSYM("__ecospro_syminfo.size.HAL_SavedRegisters.u.thread.r", true, target_cortex_m),
ECOSSYM("__ecospro_syminfo.off.HAL_SavedRegisters.u.thread.pc", true, target_cortex_m),
ECOSSYM("__ecospro_syminfo.size.HAL_SavedRegisters.u.thread.pc", true, target_cortex_m),
ECOSSYM("__ecospro_syminfo.value.HAL_SAVEDREGISTERS.EXCEPTION", true, target_cortex_m),
ECOSSYM("__ecospro_syminfo.value.HAL_SAVEDREGISTERS.THREAD", true, target_cortex_m),
ECOSSYM("__ecospro_syminfo.value.HAL_SAVEDREGISTERS.INTERRUPT", true, target_cortex_m),
/* optional Cortex-M with H/W FPU configured: */
ECOSSYM("__ecospro_syminfo.value.HAL_SAVEDREGISTERS.WITH_FPU", true, target_cortex_m),
ECOSSYM("__ecospro_syminfo.off.HAL_SavedRegisters.u.thread.fpscr", true, target_cortex_m),
ECOSSYM("__ecospro_syminfo.size.HAL_SavedRegisters.u.thread.fpscr", true, target_cortex_m),
ECOSSYM("__ecospro_syminfo.off.HAL_SavedRegisters.u.thread.s", true, target_cortex_m),
ECOSSYM("__ecospro_syminfo.size.HAL_SavedRegisters.u.thread.s", true, target_cortex_m),
/* optional ARM: */
ECOSSYM("ARMREG_SIZE", true, target_arm),
ECOSSYM("armreg_r0", true, target_arm),
ECOSSYM("armreg_r1", true, target_arm),
ECOSSYM("armreg_r2", true, target_arm),
ECOSSYM("armreg_r3", true, target_arm),
ECOSSYM("armreg_r4", true, target_arm),
ECOSSYM("armreg_r5", true, target_arm),
ECOSSYM("armreg_r6", true, target_arm),
ECOSSYM("armreg_r7", true, target_arm),
ECOSSYM("armreg_r8", true, target_arm),
ECOSSYM("armreg_r9", true, target_arm),
ECOSSYM("armreg_r10", true, target_arm),
ECOSSYM("armreg_fp", true, target_arm),
ECOSSYM("armreg_ip", true, target_arm),
ECOSSYM("armreg_sp", true, target_arm),
ECOSSYM("armreg_lr", true, target_arm),
ECOSSYM("armreg_pc", true, target_arm),
ECOSSYM("armreg_cpsr", true, target_arm),
/* optional ARM FPU common: */
ECOSSYM("ARMREG_FPUCONTEXT_SIZE", true, target_arm),
ECOSSYM("armreg_fpscr", true, target_arm),
/* optional ARM FPU single-precision: */
ECOSSYM("ARMREG_S_COUNT", true, target_arm),
ECOSSYM("armreg_s_vec", true, target_arm),
/* optional ARM FPU double-precision: */
ECOSSYM("ARMREG_VFP_COUNT", true, target_arm),
ECOSSYM("armreg_vfp_vec", true, target_arm),
};
const struct rtos_type ecos_rtos = {
.name = "eCos",
.detect_rtos = ecos_detect_rtos,
.create = ecos_create,
.update_threads = ecos_update_threads,
.get_thread_reg_list = ecos_get_thread_reg_list,
.get_symbol_list_to_lookup = ecos_get_symbol_list_to_lookup,
};
static symbol_address_t ecos_value(struct rtos *rtos, unsigned int idx)
{
if (idx < ARRAY_SIZE(ecos_symbol_list))
return rtos->symbols[idx].address;
/* We do not terminate, just return 0 in this case. */
LOG_ERROR("eCos: Invalid symbol index %u", idx);
return 0;
}
#define XMLENTRY(_c, _s) { .xc = (_c), .rs = (_s), .rlen = (sizeof(_s) - 1) }
static const struct {
char xc;
const char *rs;
size_t rlen;
} xmlchars[] = {
XMLENTRY('<', "&lt;"),
XMLENTRY('&', "&amp;"),
XMLENTRY('>', "&gt;"),
XMLENTRY('\'', "&apos;"),
XMLENTRY('"', "&quot;")
};
/** Escape any XML reserved characters in a string. */
static bool ecos_escape_string(const char *raw, char *out, size_t limit)
{
static const char *tokens = "<&>\'\"";
bool escaped = false;
if (!out || !limit)
return false;
(void)memset(out, '\0', limit);
while (raw && *raw && limit) {
size_t lok = strcspn(raw, tokens);
if (lok) {
size_t tocopy;
tocopy = ((limit < lok) ? limit : lok);
(void)memcpy(out, raw, tocopy);
limit -= tocopy;
out += tocopy;
raw += lok;
continue;
}
char *fidx = strchr(tokens, *raw);
if (!fidx) {
/* Should never happen assuming xmlchars
* vector and tokens string match. */
LOG_ERROR("eCos: Unexpected XML char %c", *raw);
continue;
}
uint32_t cidx = (fidx - tokens);
size_t tocopy = xmlchars[cidx].rlen;
if (limit < tocopy)
break;
escaped = true;
(void)memcpy(out, xmlchars[cidx].rs, tocopy);
limit -= tocopy;
out += tocopy;
raw++;
}
return escaped;
}
static int ecos_check_app_info(struct rtos *rtos, struct ecos_params *param)
{
if (!rtos || !param)
return -1;
if (param->flush_common) {
if (debug_level >= LOG_LVL_DEBUG) {
for (unsigned int idx = 0; idx < ARRAY_SIZE(ecos_symbol_list); idx++) {
LOG_DEBUG("eCos: %s 0x%016" PRIX64 " %s",
rtos->symbols[idx].optional ? "OPTIONAL" : " ",
rtos->symbols[idx].address, rtos->symbols[idx].symbol_name);
}
}
/* If "__ecospro_syminfo.size.cyg_thread.list_next" is non-zero then we
* expect all of the generic thread structure symbols to have been
* provided. */
symbol_address_t thread_next_size = ecos_value(rtos, ECOS_VAL_COMMON_THREAD_NEXT_SIZE);
if (thread_next_size != 0) {
param->pointer_width = thread_next_size;
param->uid_width = ecos_value(rtos, ECOS_VAL_COMMON_THREAD_ID_SIZE);
param->state_width = ecos_value(rtos, ECOS_VAL_COMMON_THREAD_STATE_SIZE);
param->thread_stack_offset = ecos_value(rtos, ECOS_VAL_COMMON_THREAD_STACK_OFF);
param->thread_name_offset = ecos_value(rtos, ECOS_VAL_COMMON_THREAD_NAME_OFF);
param->thread_state_offset = ecos_value(rtos, ECOS_VAL_COMMON_THREAD_STATE_OFF);
param->thread_next_offset = ecos_value(rtos, ECOS_VAL_COMMON_THREAD_NEXT_OFF);
param->thread_uniqueid_offset = ecos_value(rtos, ECOS_VAL_COMMON_THREAD_ID_OFF);
}
if (param->uid_width != sizeof(uint16_t)) {
/* Currently all eCos configurations use a 16-bit field to hold the
* unique thread ID. */
LOG_WARNING("eCos: Unexpected unique_id width %" PRIu8, param->uid_width);
param->uid_width = (unsigned char)sizeof(uint16_t);
}
param->stacking_info = NULL;
param->flush_common = false;
}
return ERROR_OK;
}
/* The Cortex-M eCosPro "thread" contexts have a "type" indicator, which tracks
* the context state of (THREAD | EXCEPTION | INTERRUPT) and whether FPU
* registers are saved.
*
* For thread-aware debugging from GDB we are only interested in THREAD states
* and so do not need to implement support for INTERRUPT or EXCEPTION thread
* contexts since this code does not expose those stack contexts via the
* constructed thread list support. */
static int ecos_stack_layout_cortexm(struct rtos *rtos,
struct ecos_params *param, int64_t stack_ptr,
const struct rtos_register_stacking **si)
{
int retval = ERROR_OK;
/* CONSIDER: We could return
* ecos_value(rtos, ECOS_VAL_CORTEXM_THREAD_SAVED) as the actual PC
* address of a context switch, with the LR being set to the context PC
* field to give a true representation of where the thread switch
* occurs. However that would require extending the common
* rtos_generic_stack_read() code with suitable support for applying a
* supplied value, or just implementing our own version of that code that
* can inject data into what is passed onwards to GDB. */
/* UPDATE: When we can return VFP register state then we will NOT be
* basing the cached state on the single param->stacking_info value,
* since we will need a different stacking_info structure returned for
* each thread type when FPU support is enabled. The use of the single
* param->stacking_info is a holder whilst we are limited to the fixed
* ARMV7M_NUM_CORE_REGS set of descriptors. */
if (!param->stacking_info &&
ecos_value(rtos, ECOS_VAL_CORTEXM_THREAD_SAVED) &&
ecos_value(rtos, ECOS_VAL_CORTEXM_VAL_THREAD)) {
unsigned char numoutreg = ECOS_CORTEXM_BASE_NUMREGS;
rtos_ecos_stacking.stack_registers_size = ecos_value(rtos, ECOS_VAL_CORTEXM_CTX_THREAD_SIZE);
rtos_ecos_stacking.calculate_process_stack = rtos_generic_stack_align8;
rtos_ecos_stacking.register_offsets = rtos_ecos_regoff_cortexm;
rtos_ecos_regoff_cortexm[ECOS_REGLIST_R0].offset = (ecos_value(rtos, ECOS_VAL_CORTEXM_CTX_REG_OFF) + 0x00);
rtos_ecos_regoff_cortexm[ECOS_REGLIST_R1].offset = (ecos_value(rtos, ECOS_VAL_CORTEXM_CTX_REG_OFF) + 0x04);
rtos_ecos_regoff_cortexm[ECOS_REGLIST_R2].offset = (ecos_value(rtos, ECOS_VAL_CORTEXM_CTX_REG_OFF) + 0x08);
rtos_ecos_regoff_cortexm[ECOS_REGLIST_R3].offset = (ecos_value(rtos, ECOS_VAL_CORTEXM_CTX_REG_OFF) + 0x0C);
rtos_ecos_regoff_cortexm[ECOS_REGLIST_R4].offset = (ecos_value(rtos, ECOS_VAL_CORTEXM_CTX_REG_OFF) + 0x10);
rtos_ecos_regoff_cortexm[ECOS_REGLIST_R5].offset = (ecos_value(rtos, ECOS_VAL_CORTEXM_CTX_REG_OFF) + 0x14);
rtos_ecos_regoff_cortexm[ECOS_REGLIST_R6].offset = (ecos_value(rtos, ECOS_VAL_CORTEXM_CTX_REG_OFF) + 0x18);
rtos_ecos_regoff_cortexm[ECOS_REGLIST_R7].offset = (ecos_value(rtos, ECOS_VAL_CORTEXM_CTX_REG_OFF) + 0x1C);
rtos_ecos_regoff_cortexm[ECOS_REGLIST_R8].offset = (ecos_value(rtos, ECOS_VAL_CORTEXM_CTX_REG_OFF) + 0x20);
rtos_ecos_regoff_cortexm[ECOS_REGLIST_R9].offset = (ecos_value(rtos, ECOS_VAL_CORTEXM_CTX_REG_OFF) + 0x24);
rtos_ecos_regoff_cortexm[ECOS_REGLIST_R10].offset = (ecos_value(rtos, ECOS_VAL_CORTEXM_CTX_REG_OFF) + 0x28);
rtos_ecos_regoff_cortexm[ECOS_REGLIST_R11].offset = (ecos_value(rtos, ECOS_VAL_CORTEXM_CTX_REG_OFF) + 0x2C);
rtos_ecos_regoff_cortexm[ECOS_REGLIST_R12].offset = (ecos_value(rtos, ECOS_VAL_CORTEXM_CTX_REG_OFF) + 0x30);
/* Rather than using the stacked ECOS_VAL_CORTEXM_CTX_SP_OFF
* value we force the reported sp to be after the stacked
* register context. */
rtos_ecos_regoff_cortexm[ECOS_REGLIST_R13].offset = -2;
rtos_ecos_regoff_cortexm[ECOS_REGLIST_R14].offset = -1;
rtos_ecos_regoff_cortexm[ECOS_REGLIST_PC].offset = ecos_value(rtos, ECOS_VAL_CORTEXM_CTX_PC_OFF);
rtos_ecos_regoff_cortexm[ECOS_REGLIST_XPSR].offset = -1;
param->stacking_info = &rtos_ecos_stacking;
/* Common Cortex-M thread register offsets for the current
* symbol table: */
if (retval == ERROR_OK && param->stacking_info) {
if (numoutreg > ECOS_REGLIST_BASEPRI) {
rtos_ecos_regoff_cortexm[ECOS_REGLIST_BASEPRI].offset =
ecos_value(rtos, ECOS_VAL_CORTEXM_CTX_BASEPRI_OFF);
}
rtos_ecos_stacking.num_output_registers = numoutreg;
}
}
if (si)
*si = param->stacking_info;
return retval;
}
static int ecos_stack_layout_arm(struct rtos *rtos, struct ecos_params *param,
int64_t stack_ptr, const struct rtos_register_stacking **si)
{
int retval = ERROR_OK;
if (!param->stacking_info && ecos_value(rtos, ECOS_VAL_ARM_REGSIZE)) {
/* When OpenOCD is extended to allow FPU registers to be returned from a
* stacked thread context we can check:
* if (0 != ecos_value(rtos, ECOS_VAL_ARM_FPUSIZE)) { FPU }
* for presence of FPU registers in the context. */
rtos_ecos_stacking.stack_registers_size = ecos_value(rtos, ECOS_VAL_ARM_REGSIZE);
rtos_ecos_stacking.num_output_registers = ARRAY_SIZE(rtos_ecos_regoff_arm);
rtos_ecos_stacking.register_offsets = rtos_ecos_regoff_arm;
rtos_ecos_regoff_arm[0].offset = ecos_value(rtos, ECOS_VAL_ARM_CTX_R0_OFF);
rtos_ecos_regoff_arm[1].offset = ecos_value(rtos, ECOS_VAL_ARM_CTX_R1_OFF);
rtos_ecos_regoff_arm[2].offset = ecos_value(rtos, ECOS_VAL_ARM_CTX_R2_OFF);
rtos_ecos_regoff_arm[3].offset = ecos_value(rtos, ECOS_VAL_ARM_CTX_R3_OFF);
rtos_ecos_regoff_arm[4].offset = ecos_value(rtos, ECOS_VAL_ARM_CTX_R4_OFF);
rtos_ecos_regoff_arm[5].offset = ecos_value(rtos, ECOS_VAL_ARM_CTX_R5_OFF);
rtos_ecos_regoff_arm[6].offset = ecos_value(rtos, ECOS_VAL_ARM_CTX_R6_OFF);
rtos_ecos_regoff_arm[7].offset = ecos_value(rtos, ECOS_VAL_ARM_CTX_R7_OFF);
rtos_ecos_regoff_arm[8].offset = ecos_value(rtos, ECOS_VAL_ARM_CTX_R8_OFF);
rtos_ecos_regoff_arm[9].offset = ecos_value(rtos, ECOS_VAL_ARM_CTX_R9_OFF);
rtos_ecos_regoff_arm[10].offset = ecos_value(rtos, ECOS_VAL_ARM_CTX_R10_OFF);
rtos_ecos_regoff_arm[11].offset = ecos_value(rtos, ECOS_VAL_ARM_CTX_FP_OFF);
rtos_ecos_regoff_arm[12].offset = ecos_value(rtos, ECOS_VAL_ARM_CTX_IP_OFF);
rtos_ecos_regoff_arm[13].offset = ecos_value(rtos, ECOS_VAL_ARM_CTX_SP_OFF);
rtos_ecos_regoff_arm[14].offset = ecos_value(rtos, ECOS_VAL_ARM_CTX_LR_OFF);
rtos_ecos_regoff_arm[15].offset = ecos_value(rtos, ECOS_VAL_ARM_CTX_PC_OFF);
rtos_ecos_regoff_arm[16].offset = ecos_value(rtos, ECOS_VAL_ARM_CTX_CPSR_OFF);
param->stacking_info = &rtos_ecos_stacking;
}
if (si)
*si = param->stacking_info;
return retval;
}
/* We see this function called on a new connection, it looks like before and
* after the "tar rem"/"tar extended-remote". It might be the only point we can
* decide to cache information (to check if the symbol table has changed). */
static int ecos_update_threads(struct rtos *rtos)
{
int retval;
int tasks_found = 0;
int thread_list_size = 0;
struct ecos_params *param;
if (!rtos)
return -1;
/* wipe out previous thread details if any */
rtos_free_threadlist(rtos);
if (!rtos->rtos_specific_params)
return -3;
param = rtos->rtos_specific_params;
if (!rtos->symbols) {
/* NOTE: We only see this when connecting from GDB the first
* time before the application image is loaded. So it is not a
* hook for detecting an application change. */
param->flush_common = true;
LOG_ERROR("No symbols for eCos");
return -4;
}
retval = ecos_check_app_info(rtos, param);
if (retval != ERROR_OK)
return retval;
if (rtos->symbols[ECOS_VAL_THREAD_LIST].address == 0) {
LOG_ERROR("Don't have the thread list head");
return -2;
}
/* determine the number of current threads */
uint32_t thread_list_head = rtos->symbols[ECOS_VAL_THREAD_LIST].address;
uint32_t thread_index;
target_read_buffer(rtos->target,
thread_list_head,
param->pointer_width,
(uint8_t *) &thread_index);
uint32_t first_thread = thread_index;
/* Even if 0==first_thread indicates a system with no defined eCos
* threads, instead of early exiting here we fall through the code to
* allow the creation of a faked "Current Execution" descriptor as
* needed. */
if (first_thread) {
/* Since the OpenOCD RTOS support can attempt to obtain thread
* information on initial connection when the system *may* have
* undefined memory state it is possible for a simple thread count scan
* to produce invalid results. To avoid blocking indefinitely when
* encountering an invalid closed loop we limit the number of threads to
* the maximum possible, and if we pass that limit then something is
* wrong so treat the system as having no threads defined. */
do {
thread_list_size++;
if (thread_list_size > ECOS_MAX_THREAD_COUNT) {
/* Treat as "no threads" case: */
first_thread = 0;
thread_list_size = 0;
break;
}
retval = target_read_buffer(rtos->target,
thread_index + param->thread_next_offset,
param->pointer_width,
(uint8_t *)&thread_index);
if (retval != ERROR_OK)
return retval;
} while (thread_index != first_thread);
}
/* read the current thread id */
rtos->current_thread = 0;
uint32_t current_thread_addr;
retval = target_read_buffer(rtos->target,
rtos->symbols[ECOS_VAL_CURRENT_THREAD_PTR].address,
param->pointer_width,
(uint8_t *)&current_thread_addr);
if (retval != ERROR_OK) {
LOG_ERROR("Reading active thread address");
return retval;
}
if (current_thread_addr) {
uint16_t id = 0;
retval = target_read_buffer(rtos->target,
current_thread_addr + param->thread_uniqueid_offset,
param->uid_width,
(uint8_t *)&id);
if (retval != ERROR_OK) {
LOG_ERROR("Could not read eCos current thread from target");
return retval;
}
rtos->current_thread = (threadid_t)id;
}
if (thread_list_size == 0 || rtos->current_thread == 0) {
/* Either : No RTOS threads - there is always at least the current execution though */
/* OR : No current thread - all threads suspended - show the current execution
* of idling */
static const char tmp_str[] = "Current Execution";
thread_list_size++;
tasks_found++;
rtos->thread_details = malloc(
sizeof(struct thread_detail) * thread_list_size);
/* 1 is a valid eCos thread id, so we return 0 for this faked
* "current" CPU state: */
rtos->thread_details->threadid = 0;
rtos->thread_details->exists = true;
rtos->thread_details->extra_info_str = NULL;
rtos->thread_details->thread_name_str = malloc(sizeof(tmp_str));
strcpy(rtos->thread_details->thread_name_str, tmp_str);
/* Early exit if current CPU state our only "thread": */
if (thread_list_size == 1) {
rtos->thread_count = 1;
return ERROR_OK;
}
} else {
/* create space for new thread details */
rtos->thread_details = malloc(
sizeof(struct thread_detail) * thread_list_size);
}
/* loop over all threads */
thread_index = first_thread;
do {
#define ECOS_THREAD_NAME_STR_SIZE (200)
char tmp_str[ECOS_THREAD_NAME_STR_SIZE];
uint32_t name_ptr = 0;
uint32_t prev_thread_ptr;
/* Save the thread ID. For eCos the thread has a unique ID distinct from
* the thread_index descriptor pointer. We present this scheduler ID
* instead of the descriptor memory address. */
uint16_t thread_id = 0;
retval = target_read_buffer(rtos->target,
thread_index + param->thread_uniqueid_offset,
param->uid_width,
(uint8_t *)&thread_id);
if (retval != ERROR_OK) {
LOG_ERROR("Could not read eCos thread id from target");
return retval;
}
rtos->thread_details[tasks_found].threadid = thread_id;
/* Read the name pointer */
retval = target_read_buffer(rtos->target,
thread_index + param->thread_name_offset,
param->pointer_width,
(uint8_t *)&name_ptr);
if (retval != ERROR_OK) {
LOG_ERROR("Could not read eCos thread name pointer from target");
return retval;
}
/* Read the thread name */
retval =
target_read_buffer(rtos->target,
name_ptr,
ECOS_THREAD_NAME_STR_SIZE,
(uint8_t *)&tmp_str);
if (retval != ERROR_OK) {
LOG_ERROR("Error reading thread name from eCos target");
return retval;
}
tmp_str[ECOS_THREAD_NAME_STR_SIZE-1] = '\x00';
/* Since eCos can have arbitrary C string names we can sometimes
* get an internal warning from GDB about "not well-formed
* (invalid token)" since the XML post-processing done by GDB on
* the OpenOCD returned response containing the thread strings
* is not escaped. For example the eCos kernel testsuite
* application tm_basic uses the thread name "<<NULL>>" which
* will trigger this failure unless escaped. */
if (tmp_str[0] == '\x00') {
snprintf(tmp_str, ECOS_THREAD_NAME_STR_SIZE, "NoName:[0x%08" PRIX32 "]", thread_index);
} else {
/* The following is a workaround to avoid any issues
* from arbitrary eCos thread names causing GDB/OpenOCD
* issues. We limit the escaped thread name passed to
* GDB to the same length as the un-escaped just to
* avoid overly long strings. */
char esc_str[ECOS_THREAD_NAME_STR_SIZE];
bool escaped = ecos_escape_string(tmp_str, esc_str, sizeof(esc_str));
if (escaped)
strcpy(tmp_str, esc_str);
}
rtos->thread_details[tasks_found].thread_name_str =
malloc(strlen(tmp_str)+1);
strcpy(rtos->thread_details[tasks_found].thread_name_str, tmp_str);
/* Read the thread status */
int64_t thread_status = 0;
retval = target_read_buffer(rtos->target,
thread_index + param->thread_state_offset,
param->state_width,
(uint8_t *)&thread_status);
if (retval != ERROR_OK) {
LOG_ERROR("Error reading thread state from eCos target");
return retval;
}
/* The thread_status is a BITMASK */
char state_desc[21]; /* Enough for "suspended+countsleep\0" maximum */
if (thread_status & SUSPENDED)
strcpy(state_desc, "suspended+");
else
state_desc[0] = '\0';
switch (thread_status & ~SUSPENDED) {
case RUNNING:
if (thread_index == current_thread_addr)
strcat(state_desc, "running");
else if (thread_status & SUSPENDED)
state_desc[9] = '\0'; /* Drop '+' from "suspended+" */
else
strcat(state_desc, "ready");
break;
case SLEEPING:
strcat(state_desc, "sleeping");
break;
case SLEEPSET:
case COUNTSLEEP:
strcat(state_desc, "counted sleep");
break;
case CREATING:
strcpy(state_desc, "creating");
break;
case EXITED:
strcpy(state_desc, "exited");
break;
default:
strcpy(state_desc, "unknown state");
break;
}
/* For the moment we do not bother decoding the wake reason for the
* active "running" thread, but it is useful providing the sleep reason
* for stacked threads. */
int64_t sleep_reason = 0; /* sleep reason */
if (thread_index != current_thread_addr &&
ecos_value(rtos, ECOS_VAL_COMMON_THREAD_SLEEP_SIZE)) {
retval = target_read_buffer(rtos->target,
(thread_index + ecos_value(rtos, ECOS_VAL_COMMON_THREAD_SLEEP_OFF)),
ecos_value(rtos, ECOS_VAL_COMMON_THREAD_SLEEP_SIZE),
(uint8_t *)&sleep_reason);
if (retval != ERROR_OK) {
LOG_ERROR("Error reading thread sleep reason from eCos target");
return retval;
}
if (sleep_reason < 0 ||
sleep_reason > (int64_t)ARRAY_SIZE(ecos_thread_reasons)) {
sleep_reason = 0;
}
}
/* We do not display anything for the Cyg_Thread::NONE reason */
size_t tr_extra = 0;
const char *reason_desc = NULL;
if (sleep_reason)
reason_desc = ecos_thread_reasons[sleep_reason].desc;
if (reason_desc)
tr_extra = 2 + strlen(reason_desc) + 1;
/* Display thread priority if available: */
int64_t priority = 0;
size_t pri_extra = 0;
if (ecos_value(rtos, ECOS_VAL_COMMON_THREAD_PRI_SIZE)) {
retval = target_read_buffer(rtos->target,
(thread_index + ecos_value(rtos, ECOS_VAL_COMMON_THREAD_PRI_OFF)),
ecos_value(rtos, ECOS_VAL_COMMON_THREAD_PRI_SIZE),
(uint8_t *)&priority);
if (retval != ERROR_OK) {
LOG_ERROR("Error reading thread priority from eCos target");
return retval;
}
pri_extra = (12 + 20); /* worst-case ", Priority: " */
}
size_t eilen = (8 + strlen(state_desc) + tr_extra + pri_extra);
char *eistr = malloc(eilen);
/* We do not need to treat a malloc failure as a fatal error here since
* the code below will just not report extra thread information if NULL,
* thus allowing all of the threads to be enumerated even with reduced
* information when the host is low on memory. However... */
if (!eistr) {
LOG_ERROR("OOM allocating extra information buffer");
return ERROR_FAIL;
}
int soff = snprintf(eistr, eilen, "State: %s", state_desc);
if (tr_extra && reason_desc)
soff += snprintf(&eistr[soff], (eilen - soff), " (%s)", reason_desc);
if (pri_extra)
(void)snprintf(&eistr[soff], (eilen - soff), ", Priority: %" PRId64 "", priority);
rtos->thread_details[tasks_found].extra_info_str = eistr;
rtos->thread_details[tasks_found].exists = true;
tasks_found++;
prev_thread_ptr = thread_index;
/* Get the location of the next thread structure. */
thread_index = rtos->symbols[ECOS_VAL_THREAD_LIST].address;
retval = target_read_buffer(rtos->target,
prev_thread_ptr + param->thread_next_offset,
param->pointer_width,
(uint8_t *) &thread_index);
if (retval != ERROR_OK) {
LOG_ERROR("Error reading next thread pointer in eCos thread list");
return retval;
}
} while (thread_index != first_thread);
rtos->thread_count = tasks_found;
return ERROR_OK;
}
static int ecos_get_thread_reg_list(struct rtos *rtos, int64_t thread_id,
struct rtos_reg **reg_list, int *num_regs)
{
int retval;
struct ecos_params *param;
if (!rtos)
return -1;
if (thread_id == 0)
return -2;
if (!rtos->rtos_specific_params)
return -3;
param = rtos->rtos_specific_params;
retval = ecos_check_app_info(rtos, param);
if (retval != ERROR_OK)
return retval;
/* We can get memory access errors reported by this function on
* re-connecting to a board with stale thread information in memory. The
* initial ecos_update_threads() is called twice and may read
* stale/invalid information depending on the memory state. This happens
* as part of the "target remote" connection so cannot be avoided by GDB
* scripting. It is not critical and allowing the application to run and
* initialise its BSS etc. will allow correct thread and register
* information to be obtained. This really only affects debug sessions
* where "info thr" is used before the initial run-time initialisation
* has occurred. */
/* Find the thread with that thread id */
uint16_t id = 0;
uint32_t thread_list_head = rtos->symbols[ECOS_VAL_THREAD_LIST].address;
uint32_t thread_index;
target_read_buffer(rtos->target, thread_list_head, param->pointer_width,
(uint8_t *)&thread_index);
bool done = false;
while (!done) {
retval = target_read_buffer(rtos->target,
thread_index + param->thread_uniqueid_offset,
param->uid_width,
(uint8_t *)&id);
if (retval != ERROR_OK) {
LOG_ERROR("Error reading unique id from eCos thread 0x%08" PRIX32 "", thread_index);
return retval;
}
if (id == thread_id) {
done = true;
break;
}
target_read_buffer(rtos->target,
thread_index + param->thread_next_offset,
param->pointer_width,
(uint8_t *) &thread_index);
}
if (done) {
/* Read the stack pointer */
int64_t stack_ptr = 0;
retval = target_read_buffer(rtos->target,
thread_index + param->thread_stack_offset,
param->pointer_width,
(uint8_t *)&stack_ptr);
if (retval != ERROR_OK) {
LOG_ERROR("Error reading stack frame from eCos thread");
return retval;
}
if (!stack_ptr) {
LOG_ERROR("NULL stack pointer in thread %" PRIu64, thread_id);
return -5;
}
const struct rtos_register_stacking *stacking_info = NULL;
if (param->target_stack_layout) {
retval = param->target_stack_layout(rtos, param, stack_ptr, &stacking_info);
if (retval != ERROR_OK) {
LOG_ERROR("Error reading stack layout for eCos thread");
return retval;
}
}
if (!stacking_info)
stacking_info = &rtos_ecos_cortex_m3_stacking;
return rtos_generic_stack_read(rtos->target,
stacking_info,
stack_ptr,
reg_list,
num_regs);
}
return -1;
}
/* NOTE: This is only called once when the first GDB connection is made to
* OpenOCD and not on subsequent connections (when the application symbol table
* may have changed, affecting the offsets of critical fields and the stacked
* context shape). */
static int ecos_get_symbol_list_to_lookup(struct symbol_table_elem *symbol_list[])
{
unsigned int i;
*symbol_list = calloc(
ARRAY_SIZE(ecos_symbol_list), sizeof(struct symbol_table_elem));
/* If the target reference was passed into this function we could limit
* the symbols we need to lookup to the target_type_name(target) based
* range. For the moment we need to provide a single vector with all of
* the symbols across all of the supported architectures. */
for (i = 0; i < ARRAY_SIZE(ecos_symbol_list); i++) {
(*symbol_list)[i].symbol_name = ecos_symbol_list[i].name;
(*symbol_list)[i].optional = ecos_symbol_list[i].optional;
}
return 0;
}
/* NOTE: Only called by rtos.c:rtos_qsymbol() when auto-detecting the RTOS. If
* the target configuration uses the explicit "-rtos" config option then this
* detection routine is NOT called. */
static bool ecos_detect_rtos(struct target *target)
{
if ((target->rtos->symbols) &&
(target->rtos->symbols[ECOS_VAL_THREAD_LIST].address != 0)) {
/* looks like eCos */
return true;
}
return false;
}
/* Since we should never have 0 as a valid eCos thread ID we use $Hg0 as the
* indicator of a new session as regards flushing any cached state. */
static int ecos_packet_hook(struct connection *connection,
const char *packet, int packet_size)
{
int64_t current_threadid;
if (packet[0] == 'H' && packet[1] == 'g') {
int numscan = sscanf(packet, "Hg%16" SCNx64, &current_threadid);
if (numscan == 1 && current_threadid == 0) {
struct target *target = get_target_from_connection(connection);
if (target && target->rtos && target->rtos->rtos_specific_params) {
struct ecos_params *param;
param = target->rtos->rtos_specific_params;
param->flush_common = true;
}
}
}
return rtos_thread_packet(connection, packet, packet_size);
}
/* Called at start of day when eCos detected or specified in config file. */
static int ecos_create(struct target *target)
{
for (unsigned int i = 0; i < ARRAY_SIZE(ecos_params_list); i++) {
const char * const *tnames = ecos_params_list[i].target_names;
while (*tnames) {
if (strcmp(*tnames, target_type_name(target)) == 0) {
/* LOG_DEBUG("eCos: matched target \"%s\"", target_type_name(target)); */
target->rtos->rtos_specific_params = (void *)&ecos_params_list[i];
ecos_params_list[i].flush_common = true;
ecos_params_list[i].stacking_info = NULL;
target->rtos->current_thread = 0;
target->rtos->thread_details = NULL;
/* We use the $Hg0 packet as a new GDB connection "start-of-day" hook to
* force a re-cache of information. It is possible for a single OpenOCD
* session to be connected to a target with multiple GDB debug sessions
* started/stopped. With eCos it is possible for those GDB sessions to
* present applications with different offsets within a thread
* descriptor for fields used by this module, and for the stacked
* context within the connected target architecture to differ between
* applications and even between threads in a single application. So we
* need to ensure any information we cache is flushed on an application
* change, and GDB referencing an invalid eCos thread ID (0) is a good
* enough point, since we can accept the re-cache hit if that packet
* appears during an established session, whilst benefiting from not
* re-loading information on every update_threads or get_thread_reg_list
* call. */
target->rtos->gdb_thread_packet = ecos_packet_hook;
/* We do not currently use the target->rtos->gdb_target_for_threadid
* hook. */
return 0;
}
tnames++;
}
}
LOG_ERROR("Could not find target in eCos compatibility list");
return -1;
}
Reference in New Issue View Git Blame Copy Permalink