* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
-
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "helper/log.h"
#include "rtos_standard_stackings.h"
-#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;
+#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;
};
-
-
-
-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;
- }
-
- 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 (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;
+
+ 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;
}
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;
}
-
#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");
- }
-
-
- 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 );
-
+ 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);
- // 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;
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)
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;
#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;
}
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");
- }
-
- detail->thread_name_str = (char*)malloc( strlen(tmp_str)+1 );
+ if (tmp_str[0] == '\x00')
+ strcpy(tmp_str, "No Name");
+ 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;
#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 *)¤t_thread_addr);
+ retval = target_read_buffer(rtos->target,
+ rtos->symbols[eCos_VAL_current_thread_ptr].address,
+ 4,
+ (uint8_t *)¤t_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];
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;
static int linux_os_dummy_update(struct rtos *rtos)
{
- /* update is done only when thread request come */
- /* too many thread to do it on each stop */
+ /* update is done only when thread request come
+ * too many thread to do it on each stop */
return 0;
}
static int linux_compute_virt2phys(struct target *target, uint32_t address)
{
struct linux_os *linux_os = (struct linux_os *)
- target->rtos->rtos_specific_params;
+ target->rtos->rtos_specific_params;
uint32_t pa = 0;
int retval = target->type->virt2phys(target, address, &pa);
if (retval != ERROR_OK) {
}
static int linux_read_memory(struct target *target,
- uint32_t address, uint32_t size, uint32_t count,
- uint8_t *buffer)
+ uint32_t address, uint32_t size, uint32_t count,
+ uint8_t *buffer)
{
#ifdef PHYS
struct linux_os *linux_os = (struct linux_os *)
- target->rtos->rtos_specific_params;
+ target->rtos->rtos_specific_params;
uint32_t pa = (address & linux_os->phys_mask) + linux_os->phys_base;
#endif
if (address < 0xc000000) {
return buffer;
}
-int fill_buffer(struct target *target, uint32_t addr, uint8_t * buffer)
+int fill_buffer(struct target *target, uint32_t addr, uint8_t *buffer)
{
if ((addr & 0xfffffffc) != addr)
}
static int linux_os_thread_reg_list(struct rtos *rtos,
- int64_t thread_id, char **hex_reg_list)
+ int64_t thread_id, char **hex_reg_list)
{
struct target *target = rtos->target;
struct linux_os *linux_os = (struct linux_os *)
- target->rtos->rtos_specific_params;
+ target->rtos->rtos_specific_params;
int i = 0;
struct current_thread *tmp = linux_os->current_threads;
struct current_thread *next;
if (found == 0) {
LOG_ERROR
- ("current thread %" PRIx64": no target to perform access of core id %x",
- thread_id, next->core_id);
+ (
+ "current thread %" PRIx64 ": no target to perform access of core id %x",
+ thread_id,
+ next->core_id);
return ERROR_FAIL;
}
/*LOG_INFO("thread %lx current on core %x",thread_id,
* target->coreid);*/
retval =
- target_get_gdb_reg_list(target, ®_list, ®_list_size);
+ target_get_gdb_reg_list(target, ®_list, ®_list_size);
if (retval != ERROR_OK)
return retval;
reg_list[i]->type->get(reg_list[i]);
hex_string = reg_converter(hex_string,
- reg_list[i]->value,
- (reg_list[i]->size) / 8);
+ reg_list[i]->value,
+ (reg_list[i]->size) / 8);
}
free(reg_list);
hex_string += sprintf(hex_string, "%02x", 0);
while ((temp != NULL) &&
- (temp->threadid != target->rtos->current_threadid))
+ (temp->threadid != target->rtos->current_threadid))
temp = temp->next;
if (temp != NULL) {
if (temp->context == NULL)
temp->context = cpu_context_read(target,
- temp->
- base_addr,
- &temp->
- thread_info_addr);
+ temp->
+ base_addr,
+ &temp->
+ thread_info_addr);
hex_string =
- reg_converter(hex_string, &temp->context->R4, 4);
+ reg_converter(hex_string, &temp->context->R4, 4);
hex_string =
- reg_converter(hex_string, &temp->context->R5, 4);
+ reg_converter(hex_string, &temp->context->R5, 4);
hex_string =
- reg_converter(hex_string, &temp->context->R6, 4);
+ reg_converter(hex_string, &temp->context->R6, 4);
hex_string =
- reg_converter(hex_string, &temp->context->R7, 4);
+ reg_converter(hex_string, &temp->context->R7, 4);
hex_string =
- reg_converter(hex_string, &temp->context->R8, 4);
+ reg_converter(hex_string, &temp->context->R8, 4);
hex_string =
- reg_converter(hex_string, &temp->context->R9, 4);
+ reg_converter(hex_string, &temp->context->R9, 4);
for (i = 0; i < 4; i++) /*R10 = 0x0 */
hex_string += sprintf(hex_string, "%02x", 0);
hex_string =
- reg_converter(hex_string, &temp->context->FP, 4);
+ reg_converter(hex_string, &temp->context->FP, 4);
hex_string =
- reg_converter(hex_string, &temp->context->IP, 4);
+ reg_converter(hex_string, &temp->context->IP, 4);
hex_string =
- reg_converter(hex_string, &temp->context->SP, 4);
+ reg_converter(hex_string, &temp->context->SP, 4);
for (i = 0; i < 4; i++)
hex_string += sprintf(hex_string, "%02x", 0);
hex_string =
- reg_converter(hex_string, &temp->context->PC, 4);
+ reg_converter(hex_string, &temp->context->PC, 4);
- for (i = 0; i < 100; i++) { /*100 */
+ for (i = 0; i < 100; i++) /*100 */
hex_string += sprintf(hex_string, "%02x", 0);
- }
uint32_t cpsr = 0x00000000;
hex_string = reg_converter(hex_string, &cpsr, 4);
{
unsigned int i;
*symbol_list = (symbol_table_elem_t *)
- malloc(sizeof(symbol_table_elem_t) / sizeof(char *));
+ malloc(sizeof(symbol_table_elem_t) / sizeof(char *));
for (i = 0; i < sizeof(linux_symbol_list) / sizeof(char *); i++)
(*symbol_list)[i].symbol_name = linux_symbol_list[i];
};
static int linux_thread_packet(struct connection *connection, char *packet,
- int packet_size);
+ int packet_size);
static void linux_identify_current_threads(struct target *target);
#ifdef PID_CHECK
int fill_task(struct target *target, struct threads *t)
{
-
int retval;
uint32_t pid_addr = t->base_addr + PID;
uint32_t mem_addr = t->base_addr + MEM;
t->asid = val;
} else
LOG_ERROR
- ("fill task: unable to read memory -- ASID");
- } else {
+ ("fill task: unable to read memory -- ASID");
+ } else
t->asid = 0;
- }
} else
LOG_ERROR("fill task: unable to read memory");
}
uint32_t raw_name = target_buffer_get_u32(target,
- (const uint8_t *)
- &full_name[0]);
+ (const uint8_t *)
+ &full_name[0]);
t->name[3] = raw_name >> 24;
t->name[2] = raw_name >> 16;
t->name[1] = raw_name >> 8;
t->name[0] = raw_name;
raw_name =
- target_buffer_get_u32(target, (const uint8_t *)&full_name[1]);
+ target_buffer_get_u32(target, (const uint8_t *)&full_name[1]);
t->name[7] = raw_name >> 24;
t->name[6] = raw_name >> 16;
t->name[5] = raw_name >> 8;
t->name[4] = raw_name;
raw_name =
- target_buffer_get_u32(target, (const uint8_t *)&full_name[2]);
+ target_buffer_get_u32(target, (const uint8_t *)&full_name[2]);
t->name[11] = raw_name >> 24;
t->name[10] = raw_name >> 16;
t->name[9] = raw_name >> 8;
t->name[8] = raw_name;
raw_name =
- target_buffer_get_u32(target, (const uint8_t *)&full_name[3]);
+ target_buffer_get_u32(target, (const uint8_t *)&full_name[3]);
t->name[15] = raw_name >> 24;
t->name[14] = raw_name >> 16;
t->name[13] = raw_name >> 8;
uint32_t ti_addr;
uint8_t *buffer = calloc(1, 4);
struct linux_os *linux_os = (struct linux_os *)
- target->rtos->rtos_specific_params;
+ target->rtos->rtos_specific_params;
struct current_thread *ctt = linux_os->current_threads;
/* invalid current threads content */
int retval;
if (target_get_gdb_reg_list(head->target, ®_list,
- ®_list_size) !=
- ERROR_OK)
+ ®_list_size) != ERROR_OK)
return ERROR_TARGET_FAILURE;
if (!reg_list[13]->valid)
if (retval == ERROR_OK) {
/*uint32_t cpu = get_buffer(target, buffer);*/
struct current_thread *ct =
- linux_os->current_threads;
+ linux_os->current_threads;
cpu = head->target->coreid;
- while ((ct != NULL)
- && (ct->core_id != (int32_t) cpu)) {
+ while ((ct != NULL) && (ct->core_id != (int32_t) cpu))
ct = ct->next;
- }
if ((ct != NULL) && (ct->TS == 0xdeadbeef))
ct->TS = TS;
else
LOG_ERROR
- ("error in linux current thread update");
+ ("error in linux current thread update");
if (create) {
struct threads *t;
}
struct cpu_context *cpu_context_read(struct target *target, uint32_t base_addr,
- uint32_t *thread_info_addr_old)
+ uint32_t *thread_info_addr_old)
{
struct cpu_context *context = calloc(1, sizeof(struct cpu_context));
uint32_t preempt_count_addr = 0;
else {
if (*thread_info_addr_old != 0xdeadbeef) {
LOG_ERROR
- ("cpu_context: cannot read at thread_info_addr");
+ ("cpu_context: cannot read at thread_info_addr");
if (*thread_info_addr_old < LINUX_USER_KERNEL_BORDER)
LOG_INFO
- ("cpu_context : thread_info_addr in userspace!!!");
+ ("cpu_context : thread_info_addr in userspace!!!");
*thread_info_addr_old = 0xdeadbeef;
goto retry;
thread_info_addr += CPU_CONT;
retval = linux_read_memory(target, thread_info_addr, 4, 10,
- (uint8_t *) registers);
+ (uint8_t *) registers);
if (retval != ERROR_OK) {
LOG_ERROR("cpu_context: unable to read memory\n");
}
context->R4 =
- target_buffer_get_u32(target, (const uint8_t *)®isters[0]);
+ target_buffer_get_u32(target, (const uint8_t *)®isters[0]);
context->R5 =
- target_buffer_get_u32(target, (const uint8_t *)®isters[1]);
+ target_buffer_get_u32(target, (const uint8_t *)®isters[1]);
context->R6 =
- target_buffer_get_u32(target, (const uint8_t *)®isters[2]);
+ target_buffer_get_u32(target, (const uint8_t *)®isters[2]);
context->R7 =
- target_buffer_get_u32(target, (const uint8_t *)®isters[3]);
+ target_buffer_get_u32(target, (const uint8_t *)®isters[3]);
context->R8 =
- target_buffer_get_u32(target, (const uint8_t *)®isters[4]);
+ target_buffer_get_u32(target, (const uint8_t *)®isters[4]);
context->R9 =
- target_buffer_get_u32(target, (const uint8_t *)®isters[5]);
+ target_buffer_get_u32(target, (const uint8_t *)®isters[5]);
context->IP =
- target_buffer_get_u32(target, (const uint8_t *)®isters[6]);
+ target_buffer_get_u32(target, (const uint8_t *)®isters[6]);
context->FP =
- target_buffer_get_u32(target, (const uint8_t *)®isters[7]);
+ target_buffer_get_u32(target, (const uint8_t *)®isters[7]);
context->SP =
- target_buffer_get_u32(target, (const uint8_t *)®isters[8]);
+ target_buffer_get_u32(target, (const uint8_t *)®isters[8]);
context->PC =
- target_buffer_get_u32(target, (const uint8_t *)®isters[9]);
+ target_buffer_get_u32(target, (const uint8_t *)®isters[9]);
if (*thread_info_addr_old == 0xdeadbeef)
*thread_info_addr_old = thread_info_addr_update;
}
struct current_thread *add_current_thread(struct current_thread *currents,
- struct current_thread *ct)
+ struct current_thread *ct)
{
ct->next = NULL;
}
struct threads *liste_del_task(struct threads *task_list, struct threads **t,
- struct threads *prev)
+ struct threads *prev)
{
LOG_INFO("del task %" PRId64, (*t)->threadid);
prev->next = (*t)->next;
}
struct threads *liste_add_task(struct threads *task_list, struct threads *t,
- struct threads **last)
+ struct threads **last)
{
t->next = NULL;
*last = t;
return task_list;
} else {
- (*last)->next = t;
- *last = t;
- return task_list;
- }
+ (*last)->next = t;
+ *last = t;
+ return task_list;
+ }
}
#ifdef PID_CHECK
int loop = 0;
int retval = 0;
struct linux_os *linux_os = (struct linux_os *)
- target->rtos->rtos_specific_params;
+ target->rtos->rtos_specific_params;
linux_os->thread_list = NULL;
linux_os->thread_count = 0;
retval = get_current(target, 1);
while (((t->base_addr != linux_os->init_task_addr) &&
- (t->base_addr != 0))
- || (loop == 0)
- ) {
+ (t->base_addr != 0)) || (loop == 0)) {
loop++;
retval = fill_task(target, t);
retval = get_name(target, t);
linux_os->threadid_count++;
linux_os->thread_list =
- liste_add_task(linux_os->thread_list, t, &last);
+ liste_add_task(linux_os->thread_list, t, &last);
/* no interest to fill the context if it is a current thread. */
linux_os->thread_count++;
t->thread_info_addr = 0xdeadbeef;
if (context)
t->context =
- cpu_context_read(target, t->base_addr,
- &t->thread_info_addr);
+ cpu_context_read(target, t->base_addr,
+ &t->thread_info_addr);
} else {
/*LOG_INFO("thread %s is a current thread already created",t->name); */
free(t);
linux_os->preupdtate_threadid_count = linux_os->threadid_count - 1;
/* check that all current threads have been identified */
- LOG_INFO("complete time %" PRId64", thread mean %" PRId64"\n",
- (timeval_ms() - start),
- (timeval_ms() - start) / linux_os->threadid_count);
+ LOG_INFO("complete time %" PRId64 ", thread mean %" PRId64 "\n",
+ (timeval_ms() - start),
+ (timeval_ms() - start) / linux_os->threadid_count);
LOG_INFO("threadid count %d", linux_os->threadid_count);
static int clean_threadlist(struct target *target)
{
struct linux_os *linux_os = (struct linux_os *)
- target->rtos->rtos_specific_params;
+ target->rtos->rtos_specific_params;
struct threads *old, *temp = linux_os->thread_list;
while (temp != NULL) {
static int linux_os_clean(struct target *target)
{
-
struct linux_os *os_linux = (struct linux_os *)
- target->rtos->rtos_specific_params;
+ target->rtos->rtos_specific_params;
clean_threadlist(target);
os_linux->init_task_addr = 0xdeadbeef;
os_linux->name = "linux";
static void linux_identify_current_threads(struct target *target)
{
struct linux_os *linux_os = (struct linux_os *)
- target->rtos->rtos_specific_params;
+ target->rtos->rtos_specific_params;
struct threads *thread_list = linux_os->thread_list;
struct current_thread *ct = linux_os->current_threads;
struct threads *t = NULL;
#ifdef PID_CHECK
if (thread_list->pid == t->pid) {
#else
- if (thread_list->base_addr == t->base_addr) {
+ if (thread_list->base_addr == t->base_addr) {
#endif
- free(t);
- t = thread_list;
- found = 1;
- }
- thread_list = thread_list->next;
+ free(t);
+ t = thread_list;
+ found = 1;
}
+ thread_list = thread_list->next;
+ }
- if (!found) {
- /* it is a new thread */
- if (fill_task(target, t) != ERROR_OK)
- goto error_handling;
+ if (!found) {
+ /* it is a new thread */
+ if (fill_task(target, t) != ERROR_OK)
+ goto error_handling;
- get_name(target, t);
- insert_into_threadlist(target, t);
- t->thread_info_addr = 0xdeadbeef;
- }
+ get_name(target, t);
+ insert_into_threadlist(target, t);
+ t->thread_info_addr = 0xdeadbeef;
+ }
- t->status = 3;
- ct->threadid = t->threadid;
+ t->status = 3;
+ ct->threadid = t->threadid;
#ifdef PID_CHECK
- ct->pid = t->pid;
+ ct->pid = t->pid;
#endif
- linux_os->thread_count++;
+ linux_os->thread_count++;
#if 0
- if (found == 0)
- LOG_INFO("current thread core %x identified %s",
- ct->core_id, t->name);
- else
- LOG_INFO("current thread core %x, reused %s",
- ct->core_id, t->name);
+ if (found == 0)
+ LOG_INFO("current thread core %x identified %s",
+ ct->core_id, t->name);
+ else
+ LOG_INFO("current thread core %x, reused %s",
+ ct->core_id, t->name);
#endif
- }
+ }
#if 0
- else {
- struct threads tmp;
- tmp.base_addr = ct->TS;
- get_name(target, &tmp);
- LOG_INFO("current thread core %x , already identified %s !!!",
- ct->core_id, tmp.name);
- }
-#endif
- ct = ct->next;
+ else {
+ struct threads tmp;
+ tmp.base_addr = ct->TS;
+ get_name(target, &tmp);
+ LOG_INFO("current thread core %x , already identified %s !!!",
+ ct->core_id, tmp.name);
}
+#endif
+ ct = ct->next;
+ }
- return;
+ return;
#ifndef PID_CHECK
error_handling:
- free(t);
- LOG_ERROR("unable toread pid");
- return;
+ free(t);
+ LOG_ERROR("unable toread pid");
+ return;
#endif
- }
+}
static int linux_task_update(struct target *target, int context)
{
struct linux_os *linux_os = (struct linux_os *)
- target->rtos->rtos_specific_params;
+ target->rtos->rtos_specific_params;
struct threads *thread_list = linux_os->thread_list;
int retval;
int loop = 0;
}
thread_list = thread_list->next;
-
}
int found = 0;
uint32_t previous = 0xdeadbeef;
t->base_addr = linux_os->init_task_addr;
retval = get_current(target, 0);
- /*check that all current threads have been identified */
+ /*check that all current threads have been identified */
linux_identify_current_threads(target);
while (((t->base_addr != linux_os->init_task_addr) &&
while (thread_list != NULL) {
#ifdef PID_CHECK
-
if (t->pid == thread_list->pid) {
#else
if (t->base_addr == thread_list->base_addr) {
#endif
-
if (!thread_list->status) {
#ifdef PID_CHECK
-
- if (t->base_addr !=
- thread_list->base_addr) {
- LOG_INFO
- ("thread base_addr has changed !!");
- }
+ if (t->base_addr != thread_list->base_addr)
+ LOG_INFO("thread base_addr has changed !!");
#endif
/* this is not a current thread */
thread_list->base_addr = t->base_addr;
*/
if (context)
thread_list->context =
- cpu_context_read(target,
- thread_list->
- base_addr,
- &thread_list->
- thread_info_addr);
+ cpu_context_read(target,
+ thread_list->
+ base_addr,
+ &thread_list->
+ thread_info_addr);
} else {
/* it is a current thread no need to read context */
}
if (context)
t->context =
- cpu_context_read(target, t->base_addr,
- &t->thread_info_addr);
+ cpu_context_read(target, t->base_addr,
+ &t->thread_info_addr);
base_addr = next_task(target, t);
t = calloc(1, sizeof(struct threads));
linux_os->thread_count++;
} else
t->base_addr = next_task(target, t);
-
}
- LOG_INFO("update thread done %" PRId64", mean%" PRId64"\n",
- (timeval_ms() - start), (timeval_ms() - start) / loop);
+ LOG_INFO("update thread done %" PRId64 ", mean%" PRId64 "\n",
+ (timeval_ms() - start), (timeval_ms() - start) / loop);
free(t);
linux_os->threads_needs_update = 0;
return ERROR_OK;
}
int linux_gdb_thread_packet(struct target *target,
- struct connection *connection, char *packet,
- int packet_size)
+ struct connection *connection, char *packet,
+ int packet_size)
{
-
int retval;
struct linux_os *linux_os =
- (struct linux_os *)target->rtos->rtos_specific_params;
+ (struct linux_os *)target->rtos->rtos_specific_params;
if (linux_os->init_task_addr == 0xdeadbeef) {
/* it has not been initialized */
}
int linux_gdb_thread_update(struct target *target,
- struct connection *connection, char *packet,
- int packet_size)
+ struct connection *connection, char *packet,
+ int packet_size)
{
int found = 0;
struct linux_os *linux_os = (struct linux_os *)
- target->rtos->rtos_specific_params;
+ target->rtos->rtos_specific_params;
struct threads *temp = linux_os->thread_list;
while (temp != NULL) {
/*LOG_INFO("INTO GDB THREAD UPDATE WHILE");*/
tmp_strr += sprintf(tmp_strr, ",");
tmp_strr +=
- sprintf(tmp_strr, "%016" PRIx64, temp->threadid);
+ sprintf(tmp_strr, "%016" PRIx64, temp->threadid);
temp = temp->next;
}
/*tmp_str[0] = 0;*/
gdb_put_packet(connection, out_strr, strlen(out_strr));
linux_os->preupdtate_threadid_count =
- linux_os->threadid_count - 1;
+ linux_os->threadid_count - 1;
free(out_strr);
} else
gdb_put_packet(connection, "l", 1);
}
int linux_thread_extra_info(struct target *target,
- struct connection *connection, char *packet,
- int packet_size)
+ struct connection *connection, char *packet,
+ int packet_size)
{
int64_t threadid = 0;
struct linux_os *linux_os = (struct linux_os *)
- target->rtos->rtos_specific_params;
+ target->rtos->rtos_specific_params;
sscanf(packet, "qThreadExtraInfo,%" SCNx64, &threadid);
/*LOG_INFO("lookup extra info for thread %" SCNx64, threadid);*/
struct threads *temp = linux_os->thread_list;
/* discriminate cuurent task */
if (temp->status == 3)
tmp_str_ptr += sprintf(tmp_str_ptr, "%s",
- pid_current);
+ pid_current);
else
tmp_str_ptr += sprintf(tmp_str_ptr, "%s", pid);
tmp_str_ptr +=
- sprintf(tmp_str_ptr, "%d", (int)temp->pid);
+ sprintf(tmp_str_ptr, "%d", (int)temp->pid);
tmp_str_ptr += sprintf(tmp_str_ptr, "%s", " | ");
tmp_str_ptr += sprintf(tmp_str_ptr, "%s", name);
tmp_str_ptr += sprintf(tmp_str_ptr, "%s", temp->name);
char *hex_str =
- (char *)calloc(1, strlen(tmp_str) * 2 + 1);
+ (char *)calloc(1, strlen(tmp_str) * 2 + 1);
str_to_hex(hex_str, tmp_str);
gdb_put_packet(connection, hex_str, strlen(hex_str));
free(hex_str);
}
int linux_gdb_T_packet(struct connection *connection,
- struct target *target, char *packet, int packet_size)
+ struct target *target, char *packet, int packet_size)
{
int64_t threadid;
struct linux_os *linux_os = (struct linux_os *)
- target->rtos->rtos_specific_params;
+ target->rtos->rtos_specific_params;
int retval = ERROR_OK;
sscanf(packet, "T%" SCNx64, &threadid);
} else {
/* delete item in the list */
linux_os->thread_list =
- liste_del_task(linux_os->
- thread_list, &temp,
- prev);
+ liste_del_task(linux_os->
+ thread_list, &temp,
+ prev);
linux_os->thread_count--;
gdb_put_packet(connection, "E01", 3);
return ERROR_OK;
}
int linux_gdb_h_packet(struct connection *connection,
- struct target *target, char *packet, int packet_size)
+ struct target *target, char *packet, int packet_size)
{
struct linux_os *linux_os = (struct linux_os *)
- target->rtos->rtos_specific_params;
+ target->rtos->rtos_specific_params;
struct current_thread *ct = linux_os->current_threads;
/* select to display the current thread of the selected target */
}
if (ct == NULL) {
- /* no current thread can be identified */
- /* any way with smp */
+ /* no current thread can be identified
+ * any way with smp */
LOG_INFO("no current thread identified");
/* attempt to display the name of the 2 threads identified with
* get_current */
t.base_addr = ct->TS;
get_name(target, &t);
LOG_INFO("name of unidentified thread %s",
- t.name);
+ t.name);
ct = ct->next;
}
gdb_put_packet(connection, "OK", 2);
} else {
target->rtos->current_threadid =
- current_gdb_thread_rq;
+ current_gdb_thread_rq;
gdb_put_packet(connection, "OK", 2);
}
} else if (packet[1] == 'c') {
sscanf(packet, "Hc%16" SCNx64, ¤t_gdb_thread_rq);
if ((current_gdb_thread_rq == 0) ||
- (current_gdb_thread_rq == ct->threadid)) {
+ (current_gdb_thread_rq == ct->threadid)) {
target->rtos->current_threadid = ct->threadid;
gdb_put_packet(connection, "OK", 2);
} else
}
static int linux_thread_packet(struct connection *connection, char *packet,
- int packet_size)
+ int packet_size)
{
int retval = ERROR_OK;
struct current_thread *ct;
target->rtos->rtos_specific_params;
switch (packet[0]) {
- case 'T': /* Is thread alive?*/
-
- 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 )*/
- /*LOG_INFO(" H packet received '%s'", packet);*/
- linux_gdb_h_packet(connection, target, packet, packet_size);
- break;
- case 'q':
-
- if ((strstr(packet, "qSymbol"))) {
- if (rtos_qsymbol(connection, packet, packet_size) == 1) {
- gdb_put_packet(connection, "OK", 2);
-
- linux_compute_virt2phys(target,
- target->rtos->
- symbols[INIT_TASK].
- address);
- }
+ case 'T': /* Is thread alive?*/
+ linux_gdb_T_packet(connection, target, packet, packet_size);
break;
- } else if (strstr(packet, "qfThreadInfo")) {
- if (linux_os->thread_list == NULL) {
- retval = linux_gdb_thread_packet(target,
- connection,
- packet,
+ case 'H': /* Set current thread */
+ /* ( 'c' for step and continue, 'g' for all other operations )*/
+ /*LOG_INFO(" H packet received '%s'", packet);*/
+ linux_gdb_h_packet(connection, target, packet, packet_size);
+ break;
+ case 'q':
+
+ if ((strstr(packet, "qSymbol"))) {
+ if (rtos_qsymbol(connection, packet, packet_size) == 1) {
+ gdb_put_packet(connection, "OK", 2);
+
+ linux_compute_virt2phys(target,
+ target->rtos->
+ symbols[INIT_TASK].
+ address);
+ }
+
+ break;
+ } else if (strstr(packet, "qfThreadInfo")) {
+ if (linux_os->thread_list == NULL) {
+ retval = linux_gdb_thread_packet(target,
+ connection,
+ packet,
+ packet_size);
+ break;
+ } else {
+ retval = linux_gdb_thread_update(target,
+ connection,
+ packet,
+ packet_size);
+ break;
+ }
+ } else if (strstr(packet, "qsThreadInfo")) {
+ gdb_put_packet(connection, "l", 1);
+ break;
+ } else if (strstr(packet, "qThreadExtraInfo,")) {
+ linux_thread_extra_info(target, connection, packet,
packet_size);
break;
} else {
- retval = linux_gdb_thread_update(target,
- connection,
- packet,
- packet_size);
+ retval = GDB_THREAD_PACKET_NOT_CONSUMED;
break;
}
- } else if (strstr(packet, "qsThreadInfo")) {
- gdb_put_packet(connection, "l", 1);
- break;
- } else if (strstr(packet, "qThreadExtraInfo,")) {
- linux_thread_extra_info(target, connection, packet,
- packet_size);
- break;
- } else {
+
+ case 'Q':
+ /* previously response was : thread not found
+ * gdb_put_packet(connection, "E01", 3); */
retval = GDB_THREAD_PACKET_NOT_CONSUMED;
break;
- }
-
- case 'Q':
- /* previously response was : thread not found
- * gdb_put_packet(connection, "E01", 3); */
- retval = GDB_THREAD_PACKET_NOT_CONSUMED;
- break;
- case 'c':
- case 's':{
- if (linux_os->threads_lookup == 1) {
- ct = linux_os->current_threads;
-
- while ((ct != NULL)
- && (ct->core_id) != target->coreid) {
- ct = ct->next;
- }
-
- if ((ct != NULL) && (ct->threadid == -1)) {
+ case 'c':
+ case 's': {
+ if (linux_os->threads_lookup == 1) {
ct = linux_os->current_threads;
- while ((ct != NULL)
- && (ct->threadid == -1)) {
+ while ((ct != NULL) && (ct->core_id) != target->coreid)
ct = ct->next;
- }
- }
- if ((ct != NULL) && (ct->threadid !=
- target->rtos->
- current_threadid)
- && (target->rtos->current_threadid != -1))
- LOG_WARNING("WARNING! current GDB thread do not match"\
- "current thread running."\
- "Switch thread in GDB to threadid %d", (int)ct->threadid);
+ if ((ct != NULL) && (ct->threadid == -1)) {
+ ct = linux_os->current_threads;
+
+ while ((ct != NULL) && (ct->threadid == -1))
+ ct = ct->next;
+ }
- LOG_INFO("threads_needs_update = 1");
- linux_os->threads_needs_update = 1;
+ if ((ct != NULL) && (ct->threadid !=
+ target->rtos->
+ current_threadid)
+ && (target->rtos->current_threadid != -1))
+ LOG_WARNING("WARNING! current GDB thread do not match" \
+ "current thread running." \
+ "Switch thread in GDB to threadid %d",
+ (int)ct->threadid);
+
+ LOG_INFO("threads_needs_update = 1");
+ linux_os->threads_needs_update = 1;
+ }
}
- }
- /* if a packet handler returned an error, exit input loop */
+ /* if a packet handler returned an error, exit input loop */
if (retval != ERROR_OK)
return retval;
}
/* keep only target->rtos */
struct rtos *rtos = target->rtos;
struct linux_os *os_linux =
- (struct linux_os *)rtos->rtos_specific_params;
+ (struct linux_os *)rtos->rtos_specific_params;
struct current_thread *ct;
head = target->head;
while (head != (struct target_list *)NULL) {
if (head->target->rtos != rtos) {
struct linux_os *smp_os_linux =
- (struct linux_os *)head->target->rtos->
- rtos_specific_params;
+ (struct linux_os *)head->target->rtos->
+ rtos_specific_params;
/* remap smp target on rtos */
free(head->target->rtos);
head->target->rtos = rtos;
ct->TS = 0xdeadbeef;
ct->core_id = head->target->coreid;
os_linux->current_threads =
- add_current_thread(os_linux->current_threads, ct);
+ add_current_thread(os_linux->current_threads, ct);
os_linux->nr_cpus++;
free(smp_os_linux);
}
ct->threadid = -1;
ct->TS = 0xdeadbeef;
os_linux->current_threads =
- add_current_thread(os_linux->current_threads, ct);
+ add_current_thread(os_linux->current_threads, ct);
/* overload rtos thread default handler */
target->rtos->gdb_thread_packet = linux_thread_packet;
/* initialize a default virt 2 phys translation */
static char *linux_ps_command(struct target *target)
{
struct linux_os *linux_os = (struct linux_os *)
- target->rtos->rtos_specific_params;
+ target->rtos->rtos_specific_params;
int retval = ERROR_OK;
char *display;
- if (linux_os->threads_lookup == 0) {
+ if (linux_os->threads_lookup == 0)
retval = linux_get_tasks(target, 1);
- } else {
+ else {
if (linux_os->threads_needs_update != 0)
retval = linux_task_update(target, 0);
}
struct threads *temp = linux_os->thread_list;
char *tmp;
LOG_INFO("allocation for %d threads line",
- linux_os->thread_count);
+ linux_os->thread_count);
display = calloc((linux_os->thread_count + 2) * 80, 1);
if (!display)
if (temp->status) {
if (temp->context)
tmp +=
- sprintf(tmp,
- "%d\t\t%d\t\t%x\t\t%s\n",
- (int)temp->pid, temp->oncpu,
- temp->asid, temp->name);
+ sprintf(tmp,
+ "%d\t\t%d\t\t%x\t\t%s\n",
+ (int)temp->pid, temp->oncpu,
+ temp->asid, temp->name);
else
tmp +=
- sprintf(tmp,
- "%d\t\t%d\t\t%x\t\t%s\n",
- (int)temp->pid, temp->oncpu,
- temp->asid, temp->name);
+ sprintf(tmp,
+ "%d\t\t%d\t\t%x\t\t%s\n",
+ (int)temp->pid, temp->oncpu,
+ temp->asid, temp->name);
}
temp = temp->next;
#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;
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,
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;
/* 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;
}
{
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
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) {
(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 */
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);
}
}
}
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->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->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->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);
}
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);
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);
{
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 ( hex_reg_list != NULL )
- {
+ 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) {
gdb_put_packet(connection, hex_reg_list, strlen(hex_reg_list));
free(hex_reg_list);
return ERROR_OK;
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;
}
}
-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++;
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;
}
#ifndef RTOS_H
#define RTOS_H
-
#include "server/server.h"
#include <helper/types.h>
#include <jim-nvp.h>
/**
* 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 */
#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 */
};
-
-
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_ */
#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 */
};
-
-
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_ */
Code Review / openocd.git / commitdiff