imi415
/
openocd
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

rtos: add support for RIOT 

Add threads support for RIOT (https://github.com/RIOT-OS/RIOT).
Original code is from Daniel Krebs.

Change-Id: I83fe3b91dd75949e800b5aea1015d8fa37b09c61
Signed-off-by: Daniel Krebs <github@daniel-krebs.net>
Signed-off-by: Vincent Dupont <vincent@otakeys.com>
Signed-off-by: Benjamin Valentin <benpicco@googlemail.com>
Reviewed-on: http://openocd.zylin.com/4256
Tested-by: jenkins
Reviewed-by: Antonio Borneo <borneo.antonio@gmail.com>
This commit is contained in:
Daniel Krebs 2015-10-05 15:37:57 +02:00 committed by Antonio Borneo
parent cf902f7034
commit 6a78c8581d
6 changed files with 566 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
doc/openocd.texi
View File

@ -4637,7 +4637,8 @@ The value should normally correspond to a static mapping for the
@item @code{-rtos} @var{rtos_type} -- enable rtos support for target,
@var{rtos_type} can be one of @option{auto}, @option{eCos},
@option{ThreadX}, @option{FreeRTOS}, @option{linux}, @option{ChibiOS},
@option{embKernel}, @option{mqx}, @option{uCOS-III}, @option{nuttx}
@option{embKernel}, @option{mqx}, @option{uCOS-III}, @option{nuttx},
@option{RIOT}
@xref{gdbrtossupport,,RTOS Support}.
@item @code{-defer-examine} -- skip target examination at initial JTAG chain
@ -10556,6 +10557,7 @@ Currently supported rtos's include:
@item @option{mqx}
@item @option{uCOS-III}
@item @option{nuttx}
@item @option{RIOT}
@item @option{hwthread} (This is not an actual RTOS. @xref{usingopenocdsmpwithgdb,,Using OpenOCD SMP with GDB}.)
@end itemize
@ -10592,6 +10594,8 @@ _mqx_kernel_data, MQX_init_struct.
OSRunning, OSTCBCurPtr, OSTaskDbgListPtr, OSTaskQty
@item nuttx symbols
g_readytorun, g_tasklisttable
@item RIOT symbols
sched_threads, sched_num_threads, sched_active_pid, max_threads, _tcb_name_offset
@end table
For most RTOS supported the above symbols will be exported by default. However for

3
src/rtos/Makefile.am
View File

@ -7,6 +7,7 @@ noinst_LTLIBRARIES += %D%/librtos.la
%D%/rtos_embkernel_stackings.c \
%D%/rtos_mqx_stackings.c \
%D%/rtos_ucos_iii_stackings.c \
%D%/rtos_riot_stackings.c \
%D%/FreeRTOS.c \
%D%/ThreadX.c \
%D%/eCos.c \
@ -18,6 +19,7 @@ noinst_LTLIBRARIES += %D%/librtos.la
%D%/uCOS-III.c \
%D%/nuttx.c \
%D%/hwthread.c \
%D%/riot.c \
%D%/rtos.h \
%D%/rtos_standard_stackings.h \
%D%/rtos_ecos_stackings.h \
@ -25,6 +27,7 @@ noinst_LTLIBRARIES += %D%/librtos.la
%D%/rtos_chibios_stackings.h \
%D%/rtos_embkernel_stackings.h \
%D%/rtos_mqx_stackings.h \
%D%/rtos_riot_stackings.h \
%D%/rtos_ucos_iii_stackings.h \
%D%/nuttx_header.h

428
src/rtos/riot.c Normal file
View File

@ -0,0 +1,428 @@
/***************************************************************************
* Copyright (C) 2015 by Daniel Krebs *
* Daniel Krebs - github@daniel-krebs.net *
* *
* 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, see <http://www.gnu.org/licenses/>. *
***************************************************************************/
#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 bool 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,
struct rtos_reg **reg_list, int *num_regs);
static int riot_get_symbol_list_to_lookup(symbol_table_elem_t *symbol_list[]);
struct riot_thread_state {
int value;
const char *desc;
};
/* refer RIOT sched.h */
static const struct riot_thread_state riot_thread_states[] = {
{ 0, "Stopped" },
{ 1, "Zombie" },
{ 2, "Sleeping" },
{ 3, "Blocked mutex" },
{ 4, "Blocked receive" },
{ 5, "Blocked send" },
{ 6, "Blocked reply" },
{ 7, "Blocked any flag" },
{ 8, "Blocked all flags" },
{ 9, "Blocked mbox" },
{ 10, "Blocked condition" },
{ 11, "Running" },
{ 12, "Pending" },
};
#define RIOT_NUM_STATES ARRAY_SIZE(riot_thread_states)
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 ARRAY_SIZE(riot_params_list)
/* 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 RIOT 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 */
static 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;
unsigned int tasks_found = 0;
const struct riot_params *param;
if (rtos == NULL)
return ERROR_FAIL;
if (rtos->rtos_specific_params == NULL)
return ERROR_FAIL;
param = (const struct riot_params *)rtos->rtos_specific_params;
if (rtos->symbols == NULL) {
LOG_ERROR("No symbols for RIOT");
return ERROR_FAIL;
}
if (rtos->symbols[RIOT_THREADS_BASE].address == 0) {
LOG_ERROR("Can't find symbol `%s`",
riot_symbol_list[RIOT_THREADS_BASE]);
return ERROR_FAIL;
}
/* 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_u16(rtos->target,
rtos->symbols[RIOT_ACTIVE_PID].address,
(uint16_t *)&active_pid);
if (retval != ERROR_OK) {
LOG_ERROR("Can't read symbol `%s`",
riot_symbol_list[RIOT_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_u16(rtos->target,
rtos->symbols[RIOT_NUM_THREADS].address,
(uint16_t *)&thread_count);
if (retval != ERROR_OK) {
LOG_ERROR("Can't read symbol `%s`",
riot_symbol_list[RIOT_NUM_THREADS]);
return retval;
}
rtos->thread_count = thread_count;
/* read the maximum number of threads */
uint8_t max_threads = 0;
retval = target_read_u8(rtos->target,
rtos->symbols[RIOT_MAX_THREADS].address,
&max_threads);
if (retval != ERROR_OK) {
LOG_ERROR("Can't read symbol `%s`",
riot_symbol_list[RIOT_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_u8(rtos->target,
rtos->symbols[RIOT_NAME_OFFSET].address,
&name_offset);
if (retval != ERROR_OK) {
LOG_ERROR("Can't read symbol `%s`",
riot_symbol_list[RIOT_NAME_OFFSET]);
return retval;
}
}
/* Allocate memory for thread description */
rtos->thread_details = calloc(thread_count, sizeof(struct thread_detail));
if (rtos->thread_details == NULL) {
LOG_ERROR("RIOT: out of memory");
return ERROR_FAIL;
}
/* Buffer for thread names, maximum to display is 32 */
char buffer[32];
for (unsigned int i = 0; i < max_threads; i++) {
/* get pointer to tcb_t */
uint32_t tcb_pointer = 0;
retval = target_read_u32(rtos->target,
threads_base + (i * 4),
&tcb_pointer);
if (retval != ERROR_OK) {
LOG_ERROR("Can't parse `%s`", riot_symbol_list[RIOT_THREADS_BASE]);
goto error;
}
if (tcb_pointer == 0) {
/* PID unused */
continue;
}
/* Index is PID */
rtos->thread_details[tasks_found].threadid = i;
/* read thread state */
uint8_t status = 0;
retval = target_read_u8(rtos->target,
tcb_pointer + param->thread_status_offset,
&status);
if (retval != ERROR_OK) {
LOG_ERROR("Can't parse `%s`", riot_symbol_list[RIOT_THREADS_BASE]);
goto error;
}
/* Search for state */
unsigned int k;
for (k = 0; k < RIOT_NUM_STATES; k++) {
if (riot_thread_states[k].value == status)
break;
}
/* Copy state string */
if (k >= RIOT_NUM_STATES) {
rtos->thread_details[tasks_found].extra_info_str =
strdup("unknown state");
} else {
rtos->thread_details[tasks_found].extra_info_str =
strdup(riot_thread_states[k].desc);
}
if (rtos->thread_details[tasks_found].extra_info_str == NULL) {
LOG_ERROR("RIOT: out of memory");
retval = ERROR_FAIL;
goto error;
}
/* Thread names are only available if compiled with DEVELHELP */
if (name_offset != 0) {
uint32_t name_pointer = 0;
retval = target_read_u32(rtos->target,
tcb_pointer + name_offset,
&name_pointer);
if (retval != ERROR_OK) {
LOG_ERROR("Can't parse `%s`",
riot_symbol_list[RIOT_THREADS_BASE]);
goto error;
}
/* 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 `%s`",
riot_symbol_list[RIOT_THREADS_BASE]);
goto error;
}
/* 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 =
strdup(buffer);
} else {
rtos->thread_details[tasks_found].thread_name_str =
strdup("Enable DEVELHELP to see task names");
}
if (rtos->thread_details[tasks_found].thread_name_str == NULL) {
LOG_ERROR("RIOT: out of memory");
retval = ERROR_FAIL;
goto error;
}
rtos->thread_details[tasks_found].exists = true;
tasks_found++;
}
return ERROR_OK;
error:
rtos_free_threadlist(rtos);
return retval;
}
static int riot_get_thread_reg_list(struct rtos *rtos, int64_t thread_id,
struct rtos_reg **reg_list, int *num_regs)
{
int retval;
const struct riot_params *param;
if (rtos == NULL)
return ERROR_FAIL;
if (thread_id == 0)
return ERROR_FAIL;
if (rtos->rtos_specific_params == NULL)
return ERROR_FAIL;
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_u32(rtos->target,
threads_base + (thread_id * 4),
&tcb_pointer);
if (retval != ERROR_OK) {
LOG_ERROR("Can't parse `%s`", riot_symbol_list[RIOT_THREADS_BASE]);
return retval;
}
/* read stack pointer for that thread */
uint32_t stackptr = 0;
retval = target_read_u32(rtos->target,
tcb_pointer + param->thread_sp_offset,
&stackptr);
if (retval != ERROR_OK) {
LOG_ERROR("Can't parse `%s`", riot_symbol_list[RIOT_THREADS_BASE]);
return retval;
}
return rtos_generic_stack_read(rtos->target,
stacking_info,
stackptr,
reg_list,
num_regs);
}
static int riot_get_symbol_list_to_lookup(symbol_table_elem_t *symbol_list[])
{
*symbol_list = calloc(ARRAY_SIZE(riot_symbol_list), sizeof(symbol_table_elem_t));
if (*symbol_list == NULL) {
LOG_ERROR("RIOT: out of memory");
return ERROR_FAIL;
}
for (unsigned int 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 int k = 0; k < sizeof(riot_optional_symbols); k++) {
if (i == riot_optional_symbols[k]) {
(*symbol_list)[i].optional = true;
break;
}
}
}
return ERROR_OK;
}
static bool riot_detect_rtos(struct target *target)
{
if ((target->rtos->symbols != NULL) &&
(target->rtos->symbols[RIOT_THREADS_BASE].address != 0)) {
/* looks like RIOT */
return true;
}
return false;
}
static int riot_create(struct target *target)
{
unsigned 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 ERROR_FAIL;
}
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 ERROR_FAIL;
}
return ERROR_OK;
}

