Browse Source

rtos: rename CamelCase symbols

Only one exported symbol from eCos is included in this patch.
The eCos code is left untouched to prevent conflicts with patches
currently under review.

While there, remove an unused camelcase macro

Change-Id: I8d22dec6e243c00665d99a8b8ba00474b4f088db
Signed-off-by: Antonio Borneo <borneo.antonio@gmail.com>
Reviewed-on: http://openocd.zylin.com/6305
Tested-by: jenkins
Reviewed-by: Marc Schink <dev@zapb.de>
jim
Antonio Borneo 2 years ago
parent
commit
a489058d7b
17 changed files with 253 additions and 257 deletions
  1. +47
    -51
      src/rtos/FreeRTOS.c
  2. +47
    -47
      src/rtos/ThreadX.c
  3. +5
    -5
      src/rtos/chibios.c
  4. +2
    -2
      src/rtos/chromium-ec.c
  5. +1
    -1
      src/rtos/eCos.c
  6. +42
    -42
      src/rtos/embKernel.c
  7. +5
    -5
      src/rtos/linux.c
  8. +12
    -12
      src/rtos/rtos.c
  9. +3
    -3
      src/rtos/rtos_embkernel_stackings.c
  10. +1
    -1
      src/rtos/rtos_embkernel_stackings.h
  11. +1
    -1
      src/rtos/rtos_riot_stackings.c
  12. +25
    -25
      src/rtos/rtos_standard_stackings.c
  13. +6
    -6
      src/rtos/rtos_standard_stackings.h
  14. +8
    -8
      src/rtos/rtos_ucos_iii_stackings.c
  15. +2
    -2
      src/rtos/rtos_ucos_iii_stackings.h
  16. +45
    -45
      src/rtos/uCOS-III.c
  17. +1
    -1
      src/rtos/zephyr.c

+ 47
- 51
src/rtos/FreeRTOS.c View File

@@ -31,18 +31,14 @@
#include "target/armv7m.h"
#include "target/cortex_m.h"



#define FREERTOS_MAX_PRIORITIES 63

#define FreeRTOS_STRUCT(int_type, ptr_type, list_prev_offset)

/* FIXME: none of the _width parameters are actually observed properly!
* you WILL need to edit more if you actually attempt to target a 8/16/64
* bit target!
*/

