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

build: cleanup src/rtos directory 

Change-Id: I24bc62d12409dbfc20a0a986acf6b3f2c913e36d
Signed-off-by: Spencer Oliver <spen@spen-soft.co.uk>
Reviewed-on: http://openocd.zylin.com/416
Tested-by: jenkins
This commit is contained in:
Spencer Oliver 2012-01-30 15:32:53 +00:00
parent 8b00e56e64
commit 7b032df3aa
10 changed files with 1116 additions and 1346 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

480
src/rtos/FreeRTOS.c
View File

@ -18,7 +18,6 @@
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
@ -31,370 +30,346 @@
#include "helper/log.h"
#include "rtos_standard_stackings.h"
#define FreeRTOS_STRUCT( int_type, ptr_type, list_prev_offset )
#define FreeRTOS_STRUCT(int_type, ptr_type, list_prev_offset)
struct FreeRTOS_params
{
const char * target_name;
const unsigned char thread_count_width;
const unsigned char pointer_width;
const unsigned char list_next_offset;
const unsigned char list_width;
const unsigned char list_elem_next_offset;
const unsigned char list_elem_content_offset;
const unsigned char thread_stack_offset;
const unsigned char thread_name_offset;
const struct rtos_register_stacking* stacking_info;
struct FreeRTOS_params {
const char *target_name;
const unsigned char thread_count_width;
const unsigned char pointer_width;
const unsigned char list_next_offset;
const unsigned char list_width;
const unsigned char list_elem_next_offset;
const unsigned char list_elem_content_offset;
const unsigned char thread_stack_offset;
const unsigned char thread_name_offset;
const struct rtos_register_stacking *stacking_info;
};
const struct FreeRTOS_params FreeRTOS_params_list[] =
{
{ "cortex_m3", // target_name
4, // thread_count_width;
4, // pointer_width;
16, // list_next_offset;
20, // list_width;
8, // list_elem_next_offset;
12, // list_elem_content_offset
0, // thread_stack_offset;
52, // thread_name_offset;
&rtos_standard_Cortex_M3_stacking, // stacking_info
}
const struct FreeRTOS_params FreeRTOS_params_list[] = {
{
"cortex_m3", /* target_name */
4, /* thread_count_width; */
4, /* pointer_width; */
16, /* list_next_offset; */
20, /* list_width; */
8, /* list_elem_next_offset; */
12, /* list_elem_content_offset */
0, /* thread_stack_offset; */
52, /* thread_name_offset; */
&rtos_standard_Cortex_M3_stacking, /* stacking_info */
}
};
#define FREERTOS_NUM_PARAMS ((int)(sizeof(FreeRTOS_params_list)/sizeof(struct FreeRTOS_params)))
static int 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, char ** hex_reg_list );
static int FreeRTOS_get_symbol_list_to_lookup(symbol_table_elem_t * symbol_list[]);
static int 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, char **hex_reg_list);
static int FreeRTOS_get_symbol_list_to_lookup(symbol_table_elem_t *symbol_list[]);
struct rtos_type FreeRTOS_rtos = {
.name = "FreeRTOS",
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
{
FreeRTOS_VAL_pxCurrentTCB = 0,
FreeRTOS_VAL_pxReadyTasksLists = 1,
FreeRTOS_VAL_xDelayedTaskList1 = 2,
FreeRTOS_VAL_xDelayedTaskList2 = 3,
FreeRTOS_VAL_pxDelayedTaskList = 4,
enum FreeRTOS_symbol_values {
FreeRTOS_VAL_pxCurrentTCB = 0,
FreeRTOS_VAL_pxReadyTasksLists = 1,
FreeRTOS_VAL_xDelayedTaskList1 = 2,
FreeRTOS_VAL_xDelayedTaskList2 = 3,
FreeRTOS_VAL_pxDelayedTaskList = 4,
FreeRTOS_VAL_pxOverflowDelayedTaskList = 5,
FreeRTOS_VAL_xPendingReadyList = 6,
FreeRTOS_VAL_xTasksWaitingTermination = 7,
FreeRTOS_VAL_xSuspendedTaskList = 8,
FreeRTOS_VAL_uxCurrentNumberOfTasks = 9,
FreeRTOS_VAL_uxTopUsedPriority = 10,
FreeRTOS_VAL_xPendingReadyList = 6,
FreeRTOS_VAL_xTasksWaitingTermination = 7,
FreeRTOS_VAL_xSuspendedTaskList = 8,
FreeRTOS_VAL_uxCurrentNumberOfTasks = 9,
FreeRTOS_VAL_uxTopUsedPriority = 10,
};
static char* FreeRTOS_symbol_list[] =
{
"pxCurrentTCB",
"pxReadyTasksLists",
"xDelayedTaskList1",
"xDelayedTaskList2",
"pxDelayedTaskList",
"pxOverflowDelayedTaskList",
"xPendingReadyList",
"xTasksWaitingTermination",
"xSuspendedTaskList",
"uxCurrentNumberOfTasks",
"uxTopUsedPriority",
NULL
static char *FreeRTOS_symbol_list[] = {
"pxCurrentTCB",
"pxReadyTasksLists",
"xDelayedTaskList1",
"xDelayedTaskList2",
"pxDelayedTaskList",
"pxOverflowDelayedTaskList",
"xPendingReadyList",
"xTasksWaitingTermination",
"xSuspendedTaskList",
"uxCurrentNumberOfTasks",
"uxTopUsedPriority",
NULL
};
#define FREERTOS_NUM_SYMBOLS (sizeof(FreeRTOS_symbol_list)/sizeof(char*))
#define FREERTOS_NUM_SYMBOLS (sizeof(FreeRTOS_symbol_list)/sizeof(char *))
// TODO:
// this is not safe for little endian yet
// may be problems reading if sizes are not 32 bit long integers.
// test mallocs for failure
/* TODO: */
/* this is not safe for little endian yet */
/* 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 i = 0;
int retval;
int tasks_found = 0;
const struct FreeRTOS_params* param;
const struct FreeRTOS_params *param;
if (rtos->rtos_specific_params == NULL )
{
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 )
{
if (rtos->symbols == NULL) {
LOG_OUTPUT("No symbols for FreeRTOS\r\n");
return -3;
}
if ( rtos->symbols[FreeRTOS_VAL_uxCurrentNumberOfTasks].address == 0 )
{
if (rtos->symbols[FreeRTOS_VAL_uxCurrentNumberOfTasks].address == 0) {
LOG_OUTPUT("Don't have the number of threads in FreeRTOS \r\n");
return -2;
}
int thread_list_size = 0;
retval = target_read_buffer( rtos->target, rtos->symbols[FreeRTOS_VAL_uxCurrentNumberOfTasks].address, param->thread_count_width, (uint8_t *)&thread_list_size);
retval = target_read_buffer(rtos->target,
rtos->symbols[FreeRTOS_VAL_uxCurrentNumberOfTasks].address,
param->thread_count_width,
(uint8_t *)&thread_list_size);
if ( retval != ERROR_OK )
{
if (retval != ERROR_OK) {
LOG_OUTPUT("Could not read FreeRTOS thread count from target\r\n");
return retval;
}
// wipe out previous thread details if any
if ( rtos->thread_details != NULL )
{
/* wipe out previous thread details if any */
if (rtos->thread_details != NULL) {
int j;
for( j = 0; j < rtos->thread_count; j++ )
{
if ( rtos->thread_details[j].display_str != NULL )
{
free( rtos->thread_details[j].display_str );
for (j = 0; j < rtos->thread_count; j++) {
if (rtos->thread_details[j].display_str != NULL) {
free(rtos->thread_details[j].display_str);
rtos->thread_details[j].display_str = NULL;
}
if ( rtos->thread_details[j].thread_name_str != NULL )
{
free( rtos->thread_details[j].thread_name_str );
if (rtos->thread_details[j].thread_name_str != NULL) {
free(rtos->thread_details[j].thread_name_str);
rtos->thread_details[j].thread_name_str = NULL;
}
if ( rtos->thread_details[j].extra_info_str != NULL )
{
free( rtos->thread_details[j].extra_info_str );
if (rtos->thread_details[j].extra_info_str != NULL) {
free(rtos->thread_details[j].extra_info_str);
rtos->thread_details[j].extra_info_str = NULL;
}
}
free( rtos->thread_details );
free(rtos->thread_details);
rtos->thread_details = NULL;
}
// read the current thread
retval = target_read_buffer( rtos->target, rtos->symbols[FreeRTOS_VAL_pxCurrentTCB].address, param->pointer_width, (uint8_t *)&rtos->current_thread );
if ( retval != ERROR_OK )
{
/* read the current thread */
retval = target_read_buffer(rtos->target,
rtos->symbols[FreeRTOS_VAL_pxCurrentTCB].address,
param->pointer_width,
(uint8_t *)&rtos->current_thread);
if (retval != ERROR_OK) {
LOG_OUTPUT("Error reading current thread in FreeRTOS thread list\r\n");
return retval;
}
if ( ( thread_list_size == 0 ) || ( rtos->current_thread == 0 ) )
{
// Either : No RTOS threads - there is always at least the current execution though
// OR : No current thread - all threads suspended - show the current execution of idling
if ((thread_list_size == 0) || (rtos->current_thread == 0)) {
/* Either : No RTOS threads - there is always at least the current execution though */
/* OR : No current thread - all threads suspended - show the current execution
* of idling */
char tmp_str[] = "Current Execution";
thread_list_size++;
tasks_found++;
rtos->thread_details = (struct thread_detail*) malloc( sizeof( struct thread_detail ) * thread_list_size );
rtos->thread_details = (struct thread_detail *) malloc(
sizeof(struct thread_detail) * thread_list_size);
rtos->thread_details->threadid = 1;
rtos->thread_details->exists = true;
rtos->thread_details->display_str = NULL;
rtos->thread_details->extra_info_str = NULL;
rtos->thread_details->thread_name_str = (char*) malloc( sizeof(tmp_str) );
strcpy( rtos->thread_details->thread_name_str, tmp_str );
rtos->thread_details->thread_name_str = (char *) malloc(sizeof(tmp_str));
strcpy(rtos->thread_details->thread_name_str, tmp_str);
if ( thread_list_size == 1 )
{
if (thread_list_size == 1) {
rtos->thread_count = 1;
return ERROR_OK;
}
}
else
{
// create space for new thread details
rtos->thread_details = (struct thread_detail*) malloc( sizeof( struct thread_detail ) * thread_list_size );
} else {
/* create space for new thread details */
rtos->thread_details = (struct thread_detail *) malloc(
sizeof(struct thread_detail) * thread_list_size);
}
// Find out how many lists are needed to be read from pxReadyTasksLists,
/* Find out how many lists are needed to be read from pxReadyTasksLists, */
int64_t max_used_priority = 0;
retval = target_read_buffer( rtos->target, rtos->symbols[FreeRTOS_VAL_uxTopUsedPriority].address, param->pointer_width, (uint8_t *)&max_used_priority );
retval = target_read_buffer(rtos->target,
rtos->symbols[FreeRTOS_VAL_uxTopUsedPriority].address,
param->pointer_width,
(uint8_t *)&max_used_priority);
if (retval != ERROR_OK)
return retval;
return retval;
symbol_address_t* list_of_lists = (symbol_address_t *)malloc( sizeof( symbol_address_t ) * ( max_used_priority+1 + 5 ) );
symbol_address_t *list_of_lists =
(symbol_address_t *)malloc(sizeof(symbol_address_t) *
(max_used_priority+1 + 5));
int num_lists;
for( num_lists = 0; num_lists <= max_used_priority; num_lists++ )
{
list_of_lists[num_lists] = rtos->symbols[FreeRTOS_VAL_pxReadyTasksLists].address + num_lists * param->list_width;
}
for (num_lists = 0; num_lists <= max_used_priority; num_lists++)
list_of_lists[num_lists] = rtos->symbols[FreeRTOS_VAL_pxReadyTasksLists].address +
num_lists * param->list_width;
list_of_lists[num_lists++] = rtos->symbols[FreeRTOS_VAL_xDelayedTaskList1].address;
list_of_lists[num_lists++] = rtos->symbols[FreeRTOS_VAL_xDelayedTaskList2].address;
list_of_lists[num_lists++] = rtos->symbols[FreeRTOS_VAL_xPendingReadyList].address;
list_of_lists[num_lists++] = rtos->symbols[FreeRTOS_VAL_xSuspendedTaskList].address;
list_of_lists[num_lists++] = rtos->symbols[FreeRTOS_VAL_xTasksWaitingTermination].address;
list_of_lists[num_lists++] = rtos->symbols[FreeRTOS_VAL_xDelayedTaskList1].address;
list_of_lists[num_lists++] = rtos->symbols[FreeRTOS_VAL_xDelayedTaskList2].address;
list_of_lists[num_lists++] = rtos->symbols[FreeRTOS_VAL_xPendingReadyList].address;
list_of_lists[num_lists++] = rtos->symbols[FreeRTOS_VAL_xSuspendedTaskList].address;
list_of_lists[num_lists++] = rtos->symbols[FreeRTOS_VAL_xTasksWaitingTermination].address;
for( i = 0; i < num_lists; i++ )
{
if ( list_of_lists[i] == 0 )
{
for (i = 0; i < num_lists; i++) {
if (list_of_lists[i] == 0)
continue;
}
// Read the number of threads in this list
/* Read the number of threads in this list */
int64_t list_thread_count = 0;
retval = target_read_buffer( rtos->target, list_of_lists[i], param->thread_count_width, (uint8_t *)&list_thread_count);
if ( retval != ERROR_OK )
{
retval = target_read_buffer(rtos->target,
list_of_lists[i],
param->thread_count_width,
(uint8_t *)&list_thread_count);
if (retval != ERROR_OK) {
LOG_OUTPUT("Error reading number of threads in FreeRTOS thread list\r\n");
return retval;
}
if ( list_thread_count == 0 )
{
if (list_thread_count == 0)
continue;
}
// Read the location of first list item
/* Read the location of first list item */
uint64_t prev_list_elem_ptr = -1;
uint64_t list_elem_ptr = 0;
retval = target_read_buffer( rtos->target, list_of_lists[i] + param->list_next_offset, param->pointer_width, (uint8_t *)&list_elem_ptr);
if ( retval != ERROR_OK )
{
LOG_OUTPUT("Error reading first thread item location in FreeRTOS thread list\r\n");
retval = target_read_buffer(rtos->target,
list_of_lists[i] + param->list_next_offset,
param->pointer_width,
(uint8_t *)&list_elem_ptr);
if (retval != ERROR_OK) {
LOG_OUTPUT(
"Error reading first thread item location in FreeRTOS thread list\r\n");
return retval;
}
while ( (list_thread_count > 0) && ( list_elem_ptr != 0) && ( list_elem_ptr != prev_list_elem_ptr ) && ( tasks_found < thread_list_size ) )
{
// Get the location of the thread structure.
while ((list_thread_count > 0) && (list_elem_ptr != 0) &&
(list_elem_ptr != prev_list_elem_ptr) &&
(tasks_found < thread_list_size)) {
/* Get the location of the thread structure. */
rtos->thread_details[tasks_found].threadid = 0;
retval = target_read_buffer( rtos->target, list_elem_ptr + param->list_elem_content_offset, param->pointer_width, (uint8_t *)&(rtos->thread_details[tasks_found].threadid));
if ( retval != ERROR_OK )
{
LOG_OUTPUT("Error reading thread list item object in FreeRTOS thread list\r\n");
retval = target_read_buffer(rtos->target,
list_elem_ptr + param->list_elem_content_offset,
param->pointer_width,
(uint8_t *)&(rtos->thread_details[tasks_found].threadid));
if (retval != ERROR_OK) {
LOG_OUTPUT(
"Error reading thread list item object in FreeRTOS thread list\r\n");
return retval;
}
// get thread name
/* get thread name */
#define FREERTOS_THREAD_NAME_STR_SIZE (200)
char tmp_str[FREERTOS_THREAD_NAME_STR_SIZE];
// Read the thread name
retval = target_read_buffer( rtos->target, rtos->thread_details[tasks_found].threadid + param->thread_name_offset, FREERTOS_THREAD_NAME_STR_SIZE, (uint8_t *)&tmp_str);
if ( retval != ERROR_OK )
{
LOG_OUTPUT("Error reading first thread item location in FreeRTOS thread list\r\n");
/* Read the thread name */
retval = target_read_buffer(rtos->target,
rtos->thread_details[tasks_found].threadid + param->thread_name_offset,
FREERTOS_THREAD_NAME_STR_SIZE,
(uint8_t *)&tmp_str);
if (retval != ERROR_OK) {
LOG_OUTPUT(
"Error reading first thread item location in FreeRTOS thread list\r\n");
return retval;
}
tmp_str[FREERTOS_THREAD_NAME_STR_SIZE-1] = '\x00';
if ( tmp_str[0] == '\x00' )
{
strcpy(tmp_str,"No Name");
}
if (tmp_str[0] == '\x00')
strcpy(tmp_str, "No Name");
rtos->thread_details[tasks_found].thread_name_str = (char*)malloc( strlen(tmp_str)+1 );
strcpy( rtos->thread_details[tasks_found].thread_name_str, tmp_str );
rtos->thread_details[tasks_found].thread_name_str =
(char *)malloc(strlen(tmp_str)+1);
strcpy(rtos->thread_details[tasks_found].thread_name_str, tmp_str);
rtos->thread_details[tasks_found].display_str = NULL;
rtos->thread_details[tasks_found].exists = true;
if ( rtos->thread_details[tasks_found].threadid == rtos->current_thread )
{
if (rtos->thread_details[tasks_found].threadid == rtos->current_thread) {
char running_str[] = "Running";
rtos->thread_details[tasks_found].extra_info_str = (char*) malloc( sizeof(running_str) );
strcpy( rtos->thread_details[tasks_found].extra_info_str, running_str );
}
else
{
rtos->thread_details[tasks_found].extra_info_str = (char *) malloc(
sizeof(running_str));
strcpy(rtos->thread_details[tasks_found].extra_info_str,
running_str);
} else
rtos->thread_details[tasks_found].extra_info_str = NULL;
}
tasks_found++;
list_thread_count--;
prev_list_elem_ptr = list_elem_ptr;
list_elem_ptr = 0;
retval = target_read_buffer( rtos->target, prev_list_elem_ptr + param->list_elem_next_offset, param->pointer_width, (uint8_t *)&list_elem_ptr);
if ( retval != ERROR_OK )
{
LOG_OUTPUT("Error reading next thread item location in FreeRTOS thread list\r\n");
retval = target_read_buffer(rtos->target,
prev_list_elem_ptr + param->list_elem_next_offset,
param->pointer_width,
(uint8_t *)&list_elem_ptr);
if (retval != ERROR_OK) {
LOG_OUTPUT(
"Error reading next thread item location in FreeRTOS thread list\r\n");
return retval;
}
}
}
free( list_of_lists );
free(list_of_lists);
rtos->thread_count = tasks_found;
return 0;
}
static int FreeRTOS_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, char ** hex_reg_list )
static int FreeRTOS_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, char **hex_reg_list)
{
int retval;
const struct FreeRTOS_params* param;
const struct FreeRTOS_params *param;
int64_t stack_ptr = 0;
*hex_reg_list = NULL;
if ( rtos == NULL )
{
if (rtos == NULL)
return -1;
}
if ( thread_id == 0 )
{
if (thread_id == 0)
return -2;
}
if (rtos->rtos_specific_params == NULL )
{
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
retval = target_read_buffer( rtos->target, thread_id + param->thread_stack_offset, param->pointer_width, (uint8_t*)&stack_ptr);
if ( retval != ERROR_OK )
{
/* Read the stack pointer */
retval = target_read_buffer(rtos->target,
thread_id + param->thread_stack_offset,
param->pointer_width,
(uint8_t *)&stack_ptr);
if (retval != ERROR_OK) {
LOG_OUTPUT("Error reading stack frame from FreeRTOS thread\r\n");
return retval;
}
return rtos_generic_stack_read( rtos->target, param->stacking_info, stack_ptr, hex_reg_list );
return rtos_generic_stack_read(rtos->target, param->stacking_info, stack_ptr, hex_reg_list);
}
static int FreeRTOS_get_symbol_list_to_lookup(symbol_table_elem_t * symbol_list[])
static int FreeRTOS_get_symbol_list_to_lookup(symbol_table_elem_t *symbol_list[])
{
unsigned int i;
*symbol_list = (symbol_table_elem_t *) malloc( sizeof( symbol_table_elem_t ) * FREERTOS_NUM_SYMBOLS );
*symbol_list = (symbol_table_elem_t *) malloc(
sizeof(symbol_table_elem_t) * FREERTOS_NUM_SYMBOLS);
for( i = 0; i < FREERTOS_NUM_SYMBOLS; i++ )
{
for (i = 0; i < FREERTOS_NUM_SYMBOLS; i++)
(*symbol_list)[i].symbol_name = FreeRTOS_symbol_list[i];
}
return 0;
}
@ -406,81 +381,68 @@ 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 )
{
if (rtos == NULL)
return -1;
}
if ( thread_id == 0 )
{
if (thread_id == 0)
return -2;
}
if (rtos->rtos_specific_params == NULL )
{
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];
// Read the thread name
retval = target_read_buffer( rtos->target, thread_id + param->thread_name_offset, FREERTOS_THREAD_NAME_STR_SIZE, (uint8_t *)&tmp_str);
if ( retval != ERROR_OK )
{
/* Read the thread name */
retval = target_read_buffer(rtos->target,
thread_id + param->thread_name_offset,
FREERTOS_THREAD_NAME_STR_SIZE,
(uint8_t *)&tmp_str);
if (retval != ERROR_OK) {
LOG_OUTPUT("Error reading first thread item location in FreeRTOS thread list\r\n");
return retval;
}
tmp_str[FREERTOS_THREAD_NAME_STR_SIZE-1] = '\x00';
if ( tmp_str[0] == '\x00' )
{
strcpy(tmp_str,"No Name");
}
if (tmp_str[0] == '\x00')
strcpy(tmp_str, "No Name");
*info = (char*)malloc( strlen(tmp_str)+1 );
strcpy( *info, tmp_str );
*info = (char *)malloc(strlen(tmp_str)+1);
strcpy(*info, tmp_str);
return 0;
}
#endif
static int FreeRTOS_detect_rtos( struct target* target )
static int FreeRTOS_detect_rtos(struct target *target)
{
if ( ( target->rtos->symbols != NULL ) &&
( target->rtos->symbols[FreeRTOS_VAL_pxReadyTasksLists].address != 0 ) )
{
// looks like FreeRTOS
if ((target->rtos->symbols != NULL) &&
(target->rtos->symbols[FreeRTOS_VAL_pxReadyTasksLists].address != 0)) {
/* looks like FreeRTOS */
return 1;
}
return 0;
return 0;
}
static int FreeRTOS_create( struct target* target )
static int FreeRTOS_create(struct target *target)
{
int i = 0;
while ( ( i < FREERTOS_NUM_PARAMS ) && ( 0 != strcmp( FreeRTOS_params_list[i].target_name, target->type->name ) ) )
{
while ((i < FREERTOS_NUM_PARAMS) &&
(0 != strcmp(FreeRTOS_params_list[i].target_name, target->type->name))) {
i++;
}
if ( i >= FREERTOS_NUM_PARAMS )
{
if (i >= FREERTOS_NUM_PARAMS) {
LOG_OUTPUT("Could not find target in FreeRTOS compatibility list\r\n");
return -1;
}
target->rtos->rtos_specific_params = (void*) &FreeRTOS_params_list[i];
target->rtos->rtos_specific_params = (void *) &FreeRTOS_params_list[i];
return 0;
}

473
src/rtos/ThreadX.c
View File

@ -30,312 +30,275 @@
#include "helper/log.h"
#include "rtos_standard_stackings.h"
static int 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, char **hex_reg_list);
static int ThreadX_get_symbol_list_to_lookup(symbol_table_elem_t *symbol_list[]);
static int 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, char ** hex_reg_list );
static int ThreadX_get_symbol_list_to_lookup(symbol_table_elem_t * symbol_list[]);
struct ThreadX_thread_state
{
struct ThreadX_thread_state {
int value;
char * desc;
char *desc;
};
struct ThreadX_thread_state ThreadX_thread_states[] =
{
{ 0, "Ready" },
{ 1, "Completed" },
{ 2, "Terminated" },
{ 3, "Suspended" },
{ 4, "Sleeping" },
{ 5, "Waiting - Queue" },
{ 6, "Waiting - Semaphore" },
{ 7, "Waiting - Event flag" },
{ 8, "Waiting - Memory" },
{ 9, "Waiting - Memory" },
{ 10, "Waiting - I/O" },
{ 11, "Waiting - Filesystem" },
{ 12, "Waiting - Network" },
{ 13, "Waiting - Mutex" },
struct ThreadX_thread_state ThreadX_thread_states[] = {
{ 0, "Ready" },
{ 1, "Completed" },
{ 2, "Terminated" },
{ 3, "Suspended" },
{ 4, "Sleeping" },
{ 5, "Waiting - Queue" },
{ 6, "Waiting - Semaphore" },
{ 7, "Waiting - Event flag" },
{ 8, "Waiting - Memory" },
{ 9, "Waiting - Memory" },
{ 10, "Waiting - I/O" },
{ 11, "Waiting - Filesystem" },
{ 12, "Waiting - Network" },
{ 13, "Waiting - Mutex" },
};
#define THREADX_NUM_STATES (sizeof(ThreadX_thread_states)/sizeof(struct ThreadX_thread_state))
struct ThreadX_params
{
char * target_name;
unsigned char pointer_width;
unsigned char thread_stack_offset;
unsigned char thread_name_offset;
unsigned char thread_state_offset;
unsigned char thread_next_offset;
const struct rtos_register_stacking* stacking_info;
struct ThreadX_params {
char *target_name;
unsigned char pointer_width;
unsigned char thread_stack_offset;
unsigned char thread_name_offset;
unsigned char thread_state_offset;
unsigned char thread_next_offset;
const struct rtos_register_stacking *stacking_info;
};
const struct ThreadX_params ThreadX_params_list[] =
{
{ "cortex_m3", // target_name
4, // pointer_width;
8, // thread_stack_offset;
40, // thread_name_offset;
48, // thread_state_offset;
136, // thread_next_offset
&rtos_standard_Cortex_M3_stacking, // stacking_info
}
const struct ThreadX_params ThreadX_params_list[] = {
{
"cortex_m3", /* target_name */
4, /* pointer_width; */
8, /* thread_stack_offset; */
40, /* thread_name_offset; */
48, /* thread_state_offset; */
136, /* thread_next_offset */
&rtos_standard_Cortex_M3_stacking, /* stacking_info */
}
};
#define THREADX_NUM_PARAMS ((int)(sizeof(ThreadX_params_list)/sizeof(struct ThreadX_params)))
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,
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 char* ThreadX_symbol_list[] =
{
"_tx_thread_current_ptr",
"_tx_thread_created_ptr",
"_tx_thread_created_count",
NULL
static char *ThreadX_symbol_list[] = {
"_tx_thread_current_ptr",
"_tx_thread_created_ptr",
"_tx_thread_created_count",
NULL
};
#define THREADX_NUM_SYMBOLS (sizeof(ThreadX_symbol_list)/sizeof(char *))
const struct rtos_type ThreadX_rtos = {
.name = "ThreadX",
#define THREADX_NUM_SYMBOLS (sizeof(ThreadX_symbol_list)/sizeof(char*))
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,
.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 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 )
{
if (rtos == NULL)
return -1;
}
if (rtos->rtos_specific_params == NULL )
{
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 )
{
if (rtos->symbols == NULL) {
LOG_OUTPUT("No symbols for ThreadX\r\n");
return -4;
}
if ( rtos->symbols[ThreadX_VAL_tx_thread_created_count].address == 0 )
{
if (rtos->symbols[ThreadX_VAL_tx_thread_created_count].address == 0) {
LOG_OUTPUT("Don't have the number of threads in ThreadX \r\n");
return -2;
}
/* read the number of threads */
retval = target_read_buffer(rtos->target,
rtos->symbols[ThreadX_VAL_tx_thread_created_count].address,
4,
(uint8_t *)&thread_list_size);
// read the number of threads
retval = target_read_buffer( rtos->target, rtos->symbols[ThreadX_VAL_tx_thread_created_count].address, 4, (uint8_t *)&thread_list_size);
if ( retval != ERROR_OK )
{
if (retval != ERROR_OK) {
LOG_OUTPUT("Could not read ThreadX thread count from target\r\n");
return retval;
}
// wipe out previous thread details if any
if ( rtos->thread_details != NULL )
{
/* wipe out previous thread details if any */
if (rtos->thread_details != NULL) {
int j;
for( j = 0; j < rtos->thread_count; j++ )
{
if ( rtos->thread_details[j].display_str != NULL )
{
free( rtos->thread_details[j].display_str );
for (j = 0; j < rtos->thread_count; j++) {
if (rtos->thread_details[j].display_str != NULL) {
free(rtos->thread_details[j].display_str);
rtos->thread_details[j].display_str = NULL;
}
if ( rtos->thread_details[j].thread_name_str != NULL )
{
free( rtos->thread_details[j].thread_name_str );
if (rtos->thread_details[j].thread_name_str != NULL) {
free(rtos->thread_details[j].thread_name_str);
rtos->thread_details[j].thread_name_str = NULL;
}
if ( rtos->thread_details[j].extra_info_str != NULL )
{
free( rtos->thread_details[j].extra_info_str );
if (rtos->thread_details[j].extra_info_str != NULL) {
free(rtos->thread_details[j].extra_info_str);
rtos->thread_details[j].extra_info_str = NULL;
}
}
free( rtos->thread_details );
free(rtos->thread_details);
rtos->thread_details = NULL;
}
/* read the current thread id */
retval = target_read_buffer(rtos->target,
rtos->symbols[ThreadX_VAL_tx_thread_current_ptr].address,
4,
(uint8_t *)&rtos->current_thread);
// read the current thread id
retval = target_read_buffer( rtos->target, rtos->symbols[ThreadX_VAL_tx_thread_current_ptr].address, 4, (uint8_t *)&rtos->current_thread);
if ( retval != ERROR_OK )
{
if (retval != ERROR_OK) {
LOG_OUTPUT("Could not read ThreadX current thread from target\r\n");
return retval;
}
if ( ( thread_list_size == 0 ) || ( rtos->current_thread == 0 ) )
{
// Either : No RTOS threads - there is always at least the current execution though
// OR : No current thread - all threads suspended - show the current execution of idling
if ((thread_list_size == 0) || (rtos->current_thread == 0)) {
/* Either : No RTOS threads - there is always at least the current execution though */
/* OR : No current thread - all threads suspended - show the current execution
* of idling */
char tmp_str[] = "Current Execution";
thread_list_size++;
tasks_found++;
rtos->thread_details = (struct thread_detail*) malloc( sizeof( struct thread_detail ) * thread_list_size );
rtos->thread_details = (struct thread_detail *) malloc(
sizeof(struct thread_detail) * thread_list_size);
rtos->thread_details->threadid = 1;
rtos->thread_details->exists = true;
rtos->thread_details->display_str = NULL;
rtos->thread_details->extra_info_str = NULL;
rtos->thread_details->thread_name_str = (char*) malloc( sizeof(tmp_str) );
strcpy( rtos->thread_details->thread_name_str, tmp_str );
rtos->thread_details->thread_name_str = (char *) malloc(sizeof(tmp_str));
strcpy(rtos->thread_details->thread_name_str, tmp_str);
if ( thread_list_size == 0 )
{
if (thread_list_size == 0) {
rtos->thread_count = 1;
return ERROR_OK;
}
}
else
{
// create space for new thread details
rtos->thread_details = (struct thread_detail*) malloc( sizeof( struct thread_detail ) * thread_list_size );
} else {
/* create space for new thread details */
rtos->thread_details = (struct thread_detail *) malloc(
sizeof(struct thread_detail) * thread_list_size);
}
// Read the pointer to the first thread
/* Read the pointer to the first thread */
int64_t thread_ptr = 0;
retval = target_read_buffer( rtos->target, rtos->symbols[ThreadX_VAL_tx_thread_created_ptr].address, param->pointer_width, (uint8_t *)&thread_ptr);
if ( retval != ERROR_OK )
{
retval = target_read_buffer(rtos->target,
rtos->symbols[ThreadX_VAL_tx_thread_created_ptr].address,
param->pointer_width,
(uint8_t *)&thread_ptr);
if (retval != ERROR_OK) {
LOG_OUTPUT("Could not read ThreadX thread location from target\r\n");
return retval;
}
// loop over all threads
/* loop over all threads */
int64_t prev_thread_ptr = 0;
while ( ( thread_ptr != prev_thread_ptr ) && ( tasks_found < thread_list_size ) )
{
while ((thread_ptr != prev_thread_ptr) && (tasks_found < thread_list_size)) {
#define THREADX_THREAD_NAME_STR_SIZE (200)
char tmp_str[THREADX_THREAD_NAME_STR_SIZE];
char tmp_str[THREADX_THREAD_NAME_STR_SIZE];
unsigned int i = 0;
int64_t name_ptr = 0;
// Save the thread pointer
/* Save the thread pointer */
rtos->thread_details[tasks_found].threadid = thread_ptr;
// read the name pointer
retval = target_read_buffer( rtos->target, thread_ptr + param->thread_name_offset, param->pointer_width, (uint8_t *)&name_ptr);
if ( retval != ERROR_OK )
{
/* read the name pointer */
retval = target_read_buffer(rtos->target,
thread_ptr + param->thread_name_offset,
param->pointer_width,
(uint8_t *)&name_ptr);
if (retval != ERROR_OK) {
LOG_OUTPUT("Could not read ThreadX thread name pointer from target\r\n");
return retval;
}
// Read the thread name
retval = target_read_buffer( rtos->target, name_ptr, THREADX_THREAD_NAME_STR_SIZE, (uint8_t *)&tmp_str);
if ( retval != ERROR_OK )
{
/* Read the thread name */
retval =
target_read_buffer(rtos->target,
name_ptr,
THREADX_THREAD_NAME_STR_SIZE,
(uint8_t *)&tmp_str);
if (retval != ERROR_OK) {
LOG_OUTPUT("Error reading thread name from ThreadX target\r\n");
return retval;
}
tmp_str[THREADX_THREAD_NAME_STR_SIZE-1] = '\x00';
if ( tmp_str[0] == '\x00' )
{
strcpy(tmp_str,"No Name");
}
if (tmp_str[0] == '\x00')
strcpy(tmp_str, "No Name");
rtos->thread_details[tasks_found].thread_name_str =
(char *)malloc(strlen(tmp_str)+1);
strcpy(rtos->thread_details[tasks_found].thread_name_str, tmp_str);
rtos->thread_details[tasks_found].thread_name_str = (char*)malloc( strlen(tmp_str)+1 );
strcpy( rtos->thread_details[tasks_found].thread_name_str, tmp_str );
// Read the thread status
/* Read the thread status */
int64_t thread_status = 0;
retval = target_read_buffer( rtos->target, thread_ptr + param->thread_state_offset, 4, (uint8_t *)&thread_status);
if ( retval != ERROR_OK )
{
retval = target_read_buffer(rtos->target,
thread_ptr + param->thread_state_offset,
4,
(uint8_t *)&thread_status);
if (retval != ERROR_OK) {
LOG_OUTPUT("Error reading thread state from ThreadX target\r\n");
return retval;
}
for( i = 0; (i < THREADX_NUM_STATES) && (ThreadX_thread_states[i].value!=thread_status); i++ )
{
for (i = 0; (i < THREADX_NUM_STATES) &&
(ThreadX_thread_states[i].value != thread_status); i++) {
/* empty */
}
char * state_desc;
char *state_desc;
if (i < THREADX_NUM_STATES)
{
state_desc = ThreadX_thread_states[i].desc;
}
else
{
state_desc = "Unknown state";
}
rtos->thread_details[tasks_found].extra_info_str = (char*)malloc( strlen(state_desc)+1 );
strcpy( rtos->thread_details[tasks_found].extra_info_str, state_desc );
rtos->thread_details[tasks_found].extra_info_str = (char *)malloc(strlen(
state_desc)+1);
strcpy(rtos->thread_details[tasks_found].extra_info_str, state_desc);
rtos->thread_details[tasks_found].exists = true;
rtos->thread_details[tasks_found].display_str = NULL;
tasks_found++;
prev_thread_ptr = thread_ptr;
// Get the location of the next thread structure.
/* Get the location of the next thread structure. */
thread_ptr = 0;
retval = target_read_buffer( rtos->target, prev_thread_ptr + param->thread_next_offset, param->pointer_width, (uint8_t *) &thread_ptr );
if ( retval != ERROR_OK )
{
retval = target_read_buffer(rtos->target,
prev_thread_ptr + param->thread_next_offset,
param->pointer_width,
(uint8_t *) &thread_ptr);
if (retval != ERROR_OK) {
LOG_OUTPUT("Error reading next thread pointer in ThreadX thread list\r\n");
return retval;
}
}
rtos->thread_count = tasks_found;
@ -343,71 +306,60 @@ static int ThreadX_update_threads( struct rtos* rtos)
return 0;
}
static int ThreadX_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, char ** hex_reg_list )
static int ThreadX_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, char **hex_reg_list)
{
int retval;
const struct ThreadX_params* param;
const struct ThreadX_params *param;
*hex_reg_list = NULL;
if ( rtos == NULL )
{
if (rtos == NULL)
return -1;
}
if ( thread_id == 0 )
{
if (thread_id == 0)
return -2;
}
if (rtos->rtos_specific_params == NULL )
{
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
/* Read the stack pointer */
int64_t stack_ptr = 0;
retval = target_read_buffer( rtos->target, thread_id + param->thread_stack_offset, param->pointer_width, (uint8_t*)&stack_ptr);
if ( retval != ERROR_OK )
{
retval = target_read_buffer(rtos->target,
thread_id + param->thread_stack_offset,
param->pointer_width,
(uint8_t *)&stack_ptr);
if (retval != ERROR_OK) {
LOG_OUTPUT("Error reading stack frame from ThreadX thread\r\n");
return retval;
}
return rtos_generic_stack_read( rtos->target, param->stacking_info, stack_ptr, hex_reg_list );
return rtos_generic_stack_read(rtos->target, param->stacking_info, stack_ptr, hex_reg_list);
}
static int ThreadX_get_symbol_list_to_lookup(symbol_table_elem_t * symbol_list[])
static int ThreadX_get_symbol_list_to_lookup(symbol_table_elem_t *symbol_list[])
{
unsigned int i;
*symbol_list = (symbol_table_elem_t *) malloc( sizeof( symbol_table_elem_t ) * THREADX_NUM_SYMBOLS );
*symbol_list = (symbol_table_elem_t *) malloc(
sizeof(symbol_table_elem_t) * THREADX_NUM_SYMBOLS);
for( i = 0; i < THREADX_NUM_SYMBOLS; i++ )
{
for (i = 0; i < THREADX_NUM_SYMBOLS; i++)
(*symbol_list)[i].symbol_name = ThreadX_symbol_list[i];
}
return 0;
}
static int ThreadX_detect_rtos( struct target* target )
static int ThreadX_detect_rtos(struct target *target)
{
if ( ( target->rtos->symbols != NULL ) &&
( target->rtos->symbols[ThreadX_VAL_tx_thread_created_ptr].address != 0 ) )
{
// looks like ThreadX
if ((target->rtos->symbols != NULL) &&
(target->rtos->symbols[ThreadX_VAL_tx_thread_created_ptr].address != 0)) {
/* looks like ThreadX */
return 1;
}
return 0;
}
#if 0
static int ThreadX_set_current_thread(struct rtos *rtos, threadid_t thread_id)
@ -415,9 +367,9 @@ static int ThreadX_set_current_thread(struct rtos *rtos, threadid_t thread_id)
return 0;
}
static int ThreadX_get_thread_detail( struct rtos* rtos, threadid_t thread_id, struct thread_detail* detail )
static int ThreadX_get_thread_detail(struct rtos *rtos,
threadid_t thread_id,
struct thread_detail *detail)
{
unsigned int i = 0;
int retval;
@ -425,27 +377,20 @@ static int ThreadX_get_thread_detail( struct rtos* rtos, threadid_t thread_i
#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 )
{
if (rtos == NULL)
return -1;
}
if ( thread_id == 0 )
{
if (thread_id == 0)
return -2;
}
if (rtos->rtos_specific_params == NULL )
{
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 )
{
if (rtos->symbols == NULL) {
LOG_OUTPUT("No symbols for ThreadX\r\n");
return -3;
}
@ -453,83 +398,79 @@ static int ThreadX_get_thread_detail( struct rtos* rtos, threadid_t thread_i
detail->threadid = thread_id;
int64_t name_ptr = 0;
// read the name pointer
retval = target_read_buffer( rtos->target, thread_id + param->thread_name_offset, param->pointer_width, (uint8_t *)&name_ptr);
if ( retval != ERROR_OK )
{
/* read the name pointer */
retval = target_read_buffer(rtos->target,
thread_id + param->thread_name_offset,
param->pointer_width,
(uint8_t *)&name_ptr);
if (retval != ERROR_OK) {
LOG_OUTPUT("Could not read ThreadX thread name pointer from target\r\n");
return retval;
}
// Read the thread name
retval = target_read_buffer( rtos->target, name_ptr, THREADX_THREAD_NAME_STR_SIZE, (uint8_t *)&tmp_str);
if ( retval != ERROR_OK )
{
/* Read the thread name */
retval = target_read_buffer(rtos->target,
name_ptr,
THREADX_THREAD_NAME_STR_SIZE,
(uint8_t *)&tmp_str);
if (retval != ERROR_OK) {
LOG_OUTPUT("Error reading thread name from ThreadX target\r\n");
return retval;
}
tmp_str[THREADX_THREAD_NAME_STR_SIZE-1] = '\x00';
if ( tmp_str[0] == '\x00' )
{
strcpy(tmp_str,"No Name");
}
if (tmp_str[0] == '\x00')
strcpy(tmp_str, "No Name");
detail->thread_name_str = (char*)malloc( strlen(tmp_str)+1 );
detail->thread_name_str = (char *)malloc(strlen(tmp_str)+1);
// Read the thread status
/* Read the thread status */
int64_t thread_status = 0;
retval = target_read_buffer( rtos->target, thread_id + param->thread_state_offset, 4, (uint8_t *)&thread_status);
if ( retval != ERROR_OK )
{
retval =
target_read_buffer(rtos->target,
thread_id + param->thread_state_offset,
4,
(uint8_t *)&thread_status);
if (retval != ERROR_OK) {
LOG_OUTPUT("Error reading thread state from ThreadX target\r\n");
return retval;
}
for( i = 0; (i < THREADX_NUM_STATES) && (ThreadX_thread_states[i].value!=thread_status); i++ )
{
for (i = 0; (i < THREADX_NUM_STATES) &&
(ThreadX_thread_states[i].value != thread_status); i++) {
/* empty */
}
char * state_desc;
char *state_desc;
if (i < THREADX_NUM_STATES)
{
state_desc = ThreadX_thread_states[i].desc;
}
else
{
state_desc = "Unknown state";
}
detail->extra_info_str = (char*)malloc( strlen(state_desc)+1 );
detail->extra_info_str = (char *)malloc(strlen(state_desc)+1);
detail->exists = true;
detail->display_str = NULL;
return 0;
}
#endif
static int ThreadX_create( struct target* target )
static int ThreadX_create(struct target *target)
{
int i = 0;
while ( ( i < THREADX_NUM_PARAMS ) && ( 0 != strcmp( ThreadX_params_list[i].target_name, target->type->name ) ) )
{
while ((i < THREADX_NUM_PARAMS) &&
(0 != strcmp(ThreadX_params_list[i].target_name, target->type->name))) {
i++;
}
if ( i >= THREADX_NUM_PARAMS )
{
if (i >= THREADX_NUM_PARAMS) {
LOG_OUTPUT("Could not find target in ThreadX compatibility list\r\n");
return -1;
}
target->rtos->rtos_specific_params = (void*) &ThreadX_params_list[i];
target->rtos->rtos_specific_params = (void *) &ThreadX_params_list[i];
target->rtos->current_thread = 0;
target->rtos->thread_details = NULL;
return 0;

399
src/rtos/eCos.c
View File

@ -28,206 +28,189 @@
#include "helper/log.h"
#include "rtos_ecos_stackings.h"
static int eCos_detect_rtos( struct target* target );
static int eCos_create( struct target* target );
static int eCos_update_threads( struct rtos* rtos);
static int eCos_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, char ** hex_reg_list );
static int eCos_get_symbol_list_to_lookup(symbol_table_elem_t * symbol_list[]);
static int eCos_detect_rtos(struct target *target);
static int eCos_create(struct target *target);
static int eCos_update_threads(struct rtos *rtos);
static int eCos_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, char **hex_reg_list);
static int eCos_get_symbol_list_to_lookup(symbol_table_elem_t *symbol_list[]);
struct eCos_thread_state
{
struct eCos_thread_state {
int value;
char * desc;
char *desc;
};
struct eCos_thread_state eCos_thread_states[] =
{
{ 0, "Ready" },
{ 1, "Sleeping" },
{ 2, "Countsleep" },
{ 4, "Suspended" },
{ 8, "Creating" },
{ 16, "Exited" }
struct eCos_thread_state eCos_thread_states[] = {
{ 0, "Ready" },
{ 1, "Sleeping" },
{ 2, "Countsleep" },
{ 4, "Suspended" },
{ 8, "Creating" },
{ 16, "Exited" }
};
#define ECOS_NUM_STATES (sizeof(eCos_thread_states)/sizeof(struct eCos_thread_state))
struct eCos_params
{
char * target_name;
unsigned char pointer_width;
unsigned char thread_stack_offset;
unsigned char thread_name_offset;
unsigned char thread_state_offset;
unsigned char thread_next_offset;
unsigned char thread_uniqueid_offset;
const struct rtos_register_stacking* stacking_info;
struct eCos_params {
char *target_name;
unsigned char pointer_width;
unsigned char thread_stack_offset;
unsigned char thread_name_offset;
unsigned char thread_state_offset;
unsigned char thread_next_offset;
unsigned char thread_uniqueid_offset;
const struct rtos_register_stacking *stacking_info;
};
const struct eCos_params eCos_params_list[] =
{
{ "cortex_m3", // target_name
4, // pointer_width;
0x0c, // thread_stack_offset;
0x9c, // thread_name_offset;
0x3c, // thread_state_offset;
0xa0, // thread_next_offset
0x4c, // thread_uniqueid_offset
&rtos_eCos_Cortex_M3_stacking // stacking_info
const struct eCos_params eCos_params_list[] = {
{
"cortex_m3", /* target_name */
4, /* pointer_width; */
0x0c, /* thread_stack_offset; */
0x9c, /* thread_name_offset; */
0x3c, /* thread_state_offset; */
0xa0, /* thread_next_offset */
0x4c, /* thread_uniqueid_offset */
&rtos_eCos_Cortex_M3_stacking /* stacking_info */
}
};
#define ECOS_NUM_PARAMS ((int)(sizeof(eCos_params_list)/sizeof(struct eCos_params)))
enum eCos_symbol_values
{
eCos_VAL_thread_list = 0,
eCos_VAL_current_thread_ptr = 1
enum eCos_symbol_values {
eCos_VAL_thread_list = 0,
eCos_VAL_current_thread_ptr = 1
};
static char* eCos_symbol_list[] =
{
"Cyg_Thread::thread_list",
"Cyg_Scheduler_Base::current_thread",
NULL
static char *eCos_symbol_list[] = {
"Cyg_Thread::thread_list",
"Cyg_Scheduler_Base::current_thread",
NULL
};
#define ECOS_NUM_SYMBOLS (sizeof(eCos_symbol_list)/sizeof(char *))
const struct rtos_type eCos_rtos = {
.name = "eCos",
#define ECOS_NUM_SYMBOLS (sizeof(eCos_symbol_list)/sizeof(char*))
const struct rtos_type eCos_rtos =
{
.name = "eCos",
.detect_rtos = eCos_detect_rtos,
.create = eCos_create,
.update_threads = eCos_update_threads,
.get_thread_reg_list = eCos_get_thread_reg_list,
.detect_rtos = eCos_detect_rtos,
.create = eCos_create,
.update_threads = eCos_update_threads,
.get_thread_reg_list = eCos_get_thread_reg_list,
.get_symbol_list_to_lookup = eCos_get_symbol_list_to_lookup,
};
static int eCos_update_threads( struct rtos* rtos)
static int eCos_update_threads(struct rtos *rtos)
{
int retval;
int tasks_found = 0;
int thread_list_size = 0;
const struct eCos_params* param;
const struct eCos_params *param;
if ( rtos == NULL )
{
if (rtos == NULL)
return -1;
}
if (rtos->rtos_specific_params == NULL )
{
if (rtos->rtos_specific_params == NULL)
return -3;
}
param = (const struct eCos_params*) rtos->rtos_specific_params;
param = (const struct eCos_params *) rtos->rtos_specific_params;
if ( rtos->symbols == NULL )
{
if (rtos->symbols == NULL) {
LOG_OUTPUT("No symbols for eCos\r\n");
return -4;
}
if ( rtos->symbols[eCos_VAL_thread_list].address == 0 )
{
if (rtos->symbols[eCos_VAL_thread_list].address == 0) {
LOG_OUTPUT("Don't have the thread list head\r\n");
return -2;
}
// wipe out previous thread details if any
if ( rtos->thread_details != NULL )
{
/* wipe out previous thread details if any */
if (rtos->thread_details != NULL) {
int j;
for( j = 0; j < rtos->thread_count; j++ )
{
if ( rtos->thread_details[j].display_str != NULL )
{
free( rtos->thread_details[j].display_str );
for (j = 0; j < rtos->thread_count; j++) {
if (rtos->thread_details[j].display_str != NULL) {
free(rtos->thread_details[j].display_str);
rtos->thread_details[j].display_str = NULL;
}
if ( rtos->thread_details[j].thread_name_str != NULL )
{
free( rtos->thread_details[j].thread_name_str );
if (rtos->thread_details[j].thread_name_str != NULL) {
free(rtos->thread_details[j].thread_name_str);
rtos->thread_details[j].thread_name_str = NULL;
}
if ( rtos->thread_details[j].extra_info_str != NULL )
{
free( rtos->thread_details[j].extra_info_str );
if (rtos->thread_details[j].extra_info_str != NULL) {
free(rtos->thread_details[j].extra_info_str);
rtos->thread_details[j].extra_info_str = NULL;
}
}
free( rtos->thread_details );
free(rtos->thread_details);
rtos->thread_details = NULL;
}
// determine the number of current threads
/* determine the number of current threads */
uint32_t thread_list_head = rtos->symbols[eCos_VAL_thread_list].address;
uint32_t thread_index;
target_read_buffer( rtos->target, thread_list_head, param->pointer_width, (uint8_t *) &thread_index );
target_read_buffer(rtos->target,
thread_list_head,
param->pointer_width,
(uint8_t *) &thread_index);
uint32_t first_thread = thread_index;
do
{
do {
thread_list_size++;
retval = target_read_buffer( rtos->target, thread_index + param->thread_next_offset, param->pointer_width, (uint8_t *) &thread_index );
retval = target_read_buffer(rtos->target,
thread_index + param->thread_next_offset,
param->pointer_width,
(uint8_t *) &thread_index);
if (retval != ERROR_OK)
return retval;
} while( thread_index!=first_thread );
} while (thread_index != first_thread);
// read the current thread id
/* read the current thread id */
uint32_t current_thread_addr;
retval = target_read_buffer( rtos->target, rtos->symbols[eCos_VAL_current_thread_ptr].address, 4, (uint8_t *)&current_thread_addr);
retval = target_read_buffer(rtos->target,
rtos->symbols[eCos_VAL_current_thread_ptr].address,
4,
(uint8_t *)&current_thread_addr);
if (retval != ERROR_OK)
return retval;
rtos->current_thread = 0;
retval = target_read_buffer( rtos->target, current_thread_addr + param->thread_uniqueid_offset, 2, (uint8_t *)&rtos->current_thread);
if ( retval != ERROR_OK )
{
retval = target_read_buffer(rtos->target,
current_thread_addr + param->thread_uniqueid_offset,
2,
(uint8_t *)&rtos->current_thread);
if (retval != ERROR_OK) {
LOG_OUTPUT("Could not read eCos current thread from target\r\n");
return retval;
}
if ( ( thread_list_size == 0 ) || ( rtos->current_thread == 0 ) )
{
// Either : No RTOS threads - there is always at least the current execution though
// OR : No current thread - all threads suspended - show the current execution of idling
if ((thread_list_size == 0) || (rtos->current_thread == 0)) {
/* Either : No RTOS threads - there is always at least the current execution though */
/* OR : No current thread - all threads suspended - show the current execution
* of idling */
char tmp_str[] = "Current Execution";
thread_list_size++;
tasks_found++;
rtos->thread_details = (struct thread_detail*) malloc( sizeof( struct thread_detail ) * thread_list_size );
rtos->thread_details = (struct thread_detail *) malloc(
sizeof(struct thread_detail) * thread_list_size);
rtos->thread_details->threadid = 1;
rtos->thread_details->exists = true;
rtos->thread_details->display_str = NULL;
rtos->thread_details->extra_info_str = NULL;
rtos->thread_details->thread_name_str = (char*) malloc( sizeof(tmp_str) );
strcpy( rtos->thread_details->thread_name_str, tmp_str );
rtos->thread_details->thread_name_str = (char *) malloc(sizeof(tmp_str));
strcpy(rtos->thread_details->thread_name_str, tmp_str);
if ( thread_list_size == 0 )
{
if (thread_list_size == 0) {
rtos->thread_count = 1;
return ERROR_OK;
}
}
else
{
// create space for new thread details
rtos->thread_details = (struct thread_detail*) malloc( sizeof( struct thread_detail ) * thread_list_size );
} else {
/* create space for new thread details */
rtos->thread_details = (struct thread_detail *) malloc(
sizeof(struct thread_detail) * thread_list_size);
}
// loop over all threads
/* loop over all threads */
thread_index = first_thread;
do
{
do {
#define ECOS_THREAD_NAME_STR_SIZE (200)
char tmp_str[ECOS_THREAD_NAME_STR_SIZE];
@ -235,196 +218,198 @@ static int eCos_update_threads( struct rtos* rtos)
uint32_t name_ptr = 0;
uint32_t prev_thread_ptr;
// Save the thread pointer
/* Save the thread pointer */
uint16_t thread_id;
retval = target_read_buffer( rtos->target, thread_index + param->thread_uniqueid_offset, 2, (uint8_t *)&thread_id);
if ( retval != ERROR_OK )
{
retval = target_read_buffer(rtos->target,
thread_index + param->thread_uniqueid_offset,
2,
(uint8_t *)&thread_id);
if (retval != ERROR_OK) {
LOG_OUTPUT("Could not read eCos thread id from target\r\n");
return retval;
}
rtos->thread_details[tasks_found].threadid = thread_id;
// read the name pointer
retval = target_read_buffer( rtos->target, thread_index + param->thread_name_offset, param->pointer_width, (uint8_t *)&name_ptr);
if ( retval != ERROR_OK )
{
/* read the name pointer */
retval = target_read_buffer(rtos->target,
thread_index + param->thread_name_offset,
param->pointer_width,
(uint8_t *)&name_ptr);
if (retval != ERROR_OK) {
LOG_OUTPUT("Could not read eCos thread name pointer from target\r\n");
return retval;
}
// Read the thread name
retval = target_read_buffer( rtos->target, name_ptr, ECOS_THREAD_NAME_STR_SIZE, (uint8_t *)&tmp_str);
if ( retval != ERROR_OK )
{
/* Read the thread name */
retval =
target_read_buffer(rtos->target,
name_ptr,
ECOS_THREAD_NAME_STR_SIZE,
(uint8_t *)&tmp_str);
if (retval != ERROR_OK) {
LOG_OUTPUT("Error reading thread name from eCos target\r\n");
return retval;
}
tmp_str[ECOS_THREAD_NAME_STR_SIZE-1] = '\x00';
if ( tmp_str[0] == '\x00' )
{
strcpy(tmp_str,"No Name");
}
if (tmp_str[0] == '\x00')
strcpy(tmp_str, "No Name");
rtos->thread_details[tasks_found].thread_name_str = (char*)malloc( strlen(tmp_str)+1 );
strcpy( rtos->thread_details[tasks_found].thread_name_str, tmp_str );
rtos->thread_details[tasks_found].thread_name_str =
(char *)malloc(strlen(tmp_str)+1);
strcpy(rtos->thread_details[tasks_found].thread_name_str, tmp_str);
// Read the thread status
/* Read the thread status */
int64_t thread_status = 0;
retval = target_read_buffer( rtos->target, thread_index + param->thread_state_offset, 4, (uint8_t *)&thread_status);
if ( retval != ERROR_OK )
{
retval = target_read_buffer(rtos->target,
thread_index + param->thread_state_offset,
4,
(uint8_t *)&thread_status);
if (retval != ERROR_OK) {
LOG_OUTPUT("Error reading thread state from eCos target\r\n");
return retval;
}
for( i = 0; (i < ECOS_NUM_STATES) && (eCos_thread_states[i].value!=thread_status); i++ )
{
for (i = 0; (i < ECOS_NUM_STATES) && (eCos_thread_states[i].value != thread_status); i++) {
/*
* empty
*/
}
char * state_desc;
char *state_desc;
if (i < ECOS_NUM_STATES)
{
state_desc = eCos_thread_states[i].desc;
}
else
{
state_desc = "Unknown state";
}
rtos->thread_details[tasks_found].extra_info_str = (char*)malloc( strlen(state_desc)+1 );
strcpy( rtos->thread_details[tasks_found].extra_info_str, state_desc );
rtos->thread_details[tasks_found].extra_info_str = (char *)malloc(strlen(
state_desc)+1);
strcpy(rtos->thread_details[tasks_found].extra_info_str, state_desc);
rtos->thread_details[tasks_found].exists = true;
rtos->thread_details[tasks_found].display_str = NULL;
tasks_found++;
prev_thread_ptr = thread_index;
// Get the location of the next thread structure.
/* Get the location of the next thread structure. */
thread_index = rtos->symbols[eCos_VAL_thread_list].address;
retval = target_read_buffer( rtos->target, prev_thread_ptr + param->thread_next_offset, param->pointer_width, (uint8_t *) &thread_index );
if ( retval != ERROR_OK )
{
retval = target_read_buffer(rtos->target,
prev_thread_ptr + param->thread_next_offset,
param->pointer_width,
(uint8_t *) &thread_index);
if (retval != ERROR_OK) {
LOG_OUTPUT("Error reading next thread pointer in eCos thread list\r\n");
return retval;
}
}
while( thread_index!=first_thread );
} while (thread_index != first_thread);
rtos->thread_count = tasks_found;
return 0;
}
static int eCos_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, char ** hex_reg_list )
static int eCos_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, char **hex_reg_list)
{
int retval;
const struct eCos_params* param;
const struct eCos_params *param;
*hex_reg_list = NULL;
if ( rtos == NULL )
{
if (rtos == NULL)
return -1;
}
if ( thread_id == 0 )
{
if (thread_id == 0)
return -2;
}
if (rtos->rtos_specific_params == NULL )
{
if (rtos->rtos_specific_params == NULL)
return -3;
}
param = (const struct eCos_params*) rtos->rtos_specific_params;
param = (const struct eCos_params *) rtos->rtos_specific_params;
// Find the thread with that thread id
uint16_t id=0;
/* Find the thread with that thread id */
uint16_t id = 0;
uint32_t thread_list_head = rtos->symbols[eCos_VAL_thread_list].address;
uint32_t thread_index;
target_read_buffer( rtos->target, thread_list_head, param->pointer_width, (uint8_t *) &thread_index );
bool done=false;
while(!done)
{
retval = target_read_buffer( rtos->target, thread_index + param->thread_uniqueid_offset, 2, (uint8_t*)&id);
if ( retval != ERROR_OK )
{
target_read_buffer(rtos->target, thread_list_head, param->pointer_width,
(uint8_t *)&thread_index);
bool done = false;
while (!done) {
retval = target_read_buffer(rtos->target,
thread_index + param->thread_uniqueid_offset,
2,
(uint8_t *)&id);
if (retval != ERROR_OK) {
LOG_OUTPUT("Error reading unique id from eCos thread\r\n");
return retval;
}
if( id==thread_id )
{
done=true;
if (id == thread_id) {
done = true;
break;
}
target_read_buffer( rtos->target, thread_index + param->thread_next_offset, param->pointer_width, (uint8_t *) &thread_index );
target_read_buffer(rtos->target,
thread_index + param->thread_next_offset,
param->pointer_width,
(uint8_t *) &thread_index);
}
if(done)
{
// Read the stack pointer
if (done) {
/* Read the stack pointer */
int64_t stack_ptr = 0;
retval = target_read_buffer( rtos->target, thread_index + param->thread_stack_offset, param->pointer_width, (uint8_t*)&stack_ptr);
if ( retval != ERROR_OK )
{
retval = target_read_buffer(rtos->target,
thread_index + param->thread_stack_offset,
param->pointer_width,
(uint8_t *)&stack_ptr);
if (retval != ERROR_OK) {
LOG_OUTPUT("Error reading stack frame from eCos thread\r\n");
return retval;
}
return rtos_generic_stack_read( rtos->target, param->stacking_info, stack_ptr, hex_reg_list );
return rtos_generic_stack_read(rtos->target,
param->stacking_info,
stack_ptr,
hex_reg_list);
}
return -1;
}
static int eCos_get_symbol_list_to_lookup(symbol_table_elem_t * symbol_list[])
static int eCos_get_symbol_list_to_lookup(symbol_table_elem_t *symbol_list[])
{
unsigned int i;
*symbol_list = (symbol_table_elem_t *) malloc( sizeof( symbol_table_elem_t ) * ECOS_NUM_SYMBOLS );
*symbol_list = (symbol_table_elem_t *) malloc(
sizeof(symbol_table_elem_t) * ECOS_NUM_SYMBOLS);
for( i = 0; i < ECOS_NUM_SYMBOLS; i++ )
{
for (i = 0; i < ECOS_NUM_SYMBOLS; i++)
(*symbol_list)[i].symbol_name = eCos_symbol_list[i];
}
return 0;
}
static int eCos_detect_rtos( struct target* target )
static int eCos_detect_rtos(struct target *target)
{
if ( ( target->rtos->symbols != NULL ) &&
( target->rtos->symbols[eCos_VAL_thread_list].address != 0 ) )
{
// looks like eCos
if ((target->rtos->symbols != NULL) &&
(target->rtos->symbols[eCos_VAL_thread_list].address != 0)) {
/* looks like eCos */
return 1;
}
return 0;
}
static int eCos_create( struct target* target )
static int eCos_create(struct target *target)
{
int i = 0;
while ( ( i < ECOS_NUM_PARAMS ) && ( 0 != strcmp( eCos_params_list[i].target_name, target->type->name ) ) )
{
while ((i < ECOS_NUM_PARAMS) &&
(0 != strcmp(eCos_params_list[i].target_name, target->type->name))) {
i++;
}
if ( i >= ECOS_NUM_PARAMS )
{
if (i >= ECOS_NUM_PARAMS) {
LOG_OUTPUT("Could not find target in eCos compatibility list\r\n");
return -1;
}
target->rtos->rtos_specific_params = (void*) &eCos_params_list[i];
target->rtos->rtos_specific_params = (void *) &eCos_params_list[i];
target->rtos->current_thread = 0;
target->rtos->thread_details = NULL;
return 0;

503
src/rtos/linux.c
View File

File diff suppressed because it is too large Load Diff

388
src/rtos/rtos.c
View File

@ -22,16 +22,12 @@
#include "config.h"
#endif
#include "rtos.h"
#include "target/target.h"
#include "helper/log.h"
#include "server/gdb_server.h"
static void hex_to_str( char* dst, char * hex_src );
static void hex_to_str(char *dst, char *hex_src);
/* RTOSs */
extern struct rtos_type FreeRTOS_rtos;
@ -39,8 +35,7 @@ extern struct rtos_type ThreadX_rtos;
extern struct rtos_type eCos_rtos;
extern struct rtos_type Linux_os;
static struct rtos_type *rtos_types[] =
{
static struct rtos_type *rtos_types[] = {
&ThreadX_rtos,
&FreeRTOS_rtos,
&eCos_rtos,
@ -57,69 +52,66 @@ int rtos_smp_init(struct target *target)
return ERROR_TARGET_INIT_FAILED;
}
int rtos_create(Jim_GetOptInfo *goi, struct target * target)
int rtos_create(Jim_GetOptInfo *goi, struct target *target)
{
int x;
char *cp;
if (! goi->isconfigure) {
if (!goi->isconfigure) {
if (goi->argc != 0) {
if (goi->argc != 0) {
Jim_WrongNumArgs(goi->interp,
goi->argc, goi->argv,
"NO PARAMS");
goi->argc, goi->argv,
"NO PARAMS");
return JIM_ERR;
}
Jim_SetResultString(goi->interp,
target_type_name(target), -1);
target_type_name(target), -1);
}
}
if (target->rtos) {
if (target->rtos)
free((void *)(target->rtos));
}
// e = Jim_GetOpt_String(goi, &cp, NULL);
// target->rtos = strdup(cp);
/* e = Jim_GetOpt_String(goi,
* &cp, NULL); */
/* target->rtos = strdup(cp); */
Jim_GetOpt_String(goi, &cp, NULL);
/* now does target type exist */
if ( 0 == strcmp( cp, "auto") )
{
// auto detection of RTOS
if (0 == strcmp(cp, "auto")) {
/* auto detection of RTOS */
target->rtos_auto_detect = true;
x = 0;
}
else
{
} else {
for (x = 0 ; rtos_types[x] ; x++) {
for (x = 0; rtos_types[x]; x++) {
if (0 == strcmp(cp, rtos_types[x]->name)) {
/* found */
break;
}
}
if (rtos_types[x] == NULL) {
Jim_SetResultFormatted(goi->interp, "Unknown rtos type %s, try one of ", cp);
for (x = 0 ; rtos_types[x] ; x++) {
Jim_SetResultFormatted(goi->interp, "Unknown rtos type %s, try one of ",
cp);
for (x = 0; rtos_types[x]; x++) {
if (rtos_types[x + 1]) {
Jim_AppendStrings(goi->interp,
Jim_GetResult(goi->interp),
rtos_types[x]->name,
", ", NULL);
Jim_GetResult(goi->interp),
rtos_types[x]->name,
", ", NULL);
} else {
Jim_AppendStrings(goi->interp,
Jim_GetResult(goi->interp),
" or ",
rtos_types[x]->name,NULL);
Jim_GetResult(goi->interp),
" or ",
rtos_types[x]->name, NULL);
}
}
return JIM_ERR;
}
}
/* Create it */
target->rtos = calloc(1,sizeof(struct rtos));
target->rtos = calloc(1, sizeof(struct rtos));
target->rtos->type = rtos_types[x];
target->rtos->current_threadid = -1;
target->rtos->current_thread = 0;
@ -128,10 +120,8 @@ int rtos_create(Jim_GetOptInfo *goi, struct target * target)
/* put default thread handler in linux usecase it is overloaded*/
target->rtos->gdb_thread_packet = rtos_thread_packet;
if ( 0 != strcmp( cp, "auto") )
{
target->rtos->type->create( target );
}
if (0 != strcmp(cp, "auto"))
target->rtos->type->create(target);
return JIM_OK;
}
@ -140,7 +130,8 @@ int gdb_thread_packet(struct connection *connection, char *packet, int packet_si
{
struct target *target = get_target_from_connection(connection);
if (target->rtos == NULL)
return rtos_thread_packet(connection, packet, packet_size); /* thread not found*/
return rtos_thread_packet(connection, packet, packet_size); /* thread not
*found*/
return target->rtos->gdb_thread_packet(connection, packet, packet_size);
}
/* return -1 if no rtos defined, 0 if rtos and symbol to be asked, 1 if all
@ -171,8 +162,8 @@ int rtos_qsymbol(struct connection *connection, char *packet, int packet_size)
hex_to_str(name_str, hex_name_str);
symbol_num = 0;
while ((target->rtos->symbols[symbol_num].symbol_name != NULL)
&& (0 != strcmp(target->rtos->symbols[symbol_num].symbol_name, name_str)))
while ((target->rtos->symbols[symbol_num].symbol_name != NULL) &&
(0 != strcmp(target->rtos->symbols[symbol_num].symbol_name, name_str)))
symbol_num++;
if (target->rtos->symbols[symbol_num].symbol_name == NULL) {
@ -194,7 +185,8 @@ int rtos_qsymbol(struct connection *connection, char *packet, int packet_size)
(1 == target->rtos->type->detect_rtos(target))) {
/* Found correct RTOS or not autodetecting */
if (target->rtos_auto_detect == true)
LOG_OUTPUT("Auto-detected RTOS: %s\r\n", target->rtos->type->name);
LOG_OUTPUT("Auto-detected RTOS: %s\r\n",
target->rtos->type->name);
symbols_done = 1;
} else {
/* Auto detecting RTOS and currently not found */
@ -203,7 +195,8 @@ int rtos_qsymbol(struct connection *connection, char *packet, int packet_size)
symbols_done = 1;
else {
next_symbol_num = 0;
target->rtos->type->get_symbol_list_to_lookup(&target->rtos->symbols);
target->rtos->type->get_symbol_list_to_lookup(
&target->rtos->symbols);
}
}
}
@ -225,82 +218,63 @@ int rtos_qsymbol(struct connection *connection, char *packet, int packet_size)
return -1;
}
int rtos_thread_packet(struct connection *connection, char *packet, int packet_size)
{
struct target *target = get_target_from_connection(connection);
if (strstr(packet, "qThreadExtraInfo,"))
{
if ((target->rtos != NULL) && (target->rtos->thread_details != NULL) && (target->rtos->thread_count != 0))
{
if (strstr(packet, "qThreadExtraInfo,")) {
if ((target->rtos != NULL) && (target->rtos->thread_details != NULL) &&
(target->rtos->thread_count != 0)) {
threadid_t threadid = 0;
int found = -1;
sscanf(packet, "qThreadExtraInfo,%" SCNx64, &threadid );
sscanf(packet, "qThreadExtraInfo,%" SCNx64, &threadid);
if ((target->rtos != NULL) && (target->rtos->thread_details
!= NULL)) {
if ((target->rtos != NULL) && (target->rtos->thread_details != NULL)) {
int thread_num;
for (thread_num = 0; thread_num
< target->rtos->thread_count; thread_num++) {
if (target->rtos->thread_details[thread_num].threadid
== threadid) {
if (target->rtos->thread_details[thread_num].exists) {
for (thread_num = 0; thread_num < target->rtos->thread_count; thread_num++) {
if (target->rtos->thread_details[thread_num].threadid == threadid) {
if (target->rtos->thread_details[thread_num].exists)
found = thread_num;
}
}
}
}
if (found == -1) {
gdb_put_packet(connection, "E01", 3); // thread not found
gdb_put_packet(connection, "E01", 3); /* thread not found */
return ERROR_OK;
}
struct thread_detail* detail = &target->rtos->thread_details[found];
struct thread_detail *detail = &target->rtos->thread_details[found];
int str_size = 0;
if ( detail->display_str != NULL )
{
if (detail->display_str != NULL)
str_size += strlen(detail->display_str);
}
if ( detail->thread_name_str != NULL )
{
if (detail->thread_name_str != NULL)
str_size += strlen(detail->thread_name_str);
}
if ( detail->extra_info_str != NULL )
{
if (detail->extra_info_str != NULL)
str_size += strlen(detail->extra_info_str);
}
char * tmp_str = (char*) malloc( str_size + 7 );
char* tmp_str_ptr = tmp_str;
char *tmp_str = (char *) malloc(str_size + 7);
char *tmp_str_ptr = tmp_str;
if ( detail->display_str != NULL )
{
tmp_str_ptr += sprintf( tmp_str_ptr, "%s", detail->display_str );
if (detail->display_str != NULL)
tmp_str_ptr += sprintf(tmp_str_ptr, "%s", detail->display_str);
if (detail->thread_name_str != NULL) {
if (tmp_str_ptr != tmp_str)
tmp_str_ptr += sprintf(tmp_str_ptr, " : ");
tmp_str_ptr += sprintf(tmp_str_ptr, "%s", detail->thread_name_str);
}
if ( detail->thread_name_str != NULL )
{
if ( tmp_str_ptr != tmp_str )
{
tmp_str_ptr += sprintf( tmp_str_ptr, " : " );
}
tmp_str_ptr += sprintf( tmp_str_ptr, "%s", detail->thread_name_str );
}
if ( detail->extra_info_str != NULL )
{
if ( tmp_str_ptr != tmp_str )
{
tmp_str_ptr += sprintf( tmp_str_ptr, " : " );
}
tmp_str_ptr += sprintf( tmp_str_ptr, " : %s", detail->extra_info_str );
if (detail->extra_info_str != NULL) {
if (tmp_str_ptr != tmp_str)
tmp_str_ptr += sprintf(tmp_str_ptr, " : ");
tmp_str_ptr +=
sprintf(tmp_str_ptr, " : %s", detail->extra_info_str);
}
assert(strlen(tmp_str) ==
(size_t) (tmp_str_ptr - tmp_str));
char * hex_str = (char*) malloc( strlen(tmp_str)*2 +1 );
str_to_hex( hex_str, tmp_str );
char *hex_str = (char *) malloc(strlen(tmp_str)*2 + 1);
str_to_hex(hex_str, tmp_str);
gdb_put_packet(connection, hex_str, strlen(hex_str));
free(hex_str);
@ -310,11 +284,8 @@ int rtos_thread_packet(struct connection *connection, char *packet, int packet_s
}
gdb_put_packet(connection, "", 0);
return ERROR_OK;
}
else if (strstr(packet, "qSymbol"))
{
if (rtos_qsymbol(connection, packet, packet_size) == 1)
{
} else if (strstr(packet, "qSymbol")) {
if (rtos_qsymbol(connection, packet, packet_size) == 1) {
target->rtos_auto_detect = false;
target->rtos->type->create(target);
target->rtos->type->update_threads(target->rtos);
@ -322,91 +293,64 @@ int rtos_thread_packet(struct connection *connection, char *packet, int packet_s
gdb_put_packet(connection, "OK", 2);
}
return ERROR_OK;
}
else if (strstr(packet, "qfThreadInfo"))
{
} else if (strstr(packet, "qfThreadInfo")) {
int i;
if ( ( target->rtos != NULL ) && ( target->rtos->thread_count != 0 ) )
{
if ((target->rtos != NULL) && (target->rtos->thread_count != 0)) {
char* out_str = (char*) malloc(17 * target->rtos->thread_count + 5);
char* tmp_str = out_str;
char *out_str = (char *) malloc(17 * target->rtos->thread_count + 5);
char *tmp_str = out_str;
tmp_str += sprintf(tmp_str, "m");
for (i = 0; i < target->rtos->thread_count; i++) {
if (i != 0) {
if (i != 0)
tmp_str += sprintf(tmp_str, ",");
}
tmp_str += sprintf(tmp_str, "%016" PRIx64,
target->rtos->thread_details[i].threadid);
}
tmp_str[0] = 0;
gdb_put_packet(connection, out_str, strlen(out_str));
}
else
{
} else
gdb_put_packet(connection, "", 0);
}
return ERROR_OK;
}
else if (strstr(packet, "qsThreadInfo"))
{
} else if (strstr(packet, "qsThreadInfo")) {
gdb_put_packet(connection, "l", 1);
return ERROR_OK;
}
else if (strstr(packet, "qAttached"))
{
} else if (strstr(packet, "qAttached")) {
gdb_put_packet(connection, "1", 1);
return ERROR_OK;
}
else if (strstr(packet, "qOffsets"))
{
} else if (strstr(packet, "qOffsets")) {
char offsets[] = "Text=0;Data=0;Bss=0";
gdb_put_packet(connection, offsets, sizeof(offsets)-1);
return ERROR_OK;
}
else if (strstr(packet, "qC"))
{
if( target->rtos!=NULL )
{
} else if (strstr(packet, "qC")) {
if (target->rtos != NULL) {
char buffer[15];
int size;
size = snprintf(buffer, 15, "QC%08X", (int)target->rtos->current_thread);
gdb_put_packet(connection, buffer, size);
}
else
{
} else
gdb_put_packet(connection, "QC0", 3);
}
return ERROR_OK;
}
else if ( packet[0] == 'T' ) // Is thread alive?
{
} else if (packet[0] == 'T') { /* Is thread alive? */
threadid_t threadid;
int found = -1;
sscanf(packet, "T%" SCNx64, &threadid);
if ((target->rtos != NULL) && (target->rtos->thread_details
!= NULL)) {
if ((target->rtos != NULL) && (target->rtos->thread_details != NULL)) {
int thread_num;
for (thread_num = 0; thread_num
< target->rtos->thread_count; thread_num++) {
if (target->rtos->thread_details[thread_num].threadid
== threadid) {
if (target->rtos->thread_details[thread_num].exists) {
for (thread_num = 0; thread_num < target->rtos->thread_count; thread_num++) {
if (target->rtos->thread_details[thread_num].threadid == threadid) {
if (target->rtos->thread_details[thread_num].exists)
found = thread_num;
}
}
}
}
if (found != -1) {
gdb_put_packet(connection, "OK", 2); // thread alive
} else {
gdb_put_packet(connection, "E01", 3); // thread not found
}
if (found != -1)
gdb_put_packet(connection, "OK", 2); /* thread alive */
else
gdb_put_packet(connection, "E01", 3); /* thread not found */
return ERROR_OK;
}
else if ( packet[0] == 'H') // Set current thread ( 'c' for step and continue, 'g' for all other operations )
{
} else if (packet[0] == 'H') { /* Set current thread ( 'c' for step and continue, 'g' for
* all other operations ) */
if ((packet[1] == 'g') && (target->rtos != NULL))
sscanf(packet, "Hg%16" SCNx64, &target->rtos->current_threadid);
gdb_put_packet(connection, "OK", 2);
@ -420,17 +364,16 @@ int rtos_get_gdb_reg_list(struct connection *connection)
{
struct target *target = get_target_from_connection(connection);
int64_t current_threadid = target->rtos->current_threadid;
if ((target->rtos != NULL) &&
(current_threadid != -1) &&
(current_threadid != 0) &&
((current_threadid != target->rtos->current_thread) ||
(target->smp))) /* in smp several current thread are possible */
{
char * hex_reg_list;
target->rtos->type->get_thread_reg_list( target->rtos, current_threadid, &hex_reg_list );
if ((target->rtos != NULL) && (current_threadid != -1) &&
(current_threadid != 0) &&
((current_threadid != target->rtos->current_thread) ||
(target->smp))) { /* in smp several current thread are possible */
char *hex_reg_list;
target->rtos->type->get_thread_reg_list(target->rtos,
current_threadid,
&hex_reg_list);
if ( hex_reg_list != NULL )
{
if (hex_reg_list != NULL) {
gdb_put_packet(connection, hex_reg_list, strlen(hex_reg_list));
free(hex_reg_list);
return ERROR_OK;
@ -439,103 +382,84 @@ int rtos_get_gdb_reg_list(struct connection *connection)
return ERROR_FAIL;
}
int rtos_generic_stack_read( struct target * target, const struct rtos_register_stacking* stacking, int64_t stack_ptr, char ** hex_reg_list )
int rtos_generic_stack_read(struct target *target,
const struct rtos_register_stacking *stacking,
int64_t stack_ptr,
char **hex_reg_list)
{
int list_size = 0;
char * tmp_str_ptr;
char *tmp_str_ptr;
int64_t new_stack_ptr;
int i;
int retval;
if ( stack_ptr == 0)
{
if (stack_ptr == 0) {
LOG_OUTPUT("Error: null stack pointer in thread\r\n");
return -5;
}
// Read the stack
uint8_t * stack_data = (uint8_t*) malloc( stacking->stack_registers_size );
/* Read the stack */
uint8_t *stack_data = (uint8_t *) malloc(stacking->stack_registers_size);
uint32_t address = stack_ptr;
if ( stacking->stack_growth_direction == 1 )
{
address -= stacking->stack_registers_size;
}
retval = target_read_buffer( target, address, stacking->stack_registers_size, stack_data);
if ( retval != ERROR_OK )
{
if (stacking->stack_growth_direction == 1)
address -= stacking->stack_registers_size;
retval = target_read_buffer(target, address, stacking->stack_registers_size, stack_data);
if (retval != ERROR_OK) {
LOG_OUTPUT("Error reading stack frame from FreeRTOS thread\r\n");
return retval;
}
/*
LOG_OUTPUT("Stack Data :");
for(i = 0; i < stacking->stack_registers_size; i++ )
{
LOG_OUTPUT("%02X",stack_data[i]);
}
LOG_OUTPUT("\r\n");
*/
for( i = 0; i < stacking->num_output_registers; i++ )
{
#if 0
LOG_OUTPUT("Stack Data :");
for (i = 0; i < stacking->stack_registers_size; i++)
LOG_OUTPUT("%02X", stack_data[i]);
LOG_OUTPUT("\r\n");
#endif
for (i = 0; i < stacking->num_output_registers; i++)
list_size += stacking->register_offsets[i].width_bits/8;
}
*hex_reg_list = (char*)malloc( list_size*2 +1 );
*hex_reg_list = (char *)malloc(list_size*2 + 1);
tmp_str_ptr = *hex_reg_list;
new_stack_ptr = stack_ptr - stacking->stack_growth_direction * stacking->stack_registers_size;
new_stack_ptr = stack_ptr - stacking->stack_growth_direction *
stacking->stack_registers_size;
if (stacking->stack_alignment != 0) {
/* Align new stack pointer to x byte boundary */
new_stack_ptr =
(new_stack_ptr & (~((int64_t) stacking->stack_alignment - 1))) +
((stacking->stack_growth_direction == -1) ? stacking->stack_alignment : 0);
}
for( i = 0; i < stacking->num_output_registers; i++ )
{
for (i = 0; i < stacking->num_output_registers; i++) {
int j;
for ( j = 0; j < stacking->register_offsets[i].width_bits/8; j++ )
{
if ( stacking->register_offsets[i].offset == -1 )
{
tmp_str_ptr += sprintf( tmp_str_ptr, "%02x", 0 );
}
else if ( stacking->register_offsets[i].offset == -2 )
{
tmp_str_ptr += sprintf( tmp_str_ptr, "%02x", ((uint8_t*)&new_stack_ptr)[j] );
}
for (j = 0; j < stacking->register_offsets[i].width_bits/8; j++) {
if (stacking->register_offsets[i].offset == -1)
tmp_str_ptr += sprintf(tmp_str_ptr, "%02x", 0);
else if (stacking->register_offsets[i].offset == -2)
tmp_str_ptr += sprintf(tmp_str_ptr, "%02x",
((uint8_t *)&new_stack_ptr)[j]);
else
{
tmp_str_ptr += sprintf( tmp_str_ptr,"%02x", stack_data[ stacking->register_offsets[i].offset + j ] );
}
tmp_str_ptr += sprintf(tmp_str_ptr, "%02x",
stack_data[stacking->register_offsets[i].offset + j]);
}
}
// LOG_OUTPUT("Output register string: %s\r\n", *hex_reg_list);
/* LOG_OUTPUT("Output register string: %s\r\n", *hex_reg_list); */
return ERROR_OK;
}
int rtos_try_next( struct target * target )
int rtos_try_next(struct target *target)
{
int x;
if ( target->rtos == NULL )
{
if (target->rtos == NULL)
return -1;
}
for (x = 0 ; rtos_types[x] ; x++) {
if (target->rtos->type == rtos_types[x] ) {
for (x = 0; rtos_types[x]; x++) {
if (target->rtos->type == rtos_types[x]) {
/* found */
if ( rtos_types[x+1] != NULL )
{
if (rtos_types[x+1] != NULL) {
target->rtos->type = rtos_types[x+1];
if ( target->rtos->symbols != NULL )
{
free( target->rtos->symbols );
}
if (target->rtos->symbols != NULL)
free(target->rtos->symbols);
return 1;
}
else
{
// No more rtos types
} else {
/* No more rtos types */
return 0;
}
@ -545,24 +469,23 @@ int rtos_try_next( struct target * target )
}
static void hex_to_str( char* dst, char * hex_src )
static void hex_to_str(char *dst, char *hex_src)
{
int src_pos = 0;
int dst_pos = 0;
while ( hex_src[src_pos] != '\x00' )
{
while (hex_src[src_pos] != '\x00') {
char hex_char = hex_src[src_pos];
char hex_digit_val = (hex_char>='a')?hex_char-'a'+10:(hex_char>='A')?hex_char-'A'+10:hex_char-'0';
if ( 0 == (src_pos & 0x01) )
{
char hex_digit_val =
(hex_char >=
'a') ? hex_char-'a'+
10 : (hex_char >= 'A') ? hex_char-'A'+10 : hex_char-'0';
if (0 == (src_pos & 0x01)) {
dst[dst_pos] = hex_digit_val;
dst[dst_pos+1] = 0;
}
else
{
((unsigned char*)dst)[dst_pos] <<= 4;
((unsigned char*)dst)[dst_pos] += hex_digit_val;
} else {
((unsigned char *)dst)[dst_pos] <<= 4;
((unsigned char *)dst)[dst_pos] += hex_digit_val;
dst_pos++;
}
src_pos++;
@ -572,21 +495,16 @@ static void hex_to_str( char* dst, char * hex_src )
int str_to_hex(char *hex_dst, char *src)
{
char * posptr = hex_dst;
char *posptr = hex_dst;
unsigned i;
for( i = 0; i < strlen(src); i++)
{
posptr += sprintf( posptr, "%02x", (unsigned char)src[i] );
}
return (posptr-hex_dst);
for (i = 0; i < strlen(src); i++)
posptr += sprintf(posptr, "%02x", (unsigned char)src[i]);
return posptr - hex_dst;
}
int rtos_update_threads( struct target* target )
int rtos_update_threads(struct target *target)
{
if ((target->rtos != NULL) && (target->rtos->type != NULL))
{
target->rtos->type->update_threads(target->rtos);
}
return ERROR_OK;
}

79
src/rtos/rtos.h
View File

@ -21,7 +21,6 @@
#ifndef RTOS_H
#define RTOS_H
#include "server/server.h"
#include <helper/types.h>
#include <jim-nvp.h>
@ -34,83 +33,75 @@ struct reg;
/**
* Table should be terminated by an element with NULL in symbol_name
*/
typedef struct symbol_table_elem_struct
{
char * symbol_name;
typedef struct symbol_table_elem_struct {
char *symbol_name;
symbol_address_t address;
} symbol_table_elem_t;
struct thread_detail
{
struct thread_detail {
threadid_t threadid;
bool exists;
char * display_str;
char * thread_name_str;
char * extra_info_str;
char *display_str;
char *thread_name_str;
char *extra_info_str;
};
struct rtos
{
struct rtos {
const struct rtos_type *type;
symbol_table_elem_t * symbols;
symbol_table_elem_t *symbols;
struct target *target;
/* add a context variable instead of global variable */
int64_t current_threadid;
threadid_t current_thread;
struct thread_detail* thread_details;
struct thread_detail *thread_details;
int thread_count;
int (*gdb_thread_packet)(struct connection *connection, char *packet, int packet_size);
void * rtos_specific_params;
void *rtos_specific_params;
};
struct rtos_type
{
char * name;
int (*detect_rtos) ( struct target* target );
int (*create) ( struct target* target );
struct rtos_type {
char *name;
int (*detect_rtos)(struct target *target);
int (*create)(struct target *target);
int (*smp_init)(struct target *target);
int (*update_threads) ( struct rtos* rtos );
int (*get_thread_reg_list) ( struct rtos *rtos, int64_t thread_id, char ** hex_reg_list );
int (*get_symbol_list_to_lookup) (symbol_table_elem_t * symbol_list[] );
int (*update_threads)(struct rtos *rtos);
int (*get_thread_reg_list)(struct rtos *rtos, int64_t thread_id, char **hex_reg_list);
int (*get_symbol_list_to_lookup)(symbol_table_elem_t *symbol_list[]);
int (*clean)(struct target *target);
char * (*ps_command)(struct target *target);
};
struct stack_register_offset
{
signed short offset; // offset in bytes from stack head, or -1 to indicate register is not stacked, or -2 to indicate this is the stack pointer register
struct stack_register_offset {
signed short offset; /* offset in bytes from stack head, or -1 to indicate
* register is not stacked, or -2 to indicate this is the
* stack pointer register */
unsigned short width_bits;
};
struct rtos_register_stacking
{
unsigned char stack_registers_size;
signed char stack_growth_direction;
unsigned char num_output_registers;
unsigned char stack_alignment;
const struct stack_register_offset* register_offsets;
struct rtos_register_stacking {
unsigned char stack_registers_size;
signed char stack_growth_direction;
unsigned char num_output_registers;
unsigned char stack_alignment;
const struct stack_register_offset *register_offsets;
};
#define GDB_THREAD_PACKET_NOT_CONSUMED (-40)
int rtos_create(Jim_GetOptInfo *goi, struct target * target);
int rtos_generic_stack_read( struct target * target, const struct rtos_register_stacking* stacking, int64_t stack_ptr, char ** hex_reg_list );
int rtos_try_next( struct target * target );
int rtos_create(Jim_GetOptInfo *goi, struct target *target);
int rtos_generic_stack_read(struct target *target,
const struct rtos_register_stacking *stacking,
int64_t stack_ptr,
char **hex_reg_list);
int rtos_try_next(struct target *target);
int gdb_thread_packet(struct connection *connection, char *packet, int packet_size);
int rtos_get_gdb_reg_list(struct connection *connection);
int rtos_update_threads( struct target *target );
int rtos_update_threads(struct target *target);
int rtos_smp_init(struct target *target);
/* function for handling symbol access */
int rtos_qsymbol(struct connection *connection, char *packet, int packet_size);
int str_to_hex(char *hex_dst, char *src);
#endif // RTOS_H
#endif /* RTOS_H */

68
src/rtos/rtos_ecos_stackings.c
View File

@ -23,42 +23,38 @@
#include "rtos.h"
static const struct stack_register_offset rtos_eCos_Cortex_M3_stack_offsets[] = {
{ 0x0c, 32 }, /* r0 */
{ 0x10, 32 }, /* r1 */
{ 0x14, 32 }, /* r2 */
{ 0x18, 32 }, /* r3 */
{ 0x1c, 32 }, /* r4 */
{ 0x20, 32 }, /* r5 */
{ 0x24, 32 }, /* r6 */
{ 0x28, 32 }, /* r7 */
{ 0x2c, 32 }, /* r8 */
{ 0x30, 32 }, /* r9 */
{ 0x34, 32 }, /* r10 */
{ 0x38, 32 }, /* r11 */
{ 0x3c, 32 }, /* r12 */
{ -2, 32 }, /* sp */
{ -1, 32 }, /* lr */
{ 0x40, 32 }, /* pc */
{ -1, 96 }, /* FPA1 */
{ -1, 96 }, /* FPA2 */
{ -1, 96 }, /* FPA3 */
{ -1, 96 }, /* FPA4 */
{ -1, 96 }, /* FPA5 */
{ -1, 96 }, /* FPA6 */
{ -1, 96 }, /* FPA7 */
{ -1, 96 }, /* FPA8 */
{ -1, 32 }, /* FPS */
{ -1, 32 }, /* xPSR */
{ 0x0c, 32 }, /* r0 */
{ 0x10, 32 }, /* r1 */
{ 0x14, 32 }, /* r2 */
{ 0x18, 32 }, /* r3 */
{ 0x1c, 32 }, /* r4 */
{ 0x20, 32 }, /* r5 */
{ 0x24, 32 }, /* r6 */
{ 0x28, 32 }, /* r7 */
{ 0x2c, 32 }, /* r8 */
{ 0x30, 32 }, /* r9 */
{ 0x34, 32 }, /* r10 */
{ 0x38, 32 }, /* r11 */
{ 0x3c, 32 }, /* r12 */
{ -2, 32 }, /* sp */
{ -1, 32 }, /* lr */
{ 0x40, 32 }, /* pc */
{ -1, 96 }, /* FPA1 */
{ -1, 96 }, /* FPA2 */
{ -1, 96 }, /* FPA3 */
{ -1, 96 }, /* FPA4 */
{ -1, 96 }, /* FPA5 */
{ -1, 96 }, /* FPA6 */
{ -1, 96 }, /* FPA7 */
{ -1, 96 }, /* FPA8 */
{ -1, 32 }, /* FPS */
{ -1, 32 }, /* xPSR */
};
const struct rtos_register_stacking rtos_eCos_Cortex_M3_stacking =
{
0x44, /* stack_registers_size */
-1, /* stack_growth_direction */
26, /* num_output_registers */
8, /* stack_alignment */
rtos_eCos_Cortex_M3_stack_offsets /* register_offsets */
const struct rtos_register_stacking rtos_eCos_Cortex_M3_stacking = {
0x44, /* stack_registers_size */
-1, /* stack_growth_direction */
26, /* num_output_registers */
8, /* stack_alignment */
rtos_eCos_Cortex_M3_stack_offsets /* register_offsets */
};

2
src/rtos/rtos_ecos_stackings.h
View File

@ -27,4 +27,4 @@
extern const struct rtos_register_stacking rtos_eCos_Cortex_M3_stacking;
#endif //ifndef INCLUDED_RTOS_STANDARD_STACKINGS_H_
#endif /* ifndef INCLUDED_RTOS_STANDARD_STACKINGS_H_ */

68
src/rtos/rtos_standard_stackings.c
View File

@ -25,42 +25,38 @@
#include "rtos.h"
static const struct stack_register_offset rtos_standard_Cortex_M3_stack_offsets[] = {
{ 0x20, 32 }, /* r0 */
{ 0x24, 32 }, /* r1 */
{ 0x28, 32 }, /* r2 */
{ 0x2c, 32 }, /* r3 */
{ 0x00, 32 }, /* r4 */
{ 0x04, 32 }, /* r5 */
{ 0x08, 32 }, /* r6 */
{ 0x0c, 32 }, /* r7 */
{ 0x10, 32 }, /* r8 */
{ 0x14, 32 }, /* r9 */
{ 0x18, 32 }, /* r10 */
{ 0x1c, 32 }, /* r11 */
{ 0x30, 32 }, /* r12 */
{ -2, 32 }, /* sp */
{ 0x34, 32 }, /* lr */
{ 0x38, 32 }, /* pc */
{ -1, 96 }, /* FPA1 */
{ -1, 96 }, /* FPA2 */
{ -1, 96 }, /* FPA3 */
{ -1, 96 }, /* FPA4 */
{ -1, 96 }, /* FPA5 */
{ -1, 96 }, /* FPA6 */
{ -1, 96 }, /* FPA7 */
{ -1, 96 }, /* FPA8 */
{ -1, 32 }, /* FPS */
{ 0x3c, 32 }, /* xPSR */
{ 0x20, 32 }, /* r0 */
{ 0x24, 32 }, /* r1 */
{ 0x28, 32 }, /* r2 */
{ 0x2c, 32 }, /* r3 */
{ 0x00, 32 }, /* r4 */
{ 0x04, 32 }, /* r5 */
{ 0x08, 32 }, /* r6 */
{ 0x0c, 32 }, /* r7 */
{ 0x10, 32 }, /* r8 */
{ 0x14, 32 }, /* r9 */
{ 0x18, 32 }, /* r10 */
{ 0x1c, 32 }, /* r11 */
{ 0x30, 32 }, /* r12 */
{ -2, 32 }, /* sp */
{ 0x34, 32 }, /* lr */
{ 0x38, 32 }, /* pc */
{ -1, 96 }, /* FPA1 */
{ -1, 96 }, /* FPA2 */
{ -1, 96 }, /* FPA3 */
{ -1, 96 }, /* FPA4 */
{ -1, 96 }, /* FPA5 */
{ -1, 96 }, /* FPA6 */
{ -1, 96 }, /* FPA7 */
{ -1, 96 }, /* FPA8 */
{ -1, 32 }, /* FPS */
{ 0x3c, 32 }, /* xPSR */
};
const struct rtos_register_stacking rtos_standard_Cortex_M3_stacking =
{
0x40, /* stack_registers_size */
-1, /* stack_growth_direction */
26, /* num_output_registers */
8, /* stack_alignment */
rtos_standard_Cortex_M3_stack_offsets /* register_offsets */
const struct rtos_register_stacking rtos_standard_Cortex_M3_stacking = {
0x40, /* stack_registers_size */
-1, /* stack_growth_direction */
26, /* num_output_registers */
8, /* stack_alignment */
rtos_standard_Cortex_M3_stack_offsets /* register_offsets */
};

2
src/rtos/rtos_standard_stackings.h
View File

@ -29,4 +29,4 @@
extern const struct rtos_register_stacking rtos_standard_Cortex_M3_stacking;
#endif //ifndef INCLUDED_RTOS_STANDARD_STACKINGS_H_
#endif /* ifndef INCLUDED_RTOS_STANDARD_STACKINGS_H_ */