3
src/rtos/rtos.c
View File

@ -38,6 +38,7 @@ extern struct rtos_type mqx_rtos;
extern struct rtos_type uCOS_III_rtos;
extern struct rtos_type nuttx_rtos;
extern struct rtos_type hwthread_rtos;
extern struct rtos_type riot_rtos;
static struct rtos_type *rtos_types[] = {
&ThreadX_rtos,
@ -50,6 +51,8 @@ static struct rtos_type *rtos_types[] = {
&mqx_rtos,
&uCOS_III_rtos,
&nuttx_rtos,
&riot_rtos,
/* keep this as last, as it always matches with rtos auto */
&hwthread_rtos,
NULL
};

95
src/rtos/rtos_riot_stackings.c Normal file
View File

@ -0,0 +1,95 @@
/***************************************************************************
* Copyright (C) 2015 by Daniel Krebs *
* Daniel Krebs - github@daniel-krebs.net *
* *
* 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, see <http://www.gnu.org/licenses/>. *
***************************************************************************/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "rtos.h"
#include "target/armv7m.h"
#include "rtos_standard_stackings.h"
/* This works for the M0 and M34 stackings as xPSR is in a fixed
* location
*/
static int64_t rtos_riot_cortex_m_stack_align(struct target *target,
const uint8_t *stack_data, const struct rtos_register_stacking *stacking,
int64_t stack_ptr)
{
const int XPSR_OFFSET = 0x40;
return rtos_Cortex_M_stack_align(target, stack_data, stacking,
stack_ptr, XPSR_OFFSET);
}
/* see thread_arch.c */
static const struct stack_register_offset rtos_riot_cortex_m0_stack_offsets[ARMV7M_NUM_CORE_REGS] = {
{ ARMV7M_R0, 0x24, 32 }, /* r0 */
{ ARMV7M_R1, 0x28, 32 }, /* r1 */
{ ARMV7M_R2, 0x2c, 32 }, /* r2 */
{ ARMV7M_R3, 0x30, 32 }, /* r3 */
{ ARMV7M_R4, 0x14, 32 }, /* r4 */
{ ARMV7M_R5, 0x18, 32 }, /* r5 */
{ ARMV7M_R6, 0x1c, 32 }, /* r6 */
{ ARMV7M_R7, 0x20, 32 }, /* r7 */
{ ARMV7M_R8, 0x04, 32 }, /* r8 */
{ ARMV7M_R9, 0x08, 32 }, /* r9 */
{ ARMV7M_R10, 0x0c, 32 }, /* r10 */
{ ARMV7M_R11, 0x10, 32 }, /* r11 */
{ ARMV7M_R12, 0x34, 32 }, /* r12 */
{ ARMV7M_R13, -2, 32 }, /* sp */
{ ARMV7M_R14, 0x38, 32 }, /* lr */
{ ARMV7M_PC, 0x3c, 32 }, /* pc */
{ ARMV7M_xPSR, 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 */
rtos_riot_cortex_m_stack_align, /* 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] = {
{ ARMV7M_R0, 0x24, 32 }, /* r0 */
{ ARMV7M_R1, 0x28, 32 }, /* r1 */
{ ARMV7M_R2, 0x2c, 32 }, /* r2 */
{ ARMV7M_R3, 0x30, 32 }, /* r3 */
{ ARMV7M_R4, 0x04, 32 }, /* r4 */
{ ARMV7M_R5, 0x08, 32 }, /* r5 */
{ ARMV7M_R6, 0x0c, 32 }, /* r6 */
{ ARMV7M_R7, 0x10, 32 }, /* r7 */
{ ARMV7M_R8, 0x14, 32 }, /* r8 */
{ ARMV7M_R9, 0x18, 32 }, /* r9 */
{ ARMV7M_R10, 0x1c, 32 }, /* r10 */
{ ARMV7M_R11, 0x20, 32 }, /* r11 */
{ ARMV7M_R12, 0x34, 32 }, /* r12 */
{ ARMV7M_R13, -2, 32 }, /* sp */
{ ARMV7M_R14, 0x38, 32 }, /* lr */
{ ARMV7M_PC, 0x3c, 32 }, /* pc */
{ ARMV7M_xPSR, 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 */
rtos_riot_cortex_m_stack_align, /* stack_alignment */
rtos_riot_cortex_m34_stack_offsets /* register_offsets */
};

32
src/rtos/rtos_riot_stackings.h Normal file
View File

@ -0,0 +1,32 @@
/***************************************************************************
* Copyright (C) 2015 by Daniel Krebs *
* Daniel Krebs - github@daniel-krebs.net *
* *
* 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, see <http://www.gnu.org/licenses/>. *
***************************************************************************/
#ifndef OPENOCD_RTOS_RTOS_RIOT_STACKINGS_H
#define OPENOCD_RTOS_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 /* OPENOCD_RTOS_RTOS_RIOT_STACKINGS_H */