This is an automated email from Gerrit. Daniel Krebs ([email protected]) just uploaded a new patch set to Gerrit, which you can find at http://openocd.zylin.com/3000
-- gerrit commit e0542ce4caf42c65b11642d39aea93d3058191e9 Author: daniel-k <[email protected]> Date: Tue Oct 6 12:33:26 2015 +0200 rtos: add support for RIOT-OS Change-Id: Id6f97ae166c4c78f1858ddbd21459df2b476d057 Signed-off-by: Daniel Krebs <[email protected]> diff --git a/src/rtos/Makefile.am b/src/rtos/Makefile.am index 62293ec..6d7cd59 100644 --- a/src/rtos/Makefile.am +++ b/src/rtos/Makefile.am @@ -22,8 +22,8 @@ include $(top_srcdir)/common.mk METASOURCES = AUTO noinst_LTLIBRARIES = librtos.la -noinst_HEADERS = rtos.h rtos_standard_stackings.h rtos_ecos_stackings.h linux_header.h rtos_chibios_stackings.h rtos_embkernel_stackings.h rtos_mqx_stackings.h -librtos_la_SOURCES = rtos.c rtos_standard_stackings.c rtos_ecos_stackings.c rtos_chibios_stackings.c rtos_embkernel_stackings.c rtos_mqx_stackings.c FreeRTOS.c ThreadX.c eCos.c linux.c ChibiOS.c embKernel.c mqx.c +noinst_HEADERS = rtos.h rtos_standard_stackings.h rtos_ecos_stackings.h linux_header.h rtos_chibios_stackings.h rtos_embkernel_stackings.h rtos_mqx_stackings.h rtos_riot_stackings.h +librtos_la_SOURCES = rtos.c rtos_standard_stackings.c rtos_ecos_stackings.c rtos_chibios_stackings.c rtos_embkernel_stackings.c rtos_mqx_stackings.c rtos_riot_stackings.c FreeRTOS.c ThreadX.c eCos.c linux.c ChibiOS.c embKernel.c mqx.c riot.c librtos_la_CFLAGS = if IS_MINGW diff --git a/src/rtos/riot.c b/src/rtos/riot.c new file mode 100644 index 0000000..7675362 --- /dev/null +++ b/src/rtos/riot.c @@ -0,0 +1,408 @@ +/*************************************************************************** + * Copyright (C) 2015 by Daniel Krebs * + * Daniel Krebs - [email protected] * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * You should have received a copy of the GNU General Public License * + * along with this program; if not, write to the * + * Free Software Foundation, Inc., * + ***************************************************************************/ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <helper/time_support.h> +#include <jtag/jtag.h> +#include "target/target.h" +#include "target/target_type.h" +#include "rtos.h" +#include "helper/log.h" +#include "helper/types.h" +#include "target/armv7m.h" +#include "rtos_riot_stackings.h" + +static int riot_detect_rtos(struct target *target); +static int riot_create(struct target *target); +static int riot_update_threads(struct rtos *rtos); +static int riot_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, char **hex_reg_list); +static int riot_get_symbol_list_to_lookup(symbol_table_elem_t *symbol_list[]); + + +struct riot_thread_state { + int value; + const char *desc; +}; + +/* refer tcb.h */ +static const struct riot_thread_state riot_thread_states[] = { + { 0, "Stopped" }, + { 1, "Sleeping" }, + { 2, "Blocked mutex" }, + { 3, "Blocked receive" }, + { 4, "Blocked send" }, + { 5, "Blocked reply" }, + { 6, "Running" }, + { 7, "Pending" }, +}; +#define RIOT_NUM_STATES (sizeof(riot_thread_states)/sizeof(struct riot_thread_state)) + +struct riot_params { + const char *target_name; + unsigned char thread_sp_offset; + unsigned char thread_status_offset; +}; + +static const struct riot_params riot_params_list[] = { + { + "cortex_m", /* target_name */ + 0x00, /* thread_sp_offset */ + 0x04, /* thread_status_offset */ + }, + { /* STLink */ + "hla_target", /* target_name */ + 0x00, /* thread_sp_offset */ + 0x04, /* thread_status_offset */ + } +}; +#define RIOT_NUM_PARAMS ((int)(sizeof(riot_params_list)/sizeof(struct riot_params))) + +/* Initialize in riot_create() depending on architecture */ +static const struct rtos_register_stacking *stacking_info; + +enum riot_symbol_values { + RIOT_THREADS_BASE = 0, + RIOT_NUM_THREADS, + RIOT_ACTIVE_PID, + RIOT_MAX_THREADS, + RIOT_NAME_OFFSET, +}; + +/* refer core/sched.c */ +static const char * const riot_symbol_list[] = { + "sched_threads", + "sched_num_threads", + "sched_active_pid", + "max_threads", + "_tcb_name_offset", + NULL +}; + +/* Define which symbols are not mandatory */ +const enum riot_symbol_values riot_optional_symbols[] = { + RIOT_NAME_OFFSET, +}; + +const struct rtos_type riot_rtos = { + .name = "RIOT", + + .detect_rtos = riot_detect_rtos, + .create = riot_create, + .update_threads = riot_update_threads, + .get_thread_reg_list = riot_get_thread_reg_list, + .get_symbol_list_to_lookup = riot_get_symbol_list_to_lookup, + +}; + +static int riot_update_threads(struct rtos *rtos) +{ + int retval; + int tasks_found = 0; + const struct riot_params *param; + + if (rtos == NULL) + return -1; + + if (rtos->rtos_specific_params == NULL) + return -3; + + param = (const struct riot_params *) rtos->rtos_specific_params; + + if (rtos->symbols == NULL) { + LOG_ERROR("No symbols for RIOT"); + return -4; + } + + if (rtos->symbols[RIOT_THREADS_BASE].address == 0) { + LOG_ERROR("Can't find symbol `sched_threads`"); + return -2; + } + + /* wipe out previous thread details if any */ + rtos_free_threadlist(rtos); + + /* Reset values */ + rtos->current_thread = 0; + rtos->thread_count = 0; + + /* read the current thread id */ + int16_t active_pid = 0; + retval = target_read_buffer(rtos->target, + rtos->symbols[RIOT_ACTIVE_PID].address, + sizeof(active_pid), + (uint8_t *)&active_pid); + if (retval != ERROR_OK) { + LOG_ERROR("Can't read symbol `sched_active_pid`"); + return retval; + } + rtos->current_thread = active_pid; + + /* read the current thread count */ + /* It's `int` in RIOT, but this is Cortex M* only anyway */ + int32_t thread_count = 0; + retval = target_read_buffer(rtos->target, + rtos->symbols[RIOT_NUM_THREADS].address, + sizeof(thread_count), + (uint8_t *)&thread_count); + if (retval != ERROR_OK) { + LOG_ERROR("Can't read symbol `sched_num_threads`"); + return retval; + } + rtos->thread_count = thread_count; + + /* read the maximum number of threads */ + uint8_t max_threads = 0; + retval = target_read_buffer(rtos->target, + rtos->symbols[RIOT_MAX_THREADS].address, + sizeof(max_threads), + (uint8_t *)&max_threads); + if (retval != ERROR_OK) { + LOG_ERROR("Can't read symbol `_max_threads`"); + return retval; + } + + /* Base address of thread array */ + uint32_t threads_base = rtos->symbols[RIOT_THREADS_BASE].address; + + /* Try to get the offset of tcb_t::name, if absent RIOT wasn't compiled with + * DEVELHELP, so there are no thread names */ + uint8_t name_offset = 0; + if (rtos->symbols[RIOT_NAME_OFFSET].address != 0) { + retval = target_read_buffer(rtos->target, + rtos->symbols[RIOT_NAME_OFFSET].address, + sizeof(name_offset), + (uint8_t *)&name_offset); + if (retval != ERROR_OK) { + LOG_ERROR("Can't read symbol `_tcb_name_offset`"); + return retval; + } + } + + /* Allocate memory for thread description */ + rtos->thread_details = malloc(sizeof(struct thread_detail) * thread_count); + + /* Buffer for thread names, maximum to display is 32 */ + char buffer[32]; + + for (int i = 0; i < max_threads; i++) { + + /* get pointer to tcb_t */ + uint32_t tcb_pointer = 0; + retval = target_read_buffer(rtos->target, + threads_base + (i * 4), + sizeof(tcb_pointer), + (uint8_t *)&tcb_pointer); + if (retval != ERROR_OK) { + LOG_ERROR("Can't parse `sched_threads`"); + return retval; + } + + if (tcb_pointer == 0) { + /* PID unused */ + continue; + } + + /* Index is PID */ + rtos->thread_details[tasks_found].threadid = i; + + /* read thread state */ + uint16_t status = 0; + retval = target_read_buffer(rtos->target, + tcb_pointer + param->thread_status_offset, + sizeof(status), + (uint8_t *)&status); + if (retval != ERROR_OK) { + LOG_ERROR("Can't parse `sched_threads`"); + return retval; + } + + /* Search for state */ + unsigned int k; + for (k = 0; k < RIOT_NUM_STATES; k++) { + if (riot_thread_states[k].value == status) + break; + } + const char *state_str = (k == RIOT_NUM_STATES) ? + "unknown state" : + riot_thread_states[k].desc; + /* Copy state string */ + rtos->thread_details[tasks_found].extra_info_str = malloc( + strlen(state_str) + 1); + strcpy(rtos->thread_details[tasks_found].extra_info_str, state_str); + + /* Thread names are only available if compiled with DEVELHELP */ + if (name_offset != 0) { + uint32_t name_pointer = 0; + retval = target_read_buffer(rtos->target, + tcb_pointer + name_offset, + sizeof(name_pointer), + (uint8_t *)&name_pointer); + if (retval != ERROR_OK) { + LOG_ERROR("Can't parse `sched_threads`"); + return retval; + } + + /* read thread name */ + retval = target_read_buffer(rtos->target, + name_pointer, + sizeof(buffer), + (uint8_t *)&buffer); + if (retval != ERROR_OK) { + LOG_ERROR("Can't parse `sched_threads`"); + return retval; + } + + /* Make sure the string in the buffer terminates */ + if (buffer[sizeof(buffer)-1] != 0) + buffer[sizeof(buffer)-1] = 0; + + /* Copy thread name */ + rtos->thread_details[tasks_found].thread_name_str = malloc( + strlen(buffer) + 1); + strcpy(rtos->thread_details[tasks_found].thread_name_str, buffer); + + } else { + const char no_name[] = "Need DEVELHELP"; + rtos->thread_details[tasks_found].thread_name_str = malloc( + strlen(no_name) + 1); + strcpy(rtos->thread_details[tasks_found].thread_name_str, no_name); + } + + rtos->thread_details[tasks_found].exists = true; + rtos->thread_details[tasks_found].display_str = NULL; + + tasks_found++; + } + + return 0; +} + +static int riot_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, char **hex_reg_list) +{ + int retval; + const struct riot_params *param; + + *hex_reg_list = NULL; + + if (rtos == NULL) + return -1; + + if (thread_id == 0) + return -2; + + if (rtos->rtos_specific_params == NULL) + return -3; + + param = (const struct riot_params *) rtos->rtos_specific_params; + + /* find the thread with given thread id */ + uint32_t threads_base = rtos->symbols[RIOT_THREADS_BASE].address; + uint32_t tcb_pointer = 0; + retval = target_read_buffer(rtos->target, + threads_base + (thread_id * 4), + sizeof(tcb_pointer), + (uint8_t *)&tcb_pointer); + if (retval != ERROR_OK) { + LOG_ERROR("Can't parse `sched_threads`"); + return retval; + } + + /* read stack pointer for that thread */ + uint32_t stackptr = 0; + retval = target_read_buffer(rtos->target, + tcb_pointer + param->thread_sp_offset, + sizeof(stackptr), + (uint8_t *)&stackptr); + if (retval != ERROR_OK) { + LOG_ERROR("Can't parse `sched_threads`"); + return retval; + } + + return rtos_generic_stack_read(rtos->target, + stacking_info, + stackptr, + hex_reg_list); +} + +static int riot_get_symbol_list_to_lookup(symbol_table_elem_t *symbol_list[]) +{ + unsigned int i; + *symbol_list = calloc( + ARRAY_SIZE(riot_symbol_list), sizeof(symbol_table_elem_t)); + + for (i = 0; i < ARRAY_SIZE(riot_symbol_list); i++) { + (*symbol_list)[i].symbol_name = riot_symbol_list[i]; + (*symbol_list)[i].optional = false; + + /* Lookup if symbol is optional */ + for (unsigned k = 0; k < sizeof(riot_optional_symbols); k++) { + if (i == riot_optional_symbols[k]) { + (*symbol_list)[i].optional = true; + break; + } + } + } + + return 0; +} + +static int riot_detect_rtos(struct target *target) +{ + if ((target->rtos->symbols != NULL) && + (target->rtos->symbols[RIOT_THREADS_BASE].address != 0)) { + /* looks like RIOT */ + return 1; + } + return 0; +} + +static int riot_create(struct target *target) +{ + int i = 0; + + /* lookup if target is supported by RIOT */ + while ((i < RIOT_NUM_PARAMS) && + (0 != strcmp(riot_params_list[i].target_name, target->type->name))) { + i++; + } + if (i >= RIOT_NUM_PARAMS) { + LOG_ERROR("Could not find target in RIOT compatibility list"); + return -1; + } + + target->rtos->rtos_specific_params = (void *) &riot_params_list[i]; + target->rtos->current_thread = 0; + target->rtos->thread_details = NULL; + + /* Stacking is different depending on architecture */ + struct armv7m_common *armv7m_target = target_to_armv7m(target); + + if (armv7m_target->arm.is_armv6m) { + stacking_info = &rtos_riot_Cortex_M0_stacking; + } else if (is_armv7m(armv7m_target)) { + stacking_info = &rtos_riot_Cortex_M34_stacking; + } else { + LOG_ERROR("No stacking info for architecture"); + return -1; + } + return 0; +} diff --git a/src/rtos/rtos.c b/src/rtos/rtos.c index 3420d06..993d188 100644 --- a/src/rtos/rtos.c +++ b/src/rtos/rtos.c @@ -36,6 +36,7 @@ extern struct rtos_type Linux_os; extern struct rtos_type ChibiOS_rtos; extern struct rtos_type embKernel_rtos; extern struct rtos_type mqx_rtos; +extern struct rtos_type riot_rtos; static struct rtos_type *rtos_types[] = { &ThreadX_rtos, @@ -45,6 +46,7 @@ static struct rtos_type *rtos_types[] = { &ChibiOS_rtos, &embKernel_rtos, &mqx_rtos, + &riot_rtos, NULL }; diff --git a/src/rtos/rtos_riot_stackings.c b/src/rtos/rtos_riot_stackings.c new file mode 100644 index 0000000..491bdf2 --- /dev/null +++ b/src/rtos/rtos_riot_stackings.c @@ -0,0 +1,83 @@ +/*************************************************************************** + * Copyright (C) 2015 by Daniel Krebs * + * Daniel Krebs - [email protected] * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * You should have received a copy of the GNU General Public License * + * along with this program; if not, write to the * + * Free Software Foundation, Inc., * + ***************************************************************************/ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "rtos.h" +#include "target/armv7m.h" + +/* see thread_arch.c */ +static const struct stack_register_offset rtos_riot_Cortex_M0_stack_offsets[ARMV7M_NUM_CORE_REGS] = { + { 0x24, 32 }, /* r0 */ + { 0x28, 32 }, /* r1 */ + { 0x2c, 32 }, /* r2 */ + { 0x30, 32 }, /* r3 */ + { 0x14, 32 }, /* r4 */ + { 0x18, 32 }, /* r5 */ + { 0x1c, 32 }, /* r6 */ + { 0x20, 32 }, /* r7 */ + { 0x04, 32 }, /* r8 */ + { 0x08, 32 }, /* r9 */ + { 0x0c, 32 }, /* r10 */ + { 0x10, 32 }, /* r11 */ + { 0x34, 32 }, /* r12 */ + { -2, 32 }, /* sp */ + { 0x38, 32 }, /* lr */ + { 0x3c, 32 }, /* pc */ + { 0x40, 32 }, /* xPSR */ +}; + +const struct rtos_register_stacking rtos_riot_Cortex_M0_stacking = { + 0x44, /* stack_registers_size */ + -1, /* stack_growth_direction */ + ARMV7M_NUM_CORE_REGS, /* num_output_registers */ + 8, /* stack_alignment */ + rtos_riot_Cortex_M0_stack_offsets /* register_offsets */ +}; + +/* see thread_arch.c */ +static const struct stack_register_offset rtos_riot_Cortex_M34_stack_offsets[ARMV7M_NUM_CORE_REGS] = { + { 0x24, 32 }, /* r0 */ + { 0x28, 32 }, /* r1 */ + { 0x2c, 32 }, /* r2 */ + { 0x30, 32 }, /* r3 */ + { 0x04, 32 }, /* r4 */ + { 0x08, 32 }, /* r5 */ + { 0x0c, 32 }, /* r6 */ + { 0x10, 32 }, /* r7 */ + { 0x14, 32 }, /* r8 */ + { 0x18, 32 }, /* r9 */ + { 0x1c, 32 }, /* r10 */ + { 0x20, 32 }, /* r11 */ + { 0x34, 32 }, /* r12 */ + { -2, 32 }, /* sp */ + { 0x38, 32 }, /* lr */ + { 0x3c, 32 }, /* pc */ + { 0x40, 32 }, /* xPSR */ +}; + +const struct rtos_register_stacking rtos_riot_Cortex_M34_stacking = { + 0x44, /* stack_registers_size */ + -1, /* stack_growth_direction */ + ARMV7M_NUM_CORE_REGS, /* num_output_registers */ + 8, /* stack_alignment */ + rtos_riot_Cortex_M34_stack_offsets /* register_offsets */ +}; diff --git a/src/rtos/rtos_riot_stackings.h b/src/rtos/rtos_riot_stackings.h new file mode 100644 index 0000000..39f1726 --- /dev/null +++ b/src/rtos/rtos_riot_stackings.h @@ -0,0 +1,31 @@ +/*************************************************************************** + * Copyright (C) 2015 by Daniel Krebs * + * Daniel Krebs - [email protected] * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * You should have received a copy of the GNU General Public License * + * along with this program; if not, write to the * + * Free Software Foundation, Inc., * + ***************************************************************************/ + +#ifndef INCLUDED_RTOS_RIOT_STACKINGS_H_ +#define INCLUDED_RTOS_RIOT_STACKINGS_H_ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "rtos.h" + +extern const struct rtos_register_stacking rtos_riot_Cortex_M0_stacking; +extern const struct rtos_register_stacking rtos_riot_Cortex_M34_stacking; +#endif /* ifndef INCLUDED_RTOS_RIOT_STACKINGS_H_ */ -- ------------------------------------------------------------------------------ _______________________________________________ OpenOCD-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/openocd-devel
