diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/rtos/FreeRTOS.c | 486 | ||||
| -rw-r--r-- | src/rtos/ThreadX.c | 473 | ||||
| -rw-r--r-- | src/rtos/eCos.c | 399 | ||||
| -rw-r--r-- | src/rtos/linux.c | 501 | ||||
| -rw-r--r-- | src/rtos/rtos.c | 390 | ||||
| -rw-r--r-- | src/rtos/rtos.h | 79 | ||||
| -rw-r--r-- | src/rtos/rtos_ecos_stackings.c | 68 | ||||
| -rw-r--r-- | src/rtos/rtos_ecos_stackings.h | 2 | ||||
| -rw-r--r-- | src/rtos/rtos_standard_stackings.c | 68 | ||||
| -rw-r--r-- | src/rtos/rtos_standard_stackings.h | 2 |
10 files changed, 1119 insertions, 1349 deletions
diff --git a/src/rtos/FreeRTOS.c b/src/rtos/FreeRTOS.c index eeab134..c7b4643 100644 --- a/src/rtos/FreeRTOS.c +++ b/src/rtos/FreeRTOS.c @@ -18,7 +18,6 @@ * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * ***************************************************************************/ - #ifdef HAVE_CONFIG_H #include "config.h" #endif @@ -31,370 +30,346 @@ #include "helper/log.h" #include "rtos_standard_stackings.h" -#define FreeRTOS_STRUCT( int_type, ptr_type, list_prev_offset ) - - -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; } @@ -406,81 +381,68 @@ static int FreeRTOS_set_current_thread(struct rtos *rtos, threadid_t thread_id) return 0; } - - -static int FreeRTOS_get_thread_ascii_info( struct rtos* rtos, threadid_t thread_id, char ** info ) +static int FreeRTOS_get_thread_ascii_info(struct rtos *rtos, threadid_t thread_id, char **info) { int retval; - const struct FreeRTOS_params* param; + const struct FreeRTOS_params *param; - if ( rtos == NULL ) - { + if (rtos == NULL) return -1; - } - if ( thread_id == 0 ) - { + if (thread_id == 0) return -2; - } - if (rtos->rtos_specific_params == NULL ) - { + if (rtos->rtos_specific_params == NULL) return -3; - } - param = (const struct FreeRTOS_params*) rtos->rtos_specific_params; + param = (const struct FreeRTOS_params *) rtos->rtos_specific_params; #define FREERTOS_THREAD_NAME_STR_SIZE (200) char tmp_str[FREERTOS_THREAD_NAME_STR_SIZE]; - // Read the thread name - retval = target_read_buffer( rtos->target, thread_id + param->thread_name_offset, FREERTOS_THREAD_NAME_STR_SIZE, (uint8_t *)&tmp_str); - if ( retval != ERROR_OK ) - { + /* Read the thread name */ + retval = target_read_buffer(rtos->target, + thread_id + param->thread_name_offset, + FREERTOS_THREAD_NAME_STR_SIZE, + (uint8_t *)&tmp_str); + if (retval != ERROR_OK) { LOG_OUTPUT("Error reading first thread item location in FreeRTOS thread list\r\n"); return retval; } tmp_str[FREERTOS_THREAD_NAME_STR_SIZE-1] = '\x00'; - if ( tmp_str[0] == '\x00' ) - { - strcpy(tmp_str,"No Name"); - } + if (tmp_str[0] == '\x00') + strcpy(tmp_str, "No Name"); - *info = (char*)malloc( strlen(tmp_str)+1 ); - strcpy( *info, tmp_str ); + *info = (char *)malloc(strlen(tmp_str)+1); + strcpy(*info, tmp_str); return 0; } #endif -static int FreeRTOS_detect_rtos( struct target* target ) +static int FreeRTOS_detect_rtos(struct target *target) { - if ( ( target->rtos->symbols != NULL ) && - ( target->rtos->symbols[FreeRTOS_VAL_pxReadyTasksLists].address != 0 ) ) - { - // looks like FreeRTOS + if ((target->rtos->symbols != NULL) && + (target->rtos->symbols[FreeRTOS_VAL_pxReadyTasksLists].address != 0)) { + /* looks like FreeRTOS */ return 1; } return 0; - return 0; } - -static int FreeRTOS_create( struct target* target ) +static int FreeRTOS_create(struct target *target) { int i = 0; - while ( ( i < FREERTOS_NUM_PARAMS ) && ( 0 != strcmp( FreeRTOS_params_list[i].target_name, target->type->name ) ) ) - { + while ((i < FREERTOS_NUM_PARAMS) && + (0 != strcmp(FreeRTOS_params_list[i].target_name, target->type->name))) { i++; } - if ( i >= FREERTOS_NUM_PARAMS ) - { + if (i >= FREERTOS_NUM_PARAMS) { LOG_OUTPUT("Could not find target in FreeRTOS compatibility list\r\n"); return -1; } - target->rtos->rtos_specific_params = (void*) &FreeRTOS_params_list[i]; + target->rtos->rtos_specific_params = (void *) &FreeRTOS_params_list[i]; return 0; } - diff --git a/src/rtos/ThreadX.c b/src/rtos/ThreadX.c index 1ce47a2..a9e313b 100644 --- a/src/rtos/ThreadX.c +++ b/src/rtos/ThreadX.c @@ -30,312 +30,275 @@ #include "helper/log.h" #include "rtos_standard_stackings.h" +static int ThreadX_detect_rtos(struct target *target); +static int ThreadX_create(struct target *target); +static int ThreadX_update_threads(struct rtos *rtos); +static int ThreadX_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, char **hex_reg_list); +static int ThreadX_get_symbol_list_to_lookup(symbol_table_elem_t *symbol_list[]); -static int ThreadX_detect_rtos( struct target* target ); -static int ThreadX_create( struct target* target ); -static int ThreadX_update_threads( struct rtos* rtos); -static int ThreadX_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, char ** hex_reg_list ); -static int ThreadX_get_symbol_list_to_lookup(symbol_table_elem_t * symbol_list[]); - - - -struct ThreadX_thread_state -{ +struct ThreadX_thread_state { int value; - char * desc; + char *desc; }; - -struct ThreadX_thread_state ThreadX_thread_states[] = -{ - { 0, "Ready" }, - { 1, "Completed" }, - { 2, "Terminated" }, - { 3, "Suspended" }, - { 4, "Sleeping" }, - { 5, "Waiting - Queue" }, - { 6, "Waiting - Semaphore" }, - { 7, "Waiting - Event flag" }, - { 8, "Waiting - Memory" }, - { 9, "Waiting - Memory" }, - { 10, "Waiting - I/O" }, - { 11, "Waiting - Filesystem" }, - { 12, "Waiting - Network" }, - { 13, "Waiting - Mutex" }, +struct ThreadX_thread_state ThreadX_thread_states[] = { + { 0, "Ready" }, + { 1, "Completed" }, + { 2, "Terminated" }, + { 3, "Suspended" }, + { 4, "Sleeping" }, + { 5, "Waiting - Queue" }, + { 6, "Waiting - Semaphore" }, + { 7, "Waiting - Event flag" }, + { 8, "Waiting - Memory" }, + { 9, "Waiting - Memory" }, + { 10, "Waiting - I/O" }, + { 11, "Waiting - Filesystem" }, + { 12, "Waiting - Network" }, + { 13, "Waiting - Mutex" }, }; - #define THREADX_NUM_STATES (sizeof(ThreadX_thread_states)/sizeof(struct ThreadX_thread_state)) - -struct ThreadX_params -{ - char * target_name; - unsigned char pointer_width; - unsigned char thread_stack_offset; - unsigned char thread_name_offset; - unsigned char thread_state_offset; - unsigned char thread_next_offset; - const struct rtos_register_stacking* stacking_info; +struct ThreadX_params { + char *target_name; + unsigned char pointer_width; + unsigned char thread_stack_offset; + unsigned char thread_name_offset; + unsigned char thread_state_offset; + unsigned char thread_next_offset; + const struct rtos_register_stacking *stacking_info; }; -const struct ThreadX_params ThreadX_params_list[] = -{ - { "cortex_m3", // target_name - 4, // pointer_width; - 8, // thread_stack_offset; - 40, // thread_name_offset; - 48, // thread_state_offset; - 136, // thread_next_offset - &rtos_standard_Cortex_M3_stacking, // stacking_info - } - +const struct ThreadX_params ThreadX_params_list[] = { + { + "cortex_m3", /* target_name */ + 4, /* pointer_width; */ + 8, /* thread_stack_offset; */ + 40, /* thread_name_offset; */ + 48, /* thread_state_offset; */ + 136, /* thread_next_offset */ + &rtos_standard_Cortex_M3_stacking, /* stacking_info */ + } }; #define THREADX_NUM_PARAMS ((int)(sizeof(ThreadX_params_list)/sizeof(struct ThreadX_params))) -enum ThreadX_symbol_values -{ - ThreadX_VAL_tx_thread_current_ptr = 0, - ThreadX_VAL_tx_thread_created_ptr = 1, - ThreadX_VAL_tx_thread_created_count = 2, +enum ThreadX_symbol_values { + ThreadX_VAL_tx_thread_current_ptr = 0, + ThreadX_VAL_tx_thread_created_ptr = 1, + ThreadX_VAL_tx_thread_created_count = 2, }; -static char* ThreadX_symbol_list[] = -{ - "_tx_thread_current_ptr", - "_tx_thread_created_ptr", - "_tx_thread_created_count", - NULL +static char *ThreadX_symbol_list[] = { + "_tx_thread_current_ptr", + "_tx_thread_created_ptr", + "_tx_thread_created_count", + NULL }; +#define THREADX_NUM_SYMBOLS (sizeof(ThreadX_symbol_list)/sizeof(char *)) +const struct rtos_type ThreadX_rtos = { + .name = "ThreadX", -#define THREADX_NUM_SYMBOLS (sizeof(ThreadX_symbol_list)/sizeof(char*)) - - -const struct rtos_type ThreadX_rtos = -{ - .name = "ThreadX", - - .detect_rtos = ThreadX_detect_rtos, - .create = ThreadX_create, - .update_threads = ThreadX_update_threads, - .get_thread_reg_list = ThreadX_get_thread_reg_list, + .detect_rtos = ThreadX_detect_rtos, + .create = ThreadX_create, + .update_threads = ThreadX_update_threads, + .get_thread_reg_list = ThreadX_get_thread_reg_list, .get_symbol_list_to_lookup = ThreadX_get_symbol_list_to_lookup, }; -static int ThreadX_update_threads( struct rtos* rtos) +static int ThreadX_update_threads(struct rtos *rtos) { int retval; int tasks_found = 0; int thread_list_size = 0; - const struct ThreadX_params* param; + const struct ThreadX_params *param; - if ( rtos == NULL ) - { + if (rtos == NULL) return -1; - } - if (rtos->rtos_specific_params == NULL ) - { + if (rtos->rtos_specific_params == NULL) return -3; - } - param = (const struct ThreadX_params*) rtos->rtos_specific_params; + param = (const struct ThreadX_params *) rtos->rtos_specific_params; - if ( rtos->symbols == NULL ) - { + if (rtos->symbols == NULL) { LOG_OUTPUT("No symbols for ThreadX\r\n"); return -4; } - if ( rtos->symbols[ThreadX_VAL_tx_thread_created_count].address == 0 ) - { + if (rtos->symbols[ThreadX_VAL_tx_thread_created_count].address == 0) { LOG_OUTPUT("Don't have the number of threads in ThreadX \r\n"); return -2; } + /* read the number of threads */ + retval = target_read_buffer(rtos->target, + rtos->symbols[ThreadX_VAL_tx_thread_created_count].address, + 4, + (uint8_t *)&thread_list_size); - - - - // read the number of threads - retval = target_read_buffer( rtos->target, rtos->symbols[ThreadX_VAL_tx_thread_created_count].address, 4, (uint8_t *)&thread_list_size); - - if ( retval != ERROR_OK ) - { + if (retval != ERROR_OK) { LOG_OUTPUT("Could not read ThreadX thread count from target\r\n"); return retval; } - - // wipe out previous thread details if any - if ( rtos->thread_details != NULL ) - { + /* wipe out previous thread details if any */ + if (rtos->thread_details != NULL) { int j; - for( j = 0; j < rtos->thread_count; j++ ) - { - if ( rtos->thread_details[j].display_str != NULL ) - { - free( rtos->thread_details[j].display_str ); + for (j = 0; j < rtos->thread_count; j++) { + if (rtos->thread_details[j].display_str != NULL) { + free(rtos->thread_details[j].display_str); rtos->thread_details[j].display_str = NULL; } - if ( rtos->thread_details[j].thread_name_str != NULL ) - { - free( rtos->thread_details[j].thread_name_str ); + if (rtos->thread_details[j].thread_name_str != NULL) { + free(rtos->thread_details[j].thread_name_str); rtos->thread_details[j].thread_name_str = NULL; } - if ( rtos->thread_details[j].extra_info_str != NULL ) - { - free( rtos->thread_details[j].extra_info_str ); + if (rtos->thread_details[j].extra_info_str != NULL) { + free(rtos->thread_details[j].extra_info_str); rtos->thread_details[j].extra_info_str = NULL; } } - free( rtos->thread_details ); + free(rtos->thread_details); rtos->thread_details = NULL; } + /* read the current thread id */ + retval = target_read_buffer(rtos->target, + rtos->symbols[ThreadX_VAL_tx_thread_current_ptr].address, + 4, + (uint8_t *)&rtos->current_thread); - // read the current thread id - retval = target_read_buffer( rtos->target, rtos->symbols[ThreadX_VAL_tx_thread_current_ptr].address, 4, (uint8_t *)&rtos->current_thread); - - if ( retval != ERROR_OK ) - { + if (retval != ERROR_OK) { LOG_OUTPUT("Could not read ThreadX current thread from target\r\n"); return retval; } - if ( ( thread_list_size == 0 ) || ( rtos->current_thread == 0 ) ) - { - // Either : No RTOS threads - there is always at least the current execution though - // OR : No current thread - all threads suspended - show the current execution of idling + if ((thread_list_size == 0) || (rtos->current_thread == 0)) { + /* Either : No RTOS threads - there is always at least the current execution though */ + /* OR : No current thread - all threads suspended - show the current execution + * of idling */ char tmp_str[] = "Current Execution"; thread_list_size++; tasks_found++; - rtos->thread_details = (struct thread_detail*) malloc( sizeof( struct thread_detail ) * thread_list_size ); + rtos->thread_details = (struct thread_detail *) malloc( + sizeof(struct thread_detail) * thread_list_size); rtos->thread_details->threadid = 1; rtos->thread_details->exists = true; rtos->thread_details->display_str = NULL; rtos->thread_details->extra_info_str = NULL; - rtos->thread_details->thread_name_str = (char*) malloc( sizeof(tmp_str) ); - strcpy( rtos->thread_details->thread_name_str, tmp_str ); - + rtos->thread_details->thread_name_str = (char *) malloc(sizeof(tmp_str)); + strcpy(rtos->thread_details->thread_name_str, tmp_str); - if ( thread_list_size == 0 ) - { + if (thread_list_size == 0) { rtos->thread_count = 1; return ERROR_OK; } + } else { + /* create space for new thread details */ + rtos->thread_details = (struct thread_detail *) malloc( + sizeof(struct thread_detail) * thread_list_size); } - else - { - // create space for new thread details - rtos->thread_details = (struct thread_detail*) malloc( sizeof( struct thread_detail ) * thread_list_size ); - } - - - // Read the pointer to the first thread + /* Read the pointer to the first thread */ int64_t thread_ptr = 0; - retval = target_read_buffer( rtos->target, rtos->symbols[ThreadX_VAL_tx_thread_created_ptr].address, param->pointer_width, (uint8_t *)&thread_ptr); - if ( retval != ERROR_OK ) - { + retval = target_read_buffer(rtos->target, + rtos->symbols[ThreadX_VAL_tx_thread_created_ptr].address, + param->pointer_width, + (uint8_t *)&thread_ptr); + if (retval != ERROR_OK) { LOG_OUTPUT("Could not read ThreadX thread location from target\r\n"); return retval; } - - // loop over all threads + /* loop over all threads */ int64_t prev_thread_ptr = 0; - while ( ( thread_ptr != prev_thread_ptr ) && ( tasks_found < thread_list_size ) ) - { + while ((thread_ptr != prev_thread_ptr) && (tasks_found < thread_list_size)) { #define THREADX_THREAD_NAME_STR_SIZE (200) - char tmp_str[THREADX_THREAD_NAME_STR_SIZE]; + char tmp_str[THREADX_THREAD_NAME_STR_SIZE]; unsigned int i = 0; int64_t name_ptr = 0; - // Save the thread pointer + /* Save the thread pointer */ rtos->thread_details[tasks_found].threadid = thread_ptr; - - // read the name pointer - retval = target_read_buffer( rtos->target, thread_ptr + param->thread_name_offset, param->pointer_width, (uint8_t *)&name_ptr); - if ( retval != ERROR_OK ) - { + /* read the name pointer */ + retval = target_read_buffer(rtos->target, + thread_ptr + param->thread_name_offset, + param->pointer_width, + (uint8_t *)&name_ptr); + if (retval != ERROR_OK) { LOG_OUTPUT("Could not read ThreadX thread name pointer from target\r\n"); return retval; } - // Read the thread name - retval = target_read_buffer( rtos->target, name_ptr, THREADX_THREAD_NAME_STR_SIZE, (uint8_t *)&tmp_str); - if ( retval != ERROR_OK ) - { + /* Read the thread name */ + retval = + target_read_buffer(rtos->target, + name_ptr, + THREADX_THREAD_NAME_STR_SIZE, + (uint8_t *)&tmp_str); + if (retval != ERROR_OK) { LOG_OUTPUT("Error reading thread name from ThreadX target\r\n"); return retval; } tmp_str[THREADX_THREAD_NAME_STR_SIZE-1] = '\x00'; - if ( tmp_str[0] == '\x00' ) - { - strcpy(tmp_str,"No Name"); - } - - - 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; @@ -343,71 +306,60 @@ static int ThreadX_update_threads( struct rtos* rtos) return 0; } -static int ThreadX_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, char ** hex_reg_list ) +static int ThreadX_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, char **hex_reg_list) { - int retval; - const struct ThreadX_params* param; + const struct ThreadX_params *param; *hex_reg_list = NULL; - if ( rtos == NULL ) - { + if (rtos == NULL) return -1; - } - if ( thread_id == 0 ) - { + if (thread_id == 0) return -2; - } - if (rtos->rtos_specific_params == NULL ) - { + if (rtos->rtos_specific_params == NULL) return -3; - } - param = (const struct ThreadX_params*) rtos->rtos_specific_params; + param = (const struct ThreadX_params *) rtos->rtos_specific_params; - // Read the stack pointer + /* Read the stack pointer */ int64_t stack_ptr = 0; - retval = target_read_buffer( rtos->target, thread_id + param->thread_stack_offset, param->pointer_width, (uint8_t*)&stack_ptr); - if ( retval != ERROR_OK ) - { + retval = target_read_buffer(rtos->target, + thread_id + param->thread_stack_offset, + param->pointer_width, + (uint8_t *)&stack_ptr); + if (retval != ERROR_OK) { LOG_OUTPUT("Error reading stack frame from ThreadX thread\r\n"); return retval; } - return rtos_generic_stack_read( rtos->target, param->stacking_info, stack_ptr, hex_reg_list ); + return rtos_generic_stack_read(rtos->target, param->stacking_info, stack_ptr, hex_reg_list); } - - -static int ThreadX_get_symbol_list_to_lookup(symbol_table_elem_t * symbol_list[]) +static int ThreadX_get_symbol_list_to_lookup(symbol_table_elem_t *symbol_list[]) { unsigned int i; - *symbol_list = (symbol_table_elem_t *) malloc( sizeof( symbol_table_elem_t ) * THREADX_NUM_SYMBOLS ); + *symbol_list = (symbol_table_elem_t *) malloc( + sizeof(symbol_table_elem_t) * THREADX_NUM_SYMBOLS); - for( i = 0; i < THREADX_NUM_SYMBOLS; i++ ) - { + for (i = 0; i < THREADX_NUM_SYMBOLS; i++) (*symbol_list)[i].symbol_name = ThreadX_symbol_list[i]; - } return 0; } -static int ThreadX_detect_rtos( struct target* target ) +static int ThreadX_detect_rtos(struct target *target) { - if ( ( target->rtos->symbols != NULL ) && - ( target->rtos->symbols[ThreadX_VAL_tx_thread_created_ptr].address != 0 ) ) - { - // looks like ThreadX + if ((target->rtos->symbols != NULL) && + (target->rtos->symbols[ThreadX_VAL_tx_thread_created_ptr].address != 0)) { + /* looks like ThreadX */ return 1; } return 0; } - - #if 0 static int ThreadX_set_current_thread(struct rtos *rtos, threadid_t thread_id) @@ -415,9 +367,9 @@ static int ThreadX_set_current_thread(struct rtos *rtos, threadid_t thread_id) return 0; } - - -static int ThreadX_get_thread_detail( struct rtos* rtos, threadid_t thread_id, struct thread_detail* detail ) +static int ThreadX_get_thread_detail(struct rtos *rtos, + threadid_t thread_id, + struct thread_detail *detail) { unsigned int i = 0; int retval; @@ -425,27 +377,20 @@ static int ThreadX_get_thread_detail( struct rtos* rtos, threadid_t thread_i #define THREADX_THREAD_NAME_STR_SIZE (200) char tmp_str[THREADX_THREAD_NAME_STR_SIZE]; - const struct ThreadX_params* param; + const struct ThreadX_params *param; - if ( rtos == NULL ) - { + if (rtos == NULL) return -1; - } - if ( thread_id == 0 ) - { + if (thread_id == 0) return -2; - } - if (rtos->rtos_specific_params == NULL ) - { + if (rtos->rtos_specific_params == NULL) return -3; - } - param = (const struct ThreadX_params*) rtos->rtos_specific_params; + param = (const struct ThreadX_params *) rtos->rtos_specific_params; - if ( rtos->symbols == NULL ) - { + if (rtos->symbols == NULL) { LOG_OUTPUT("No symbols for ThreadX\r\n"); return -3; } @@ -453,83 +398,79 @@ static int ThreadX_get_thread_detail( struct rtos* rtos, threadid_t thread_i detail->threadid = thread_id; int64_t name_ptr = 0; - // read the name pointer - retval = target_read_buffer( rtos->target, thread_id + param->thread_name_offset, param->pointer_width, (uint8_t *)&name_ptr); - if ( retval != ERROR_OK ) - { + /* read the name pointer */ + retval = target_read_buffer(rtos->target, + thread_id + param->thread_name_offset, + param->pointer_width, + (uint8_t *)&name_ptr); + if (retval != ERROR_OK) { LOG_OUTPUT("Could not read ThreadX thread name pointer from target\r\n"); return retval; } - // Read the thread name - retval = target_read_buffer( rtos->target, name_ptr, THREADX_THREAD_NAME_STR_SIZE, (uint8_t *)&tmp_str); - if ( retval != ERROR_OK ) - { + /* Read the thread name */ + retval = target_read_buffer(rtos->target, + name_ptr, + THREADX_THREAD_NAME_STR_SIZE, + (uint8_t *)&tmp_str); + if (retval != ERROR_OK) { LOG_OUTPUT("Error reading thread name from ThreadX target\r\n"); return retval; } tmp_str[THREADX_THREAD_NAME_STR_SIZE-1] = '\x00'; - if ( tmp_str[0] == '\x00' ) - { - strcpy(tmp_str,"No Name"); - } - - 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; diff --git a/src/rtos/eCos.c b/src/rtos/eCos.c index cd04d9d..5c18916 100644 --- a/src/rtos/eCos.c +++ b/src/rtos/eCos.c @@ -28,206 +28,189 @@ #include "helper/log.h" #include "rtos_ecos_stackings.h" -static int eCos_detect_rtos( struct target* target ); -static int eCos_create( struct target* target ); -static int eCos_update_threads( struct rtos* rtos); -static int eCos_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, char ** hex_reg_list ); -static int eCos_get_symbol_list_to_lookup(symbol_table_elem_t * symbol_list[]); +static int eCos_detect_rtos(struct target *target); +static int eCos_create(struct target *target); +static int eCos_update_threads(struct rtos *rtos); +static int eCos_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, char **hex_reg_list); +static int eCos_get_symbol_list_to_lookup(symbol_table_elem_t *symbol_list[]); -struct eCos_thread_state -{ +struct eCos_thread_state { int value; - char * desc; + char *desc; }; - -struct eCos_thread_state eCos_thread_states[] = -{ - { 0, "Ready" }, - { 1, "Sleeping" }, - { 2, "Countsleep" }, - { 4, "Suspended" }, - { 8, "Creating" }, - { 16, "Exited" } +struct eCos_thread_state eCos_thread_states[] = { + { 0, "Ready" }, + { 1, "Sleeping" }, + { 2, "Countsleep" }, + { 4, "Suspended" }, + { 8, "Creating" }, + { 16, "Exited" } }; #define ECOS_NUM_STATES (sizeof(eCos_thread_states)/sizeof(struct eCos_thread_state)) -struct eCos_params -{ - char * target_name; - unsigned char pointer_width; - unsigned char thread_stack_offset; - unsigned char thread_name_offset; - unsigned char thread_state_offset; - unsigned char thread_next_offset; - unsigned char thread_uniqueid_offset; - const struct rtos_register_stacking* stacking_info; +struct eCos_params { + char *target_name; + unsigned char pointer_width; + unsigned char thread_stack_offset; + unsigned char thread_name_offset; + unsigned char thread_state_offset; + unsigned char thread_next_offset; + unsigned char thread_uniqueid_offset; + const struct rtos_register_stacking *stacking_info; }; -const struct eCos_params eCos_params_list[] = -{ - { "cortex_m3", // target_name - 4, // pointer_width; - 0x0c, // thread_stack_offset; - 0x9c, // thread_name_offset; - 0x3c, // thread_state_offset; - 0xa0, // thread_next_offset - 0x4c, // thread_uniqueid_offset - &rtos_eCos_Cortex_M3_stacking // stacking_info +const struct eCos_params eCos_params_list[] = { + { + "cortex_m3", /* target_name */ + 4, /* pointer_width; */ + 0x0c, /* thread_stack_offset; */ + 0x9c, /* thread_name_offset; */ + 0x3c, /* thread_state_offset; */ + 0xa0, /* thread_next_offset */ + 0x4c, /* thread_uniqueid_offset */ + &rtos_eCos_Cortex_M3_stacking /* stacking_info */ } - }; #define ECOS_NUM_PARAMS ((int)(sizeof(eCos_params_list)/sizeof(struct eCos_params))) -enum eCos_symbol_values -{ - eCos_VAL_thread_list = 0, - eCos_VAL_current_thread_ptr = 1 +enum eCos_symbol_values { + eCos_VAL_thread_list = 0, + eCos_VAL_current_thread_ptr = 1 }; -static char* eCos_symbol_list[] = -{ - "Cyg_Thread::thread_list", - "Cyg_Scheduler_Base::current_thread", - NULL +static char *eCos_symbol_list[] = { + "Cyg_Thread::thread_list", + "Cyg_Scheduler_Base::current_thread", + NULL }; +#define ECOS_NUM_SYMBOLS (sizeof(eCos_symbol_list)/sizeof(char *)) +const struct rtos_type eCos_rtos = { + .name = "eCos", -#define ECOS_NUM_SYMBOLS (sizeof(eCos_symbol_list)/sizeof(char*)) - - -const struct rtos_type eCos_rtos = -{ - .name = "eCos", - - .detect_rtos = eCos_detect_rtos, - .create = eCos_create, - .update_threads = eCos_update_threads, - .get_thread_reg_list = eCos_get_thread_reg_list, + .detect_rtos = eCos_detect_rtos, + .create = eCos_create, + .update_threads = eCos_update_threads, + .get_thread_reg_list = eCos_get_thread_reg_list, .get_symbol_list_to_lookup = eCos_get_symbol_list_to_lookup, }; -static int eCos_update_threads( struct rtos* rtos) +static int eCos_update_threads(struct rtos *rtos) { int retval; int tasks_found = 0; int thread_list_size = 0; - const struct eCos_params* param; + const struct eCos_params *param; - if ( rtos == NULL ) - { + if (rtos == NULL) return -1; - } - if (rtos->rtos_specific_params == NULL ) - { + if (rtos->rtos_specific_params == NULL) return -3; - } - param = (const struct eCos_params*) rtos->rtos_specific_params; + param = (const struct eCos_params *) rtos->rtos_specific_params; - if ( rtos->symbols == NULL ) - { + if (rtos->symbols == NULL) { LOG_OUTPUT("No symbols for eCos\r\n"); return -4; } - if ( rtos->symbols[eCos_VAL_thread_list].address == 0 ) - { + if (rtos->symbols[eCos_VAL_thread_list].address == 0) { LOG_OUTPUT("Don't have the thread list head\r\n"); return -2; } - - // wipe out previous thread details if any - if ( rtos->thread_details != NULL ) - { + /* wipe out previous thread details if any */ + if (rtos->thread_details != NULL) { int j; - for( j = 0; j < rtos->thread_count; j++ ) - { - if ( rtos->thread_details[j].display_str != NULL ) - { - free( rtos->thread_details[j].display_str ); + for (j = 0; j < rtos->thread_count; j++) { + if (rtos->thread_details[j].display_str != NULL) { + free(rtos->thread_details[j].display_str); rtos->thread_details[j].display_str = NULL; } - if ( rtos->thread_details[j].thread_name_str != NULL ) - { - free( rtos->thread_details[j].thread_name_str ); + if (rtos->thread_details[j].thread_name_str != NULL) { + free(rtos->thread_details[j].thread_name_str); rtos->thread_details[j].thread_name_str = NULL; } - if ( rtos->thread_details[j].extra_info_str != NULL ) - { - free( rtos->thread_details[j].extra_info_str ); + if (rtos->thread_details[j].extra_info_str != NULL) { + free(rtos->thread_details[j].extra_info_str); rtos->thread_details[j].extra_info_str = NULL; } } - free( rtos->thread_details ); + free(rtos->thread_details); rtos->thread_details = NULL; } - - // determine the number of current threads + /* determine the number of current threads */ uint32_t thread_list_head = rtos->symbols[eCos_VAL_thread_list].address; uint32_t thread_index; - target_read_buffer( rtos->target, thread_list_head, param->pointer_width, (uint8_t *) &thread_index ); + target_read_buffer(rtos->target, + thread_list_head, + param->pointer_width, + (uint8_t *) &thread_index); uint32_t first_thread = thread_index; - do - { + do { thread_list_size++; - retval = target_read_buffer( rtos->target, thread_index + param->thread_next_offset, param->pointer_width, (uint8_t *) &thread_index ); + retval = target_read_buffer(rtos->target, + thread_index + param->thread_next_offset, + param->pointer_width, + (uint8_t *) &thread_index); if (retval != ERROR_OK) return retval; - } while( thread_index!=first_thread ); + } while (thread_index != first_thread); - // read the current thread id + /* read the current thread id */ uint32_t current_thread_addr; - retval = target_read_buffer( rtos->target, rtos->symbols[eCos_VAL_current_thread_ptr].address, 4, (uint8_t *)¤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]; @@ -235,196 +218,198 @@ static int eCos_update_threads( struct rtos* rtos) uint32_t name_ptr = 0; uint32_t prev_thread_ptr; - // Save the thread pointer + /* Save the thread pointer */ uint16_t thread_id; - retval = target_read_buffer( rtos->target, thread_index + param->thread_uniqueid_offset, 2, (uint8_t *)&thread_id); - if ( retval != ERROR_OK ) - { + retval = target_read_buffer(rtos->target, + thread_index + param->thread_uniqueid_offset, + 2, + (uint8_t *)&thread_id); + if (retval != ERROR_OK) { LOG_OUTPUT("Could not read eCos thread id from target\r\n"); return retval; } rtos->thread_details[tasks_found].threadid = thread_id; - // read the name pointer - retval = target_read_buffer( rtos->target, thread_index + param->thread_name_offset, param->pointer_width, (uint8_t *)&name_ptr); - if ( retval != ERROR_OK ) - { + /* read the name pointer */ + retval = target_read_buffer(rtos->target, + thread_index + param->thread_name_offset, + param->pointer_width, + (uint8_t *)&name_ptr); + if (retval != ERROR_OK) { LOG_OUTPUT("Could not read eCos thread name pointer from target\r\n"); return retval; } - // Read the thread name - retval = target_read_buffer( rtos->target, name_ptr, ECOS_THREAD_NAME_STR_SIZE, (uint8_t *)&tmp_str); - if ( retval != ERROR_OK ) - { + /* Read the thread name */ + retval = + target_read_buffer(rtos->target, + name_ptr, + ECOS_THREAD_NAME_STR_SIZE, + (uint8_t *)&tmp_str); + if (retval != ERROR_OK) { LOG_OUTPUT("Error reading thread name from eCos target\r\n"); return retval; } tmp_str[ECOS_THREAD_NAME_STR_SIZE-1] = '\x00'; - if ( tmp_str[0] == '\x00' ) - { - strcpy(tmp_str,"No Name"); - } + if (tmp_str[0] == '\x00') + strcpy(tmp_str, "No Name"); - rtos->thread_details[tasks_found].thread_name_str = (char*)malloc( strlen(tmp_str)+1 ); - strcpy( rtos->thread_details[tasks_found].thread_name_str, tmp_str ); + rtos->thread_details[tasks_found].thread_name_str = + (char *)malloc(strlen(tmp_str)+1); + strcpy(rtos->thread_details[tasks_found].thread_name_str, tmp_str); - // Read the thread status + /* Read the thread status */ int64_t thread_status = 0; - retval = target_read_buffer( rtos->target, thread_index + param->thread_state_offset, 4, (uint8_t *)&thread_status); - if ( retval != ERROR_OK ) - { + retval = target_read_buffer(rtos->target, + thread_index + param->thread_state_offset, + 4, + (uint8_t *)&thread_status); + if (retval != ERROR_OK) { LOG_OUTPUT("Error reading thread state from eCos target\r\n"); return retval; } - for( i = 0; (i < ECOS_NUM_STATES) && (eCos_thread_states[i].value!=thread_status); i++ ) - { + for (i = 0; (i < ECOS_NUM_STATES) && (eCos_thread_states[i].value != thread_status); i++) { + /* + * empty + */ } - char * state_desc; + char *state_desc; if (i < ECOS_NUM_STATES) - { state_desc = eCos_thread_states[i].desc; - } else - { state_desc = "Unknown state"; - } - rtos->thread_details[tasks_found].extra_info_str = (char*)malloc( strlen(state_desc)+1 ); - strcpy( rtos->thread_details[tasks_found].extra_info_str, state_desc ); + rtos->thread_details[tasks_found].extra_info_str = (char *)malloc(strlen( + state_desc)+1); + strcpy(rtos->thread_details[tasks_found].extra_info_str, state_desc); rtos->thread_details[tasks_found].exists = true; rtos->thread_details[tasks_found].display_str = NULL; - tasks_found++; prev_thread_ptr = thread_index; - // Get the location of the next thread structure. + /* Get the location of the next thread structure. */ thread_index = rtos->symbols[eCos_VAL_thread_list].address; - retval = target_read_buffer( rtos->target, prev_thread_ptr + param->thread_next_offset, param->pointer_width, (uint8_t *) &thread_index ); - if ( retval != ERROR_OK ) - { + retval = target_read_buffer(rtos->target, + prev_thread_ptr + param->thread_next_offset, + param->pointer_width, + (uint8_t *) &thread_index); + if (retval != ERROR_OK) { LOG_OUTPUT("Error reading next thread pointer in eCos thread list\r\n"); return retval; } - } - while( thread_index!=first_thread ); + } while (thread_index != first_thread); rtos->thread_count = tasks_found; return 0; } -static int eCos_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, char ** hex_reg_list ) +static int eCos_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, char **hex_reg_list) { - int retval; - const struct eCos_params* param; + const struct eCos_params *param; *hex_reg_list = NULL; - if ( rtos == NULL ) - { + if (rtos == NULL) return -1; - } - if ( thread_id == 0 ) - { + if (thread_id == 0) return -2; - } - if (rtos->rtos_specific_params == NULL ) - { + if (rtos->rtos_specific_params == NULL) return -3; - } - - param = (const struct eCos_params*) rtos->rtos_specific_params; + param = (const struct eCos_params *) rtos->rtos_specific_params; - // Find the thread with that thread id - uint16_t id=0; + /* Find the thread with that thread id */ + uint16_t id = 0; uint32_t thread_list_head = rtos->symbols[eCos_VAL_thread_list].address; uint32_t thread_index; - target_read_buffer( rtos->target, thread_list_head, param->pointer_width, (uint8_t *) &thread_index ); - bool done=false; - while(!done) - { - retval = target_read_buffer( rtos->target, thread_index + param->thread_uniqueid_offset, 2, (uint8_t*)&id); - if ( retval != ERROR_OK ) - { + target_read_buffer(rtos->target, thread_list_head, param->pointer_width, + (uint8_t *)&thread_index); + bool done = false; + while (!done) { + retval = target_read_buffer(rtos->target, + thread_index + param->thread_uniqueid_offset, + 2, + (uint8_t *)&id); + if (retval != ERROR_OK) { LOG_OUTPUT("Error reading unique id from eCos thread\r\n"); return retval; } - if( id==thread_id ) - { - done=true; + if (id == thread_id) { + done = true; break; } - target_read_buffer( rtos->target, thread_index + param->thread_next_offset, param->pointer_width, (uint8_t *) &thread_index ); + target_read_buffer(rtos->target, + thread_index + param->thread_next_offset, + param->pointer_width, + (uint8_t *) &thread_index); } - if(done) - { - // Read the stack pointer + if (done) { + /* Read the stack pointer */ int64_t stack_ptr = 0; - retval = target_read_buffer( rtos->target, thread_index + param->thread_stack_offset, param->pointer_width, (uint8_t*)&stack_ptr); - if ( retval != ERROR_OK ) - { + retval = target_read_buffer(rtos->target, + thread_index + param->thread_stack_offset, + param->pointer_width, + (uint8_t *)&stack_ptr); + if (retval != ERROR_OK) { LOG_OUTPUT("Error reading stack frame from eCos thread\r\n"); return retval; } - return rtos_generic_stack_read( rtos->target, param->stacking_info, stack_ptr, hex_reg_list ); + return rtos_generic_stack_read(rtos->target, + param->stacking_info, + stack_ptr, + hex_reg_list); } return -1; } - - -static int eCos_get_symbol_list_to_lookup(symbol_table_elem_t * symbol_list[]) +static int eCos_get_symbol_list_to_lookup(symbol_table_elem_t *symbol_list[]) { unsigned int i; - *symbol_list = (symbol_table_elem_t *) malloc( sizeof( symbol_table_elem_t ) * ECOS_NUM_SYMBOLS ); + *symbol_list = (symbol_table_elem_t *) malloc( + sizeof(symbol_table_elem_t) * ECOS_NUM_SYMBOLS); - for( i = 0; i < ECOS_NUM_SYMBOLS; i++ ) - { + for (i = 0; i < ECOS_NUM_SYMBOLS; i++) (*symbol_list)[i].symbol_name = eCos_symbol_list[i]; - } return 0; } -static int eCos_detect_rtos( struct target* target ) +static int eCos_detect_rtos(struct target *target) { - if ( ( target->rtos->symbols != NULL ) && - ( target->rtos->symbols[eCos_VAL_thread_list].address != 0 ) ) - { - // looks like eCos + if ((target->rtos->symbols != NULL) && + (target->rtos->symbols[eCos_VAL_thread_list].address != 0)) { + /* looks like eCos */ return 1; } return 0; } -static int eCos_create( struct target* target ) +static int eCos_create(struct target *target) { int i = 0; - while ( ( i < ECOS_NUM_PARAMS ) && ( 0 != strcmp( eCos_params_list[i].target_name, target->type->name ) ) ) - { + while ((i < ECOS_NUM_PARAMS) && + (0 != strcmp(eCos_params_list[i].target_name, target->type->name))) { i++; } - if ( i >= ECOS_NUM_PARAMS ) - { + if (i >= ECOS_NUM_PARAMS) { LOG_OUTPUT("Could not find target in eCos compatibility list\r\n"); return -1; } - target->rtos->rtos_specific_params = (void*) &eCos_params_list[i]; + target->rtos->rtos_specific_params = (void *) &eCos_params_list[i]; target->rtos->current_thread = 0; target->rtos->thread_details = NULL; return 0; diff --git a/src/rtos/linux.c b/src/rtos/linux.c index 2ea3312..e249ff4 100644 --- a/src/rtos/linux.c +++ b/src/rtos/linux.c @@ -102,15 +102,15 @@ static int linux_os_create(struct target *target); 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) { @@ -127,12 +127,12 @@ static int linux_compute_virt2phys(struct target *target, uint32_t address) } 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) { @@ -156,7 +156,7 @@ static char *reg_converter(char *buffer, void *reg, int size) 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) @@ -176,11 +176,11 @@ uint32_t get_buffer(struct target *target, const uint8_t *buffer) } 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; @@ -216,15 +216,17 @@ static int linux_os_thread_reg_list(struct rtos *rtos, 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; @@ -241,8 +243,8 @@ static int linux_os_thread_reg_list(struct rtos *rtos, 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); @@ -256,49 +258,48 @@ static int linux_os_thread_reg_list(struct rtos *rtos, 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); @@ -325,7 +326,7 @@ static int linux_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) / 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]; @@ -348,7 +349,7 @@ const struct rtos_type Linux_os = { }; 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 @@ -370,7 +371,6 @@ int fill_task_pid(struct target *target, struct threads *t) 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; @@ -414,10 +414,9 @@ int fill_task(struct target *target, struct threads *t) 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"); @@ -442,26 +441,26 @@ int get_name(struct target *target, struct threads *t) } 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; @@ -479,7 +478,7 @@ int get_current(struct target *target, int create) 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 */ @@ -495,8 +494,7 @@ int get_current(struct target *target, int create) 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) @@ -516,19 +514,17 @@ int get_current(struct target *target, int create) 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; @@ -558,7 +554,7 @@ int get_current(struct target *target, int create) } 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; @@ -600,11 +596,11 @@ retry: 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; @@ -616,7 +612,7 @@ 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"); @@ -624,25 +620,25 @@ retry: } 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; @@ -668,7 +664,7 @@ uint32_t next_task(struct target *target, struct threads *t) } struct current_thread *add_current_thread(struct current_thread *currents, - struct current_thread *ct) + struct current_thread *ct) { ct->next = NULL; @@ -687,7 +683,7 @@ struct current_thread *add_current_thread(struct current_thread *currents, } 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; @@ -705,7 +701,7 @@ struct threads *liste_del_task(struct threads *task_list, struct threads **t, } struct threads *liste_add_task(struct threads *task_list, struct threads *t, - struct threads **last) + struct threads **last) { t->next = NULL; @@ -723,10 +719,10 @@ struct threads *liste_add_task(struct threads *task_list, struct threads *t, *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 @@ -758,7 +754,7 @@ int linux_get_tasks(struct target *target, int context) 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; @@ -776,9 +772,7 @@ int linux_get_tasks(struct target *target, int context) 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); @@ -806,15 +800,15 @@ int linux_get_tasks(struct target *target, int context) 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); @@ -830,9 +824,9 @@ int linux_get_tasks(struct target *target, int context) 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); @@ -842,7 +836,7 @@ int linux_get_tasks(struct target *target, int context) 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) { @@ -860,9 +854,8 @@ static int clean_threadlist(struct target *target) 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"; @@ -901,7 +894,7 @@ static int insert_into_threadlist(struct target *target, struct threads *t) 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; @@ -930,66 +923,66 @@ error_handling: #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; @@ -1005,7 +998,6 @@ static int linux_task_update(struct target *target, int context) } thread_list = thread_list->next; - } int found = 0; @@ -1019,7 +1011,7 @@ static int linux_task_update(struct target *target, int context) 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) && @@ -1042,20 +1034,14 @@ static int linux_task_update(struct target *target, int context) 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; @@ -1069,11 +1055,11 @@ static int linux_task_update(struct target *target, int context) */ 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 */ } @@ -1096,8 +1082,8 @@ static int linux_task_update(struct target *target, int 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)); @@ -1105,24 +1091,22 @@ static int linux_task_update(struct target *target, int context) 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 */ @@ -1154,12 +1138,12 @@ int linux_gdb_thread_packet(struct target *target, } 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) { @@ -1185,14 +1169,14 @@ int linux_gdb_thread_update(struct target *target, /*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); @@ -1201,12 +1185,12 @@ int linux_gdb_thread_update(struct target *target, } 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; @@ -1223,17 +1207,17 @@ int linux_thread_extra_info(struct target *target, /* 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); @@ -1249,11 +1233,11 @@ int linux_thread_extra_info(struct target *target, } 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); @@ -1269,9 +1253,9 @@ int linux_gdb_T_packet(struct connection *connection, } 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; @@ -1310,10 +1294,10 @@ int linux_gdb_T_packet(struct connection *connection, } 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 */ @@ -1331,8 +1315,8 @@ int linux_gdb_h_packet(struct connection *connection, } 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 */ @@ -1343,7 +1327,7 @@ int linux_gdb_h_packet(struct connection *connection, t.base_addr = ct->TS; get_name(target, &t); LOG_INFO("name of unidentified thread %s", - t.name); + t.name); ct = ct->next; } @@ -1359,14 +1343,14 @@ int linux_gdb_h_packet(struct connection *connection, 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 @@ -1379,7 +1363,7 @@ int linux_gdb_h_packet(struct connection *connection, } static int linux_thread_packet(struct connection *connection, char *packet, - int packet_size) + int packet_size) { int retval = ERROR_OK; struct current_thread *ct; @@ -1388,92 +1372,89 @@ static int linux_thread_packet(struct connection *connection, char *packet, 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; } @@ -1487,15 +1468,15 @@ static int linux_os_smp_init(struct target *target) /* 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; @@ -1505,7 +1486,7 @@ static int linux_os_smp_init(struct target *target) 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); } @@ -1536,7 +1517,7 @@ static int linux_os_create(struct target *target) 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 */ @@ -1548,13 +1529,13 @@ static int linux_os_create(struct target *target) 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); } @@ -1563,7 +1544,7 @@ static char *linux_ps_command(struct target *target) 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) @@ -1577,16 +1558,16 @@ static char *linux_ps_command(struct target *target) 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; diff --git a/src/rtos/rtos.c b/src/rtos/rtos.c index 3deeb68..07e44ea 100644 --- a/src/rtos/rtos.c +++ b/src/rtos/rtos.c @@ -22,16 +22,12 @@ #include "config.h" #endif - #include "rtos.h" #include "target/target.h" #include "helper/log.h" #include "server/gdb_server.h" - - -static void hex_to_str( char* dst, char * hex_src ); - +static void hex_to_str(char *dst, char *hex_src); /* RTOSs */ extern struct rtos_type FreeRTOS_rtos; @@ -39,8 +35,7 @@ extern struct rtos_type ThreadX_rtos; extern struct rtos_type eCos_rtos; extern struct rtos_type Linux_os; -static struct rtos_type *rtos_types[] = -{ +static struct rtos_type *rtos_types[] = { &ThreadX_rtos, &FreeRTOS_rtos, &eCos_rtos, @@ -57,69 +52,66 @@ int rtos_smp_init(struct target *target) return ERROR_TARGET_INIT_FAILED; } - -int rtos_create(Jim_GetOptInfo *goi, struct target * target) +int rtos_create(Jim_GetOptInfo *goi, struct target *target) { int x; char *cp; - if (! goi->isconfigure) { + if (!goi->isconfigure) { if (goi->argc != 0) { if (goi->argc != 0) { Jim_WrongNumArgs(goi->interp, - goi->argc, goi->argv, - "NO PARAMS"); + goi->argc, goi->argv, + "NO PARAMS"); return JIM_ERR; } Jim_SetResultString(goi->interp, - target_type_name(target), -1); + target_type_name(target), -1); } } - if (target->rtos) { + if (target->rtos) free((void *)(target->rtos)); - } -// e = Jim_GetOpt_String(goi, &cp, NULL); -// target->rtos = strdup(cp); + /* e = Jim_GetOpt_String(goi, + * &cp, NULL); */ +/* target->rtos = strdup(cp); */ Jim_GetOpt_String(goi, &cp, NULL); /* now does target type exist */ - if ( 0 == strcmp( cp, "auto") ) - { - // auto detection of RTOS + if (0 == strcmp(cp, "auto")) { + /* auto detection of RTOS */ target->rtos_auto_detect = true; x = 0; - } - else - { + } else { - for (x = 0 ; rtos_types[x] ; x++) { + for (x = 0; rtos_types[x]; x++) { if (0 == strcmp(cp, rtos_types[x]->name)) { /* found */ break; } } if (rtos_types[x] == NULL) { - Jim_SetResultFormatted(goi->interp, "Unknown rtos type %s, try one of ", cp); - for (x = 0 ; rtos_types[x] ; x++) { + Jim_SetResultFormatted(goi->interp, "Unknown rtos type %s, try one of ", + cp); + for (x = 0; rtos_types[x]; x++) { if (rtos_types[x + 1]) { Jim_AppendStrings(goi->interp, - Jim_GetResult(goi->interp), - rtos_types[x]->name, - ", ", NULL); + Jim_GetResult(goi->interp), + rtos_types[x]->name, + ", ", NULL); } else { Jim_AppendStrings(goi->interp, - Jim_GetResult(goi->interp), - " or ", - rtos_types[x]->name,NULL); + Jim_GetResult(goi->interp), + " or ", + rtos_types[x]->name, NULL); } } return JIM_ERR; } } /* Create it */ - target->rtos = calloc(1,sizeof(struct rtos)); + target->rtos = calloc(1, sizeof(struct rtos)); target->rtos->type = rtos_types[x]; target->rtos->current_threadid = -1; target->rtos->current_thread = 0; @@ -128,10 +120,8 @@ int rtos_create(Jim_GetOptInfo *goi, struct target * target) /* put default thread handler in linux usecase it is overloaded*/ target->rtos->gdb_thread_packet = rtos_thread_packet; - if ( 0 != strcmp( cp, "auto") ) - { - target->rtos->type->create( target ); - } + if (0 != strcmp(cp, "auto")) + target->rtos->type->create(target); return JIM_OK; } @@ -140,7 +130,8 @@ int gdb_thread_packet(struct connection *connection, char *packet, int packet_si { struct target *target = get_target_from_connection(connection); if (target->rtos == NULL) - return rtos_thread_packet(connection, packet, packet_size); /* thread not found*/ + return rtos_thread_packet(connection, packet, packet_size); /* thread not + *found*/ return target->rtos->gdb_thread_packet(connection, packet, packet_size); } /* return -1 if no rtos defined, 0 if rtos and symbol to be asked, 1 if all @@ -171,8 +162,8 @@ int rtos_qsymbol(struct connection *connection, char *packet, int packet_size) hex_to_str(name_str, hex_name_str); symbol_num = 0; - while ((target->rtos->symbols[symbol_num].symbol_name != NULL) - && (0 != strcmp(target->rtos->symbols[symbol_num].symbol_name, name_str))) + while ((target->rtos->symbols[symbol_num].symbol_name != NULL) && + (0 != strcmp(target->rtos->symbols[symbol_num].symbol_name, name_str))) symbol_num++; if (target->rtos->symbols[symbol_num].symbol_name == NULL) { @@ -194,7 +185,8 @@ int rtos_qsymbol(struct connection *connection, char *packet, int packet_size) (1 == target->rtos->type->detect_rtos(target))) { /* Found correct RTOS or not autodetecting */ if (target->rtos_auto_detect == true) - LOG_OUTPUT("Auto-detected RTOS: %s\r\n", target->rtos->type->name); + LOG_OUTPUT("Auto-detected RTOS: %s\r\n", + target->rtos->type->name); symbols_done = 1; } else { /* Auto detecting RTOS and currently not found */ @@ -203,7 +195,8 @@ int rtos_qsymbol(struct connection *connection, char *packet, int packet_size) symbols_done = 1; else { next_symbol_num = 0; - target->rtos->type->get_symbol_list_to_lookup(&target->rtos->symbols); + target->rtos->type->get_symbol_list_to_lookup( + &target->rtos->symbols); } } } @@ -225,82 +218,63 @@ int rtos_qsymbol(struct connection *connection, char *packet, int packet_size) return -1; } - int rtos_thread_packet(struct connection *connection, char *packet, int packet_size) { struct target *target = get_target_from_connection(connection); - if (strstr(packet, "qThreadExtraInfo,")) - { - if ((target->rtos != NULL) && (target->rtos->thread_details != NULL) && (target->rtos->thread_count != 0)) - { + if (strstr(packet, "qThreadExtraInfo,")) { + if ((target->rtos != NULL) && (target->rtos->thread_details != NULL) && + (target->rtos->thread_count != 0)) { threadid_t threadid = 0; int found = -1; - sscanf(packet, "qThreadExtraInfo,%" SCNx64, &threadid ); + sscanf(packet, "qThreadExtraInfo,%" SCNx64, &threadid); - if ((target->rtos != NULL) && (target->rtos->thread_details - != NULL)) { + if ((target->rtos != NULL) && (target->rtos->thread_details != NULL)) { int thread_num; - for (thread_num = 0; thread_num - < target->rtos->thread_count; thread_num++) { - if (target->rtos->thread_details[thread_num].threadid - == threadid) { - if (target->rtos->thread_details[thread_num].exists) { + for (thread_num = 0; thread_num < target->rtos->thread_count; thread_num++) { + if (target->rtos->thread_details[thread_num].threadid == threadid) { + if (target->rtos->thread_details[thread_num].exists) found = thread_num; - } } } } if (found == -1) { - gdb_put_packet(connection, "E01", 3); // thread not found + gdb_put_packet(connection, "E01", 3); /* thread not found */ return ERROR_OK; } - struct thread_detail* detail = &target->rtos->thread_details[found]; + struct thread_detail *detail = &target->rtos->thread_details[found]; int str_size = 0; - if ( detail->display_str != NULL ) - { + if (detail->display_str != NULL) str_size += strlen(detail->display_str); - } - if ( detail->thread_name_str != NULL ) - { + if (detail->thread_name_str != NULL) str_size += strlen(detail->thread_name_str); - } - if ( detail->extra_info_str != NULL ) - { + if (detail->extra_info_str != NULL) str_size += strlen(detail->extra_info_str); - } - char * tmp_str = (char*) malloc( str_size + 7 ); - char* tmp_str_ptr = tmp_str; + char *tmp_str = (char *) malloc(str_size + 7); + char *tmp_str_ptr = tmp_str; - if ( detail->display_str != NULL ) - { - tmp_str_ptr += sprintf( tmp_str_ptr, "%s", detail->display_str ); - } - if ( detail->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); @@ -310,11 +284,8 @@ int rtos_thread_packet(struct connection *connection, char *packet, int packet_s } gdb_put_packet(connection, "", 0); return ERROR_OK; - } - else if (strstr(packet, "qSymbol")) - { - if (rtos_qsymbol(connection, packet, packet_size) == 1) - { + } else if (strstr(packet, "qSymbol")) { + if (rtos_qsymbol(connection, packet, packet_size) == 1) { target->rtos_auto_detect = false; target->rtos->type->create(target); target->rtos->type->update_threads(target->rtos); @@ -322,91 +293,64 @@ int rtos_thread_packet(struct connection *connection, char *packet, int packet_s gdb_put_packet(connection, "OK", 2); } return ERROR_OK; - } - else if (strstr(packet, "qfThreadInfo")) - { + } else if (strstr(packet, "qfThreadInfo")) { int i; - if ( ( target->rtos != NULL ) && ( target->rtos->thread_count != 0 ) ) - { + if ((target->rtos != NULL) && (target->rtos->thread_count != 0)) { - char* out_str = (char*) malloc(17 * target->rtos->thread_count + 5); - char* tmp_str = out_str; + char *out_str = (char *) malloc(17 * target->rtos->thread_count + 5); + char *tmp_str = out_str; tmp_str += sprintf(tmp_str, "m"); for (i = 0; i < target->rtos->thread_count; i++) { - if (i != 0) { + if (i != 0) tmp_str += sprintf(tmp_str, ","); - } tmp_str += sprintf(tmp_str, "%016" PRIx64, target->rtos->thread_details[i].threadid); } tmp_str[0] = 0; gdb_put_packet(connection, out_str, strlen(out_str)); - } - else - { + } else gdb_put_packet(connection, "", 0); - } return ERROR_OK; - } - else if (strstr(packet, "qsThreadInfo")) - { + } else if (strstr(packet, "qsThreadInfo")) { gdb_put_packet(connection, "l", 1); return ERROR_OK; - } - else if (strstr(packet, "qAttached")) - { + } else if (strstr(packet, "qAttached")) { gdb_put_packet(connection, "1", 1); return ERROR_OK; - } - else if (strstr(packet, "qOffsets")) - { + } else if (strstr(packet, "qOffsets")) { char offsets[] = "Text=0;Data=0;Bss=0"; gdb_put_packet(connection, offsets, sizeof(offsets)-1); return ERROR_OK; - } - else if (strstr(packet, "qC")) - { - if( target->rtos!=NULL ) - { + } else if (strstr(packet, "qC")) { + if (target->rtos != NULL) { char buffer[15]; int size; size = snprintf(buffer, 15, "QC%08X", (int)target->rtos->current_thread); gdb_put_packet(connection, buffer, size); - } - else - { + } else gdb_put_packet(connection, "QC0", 3); - } return ERROR_OK; - } - else if ( packet[0] == 'T' ) // Is thread alive? - { + } else if (packet[0] == 'T') { /* Is thread alive? */ threadid_t threadid; int found = -1; sscanf(packet, "T%" SCNx64, &threadid); - if ((target->rtos != NULL) && (target->rtos->thread_details - != NULL)) { + if ((target->rtos != NULL) && (target->rtos->thread_details != NULL)) { int thread_num; - for (thread_num = 0; thread_num - < target->rtos->thread_count; thread_num++) { - if (target->rtos->thread_details[thread_num].threadid - == threadid) { - if (target->rtos->thread_details[thread_num].exists) { + for (thread_num = 0; thread_num < target->rtos->thread_count; thread_num++) { + if (target->rtos->thread_details[thread_num].threadid == threadid) { + if (target->rtos->thread_details[thread_num].exists) found = thread_num; - } } } } - if (found != -1) { - gdb_put_packet(connection, "OK", 2); // thread alive - } else { - gdb_put_packet(connection, "E01", 3); // thread not found - } + if (found != -1) + gdb_put_packet(connection, "OK", 2); /* thread alive */ + else + gdb_put_packet(connection, "E01", 3); /* thread not found */ return ERROR_OK; - } - else if ( packet[0] == 'H') // Set current thread ( 'c' for step and continue, 'g' for all other operations ) - { + } else if (packet[0] == 'H') { /* Set current thread ( 'c' for step and continue, 'g' for + * all other operations ) */ if ((packet[1] == 'g') && (target->rtos != NULL)) sscanf(packet, "Hg%16" SCNx64, &target->rtos->current_threadid); gdb_put_packet(connection, "OK", 2); @@ -420,17 +364,16 @@ int rtos_get_gdb_reg_list(struct connection *connection) { struct target *target = get_target_from_connection(connection); int64_t current_threadid = target->rtos->current_threadid; - if ((target->rtos != NULL) && - (current_threadid != -1) && - (current_threadid != 0) && - ((current_threadid != target->rtos->current_thread) || - (target->smp))) /* in smp several current thread are possible */ - { - char * hex_reg_list; - target->rtos->type->get_thread_reg_list( target->rtos, current_threadid, &hex_reg_list ); - - if ( 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; @@ -439,103 +382,84 @@ int rtos_get_gdb_reg_list(struct connection *connection) return ERROR_FAIL; } - - -int rtos_generic_stack_read( struct target * target, const struct rtos_register_stacking* stacking, int64_t stack_ptr, char ** hex_reg_list ) +int rtos_generic_stack_read(struct target *target, + const struct rtos_register_stacking *stacking, + int64_t stack_ptr, + char **hex_reg_list) { int list_size = 0; - char * tmp_str_ptr; + char *tmp_str_ptr; int64_t new_stack_ptr; int i; int retval; - if ( stack_ptr == 0) - { + if (stack_ptr == 0) { LOG_OUTPUT("Error: null stack pointer in thread\r\n"); return -5; } - // Read the stack - uint8_t * stack_data = (uint8_t*) malloc( stacking->stack_registers_size ); + /* Read the stack */ + uint8_t *stack_data = (uint8_t *) malloc(stacking->stack_registers_size); uint32_t address = stack_ptr; - if ( stacking->stack_growth_direction == 1 ) - { - address -= stacking->stack_registers_size; - } - retval = target_read_buffer( target, address, stacking->stack_registers_size, stack_data); - if ( retval != ERROR_OK ) - { + if (stacking->stack_growth_direction == 1) + address -= stacking->stack_registers_size; + retval = target_read_buffer(target, address, stacking->stack_registers_size, stack_data); + if (retval != ERROR_OK) { LOG_OUTPUT("Error reading stack frame from FreeRTOS thread\r\n"); return retval; } -/* - LOG_OUTPUT("Stack Data :"); - for(i = 0; i < stacking->stack_registers_size; i++ ) - { - LOG_OUTPUT("%02X",stack_data[i]); - } - LOG_OUTPUT("\r\n"); -*/ - for( i = 0; i < stacking->num_output_registers; i++ ) - { +#if 0 + LOG_OUTPUT("Stack Data :"); + for (i = 0; i < stacking->stack_registers_size; i++) + LOG_OUTPUT("%02X", stack_data[i]); + LOG_OUTPUT("\r\n"); +#endif + for (i = 0; i < stacking->num_output_registers; i++) list_size += stacking->register_offsets[i].width_bits/8; - } - *hex_reg_list = (char*)malloc( list_size*2 +1 ); + *hex_reg_list = (char *)malloc(list_size*2 + 1); tmp_str_ptr = *hex_reg_list; - new_stack_ptr = stack_ptr - stacking->stack_growth_direction * stacking->stack_registers_size; + new_stack_ptr = stack_ptr - stacking->stack_growth_direction * + stacking->stack_registers_size; if (stacking->stack_alignment != 0) { /* Align new stack pointer to x byte boundary */ new_stack_ptr = (new_stack_ptr & (~((int64_t) stacking->stack_alignment - 1))) + ((stacking->stack_growth_direction == -1) ? stacking->stack_alignment : 0); } - for( i = 0; i < stacking->num_output_registers; i++ ) - { + for (i = 0; i < stacking->num_output_registers; i++) { int j; - for ( j = 0; j < stacking->register_offsets[i].width_bits/8; j++ ) - { - if ( stacking->register_offsets[i].offset == -1 ) - { - tmp_str_ptr += sprintf( tmp_str_ptr, "%02x", 0 ); - } - else if ( stacking->register_offsets[i].offset == -2 ) - { - tmp_str_ptr += sprintf( tmp_str_ptr, "%02x", ((uint8_t*)&new_stack_ptr)[j] ); - } + for (j = 0; j < stacking->register_offsets[i].width_bits/8; j++) { + if (stacking->register_offsets[i].offset == -1) + tmp_str_ptr += sprintf(tmp_str_ptr, "%02x", 0); + else if (stacking->register_offsets[i].offset == -2) + tmp_str_ptr += sprintf(tmp_str_ptr, "%02x", + ((uint8_t *)&new_stack_ptr)[j]); else - { - tmp_str_ptr += sprintf( tmp_str_ptr,"%02x", stack_data[ stacking->register_offsets[i].offset + j ] ); - } + tmp_str_ptr += sprintf(tmp_str_ptr, "%02x", + stack_data[stacking->register_offsets[i].offset + j]); } } -// LOG_OUTPUT("Output register string: %s\r\n", *hex_reg_list); +/* LOG_OUTPUT("Output register string: %s\r\n", *hex_reg_list); */ return ERROR_OK; } -int rtos_try_next( struct target * target ) +int rtos_try_next(struct target *target) { int x; - if ( target->rtos == NULL ) - { + if (target->rtos == NULL) return -1; - } - for (x = 0 ; rtos_types[x] ; x++) { - if (target->rtos->type == rtos_types[x] ) { + for (x = 0; rtos_types[x]; x++) { + if (target->rtos->type == rtos_types[x]) { /* found */ - if ( rtos_types[x+1] != NULL ) - { + if (rtos_types[x+1] != NULL) { target->rtos->type = rtos_types[x+1]; - if ( target->rtos->symbols != NULL ) - { - free( target->rtos->symbols ); - } + if (target->rtos->symbols != NULL) + free(target->rtos->symbols); return 1; - } - else - { - // No more rtos types + } else { + /* No more rtos types */ return 0; } @@ -545,24 +469,23 @@ int rtos_try_next( struct target * target ) } -static void hex_to_str( char* dst, char * hex_src ) +static void hex_to_str(char *dst, char *hex_src) { int src_pos = 0; int dst_pos = 0; - while ( hex_src[src_pos] != '\x00' ) - { + while (hex_src[src_pos] != '\x00') { char hex_char = hex_src[src_pos]; - char hex_digit_val = (hex_char>='a')?hex_char-'a'+10:(hex_char>='A')?hex_char-'A'+10:hex_char-'0'; - if ( 0 == (src_pos & 0x01) ) - { + char hex_digit_val = + (hex_char >= + 'a') ? hex_char-'a'+ + 10 : (hex_char >= 'A') ? hex_char-'A'+10 : hex_char-'0'; + if (0 == (src_pos & 0x01)) { dst[dst_pos] = hex_digit_val; dst[dst_pos+1] = 0; - } - else - { - ((unsigned char*)dst)[dst_pos] <<= 4; - ((unsigned char*)dst)[dst_pos] += hex_digit_val; + } else { + ((unsigned char *)dst)[dst_pos] <<= 4; + ((unsigned char *)dst)[dst_pos] += hex_digit_val; dst_pos++; } src_pos++; @@ -572,21 +495,16 @@ static void hex_to_str( char* dst, char * hex_src ) int str_to_hex(char *hex_dst, char *src) { - char * posptr = hex_dst; + char *posptr = hex_dst; unsigned i; - for( i = 0; i < strlen(src); i++) - { - posptr += sprintf( posptr, "%02x", (unsigned char)src[i] ); - } - return (posptr-hex_dst); + for (i = 0; i < strlen(src); i++) + posptr += sprintf(posptr, "%02x", (unsigned char)src[i]); + return posptr - hex_dst; } - -int rtos_update_threads( struct target* target ) +int rtos_update_threads(struct target *target) { if ((target->rtos != NULL) && (target->rtos->type != NULL)) - { target->rtos->type->update_threads(target->rtos); - } return ERROR_OK; } diff --git a/src/rtos/rtos.h b/src/rtos/rtos.h index 80ba0e2..a93daee 100644 --- a/src/rtos/rtos.h +++ b/src/rtos/rtos.h @@ -21,7 +21,6 @@ #ifndef RTOS_H #define RTOS_H - #include "server/server.h" #include <helper/types.h> #include <jim-nvp.h> @@ -34,83 +33,75 @@ struct reg; /** * Table should be terminated by an element with NULL in symbol_name */ -typedef struct symbol_table_elem_struct -{ - char * symbol_name; +typedef struct symbol_table_elem_struct { + char *symbol_name; symbol_address_t address; } symbol_table_elem_t; -struct thread_detail -{ +struct thread_detail { threadid_t threadid; bool exists; - char * display_str; - char * thread_name_str; - char * extra_info_str; + char *display_str; + char *thread_name_str; + char *extra_info_str; }; -struct rtos -{ +struct rtos { const struct rtos_type *type; - - symbol_table_elem_t * symbols; + symbol_table_elem_t *symbols; struct target *target; /* add a context variable instead of global variable */ int64_t current_threadid; threadid_t current_thread; - struct thread_detail* thread_details; + struct thread_detail *thread_details; int thread_count; int (*gdb_thread_packet)(struct connection *connection, char *packet, int packet_size); - void * rtos_specific_params; - - + void *rtos_specific_params; }; - - -struct rtos_type -{ - char * name; - int (*detect_rtos) ( struct target* target ); - int (*create) ( struct target* target ); +struct rtos_type { + char *name; + int (*detect_rtos)(struct target *target); + int (*create)(struct target *target); int (*smp_init)(struct target *target); - int (*update_threads) ( struct rtos* rtos ); - int (*get_thread_reg_list) ( struct rtos *rtos, int64_t thread_id, char ** hex_reg_list ); - int (*get_symbol_list_to_lookup) (symbol_table_elem_t * symbol_list[] ); + int (*update_threads)(struct rtos *rtos); + int (*get_thread_reg_list)(struct rtos *rtos, int64_t thread_id, char **hex_reg_list); + int (*get_symbol_list_to_lookup)(symbol_table_elem_t *symbol_list[]); int (*clean)(struct target *target); char * (*ps_command)(struct target *target); }; - -struct stack_register_offset -{ - signed short offset; // offset in bytes from stack head, or -1 to indicate register is not stacked, or -2 to indicate this is the stack pointer register +struct stack_register_offset { + signed short offset; /* offset in bytes from stack head, or -1 to indicate + * register is not stacked, or -2 to indicate this is the + * stack pointer register */ unsigned short width_bits; - }; -struct rtos_register_stacking -{ - unsigned char stack_registers_size; - signed char stack_growth_direction; - unsigned char num_output_registers; - unsigned char stack_alignment; - const struct stack_register_offset* register_offsets; +struct rtos_register_stacking { + unsigned char stack_registers_size; + signed char stack_growth_direction; + unsigned char num_output_registers; + unsigned char stack_alignment; + const struct stack_register_offset *register_offsets; }; #define GDB_THREAD_PACKET_NOT_CONSUMED (-40) -int rtos_create(Jim_GetOptInfo *goi, struct target * target); -int rtos_generic_stack_read( struct target * target, const struct rtos_register_stacking* stacking, int64_t stack_ptr, char ** hex_reg_list ); -int rtos_try_next( struct target * target ); +int rtos_create(Jim_GetOptInfo *goi, struct target *target); +int rtos_generic_stack_read(struct target *target, + const struct rtos_register_stacking *stacking, + int64_t stack_ptr, + char **hex_reg_list); +int rtos_try_next(struct target *target); int gdb_thread_packet(struct connection *connection, char *packet, int packet_size); int rtos_get_gdb_reg_list(struct connection *connection); -int rtos_update_threads( struct target *target ); +int rtos_update_threads(struct target *target); int rtos_smp_init(struct target *target); /* function for handling symbol access */ int rtos_qsymbol(struct connection *connection, char *packet, int packet_size); int str_to_hex(char *hex_dst, char *src); -#endif // RTOS_H +#endif /* RTOS_H */ diff --git a/src/rtos/rtos_ecos_stackings.c b/src/rtos/rtos_ecos_stackings.c index 995c113..4f9c405 100644 --- a/src/rtos/rtos_ecos_stackings.c +++ b/src/rtos/rtos_ecos_stackings.c @@ -23,42 +23,38 @@ #include "rtos.h" static const struct stack_register_offset rtos_eCos_Cortex_M3_stack_offsets[] = { - { 0x0c, 32 }, /* r0 */ - { 0x10, 32 }, /* r1 */ - { 0x14, 32 }, /* r2 */ - { 0x18, 32 }, /* r3 */ - { 0x1c, 32 }, /* r4 */ - { 0x20, 32 }, /* r5 */ - { 0x24, 32 }, /* r6 */ - { 0x28, 32 }, /* r7 */ - { 0x2c, 32 }, /* r8 */ - { 0x30, 32 }, /* r9 */ - { 0x34, 32 }, /* r10 */ - { 0x38, 32 }, /* r11 */ - { 0x3c, 32 }, /* r12 */ - { -2, 32 }, /* sp */ - { -1, 32 }, /* lr */ - { 0x40, 32 }, /* pc */ - { -1, 96 }, /* FPA1 */ - { -1, 96 }, /* FPA2 */ - { -1, 96 }, /* FPA3 */ - { -1, 96 }, /* FPA4 */ - { -1, 96 }, /* FPA5 */ - { -1, 96 }, /* FPA6 */ - { -1, 96 }, /* FPA7 */ - { -1, 96 }, /* FPA8 */ - { -1, 32 }, /* FPS */ - { -1, 32 }, /* xPSR */ + { 0x0c, 32 }, /* r0 */ + { 0x10, 32 }, /* r1 */ + { 0x14, 32 }, /* r2 */ + { 0x18, 32 }, /* r3 */ + { 0x1c, 32 }, /* r4 */ + { 0x20, 32 }, /* r5 */ + { 0x24, 32 }, /* r6 */ + { 0x28, 32 }, /* r7 */ + { 0x2c, 32 }, /* r8 */ + { 0x30, 32 }, /* r9 */ + { 0x34, 32 }, /* r10 */ + { 0x38, 32 }, /* r11 */ + { 0x3c, 32 }, /* r12 */ + { -2, 32 }, /* sp */ + { -1, 32 }, /* lr */ + { 0x40, 32 }, /* pc */ + { -1, 96 }, /* FPA1 */ + { -1, 96 }, /* FPA2 */ + { -1, 96 }, /* FPA3 */ + { -1, 96 }, /* FPA4 */ + { -1, 96 }, /* FPA5 */ + { -1, 96 }, /* FPA6 */ + { -1, 96 }, /* FPA7 */ + { -1, 96 }, /* FPA8 */ + { -1, 32 }, /* FPS */ + { -1, 32 }, /* xPSR */ }; - -const struct rtos_register_stacking rtos_eCos_Cortex_M3_stacking = -{ - 0x44, /* stack_registers_size */ - -1, /* stack_growth_direction */ - 26, /* num_output_registers */ - 8, /* stack_alignment */ - rtos_eCos_Cortex_M3_stack_offsets /* register_offsets */ +const struct rtos_register_stacking rtos_eCos_Cortex_M3_stacking = { + 0x44, /* stack_registers_size */ + -1, /* stack_growth_direction */ + 26, /* num_output_registers */ + 8, /* stack_alignment */ + rtos_eCos_Cortex_M3_stack_offsets /* register_offsets */ }; - - diff --git a/src/rtos/rtos_ecos_stackings.h b/src/rtos/rtos_ecos_stackings.h index 82f0855..034251c 100644 --- a/src/rtos/rtos_ecos_stackings.h +++ b/src/rtos/rtos_ecos_stackings.h @@ -27,4 +27,4 @@ extern const struct rtos_register_stacking rtos_eCos_Cortex_M3_stacking; -#endif //ifndef INCLUDED_RTOS_STANDARD_STACKINGS_H_ +#endif /* ifndef INCLUDED_RTOS_STANDARD_STACKINGS_H_ */ diff --git a/src/rtos/rtos_standard_stackings.c b/src/rtos/rtos_standard_stackings.c index 278d3ef..30d9cd9 100644 --- a/src/rtos/rtos_standard_stackings.c +++ b/src/rtos/rtos_standard_stackings.c @@ -25,42 +25,38 @@ #include "rtos.h" static const struct stack_register_offset rtos_standard_Cortex_M3_stack_offsets[] = { - { 0x20, 32 }, /* r0 */ - { 0x24, 32 }, /* r1 */ - { 0x28, 32 }, /* r2 */ - { 0x2c, 32 }, /* r3 */ - { 0x00, 32 }, /* r4 */ - { 0x04, 32 }, /* r5 */ - { 0x08, 32 }, /* r6 */ - { 0x0c, 32 }, /* r7 */ - { 0x10, 32 }, /* r8 */ - { 0x14, 32 }, /* r9 */ - { 0x18, 32 }, /* r10 */ - { 0x1c, 32 }, /* r11 */ - { 0x30, 32 }, /* r12 */ - { -2, 32 }, /* sp */ - { 0x34, 32 }, /* lr */ - { 0x38, 32 }, /* pc */ - { -1, 96 }, /* FPA1 */ - { -1, 96 }, /* FPA2 */ - { -1, 96 }, /* FPA3 */ - { -1, 96 }, /* FPA4 */ - { -1, 96 }, /* FPA5 */ - { -1, 96 }, /* FPA6 */ - { -1, 96 }, /* FPA7 */ - { -1, 96 }, /* FPA8 */ - { -1, 32 }, /* FPS */ - { 0x3c, 32 }, /* xPSR */ + { 0x20, 32 }, /* r0 */ + { 0x24, 32 }, /* r1 */ + { 0x28, 32 }, /* r2 */ + { 0x2c, 32 }, /* r3 */ + { 0x00, 32 }, /* r4 */ + { 0x04, 32 }, /* r5 */ + { 0x08, 32 }, /* r6 */ + { 0x0c, 32 }, /* r7 */ + { 0x10, 32 }, /* r8 */ + { 0x14, 32 }, /* r9 */ + { 0x18, 32 }, /* r10 */ + { 0x1c, 32 }, /* r11 */ + { 0x30, 32 }, /* r12 */ + { -2, 32 }, /* sp */ + { 0x34, 32 }, /* lr */ + { 0x38, 32 }, /* pc */ + { -1, 96 }, /* FPA1 */ + { -1, 96 }, /* FPA2 */ + { -1, 96 }, /* FPA3 */ + { -1, 96 }, /* FPA4 */ + { -1, 96 }, /* FPA5 */ + { -1, 96 }, /* FPA6 */ + { -1, 96 }, /* FPA7 */ + { -1, 96 }, /* FPA8 */ + { -1, 32 }, /* FPS */ + { 0x3c, 32 }, /* xPSR */ }; - -const struct rtos_register_stacking rtos_standard_Cortex_M3_stacking = -{ - 0x40, /* stack_registers_size */ - -1, /* stack_growth_direction */ - 26, /* num_output_registers */ - 8, /* stack_alignment */ - rtos_standard_Cortex_M3_stack_offsets /* register_offsets */ +const struct rtos_register_stacking rtos_standard_Cortex_M3_stacking = { + 0x40, /* stack_registers_size */ + -1, /* stack_growth_direction */ + 26, /* num_output_registers */ + 8, /* stack_alignment */ + rtos_standard_Cortex_M3_stack_offsets /* register_offsets */ }; - - diff --git a/src/rtos/rtos_standard_stackings.h b/src/rtos/rtos_standard_stackings.h index 1e8568c..9f26b8e 100644 --- a/src/rtos/rtos_standard_stackings.h +++ b/src/rtos/rtos_standard_stackings.h @@ -29,4 +29,4 @@ extern const struct rtos_register_stacking rtos_standard_Cortex_M3_stacking; -#endif //ifndef INCLUDED_RTOS_STANDARD_STACKINGS_H_ +#endif /* ifndef INCLUDED_RTOS_STANDARD_STACKINGS_H_ */ |