struct FreeRTOS_params {
struct freertos_params {
const char *target_name;
const unsigned char thread_count_width;
const unsigned char pointer_width;
@@ -57,7 +53,7 @@ struct FreeRTOS_params {
const struct rtos_register_stacking *stacking_info_cm4f_fpu;
};

static const struct FreeRTOS_params FreeRTOS_params_list[] = {
static const struct freertos_params freertos_params_list[] = {
{
"cortex_m", /* target_name */
4, /* thread_count_width; */
@@ -68,9 +64,9 @@ static const struct FreeRTOS_params FreeRTOS_params_list[] = {
12, /* list_elem_content_offset */
0, /* thread_stack_offset; */
52, /* thread_name_offset; */
&rtos_standard_Cortex_M3_stacking, /* stacking_info */
&rtos_standard_Cortex_M4F_stacking,
&rtos_standard_Cortex_M4F_FPU_stacking,
&rtos_standard_cortex_m3_stacking, /* stacking_info */
&rtos_standard_cortex_m4f_stacking,
&rtos_standard_cortex_m4f_fpu_stacking,
},
{
"hla_target", /* target_name */
@@ -82,9 +78,9 @@ static const struct FreeRTOS_params FreeRTOS_params_list[] = {
12, /* list_elem_content_offset */
0, /* thread_stack_offset; */
52, /* thread_name_offset; */
&rtos_standard_Cortex_M3_stacking, /* stacking_info */
&rtos_standard_Cortex_M4F_stacking,
&rtos_standard_Cortex_M4F_FPU_stacking,
&rtos_standard_cortex_m3_stacking, /* stacking_info */
&rtos_standard_cortex_m4f_stacking,
&rtos_standard_cortex_m4f_fpu_stacking,
},
{
"nds32_v3", /* target_name */
@@ -96,30 +92,30 @@ static const struct FreeRTOS_params FreeRTOS_params_list[] = {
12, /* list_elem_content_offset */
0, /* thread_stack_offset; */
52, /* thread_name_offset; */
&rtos_standard_NDS32_N1068_stacking, /* stacking_info */
&rtos_standard_Cortex_M4F_stacking,
&rtos_standard_Cortex_M4F_FPU_stacking,
&rtos_standard_nds32_n1068_stacking, /* stacking_info */
&rtos_standard_cortex_m4f_stacking,
&rtos_standard_cortex_m4f_fpu_stacking,
},
};

static bool FreeRTOS_detect_rtos(struct target *target);
static int FreeRTOS_create(struct target *target);
static int FreeRTOS_update_threads(struct rtos *rtos);
static int FreeRTOS_get_thread_reg_list(struct rtos *rtos, int64_t thread_id,
static bool freertos_detect_rtos(struct target *target);
static int freertos_create(struct target *target);
static int freertos_update_threads(struct rtos *rtos);
static int freertos_get_thread_reg_list(struct rtos *rtos, int64_t thread_id,
struct rtos_reg **reg_list, int *num_regs);
static int FreeRTOS_get_symbol_list_to_lookup(struct symbol_table_elem *symbol_list[]);
static int freertos_get_symbol_list_to_lookup(struct symbol_table_elem *symbol_list[]);

struct rtos_type FreeRTOS_rtos = {
struct rtos_type freertos_rtos = {
.name = "FreeRTOS",

.detect_rtos = FreeRTOS_detect_rtos,
.create = FreeRTOS_create,
.update_threads = FreeRTOS_update_threads,
.get_thread_reg_list = FreeRTOS_get_thread_reg_list,
.get_symbol_list_to_lookup = FreeRTOS_get_symbol_list_to_lookup,
.detect_rtos = freertos_detect_rtos,
.create = freertos_create,
.update_threads = freertos_update_threads,
.get_thread_reg_list = freertos_get_thread_reg_list,
.get_symbol_list_to_lookup = freertos_get_symbol_list_to_lookup,
};

enum FreeRTOS_symbol_values {
enum freertos_symbol_values {
FREERTOS_VAL_PX_CURRENT_TCB = 0,
FREERTOS_VAL_PX_READY_TASKS_LISTS = 1,
FREERTOS_VAL_X_DELAYED_TASK_LIST1 = 2,
@@ -138,7 +134,7 @@ struct symbols {
bool optional;
};

static const struct symbols FreeRTOS_symbol_list[] = {
static const struct symbols freertos_symbol_list[] = {
{ "pxCurrentTCB", false },
{ "pxReadyTasksLists", false },
{ "xDelayedTaskList1", false },
@@ -158,16 +154,16 @@ static const struct symbols FreeRTOS_symbol_list[] = {
/* may be problems reading if sizes are not 32 bit long integers. */
/* test mallocs for failure */

static int FreeRTOS_update_threads(struct rtos *rtos)
static int freertos_update_threads(struct rtos *rtos)
{
int retval;
unsigned int tasks_found = 0;
const struct FreeRTOS_params *param;
const struct freertos_params *param;

if (rtos->rtos_specific_params == NULL)
return -1;

param = (const struct FreeRTOS_params *) rtos->rtos_specific_params;
param = (const struct freertos_params *) rtos->rtos_specific_params;

if (rtos->symbols == NULL) {
LOG_ERROR("No symbols for FreeRTOS");
@@ -400,11 +396,11 @@ static int FreeRTOS_update_threads(struct rtos *rtos)
return 0;
}

static int FreeRTOS_get_thread_reg_list(struct rtos *rtos, int64_t thread_id,
static int freertos_get_thread_reg_list(struct rtos *rtos, int64_t thread_id,
struct rtos_reg **reg_list, int *num_regs)
{
int retval;
const struct FreeRTOS_params *param;
const struct freertos_params *param;
int64_t stack_ptr = 0;

if (rtos == NULL)
@@ -416,7 +412,7 @@ static int FreeRTOS_get_thread_reg_list(struct rtos *rtos, int64_t thread_id,
if (rtos->rtos_specific_params == NULL)
return -1;

param = (const struct FreeRTOS_params *) rtos->rtos_specific_params;
param = (const struct freertos_params *) rtos->rtos_specific_params;

/* Read the stack pointer */
uint32_t pointer_casts_are_bad;
@@ -456,15 +452,15 @@ static int FreeRTOS_get_thread_reg_list(struct rtos *rtos, int64_t thread_id,

if (cm4_fpu_enabled == 1) {
/* Read the LR to decide between stacking with or without FPU */
uint32_t LR_svc = 0;
uint32_t lr_svc = 0;
retval = target_read_u32(rtos->target,
stack_ptr + 0x20,
&LR_svc);
&lr_svc);
if (retval != ERROR_OK) {
LOG_OUTPUT("Error reading stack frame from FreeRTOS thread");
return retval;
}
if ((LR_svc & 0x10) == 0)
if ((lr_svc & 0x10) == 0)
return rtos_generic_stack_read(rtos->target, param->stacking_info_cm4f_fpu, stack_ptr, reg_list, num_regs);
else
return rtos_generic_stack_read(rtos->target, param->stacking_info_cm4f, stack_ptr, reg_list, num_regs);
@@ -472,15 +468,15 @@ static int FreeRTOS_get_thread_reg_list(struct rtos *rtos, int64_t thread_id,
return rtos_generic_stack_read(rtos->target, param->stacking_info_cm3, stack_ptr, reg_list, num_regs);
}

static int FreeRTOS_get_symbol_list_to_lookup(struct symbol_table_elem *symbol_list[])
static int freertos_get_symbol_list_to_lookup(struct symbol_table_elem *symbol_list[])
{
unsigned int i;
*symbol_list = calloc(
ARRAY_SIZE(FreeRTOS_symbol_list), sizeof(struct symbol_table_elem));
ARRAY_SIZE(freertos_symbol_list), sizeof(struct symbol_table_elem));

for (i = 0; i < ARRAY_SIZE(FreeRTOS_symbol_list); i++) {
(*symbol_list)[i].symbol_name = FreeRTOS_symbol_list[i].name;
(*symbol_list)[i].optional = FreeRTOS_symbol_list[i].optional;
for (i = 0; i < ARRAY_SIZE(freertos_symbol_list); i++) {
(*symbol_list)[i].symbol_name = freertos_symbol_list[i].name;
(*symbol_list)[i].optional = freertos_symbol_list[i].optional;
}

return 0;
@@ -488,15 +484,15 @@ static int FreeRTOS_get_symbol_list_to_lookup(struct symbol_table_elem *symbol_l

#if 0

static int FreeRTOS_set_current_thread(struct rtos *rtos, threadid_t thread_id)
static int freertos_set_current_thread(struct rtos *rtos, threadid_t thread_id)
{
return 0;
}

static int FreeRTOS_get_thread_ascii_info(struct rtos *rtos, threadid_t thread_id, char **info)
static int freertos_get_thread_ascii_info(struct rtos *rtos, threadid_t thread_id, char **info)
{
int retval;
const struct FreeRTOS_params *param;
const struct freertos_params *param;

if (rtos == NULL)
return -1;
@@ -507,7 +503,7 @@ static int FreeRTOS_get_thread_ascii_info(struct rtos *rtos, threadid_t thread_i
if (rtos->rtos_specific_params == NULL)
return -3;

param = (const struct FreeRTOS_params *) rtos->rtos_specific_params;
param = (const struct freertos_params *) rtos->rtos_specific_params;

#define FREERTOS_THREAD_NAME_STR_SIZE (200)
char tmp_str[FREERTOS_THREAD_NAME_STR_SIZE];
@@ -533,7 +529,7 @@ static int FreeRTOS_get_thread_ascii_info(struct rtos *rtos, threadid_t thread_i

#endif

static bool FreeRTOS_detect_rtos(struct target *target)
static bool freertos_detect_rtos(struct target *target)
{
if ((target->rtos->symbols != NULL) &&
(target->rtos->symbols[FREERTOS_VAL_PX_READY_TASKS_LISTS].address != 0)) {
@@ -543,11 +539,11 @@ static bool FreeRTOS_detect_rtos(struct target *target)
return false;
}

static int FreeRTOS_create(struct target *target)
static int freertos_create(struct target *target)
{
for (unsigned int i = 0; i < ARRAY_SIZE(FreeRTOS_params_list); i++)
if (strcmp(FreeRTOS_params_list[i].target_name, target->type->name) == 0) {
target->rtos->rtos_specific_params = (void *)&FreeRTOS_params_list[i];
for (unsigned int i = 0; i < ARRAY_SIZE(freertos_params_list); i++)
if (strcmp(freertos_params_list[i].target_name, target->type->name) == 0) {
target->rtos->rtos_specific_params = (void *)&freertos_params_list[i];
return 0;
}



+ 47
- 47
src/rtos/ThreadX.c View File

@@ -35,20 +35,20 @@ static const struct rtos_register_stacking *get_stacking_info_arm926ejs(const st
static int is_thread_id_valid(const struct rtos *rtos, int64_t thread_id);
static int is_thread_id_valid_arm926ejs(const struct rtos *rtos, int64_t thread_id);

static bool ThreadX_detect_rtos(struct target *target);
static int ThreadX_create(struct target *target);
static int ThreadX_update_threads(struct rtos *rtos);
static int ThreadX_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, struct rtos_reg **reg_list, int *num_regs);
static int ThreadX_get_symbol_list_to_lookup(struct symbol_table_elem *symbol_list[]);
static bool threadx_detect_rtos(struct target *target);
static int threadx_create(struct target *target);
static int threadx_update_threads(struct rtos *rtos);
static int threadx_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, struct rtos_reg **reg_list, int *num_regs);
static int threadx_get_symbol_list_to_lookup(struct symbol_table_elem *symbol_list[]);



struct ThreadX_thread_state {
struct threadx_thread_state {
int value;
const char *desc;
};

static const struct ThreadX_thread_state ThreadX_thread_states[] = {
static const struct threadx_thread_state threadx_thread_states[] = {
{ 0, "Ready" },
{ 1, "Completed" },
{ 2, "Terminated" },
@@ -65,7 +65,7 @@ static const struct ThreadX_thread_state ThreadX_thread_states[] = {
{ 13, "Waiting - Mutex" },
};

#define THREADX_NUM_STATES ARRAY_SIZE(ThreadX_thread_states)
#define THREADX_NUM_STATES ARRAY_SIZE(threadx_thread_states)

#define ARM926EJS_REGISTERS_SIZE_SOLICITED (11 * 4)
static const struct stack_register_offset rtos_threadx_arm926ejs_stack_offsets_solicited[] = {
@@ -127,7 +127,7 @@ static const struct rtos_register_stacking rtos_threadx_arm926ejs_stacking[] = {
},
};

struct ThreadX_params {
struct threadx_params {
const char *target_name;
unsigned char pointer_width;
unsigned char thread_stack_offset;
@@ -140,7 +140,7 @@ struct ThreadX_params {
int (*fn_is_thread_id_valid)(const struct rtos *rtos, int64_t thread_id);
};

static const struct ThreadX_params ThreadX_params_list[] = {
static const struct threadx_params threadx_params_list[] = {
{
"cortex_m", /* target_name */
4, /* pointer_width; */
@@ -148,7 +148,7 @@ static const struct ThreadX_params ThreadX_params_list[] = {
40, /* thread_name_offset; */
48, /* thread_state_offset; */
136, /* thread_next_offset */
&rtos_standard_Cortex_M3_stacking, /* stacking_info */
&rtos_standard_cortex_m3_stacking, /* stacking_info */
1, /* stacking_info_nb */
NULL, /* fn_get_stacking_info */
NULL, /* fn_is_thread_id_valid */
@@ -160,7 +160,7 @@ static const struct ThreadX_params ThreadX_params_list[] = {
40, /* thread_name_offset; */
48, /* thread_state_offset; */
136, /* thread_next_offset */
&rtos_standard_Cortex_R4_stacking, /* stacking_info */
&rtos_standard_cortex_r4_stacking, /* stacking_info */
1, /* stacking_info_nb */
NULL, /* fn_get_stacking_info */
NULL, /* fn_is_thread_id_valid */
@@ -179,32 +179,32 @@ static const struct ThreadX_params ThreadX_params_list[] = {
},
};

enum ThreadX_symbol_values {
enum threadx_symbol_values {
THREADX_VAL_TX_THREAD_CURRENT_PTR = 0,
THREADX_VAL_TX_THREAD_CREATED_PTR = 1,
THREADX_VAL_TX_THREAD_CREATED_COUNT = 2,
};

static const char * const ThreadX_symbol_list[] = {
static const char * const threadx_symbol_list[] = {
"_tx_thread_current_ptr",
"_tx_thread_created_ptr",
"_tx_thread_created_count",
NULL
};

const struct rtos_type ThreadX_rtos = {
const struct rtos_type threadx_rtos = {
.name = "ThreadX",

.detect_rtos = ThreadX_detect_rtos,
.create = ThreadX_create,
.update_threads = ThreadX_update_threads,
.get_thread_reg_list = ThreadX_get_thread_reg_list,
.get_symbol_list_to_lookup = ThreadX_get_symbol_list_to_lookup,
.detect_rtos = threadx_detect_rtos,
.create = threadx_create,
.update_threads = threadx_update_threads,
.get_thread_reg_list = threadx_get_thread_reg_list,
.get_symbol_list_to_lookup = threadx_get_symbol_list_to_lookup,
};

static const struct rtos_register_stacking *get_stacking_info(const struct rtos *rtos, int64_t stack_ptr)
{
const struct ThreadX_params *param = (const struct ThreadX_params *) rtos->rtos_specific_params;
const struct threadx_params *param = (const struct threadx_params *) rtos->rtos_specific_params;

if (param->fn_get_stacking_info != NULL)
return param->fn_get_stacking_info(rtos, stack_ptr);
@@ -214,12 +214,12 @@ static const struct rtos_register_stacking *get_stacking_info(const struct rtos

static int is_thread_id_valid(const struct rtos *rtos, int64_t thread_id)
{
const struct ThreadX_params *param;
const struct threadx_params *param;

if (rtos->rtos_specific_params == NULL)
return 0; /* invalid */

param = (const struct ThreadX_params *) rtos->rtos_specific_params;
param = (const struct threadx_params *) rtos->rtos_specific_params;

if (param->fn_is_thread_id_valid != NULL)
return param->fn_is_thread_id_valid(rtos, thread_id);
@@ -229,7 +229,7 @@ static int is_thread_id_valid(const struct rtos *rtos, int64_t thread_id)

static const struct rtos_register_stacking *get_stacking_info_arm926ejs(const struct rtos *rtos, int64_t stack_ptr)
{
const struct ThreadX_params *param = (const struct ThreadX_params *) rtos->rtos_specific_params;
const struct threadx_params *param = (const struct threadx_params *) rtos->rtos_specific_params;
int retval;
uint32_t flag;

@@ -256,12 +256,12 @@ static int is_thread_id_valid_arm926ejs(const struct rtos *rtos, int64_t thread_
return (thread_id != 0 && thread_id != 1);
}

static int ThreadX_update_threads(struct rtos *rtos)
static int threadx_update_threads(struct rtos *rtos)
{
int retval;
int tasks_found = 0;
int thread_list_size = 0;
const struct ThreadX_params *param;
const struct threadx_params *param;

if (rtos == NULL)
return -1;
@@ -269,7 +269,7 @@ static int ThreadX_update_threads(struct rtos *rtos)
if (rtos->rtos_specific_params == NULL)
return -3;

param = (const struct ThreadX_params *) rtos->rtos_specific_params;
param = (const struct threadx_params *) rtos->rtos_specific_params;

if (rtos->symbols == NULL) {
LOG_ERROR("No symbols for ThreadX");
@@ -395,13 +395,13 @@ static int ThreadX_update_threads(struct rtos *rtos)
}

for (i = 0; (i < THREADX_NUM_STATES) &&
(ThreadX_thread_states[i].value != thread_status); i++) {
(threadx_thread_states[i].value != thread_status); i++) {
/* empty */
}

const char *state_desc;
if (i < THREADX_NUM_STATES)
state_desc = ThreadX_thread_states[i].desc;
state_desc = threadx_thread_states[i].desc;
else
state_desc = "Unknown state";

@@ -431,11 +431,11 @@ static int ThreadX_update_threads(struct rtos *rtos)
return 0;
}

static int ThreadX_get_thread_reg_list(struct rtos *rtos, int64_t thread_id,
static int threadx_get_thread_reg_list(struct rtos *rtos, int64_t thread_id,
struct rtos_reg **reg_list, int *num_regs)
{
int retval;
const struct ThreadX_params *param;
const struct threadx_params *param;

if (rtos == NULL)
return -1;
@@ -446,7 +446,7 @@ static int ThreadX_get_thread_reg_list(struct rtos *rtos, int64_t thread_id,
if (rtos->rtos_specific_params == NULL)
return -3;

param = (const struct ThreadX_params *) rtos->rtos_specific_params;
param = (const struct threadx_params *) rtos->rtos_specific_params;

/* Read the stack pointer */
int64_t stack_ptr = 0;
@@ -477,19 +477,19 @@ static int ThreadX_get_thread_reg_list(struct rtos *rtos, int64_t thread_id,
return rtos_generic_stack_read(rtos->target, stacking_info, stack_ptr, reg_list, num_regs);
}

static int ThreadX_get_symbol_list_to_lookup(struct symbol_table_elem *symbol_list[])
static int threadx_get_symbol_list_to_lookup(struct symbol_table_elem *symbol_list[])
{
unsigned int i;
*symbol_list = calloc(
ARRAY_SIZE(ThreadX_symbol_list), sizeof(struct symbol_table_elem));
ARRAY_SIZE(threadx_symbol_list), sizeof(struct symbol_table_elem));

for (i = 0; i < ARRAY_SIZE(ThreadX_symbol_list); i++)
(*symbol_list)[i].symbol_name = ThreadX_symbol_list[i];
for (i = 0; i < ARRAY_SIZE(threadx_symbol_list); i++)
(*symbol_list)[i].symbol_name = threadx_symbol_list[i];

return 0;
}

static bool ThreadX_detect_rtos(struct target *target)
static bool threadx_detect_rtos(struct target *target)
{
if ((target->rtos->symbols != NULL) &&
(target->rtos->symbols[THREADX_VAL_TX_THREAD_CREATED_PTR].address != 0)) {
@@ -501,12 +501,12 @@ static bool ThreadX_detect_rtos(struct target *target)

#if 0

static int ThreadX_set_current_thread(struct rtos *rtos, threadid_t thread_id)
static int threadx_set_current_thread(struct rtos *rtos, threadid_t thread_id)
{
return 0;
}

static int ThreadX_get_thread_detail(struct rtos *rtos,
static int threadx_get_thread_detail(struct rtos *rtos,
threadid_t thread_id,
struct thread_detail *detail)
{
@@ -516,7 +516,7 @@ static int ThreadX_get_thread_detail(struct rtos *rtos,
#define THREADX_THREAD_NAME_STR_SIZE (200)
char tmp_str[THREADX_THREAD_NAME_STR_SIZE];

const struct ThreadX_params *param;
const struct threadx_params *param;

if (rtos == NULL)
return -1;
@@ -527,7 +527,7 @@ static int ThreadX_get_thread_detail(struct rtos *rtos,
if (rtos->rtos_specific_params == NULL)
return -3;

param = (const struct ThreadX_params *) rtos->rtos_specific_params;
param = (const struct threadx_params *) rtos->rtos_specific_params;

if (rtos->symbols == NULL) {
LOG_ERROR("No symbols for ThreadX");
@@ -576,13 +576,13 @@ static int ThreadX_get_thread_detail(struct rtos *rtos,
}

for (i = 0; (i < THREADX_NUM_STATES) &&
(ThreadX_thread_states[i].value != thread_status); i++) {
(threadx_thread_states[i].value != thread_status); i++) {
/* empty */
}

char *state_desc;
if (i < THREADX_NUM_STATES)
state_desc = ThreadX_thread_states[i].desc;
state_desc = threadx_thread_states[i].desc;
else
state_desc = "Unknown state";

@@ -595,11 +595,11 @@ static int ThreadX_get_thread_detail(struct rtos *rtos,

#endif

static int ThreadX_create(struct target *target)
static int threadx_create(struct target *target)
{
for (unsigned int i = 0; i < ARRAY_SIZE(ThreadX_params_list); i++)
if (strcmp(ThreadX_params_list[i].target_name, target->type->name) == 0) {
target->rtos->rtos_specific_params = (void *)&ThreadX_params_list[i];
for (unsigned int i = 0; i < ARRAY_SIZE(threadx_params_list); i++)
if (strcmp(threadx_params_list[i].target_name, target->type->name) == 0) {
target->rtos->rtos_specific_params = (void *)&threadx_params_list[i];
target->rtos->current_thread = 0;
target->rtos->thread_details = NULL;
return 0;


+ 5
- 5
src/rtos/chibios.c View File

@@ -62,9 +62,9 @@ struct chibios_chdebug {
uint8_t cf_off_time; /**< @brief Offset of @p p_time field. */
};

#define GET_CH_KERNEL_MAJOR(codedVersion) ((codedVersion >> 11) & 0x1f)
#define GET_CH_KERNEL_MINOR(codedVersion) ((codedVersion >> 6) & 0x1f)
#define GET_CH_KERNEL_PATCH(codedVersion) ((codedVersion >> 0) & 0x3f)
#define GET_CH_KERNEL_MAJOR(coded_version) ((coded_version >> 11) & 0x1f)
#define GET_CH_KERNEL_MINOR(coded_version) ((coded_version >> 6) & 0x1f)
#define GET_CH_KERNEL_PATCH(coded_version) ((coded_version >> 0) & 0x3f)

/**
* @brief ChibiOS thread states.
@@ -184,10 +184,10 @@ static int chibios_update_memory_signature(struct rtos *rtos)
}

/* Convert endianness of version field */
const uint8_t *versionTarget = (const uint8_t *)
const uint8_t *versiontarget = (const uint8_t *)
&signature->ch_version;
signature->ch_version = rtos->target->endianness == TARGET_LITTLE_ENDIAN ?
le_to_h_u32(versionTarget) : be_to_h_u32(versionTarget);
le_to_h_u32(versiontarget) : be_to_h_u32(versiontarget);

const uint16_t ch_version = signature->ch_version;
LOG_INFO("Successfully loaded memory map of ChibiOS/RT target "


+ 2
- 2
src/rtos/chromium-ec.c View File

@@ -36,7 +36,7 @@ static const struct chromium_ec_params chromium_ec_params_list[] = {
.task_offset_sp = 0,
.task_offset_events = 4,
.task_offset_runtime = 8,
.stacking = &rtos_standard_Cortex_M3_stacking,
.stacking = &rtos_standard_cortex_m3_stacking,

},
{
@@ -46,7 +46,7 @@ static const struct chromium_ec_params chromium_ec_params_list[] = {
.task_offset_sp = 0,
.task_offset_events = 4,
.task_offset_runtime = 8,
.stacking = &rtos_standard_Cortex_M3_stacking,
.stacking = &rtos_standard_cortex_m3_stacking,
},
};



+ 1
- 1
src/rtos/eCos.c View File

@@ -84,7 +84,7 @@ static const char * const eCos_symbol_list[] = {
NULL
};

const struct rtos_type eCos_rtos = {
const struct rtos_type ecos_rtos = {
.name = "eCos",

.detect_rtos = eCos_detect_rtos,


+ 42
- 42
src/rtos/embKernel.c View File

@@ -31,21 +31,21 @@

#define EMBKERNEL_MAX_THREAD_NAME_STR_SIZE (64)

static bool embKernel_detect_rtos(struct target *target);
static int embKernel_create(struct target *target);
static int embKernel_update_threads(struct rtos *rtos);
static int embKernel_get_thread_reg_list(struct rtos *rtos, int64_t thread_id,
static bool embkernel_detect_rtos(struct target *target);
static int embkernel_create(struct target *target);
static int embkernel_update_threads(struct rtos *rtos);
static int embkernel_get_thread_reg_list(struct rtos *rtos, int64_t thread_id,
struct rtos_reg **reg_list, int *num_regs);
static int embKernel_get_symbol_list_to_lookup(struct symbol_table_elem *symbol_list[]);
static int embkernel_get_symbol_list_to_lookup(struct symbol_table_elem *symbol_list[]);

struct rtos_type embKernel_rtos = {
struct rtos_type embkernel_rtos = {
.name = "embKernel",
.detect_rtos = embKernel_detect_rtos,
.create = embKernel_create,
.update_threads = embKernel_update_threads,
.detect_rtos = embkernel_detect_rtos,
.create = embkernel_create,
.update_threads = embkernel_update_threads,
.get_thread_reg_list =
embKernel_get_thread_reg_list,
.get_symbol_list_to_lookup = embKernel_get_symbol_list_to_lookup,
embkernel_get_thread_reg_list,
.get_symbol_list_to_lookup = embkernel_get_symbol_list_to_lookup,
};

enum {
@@ -57,7 +57,7 @@ enum {
SYMBOL_ID_S_CURRENT_TASK_COUNT = 5,
};

static const char * const embKernel_symbol_list[] = {
static const char * const embkernel_symbol_list[] = {
"Rtos::sCurrentTask",
"Rtos::sListReady",
"Rtos::sListSleep",
@@ -66,7 +66,7 @@ static const char * const embKernel_symbol_list[] = {
"Rtos::sCurrentTaskCount",
NULL };

struct embKernel_params {
struct embkernel_params {
const char *target_name;
const unsigned char pointer_width;
const unsigned char thread_count_width;
@@ -80,7 +80,7 @@ struct embKernel_params {
const struct rtos_register_stacking *stacking_info;
};

static const struct embKernel_params embKernel_params_list[] = {
static const struct embkernel_params embkernel_params_list[] = {
{
"cortex_m", /* target_name */
4, /* pointer_width */
@@ -92,7 +92,7 @@ static const struct embKernel_params embKernel_params_list[] = {
4, /*thread_priority_width */
4, /*iterable_next_offset */
12, /*iterable_task_owner_offset */
&rtos_embkernel_Cortex_M_stacking, /* stacking_info*/
&rtos_embkernel_cortex_m_stacking, /* stacking_info*/
},
{ "hla_target", /* target_name */
4, /* pointer_width */
@@ -104,11 +104,11 @@ static const struct embKernel_params embKernel_params_list[] = {
4, /*thread_priority_width */
4, /*iterable_next_offset */
12, /*iterable_task_owner_offset */
&rtos_embkernel_Cortex_M_stacking, /* stacking_info */
&rtos_embkernel_cortex_m_stacking, /* stacking_info */
}
};

static bool embKernel_detect_rtos(struct target *target)
static bool embkernel_detect_rtos(struct target *target)
{
if (target->rtos->symbols != NULL) {
if (target->rtos->symbols[SYMBOL_ID_S_CURRENT_TASK].address != 0)
@@ -117,24 +117,24 @@ static bool embKernel_detect_rtos(struct target *target)
return false;
}

static int embKernel_create(struct target *target)
static int embkernel_create(struct target *target)
{
size_t i = 0;
while ((i < ARRAY_SIZE(embKernel_params_list)) &&
(0 != strcmp(embKernel_params_list[i].target_name, target->type->name)))
while ((i < ARRAY_SIZE(embkernel_params_list)) &&
(0 != strcmp(embkernel_params_list[i].target_name, target->type->name)))
i++;

if (i >= ARRAY_SIZE(embKernel_params_list)) {
if (i >= ARRAY_SIZE(embkernel_params_list)) {
LOG_WARNING("Could not find target \"%s\" in embKernel compatibility "
"list", target->type->name);
return -1;
}

target->rtos->rtos_specific_params = (void *) &embKernel_params_list[i];
target->rtos->rtos_specific_params = (void *) &embkernel_params_list[i];
return 0;
}

static int embKernel_get_tasks_details(struct rtos *rtos, int64_t iterable, const struct embKernel_params *param,
static int embkernel_get_tasks_details(struct rtos *rtos, int64_t iterable, const struct embkernel_params *param,
struct thread_detail *details, const char *state_str)
{
int64_t task = 0;
@@ -181,11 +181,11 @@ static int embKernel_get_tasks_details(struct rtos *rtos, int64_t iterable, cons
return 0;
}

static int embKernel_update_threads(struct rtos *rtos)
static int embkernel_update_threads(struct rtos *rtos)
{
/* int i = 0; */
int retval;
const struct embKernel_params *param;
const struct embkernel_params *param;

if (rtos == NULL)
return -1;
@@ -206,7 +206,7 @@ static int embKernel_update_threads(struct rtos *rtos)
/* wipe out previous thread details if any */
rtos_free_threadlist(rtos);

param = (const struct embKernel_params *) rtos->rtos_specific_params;
param = (const struct embkernel_params *) rtos->rtos_specific_params;

retval = target_read_buffer(rtos->target, rtos->symbols[SYMBOL_ID_S_CURRENT_TASK].address, param->pointer_width,
(uint8_t *) &rtos->current_thread);
@@ -237,7 +237,7 @@ static int embKernel_update_threads(struct rtos *rtos)
return ERROR_FAIL;
}

int threadIdx = 0;
int thread_idx = 0;
/* Look for ready tasks */
for (int pri = 0; pri < max_used_priority; pri++) {
/* Get first item in queue */
@@ -247,9 +247,9 @@ static int embKernel_update_threads(struct rtos *rtos)
(uint8_t *) &iterable);
if (retval != ERROR_OK)
return retval;
for (; iterable && threadIdx < thread_list_size; threadIdx++) {
for (; iterable && thread_idx < thread_list_size; thread_idx++) {
/* Get info from this iterable item */
retval = embKernel_get_tasks_details(rtos, iterable, param, &rtos->thread_details[threadIdx], "Ready");
retval = embkernel_get_tasks_details(rtos, iterable, param, &rtos->thread_details[thread_idx], "Ready");
if (retval != ERROR_OK)
return retval;
/* Get next iterable item */
@@ -265,9 +265,9 @@ static int embKernel_update_threads(struct rtos *rtos)
(uint8_t *) &iterable);
if (retval != ERROR_OK)
return retval;
for (; iterable && threadIdx < thread_list_size; threadIdx++) {
for (; iterable && thread_idx < thread_list_size; thread_idx++) {
/*Get info from this iterable item */
retval = embKernel_get_tasks_details(rtos, iterable, param, &rtos->thread_details[threadIdx], "Sleeping");
retval = embkernel_get_tasks_details(rtos, iterable, param, &rtos->thread_details[thread_idx], "Sleeping");
if (retval != ERROR_OK)
return retval;
/*Get next iterable item */
@@ -283,9 +283,9 @@ static int embKernel_update_threads(struct rtos *rtos)
(uint8_t *) &iterable);
if (retval != ERROR_OK)
return retval;
for (; iterable && threadIdx < thread_list_size; threadIdx++) {
for (; iterable && thread_idx < thread_list_size; thread_idx++) {
/* Get info from this iterable item */
retval = embKernel_get_tasks_details(rtos, iterable, param, &rtos->thread_details[threadIdx], "Suspended");
retval = embkernel_get_tasks_details(rtos, iterable, param, &rtos->thread_details[thread_idx], "Suspended");
if (retval != ERROR_OK)
return retval;
/*Get next iterable item */
@@ -296,16 +296,16 @@ static int embKernel_update_threads(struct rtos *rtos)
}

rtos->thread_count = 0;
rtos->thread_count = threadIdx;
LOG_OUTPUT("Found %u tasks\n", (unsigned int)threadIdx);
rtos->thread_count = thread_idx;
LOG_OUTPUT("Found %u tasks\n", (unsigned int)thread_idx);
return 0;
}

static int embKernel_get_thread_reg_list(struct rtos *rtos, int64_t thread_id,
static int embkernel_get_thread_reg_list(struct rtos *rtos, int64_t thread_id,
struct rtos_reg **reg_list, int *num_regs)
{
int retval;
const struct embKernel_params *param;
const struct embkernel_params *param;
int64_t stack_ptr = 0;

if (rtos == NULL)
@@ -317,7 +317,7 @@ static int embKernel_get_thread_reg_list(struct rtos *rtos, int64_t thread_id,
if (rtos->rtos_specific_params == NULL)
return -1;

param = (const struct embKernel_params *) rtos->rtos_specific_params;
param = (const struct embkernel_params *) rtos->rtos_specific_params;

/* Read the stack pointer */
retval = target_read_buffer(rtos->target, thread_id + param->thread_stack_offset, param->pointer_width,
@@ -330,13 +330,13 @@ static int embKernel_get_thread_reg_list(struct rtos *rtos, int64_t thread_id,
return rtos_generic_stack_read(rtos->target, param->stacking_info, stack_ptr, reg_list, num_regs);
}

static int embKernel_get_symbol_list_to_lookup(struct symbol_table_elem *symbol_list[])
static int embkernel_get_symbol_list_to_lookup(struct symbol_table_elem *symbol_list[])
{
unsigned int i;
*symbol_list = calloc(ARRAY_SIZE(embKernel_symbol_list), sizeof(struct symbol_table_elem));
*symbol_list = calloc(ARRAY_SIZE(embkernel_symbol_list), sizeof(struct symbol_table_elem));

for (i = 0; i < ARRAY_SIZE(embKernel_symbol_list); i++)
(*symbol_list)[i].symbol_name = embKernel_symbol_list[i];
for (i = 0; i < ARRAY_SIZE(embkernel_symbol_list); i++)
(*symbol_list)[i].symbol_name = embkernel_symbol_list[i];

return 0;
}

+ 5
- 5
src/rtos/linux.c View File

@@ -260,7 +260,7 @@ static int linux_get_symbol_list_to_lookup(struct symbol_table_elem *symbol_list

static char *linux_ps_command(struct target *target);

const struct rtos_type Linux_os = {
const struct rtos_type linux_rtos = {
.name = "linux",
.detect_rtos = linux_os_detect,
.create = linux_os_create,
@@ -431,8 +431,8 @@ static int get_current(struct target *target, int create)
buf = reg_list[13]->value;
val = get_buffer(target, buf);
ti_addr = (val & 0xffffe000);
uint32_t TS_addr = ti_addr + 0xc;
retval = fill_buffer(target, TS_addr, buffer);
uint32_t ts_addr = ti_addr + 0xc;
retval = fill_buffer(target, ts_addr, buffer);

if (retval == ERROR_OK) {
uint32_t TS = get_buffer(target, buffer);
@@ -1163,7 +1163,7 @@ static int linux_thread_extra_info(struct target *target,
return ERROR_OK;
}

static int linux_gdb_T_packet(struct connection *connection,
static int linux_gdb_t_packet(struct connection *connection,
struct target *target, char const *packet, int packet_size)
{
int64_t threadid;
@@ -1304,7 +1304,7 @@ static int linux_thread_packet(struct connection *connection, char const *packet
switch (packet[0]) {
case 'T': /* Is thread alive?*/

linux_gdb_T_packet(connection, target, packet, packet_size);
linux_gdb_t_packet(connection, target, packet, packet_size);
break;
case 'H': /* Set current thread */
/* ( 'c' for step and continue, 'g' for all other operations )*/


+ 12
- 12
src/rtos/rtos.c View File

@@ -27,30 +27,30 @@
#include "server/gdb_server.h"

/* RTOSs */
extern struct rtos_type FreeRTOS_rtos;
extern struct rtos_type ThreadX_rtos;
extern struct rtos_type eCos_rtos;
extern struct rtos_type Linux_os;
extern struct rtos_type freertos_rtos;
extern struct rtos_type threadx_rtos;
extern struct rtos_type ecos_rtos;
extern struct rtos_type linux_rtos;
extern struct rtos_type chibios_rtos;
extern struct rtos_type chromium_ec_rtos;
extern struct rtos_type embKernel_rtos;
extern struct rtos_type embkernel_rtos;
extern struct rtos_type mqx_rtos;
extern struct rtos_type uCOS_III_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;
extern struct rtos_type zephyr_rtos;

static struct rtos_type *rtos_types[] = {
&ThreadX_rtos,
&FreeRTOS_rtos,
&eCos_rtos,
&Linux_os,
&threadx_rtos,
&freertos_rtos,
&ecos_rtos,
&linux_rtos,
&chibios_rtos,
&chromium_ec_rtos,
&embKernel_rtos,
&embkernel_rtos,
&mqx_rtos,
&uCOS_III_rtos,
&ucos_iii_rtos,
&nuttx_rtos,
&riot_rtos,
&zephyr_rtos,


+ 3
- 3
src/rtos/rtos_embkernel_stackings.c View File

@@ -24,7 +24,7 @@
#include "target/armv7m.h"
#include "rtos_standard_stackings.h"

static const struct stack_register_offset rtos_embkernel_Cortex_M_stack_offsets[ARMV7M_NUM_CORE_REGS] = {
static const struct stack_register_offset rtos_embkernel_cortex_m_stack_offsets[ARMV7M_NUM_CORE_REGS] = {
{ ARMV7M_R0, 0x24, 32 }, /* r0 */
{ ARMV7M_R1, 0x28, 32 }, /* r1 */
{ ARMV7M_R2, 0x2c, 32 }, /* r2 */
@@ -44,10 +44,10 @@ static const struct stack_register_offset rtos_embkernel_Cortex_M_stack_offsets[
{ ARMV7M_xPSR, 0x40, 32 }, /* xPSR */
};

const struct rtos_register_stacking rtos_embkernel_Cortex_M_stacking = {
const struct rtos_register_stacking rtos_embkernel_cortex_m_stacking = {
0x40, /* stack_registers_size */
-1, /* stack_growth_direction */
ARMV7M_NUM_CORE_REGS, /* num_output_registers */
rtos_generic_stack_align8, /* stack_alignment */
rtos_embkernel_Cortex_M_stack_offsets /* register_offsets */
rtos_embkernel_cortex_m_stack_offsets /* register_offsets */
};

+ 1
- 1
src/rtos/rtos_embkernel_stackings.h View File

@@ -25,6 +25,6 @@

#include "rtos.h"

extern const struct rtos_register_stacking rtos_embkernel_Cortex_M_stacking;
extern const struct rtos_register_stacking rtos_embkernel_cortex_m_stacking;

#endif /* OPENOCD_RTOS_RTOS_EMBKERNEL_STACKINGS_H */

+ 1
- 1
src/rtos/rtos_riot_stackings.c View File

@@ -32,7 +32,7 @@ static int64_t rtos_riot_cortex_m_stack_align(struct target *target,
int64_t stack_ptr)
{
const int XPSR_OFFSET = 0x40;
return rtos_Cortex_M_stack_align(target, stack_data, stacking,
return rtos_cortex_m_stack_align(target, stack_data, stacking,
stack_ptr, XPSR_OFFSET);
}



+ 25
- 25
src/rtos/rtos_standard_stackings.c View File

@@ -23,7 +23,7 @@
#include "rtos.h"
#include "target/armv7m.h"

static const struct stack_register_offset rtos_standard_Cortex_M3_stack_offsets[ARMV7M_NUM_CORE_REGS] = {
static const struct stack_register_offset rtos_standard_cortex_m3_stack_offsets[ARMV7M_NUM_CORE_REGS] = {
{ ARMV7M_R0, 0x20, 32 }, /* r0 */
{ ARMV7M_R1, 0x24, 32 }, /* r1 */
{ ARMV7M_R2, 0x28, 32 }, /* r2 */
@@ -43,7 +43,7 @@ static const struct stack_register_offset rtos_standard_Cortex_M3_stack_offsets[
{ ARMV7M_xPSR, 0x3c, 32 }, /* xPSR */
};

static const struct stack_register_offset rtos_standard_Cortex_M4F_stack_offsets[] = {
static const struct stack_register_offset rtos_standard_cortex_m4f_stack_offsets[] = {
{ ARMV7M_R0, 0x24, 32 }, /* r0 */
{ ARMV7M_R1, 0x28, 32 }, /* r1 */
{ ARMV7M_R2, 0x2c, 32 }, /* r2 */
@@ -63,7 +63,7 @@ static const struct stack_register_offset rtos_standard_Cortex_M4F_stack_offsets
{ ARMV7M_xPSR, 0x40, 32 }, /* xPSR */
};

static const struct stack_register_offset rtos_standard_Cortex_M4F_FPU_stack_offsets[] = {
static const struct stack_register_offset rtos_standard_cortex_m4f_fpu_stack_offsets[] = {
{ ARMV7M_R0, 0x64, 32 }, /* r0 */
{ ARMV7M_R1, 0x68, 32 }, /* r1 */
{ ARMV7M_R2, 0x6c, 32 }, /* r2 */
@@ -84,7 +84,7 @@ static const struct stack_register_offset rtos_standard_Cortex_M4F_FPU_stack_off
};


static const struct stack_register_offset rtos_standard_Cortex_R4_stack_offsets[] = {
static const struct stack_register_offset rtos_standard_cortex_r4_stack_offsets[] = {
{ 0, 0x08, 32 }, /* r0 (a1) */
{ 1, 0x0c, 32 }, /* r1 (a2) */
{ 2, 0x10, 32 }, /* r2 (a3) */
@@ -113,7 +113,7 @@ static const struct stack_register_offset rtos_standard_Cortex_R4_stack_offsets[
{ 26, 0x04, 32 }, /* CSPR */
};

static const struct stack_register_offset rtos_standard_NDS32_N1068_stack_offsets[] = {
static const struct stack_register_offset rtos_standard_nds32_n1068_stack_offsets[] = {
{ 0, 0x88, 32 }, /* R0 */
{ 1, 0x8C, 32 }, /* R1 */
{ 2, 0x14, 32 }, /* R2 */
@@ -199,7 +199,7 @@ int64_t rtos_generic_stack_align8(struct target *target,
* This is just a helper function for use in the calculate_process_stack
* function for a given architecture/rtos.
*/
int64_t rtos_Cortex_M_stack_align(struct target *target,
int64_t rtos_cortex_m_stack_align(struct target *target,
const uint8_t *stack_data, const struct rtos_register_stacking *stacking,
int64_t stack_ptr, size_t xpsr_offset)
{
@@ -220,70 +220,70 @@ int64_t rtos_Cortex_M_stack_align(struct target *target,
return new_stack_ptr;
}

static int64_t rtos_standard_Cortex_M3_stack_align(struct target *target,
static int64_t rtos_standard_cortex_m3_stack_align(struct target *target,
const uint8_t *stack_data, const struct rtos_register_stacking *stacking,
int64_t stack_ptr)
{
const int XPSR_OFFSET = 0x3c;
return rtos_Cortex_M_stack_align(target, stack_data, stacking,
return rtos_cortex_m_stack_align(target, stack_data, stacking,
stack_ptr, XPSR_OFFSET);
}

static int64_t rtos_standard_Cortex_M4F_stack_align(struct target *target,
static int64_t rtos_standard_cortex_m4f_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,
return rtos_cortex_m_stack_align(target, stack_data, stacking,
stack_ptr, XPSR_OFFSET);
}

static int64_t rtos_standard_Cortex_M4F_FPU_stack_align(struct target *target,
static int64_t rtos_standard_cortex_m4f_fpu_stack_align(struct target *target,
const uint8_t *stack_data, const struct rtos_register_stacking *stacking,
int64_t stack_ptr)
{
const int XPSR_OFFSET = 0x80;
return rtos_Cortex_M_stack_align(target, stack_data, stacking,
return rtos_cortex_m_stack_align(target, stack_data, stacking,
stack_ptr, XPSR_OFFSET);
}


const struct rtos_register_stacking rtos_standard_Cortex_M3_stacking = {
const struct rtos_register_stacking rtos_standard_cortex_m3_stacking = {
0x40, /* stack_registers_size */
-1, /* stack_growth_direction */
ARMV7M_NUM_CORE_REGS, /* num_output_registers */
rtos_standard_Cortex_M3_stack_align, /* stack_alignment */
rtos_standard_Cortex_M3_stack_offsets /* register_offsets */
rtos_standard_cortex_m3_stack_align, /* stack_alignment */
rtos_standard_cortex_m3_stack_offsets /* register_offsets */
};

const struct rtos_register_stacking rtos_standard_Cortex_M4F_stacking = {
const struct rtos_register_stacking rtos_standard_cortex_m4f_stacking = {
0x44, /* stack_registers_size 4 more for LR*/
-1, /* stack_growth_direction */
ARMV7M_NUM_CORE_REGS, /* num_output_registers */
rtos_standard_Cortex_M4F_stack_align, /* stack_alignment */
rtos_standard_Cortex_M4F_stack_offsets /* register_offsets */
rtos_standard_cortex_m4f_stack_align, /* stack_alignment */
rtos_standard_cortex_m4f_stack_offsets /* register_offsets */
};

const struct rtos_register_stacking rtos_standard_Cortex_M4F_FPU_stacking = {
const struct rtos_register_stacking rtos_standard_cortex_m4f_fpu_stacking = {
0xcc, /* stack_registers_size 4 more for LR + 48 more for FPU S0-S15 register*/
-1, /* stack_growth_direction */
ARMV7M_NUM_CORE_REGS, /* num_output_registers */
rtos_standard_Cortex_M4F_FPU_stack_align, /* stack_alignment */
rtos_standard_Cortex_M4F_FPU_stack_offsets /* register_offsets */
rtos_standard_cortex_m4f_fpu_stack_align, /* stack_alignment */
rtos_standard_cortex_m4f_fpu_stack_offsets /* register_offsets */
};

const struct rtos_register_stacking rtos_standard_Cortex_R4_stacking = {
const struct rtos_register_stacking rtos_standard_cortex_r4_stacking = {
0x48, /* stack_registers_size */
-1, /* stack_growth_direction */
26, /* num_output_registers */
rtos_generic_stack_align8, /* stack_alignment */
rtos_standard_Cortex_R4_stack_offsets /* register_offsets */
rtos_standard_cortex_r4_stack_offsets /* register_offsets */
};

const struct rtos_register_stacking rtos_standard_NDS32_N1068_stacking = {
const struct rtos_register_stacking rtos_standard_nds32_n1068_stacking = {
0x90, /* stack_registers_size */
-1, /* stack_growth_direction */
32, /* num_output_registers */
rtos_generic_stack_align8, /* stack_alignment */
rtos_standard_NDS32_N1068_stack_offsets /* register_offsets */
rtos_standard_nds32_n1068_stack_offsets /* register_offsets */
};

+ 6
- 6
src/rtos/rtos_standard_stackings.h View File

@@ -25,15 +25,15 @@

#include "rtos.h"

extern const struct rtos_register_stacking rtos_standard_Cortex_M3_stacking;
extern const struct rtos_register_stacking rtos_standard_Cortex_M4F_stacking;
extern const struct rtos_register_stacking rtos_standard_Cortex_M4F_FPU_stacking;
extern const struct rtos_register_stacking rtos_standard_Cortex_R4_stacking;
extern const struct rtos_register_stacking rtos_standard_NDS32_N1068_stacking;
extern const struct rtos_register_stacking rtos_standard_cortex_m3_stacking;
extern const struct rtos_register_stacking rtos_standard_cortex_m4f_stacking;
extern const struct rtos_register_stacking rtos_standard_cortex_m4f_fpu_stacking;
extern const struct rtos_register_stacking rtos_standard_cortex_r4_stacking;
extern const struct rtos_register_stacking rtos_standard_nds32_n1068_stacking;
int64_t rtos_generic_stack_align8(struct target *target,
const uint8_t *stack_data, const struct rtos_register_stacking *stacking,
int64_t stack_ptr);
int64_t rtos_Cortex_M_stack_align(struct target *target,
int64_t rtos_cortex_m_stack_align(struct target *target,
const uint8_t *stack_data, const struct rtos_register_stacking *stacking,
int64_t stack_ptr, size_t xpsr_offset);



+ 8
- 8
src/rtos/rtos_ucos_iii_stackings.c View File

@@ -26,7 +26,7 @@
#include <target/armv7m.h>
#include <target/esirisc.h>

static const struct stack_register_offset rtos_uCOS_III_Cortex_M_stack_offsets[] = {
static const struct stack_register_offset rtos_ucos_iii_cortex_m_stack_offsets[] = {
{ ARMV7M_R0, 0x20, 32 }, /* r0 */
{ ARMV7M_R1, 0x24, 32 }, /* r1 */
{ ARMV7M_R2, 0x28, 32 }, /* r2 */
@@ -46,7 +46,7 @@ static const struct stack_register_offset rtos_uCOS_III_Cortex_M_stack_offsets[]
{ ARMV7M_xPSR, 0x3c, 32 }, /* xPSR */
};

static const struct stack_register_offset rtos_uCOS_III_eSi_RISC_stack_offsets[] = {
static const struct stack_register_offset rtos_ucos_iii_esi_risc_stack_offsets[] = {
{ ESIRISC_SP, -2, 32 }, /* sp */
{ ESIRISC_RA, 0x48, 32 }, /* ra */
{ ESIRISC_R2, 0x44, 32 }, /* r2 */
@@ -67,18 +67,18 @@ static const struct stack_register_offset rtos_uCOS_III_eSi_RISC_stack_offsets[]
{ ESIRISC_CAS, 0x08, 32 }, /* CAS */
};

const struct rtos_register_stacking rtos_uCOS_III_Cortex_M_stacking = {
const struct rtos_register_stacking rtos_ucos_iii_cortex_m_stacking = {
0x40, /* stack_registers_size */
-1, /* stack_growth_direction */
ARRAY_SIZE(rtos_uCOS_III_Cortex_M_stack_offsets), /* num_output_registers */
ARRAY_SIZE(rtos_ucos_iii_cortex_m_stack_offsets), /* num_output_registers */
rtos_generic_stack_align8, /* stack_alignment */
rtos_uCOS_III_Cortex_M_stack_offsets /* register_offsets */
rtos_ucos_iii_cortex_m_stack_offsets /* register_offsets */
};

const struct rtos_register_stacking rtos_uCOS_III_eSi_RISC_stacking = {
const struct rtos_register_stacking rtos_ucos_iii_esi_risc_stacking = {
0x4c, /* stack_registers_size */
-1, /* stack_growth_direction */
ARRAY_SIZE(rtos_uCOS_III_eSi_RISC_stack_offsets), /* num_output_registers */
ARRAY_SIZE(rtos_ucos_iii_esi_risc_stack_offsets), /* num_output_registers */
NULL, /* stack_alignment */
rtos_uCOS_III_eSi_RISC_stack_offsets /* register_offsets */
rtos_ucos_iii_esi_risc_stack_offsets /* register_offsets */
};

+ 2
- 2
src/rtos/rtos_ucos_iii_stackings.h View File

@@ -25,7 +25,7 @@

#include <rtos/rtos.h>

extern const struct rtos_register_stacking rtos_uCOS_III_Cortex_M_stacking;
extern const struct rtos_register_stacking rtos_uCOS_III_eSi_RISC_stacking;
extern const struct rtos_register_stacking rtos_ucos_iii_cortex_m_stacking;
extern const struct rtos_register_stacking rtos_ucos_iii_esi_risc_stacking;

#endif /* OPENOCD_RTOS_RTOS_UCOS_III_STACKINGS_H */

+ 45
- 45
src/rtos/uCOS-III.c View File

@@ -37,7 +37,7 @@
#define UCOS_III_MAX_THREADS 256
#endif

struct uCOS_III_params {
struct ucos_iii_params {
const char *target_name;
const unsigned char pointer_width;
symbol_address_t thread_stack_offset;
@@ -53,7 +53,7 @@ struct uCOS_III_params {
symbol_address_t threads[];
};

static const struct uCOS_III_params uCOS_III_params_list[] = {
static const struct ucos_iii_params ucos_iii_params_list[] = {
{
"cortex_m", /* target_name */
sizeof(uint32_t), /* pointer_width */
@@ -65,7 +65,7 @@ static const struct uCOS_III_params uCOS_III_params_list[] = {
0, /* thread_next_offset */
false, /* thread_offsets_updated */
1, /* threadid_start */
&rtos_uCOS_III_Cortex_M_stacking, /* stacking_info */
&rtos_ucos_iii_cortex_m_stacking, /* stacking_info */
0, /* num_threads */
},
{
@@ -79,12 +79,12 @@ static const struct uCOS_III_params uCOS_III_params_list[] = {
0, /* thread_next_offset */
false, /* thread_offsets_updated */
1, /* threadid_start */
&rtos_uCOS_III_eSi_RISC_stacking, /* stacking_info */
&rtos_ucos_iii_esi_risc_stacking, /* stacking_info */
0, /* num_threads */
},
};

static const char * const uCOS_III_symbol_list[] = {
static const char * const ucos_iii_symbol_list[] = {
"OSRunning",
"OSTCBCurPtr",
"OSTaskDbgListPtr",
@@ -100,7 +100,7 @@ static const char * const uCOS_III_symbol_list[] = {
NULL
};

enum uCOS_III_symbol_values {
enum ucos_iii_symbol_values {
UCOS_III_VAL_OS_RUNNING,
UCOS_III_VAL_OS_TCB_CUR_PTR,
UCOS_III_VAL_OS_TASK_DBG_LIST_PTR,
@@ -115,7 +115,7 @@ enum uCOS_III_symbol_values {
UCOS_III_VAL_OS_TCB_DBG_NEXT_PTR_OFFSET,
};

static const char * const uCOS_III_thread_state_list[] = {
static const char * const ucos_iii_thread_state_list[] = {
"Ready",
"Delay",
"Pend",
@@ -126,10 +126,10 @@ static const char * const uCOS_III_thread_state_list[] = {
"Pend Timeout Suspended",
};

static int uCOS_III_find_or_create_thread(struct rtos *rtos, symbol_address_t thread_address,
static int ucos_iii_find_or_create_thread(struct rtos *rtos, symbol_address_t thread_address,
threadid_t *threadid)
{
struct uCOS_III_params *params = rtos->rtos_specific_params;
struct ucos_iii_params *params = rtos->rtos_specific_params;
size_t thread_index;

for (thread_index = 0; thread_index < params->num_threads; thread_index++)
@@ -148,10 +148,10 @@ found:
return ERROR_OK;
}

static int uCOS_III_find_thread_address(struct rtos *rtos, threadid_t threadid,
static int ucos_iii_find_thread_address(struct rtos *rtos, threadid_t threadid,
symbol_address_t *thread_address)
{
struct uCOS_III_params *params = rtos->rtos_specific_params;
struct ucos_iii_params *params = rtos->rtos_specific_params;
size_t thread_index;

thread_index = threadid - params->threadid_start;
@@ -164,9 +164,9 @@ static int uCOS_III_find_thread_address(struct rtos *rtos, threadid_t threadid,
return ERROR_OK;
}

static int uCOS_III_find_last_thread_address(struct rtos *rtos, symbol_address_t *thread_address)
static int ucos_iii_find_last_thread_address(struct rtos *rtos, symbol_address_t *thread_address)
{
struct uCOS_III_params *params = rtos->rtos_specific_params;
struct ucos_iii_params *params = rtos->rtos_specific_params;
int retval;

/* read the thread list head */
@@ -200,15 +200,15 @@ static int uCOS_III_find_last_thread_address(struct rtos *rtos, symbol_address_t
return ERROR_OK;
}

static int uCOS_III_update_thread_offsets(struct rtos *rtos)
static int ucos_iii_update_thread_offsets(struct rtos *rtos)
{
struct uCOS_III_params *params = rtos->rtos_specific_params;
struct ucos_iii_params *params = rtos->rtos_specific_params;

if (params->thread_offsets_updated)
return ERROR_OK;

const struct thread_offset_map {
enum uCOS_III_symbol_values symbol_value;
enum ucos_iii_symbol_values symbol_value;
symbol_address_t *thread_offset;
} thread_offset_maps[] = {
{
@@ -255,15 +255,15 @@ static int uCOS_III_update_thread_offsets(struct rtos *rtos)
return ERROR_OK;
}

static bool uCOS_III_detect_rtos(struct target *target)
static bool ucos_iii_detect_rtos(struct target *target)
{
return target->rtos->symbols != NULL &&
target->rtos->symbols[UCOS_III_VAL_OS_RUNNING].address != 0;
}

static int uCOS_III_reset_handler(struct target *target, enum target_reset_mode reset_mode, void *priv)
static int ucos_iii_reset_handler(struct target *target, enum target_reset_mode reset_mode, void *priv)
{
struct uCOS_III_params *params = target->rtos->rtos_specific_params;
struct ucos_iii_params *params = target->rtos->rtos_specific_params;

params->thread_offsets_updated = false;
params->num_threads = 0;
@@ -271,22 +271,22 @@ static int uCOS_III_reset_handler(struct target *target, enum target_reset_mode
return ERROR_OK;
}

static int uCOS_III_create(struct target *target)
static int ucos_iii_create(struct target *target)
{
struct uCOS_III_params *params;
struct ucos_iii_params *params;

for (size_t i = 0; i < ARRAY_SIZE(uCOS_III_params_list); i++)
if (strcmp(uCOS_III_params_list[i].target_name, target->type->name) == 0) {
for (size_t i = 0; i < ARRAY_SIZE(ucos_iii_params_list); i++)
if (strcmp(ucos_iii_params_list[i].target_name, target->type->name) == 0) {
params = malloc(sizeof(*params) + (UCOS_III_MAX_THREADS * sizeof(*params->threads)));
if (params == NULL) {
LOG_ERROR("uCOS-III: out of memory");
return ERROR_FAIL;
}

memcpy(params, &uCOS_III_params_list[i], sizeof(uCOS_III_params_list[i]));
memcpy(params, &ucos_iii_params_list[i], sizeof(ucos_iii_params_list[i]));
target->rtos->rtos_specific_params = (void *)params;

target_register_reset_callback(uCOS_III_reset_handler, NULL);
target_register_reset_callback(ucos_iii_reset_handler, NULL);

return ERROR_OK;
}
@@ -295,9 +295,9 @@ static int uCOS_III_create(struct target *target)
return ERROR_FAIL;
}

static int uCOS_III_update_threads(struct rtos *rtos)
static int ucos_iii_update_threads(struct rtos *rtos)
{
struct uCOS_III_params *params = rtos->rtos_specific_params;
struct ucos_iii_params *params = rtos->rtos_specific_params;
int retval;

if (rtos->symbols == NULL) {
@@ -340,7 +340,7 @@ static int uCOS_III_update_threads(struct rtos *rtos)
}

/* update thread offsets */
retval = uCOS_III_update_thread_offsets(rtos);
retval = ucos_iii_update_thread_offsets(rtos);
if (retval != ERROR_OK) {
LOG_ERROR("uCOS-III: failed to update thread offsets");
return retval;
@@ -380,7 +380,7 @@ static int uCOS_III_update_threads(struct rtos *rtos)
*/
symbol_address_t thread_address = 0;

retval = uCOS_III_find_last_thread_address(rtos, &thread_address);
retval = ucos_iii_find_last_thread_address(rtos, &thread_address);
if (retval != ERROR_OK) {
LOG_ERROR("uCOS-III: failed to find last thread address");
return retval;
@@ -391,7 +391,7 @@ static int uCOS_III_update_threads(struct rtos *rtos)
char thread_str_buffer[UCOS_III_MAX_STRLEN + 1];

/* find or create new threadid */
retval = uCOS_III_find_or_create_thread(rtos, thread_address, &thread_detail->threadid);
retval = ucos_iii_find_or_create_thread(rtos, thread_address, &thread_detail->threadid);
if (retval != ERROR_OK) {
LOG_ERROR("uCOS-III: failed to find or create thread");
return retval;
@@ -449,8 +449,8 @@ static int uCOS_III_update_threads(struct rtos *rtos)

const char *thread_state_str;

if (thread_state < ARRAY_SIZE(uCOS_III_thread_state_list))
thread_state_str = uCOS_III_thread_state_list[thread_state];
if (thread_state < ARRAY_SIZE(ucos_iii_thread_state_list))
thread_state_str = ucos_iii_thread_state_list[thread_state];
else
thread_state_str = "Unknown";

@@ -473,16 +473,16 @@ static int uCOS_III_update_threads(struct rtos *rtos)
return ERROR_OK;
}

static int uCOS_III_get_thread_reg_list(struct rtos *rtos, threadid_t threadid,
static int ucos_iii_get_thread_reg_list(struct rtos *rtos, threadid_t threadid,
struct rtos_reg **reg_list, int *num_regs)
{
struct uCOS_III_params *params = rtos->rtos_specific_params;
struct ucos_iii_params *params = rtos->rtos_specific_params;
int retval;

/* find thread address for threadid */
symbol_address_t thread_address = 0;

retval = uCOS_III_find_thread_address(rtos, threadid, &thread_address);
retval = ucos_iii_find_thread_address(rtos, threadid, &thread_address);
if (retval != ERROR_OK) {
LOG_ERROR("uCOS-III: failed to find thread address");
return retval;
@@ -508,25 +508,25 @@ static int uCOS_III_get_thread_reg_list(struct rtos *rtos, threadid_t threadid,
num_regs);
}

static int uCOS_III_get_symbol_list_to_lookup(struct symbol_table_elem *symbol_list[])
static int ucos_iii_get_symbol_list_to_lookup(struct symbol_table_elem *symbol_list[])
{
*symbol_list = calloc(ARRAY_SIZE(uCOS_III_symbol_list), sizeof(struct symbol_table_elem));
*symbol_list = calloc(ARRAY_SIZE(ucos_iii_symbol_list), sizeof(struct symbol_table_elem));
if (*symbol_list == NULL) {
LOG_ERROR("uCOS-III: out of memory");
return ERROR_FAIL;
}

for (size_t i = 0; i < ARRAY_SIZE(uCOS_III_symbol_list); i++)
(*symbol_list)[i].symbol_name = uCOS_III_symbol_list[i];
for (size_t i = 0; i < ARRAY_SIZE(ucos_iii_symbol_list); i++)
(*symbol_list)[i].symbol_name = ucos_iii_symbol_list[i];

return ERROR_OK;
}

const struct rtos_type uCOS_III_rtos = {
const struct rtos_type ucos_iii_rtos = {
.name = "uCOS-III",
.detect_rtos = uCOS_III_detect_rtos,
.create = uCOS_III_create,
.update_threads = uCOS_III_update_threads,
.get_thread_reg_list = uCOS_III_get_thread_reg_list,
.get_symbol_list_to_lookup = uCOS_III_get_symbol_list_to_lookup,
.detect_rtos = ucos_iii_detect_rtos,
.create = ucos_iii_create,
.update_threads = ucos_iii_update_threads,
.get_thread_reg_list = ucos_iii_get_thread_reg_list,
.get_symbol_list_to_lookup = ucos_iii_get_symbol_list_to_lookup,
};

+ 1
- 1
src/rtos/zephyr.c View File

@@ -193,7 +193,7 @@ static int64_t zephyr_cortex_m_stack_align(struct target *target,
const uint8_t *stack_data,
const struct rtos_register_stacking *stacking, int64_t stack_ptr)
{
return rtos_Cortex_M_stack_align(target, stack_data, stacking,
return rtos_cortex_m_stack_align(target, stack_data, stacking,
stack_ptr, ARM_XPSR_OFFSET);
}



Loading…
Cancel
Save