]> git.sur5r.net Git - openocd/commitdiff
build: cleanup src/rtos directory
authorSpencer Oliver <spen@spen-soft.co.uk>
Mon, 30 Jan 2012 15:32:53 +0000 (15:32 +0000)
committerSpencer Oliver <spen@spen-soft.co.uk>
Mon, 6 Feb 2012 10:50:26 +0000 (10:50 +0000)
Change-Id: I24bc62d12409dbfc20a0a986acf6b3f2c913e36d
Signed-off-by: Spencer Oliver <spen@spen-soft.co.uk>
Reviewed-on: http://openocd.zylin.com/416
Tested-by: jenkins
src/rtos/FreeRTOS.c
src/rtos/ThreadX.c
src/rtos/eCos.c
src/rtos/linux.c
src/rtos/rtos.c
src/rtos/rtos.h
src/rtos/rtos_ecos_stackings.c
src/rtos/rtos_ecos_stackings.h
src/rtos/rtos_standard_stackings.c
src/rtos/rtos_standard_stackings.h

index eeab1341dba3671c2a2782ab0c7684ebca91fbcf..c7b46434ba8102823fcb71d0effb25f5b9ce3dc1 100644 (file)
@@ -18,7 +18,6 @@
  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  ***************************************************************************/
 
-
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 #include "helper/log.h"
 #include "rtos_standard_stackings.h"
 
-#define FreeRTOS_STRUCT( int_type, ptr_type, list_prev_offset )
-
-
-struct FreeRTOS_params
-{
-       const char *                         target_name;
-       const unsigned char                  thread_count_width;
-       const unsigned char                  pointer_width;
-       const unsigned char                  list_next_offset;
-       const unsigned char                  list_width;
-       const unsigned char                  list_elem_next_offset;
-       const unsigned char                  list_elem_content_offset;
-       const unsigned char                  thread_stack_offset;
-       const unsigned char                  thread_name_offset;
-       const struct rtos_register_stacking* stacking_info;
+#define FreeRTOS_STRUCT(int_type, ptr_type, list_prev_offset)
+
+struct FreeRTOS_params {
+       const char *target_name;
+       const unsigned char thread_count_width;
+       const unsigned char pointer_width;
+       const unsigned char list_next_offset;
+       const unsigned char list_width;
+       const unsigned char list_elem_next_offset;
+       const unsigned char list_elem_content_offset;
+       const unsigned char thread_stack_offset;
+       const unsigned char thread_name_offset;
+       const struct rtos_register_stacking *stacking_info;
 };
 
-
-
-
-const struct FreeRTOS_params FreeRTOS_params_list[] =
-{
-               { "cortex_m3",                      // target_name
-          4,                                // thread_count_width;
-          4,                                // pointer_width;
-          16,                               // list_next_offset;
-          20,                               // list_width;
-          8,                                // list_elem_next_offset;
-          12,                               // list_elem_content_offset
-          0,                                // thread_stack_offset;
-          52,                               // thread_name_offset;
-          &rtos_standard_Cortex_M3_stacking, // stacking_info
-               }
-
+const struct FreeRTOS_params FreeRTOS_params_list[] = {
+       {
+       "cortex_m3",                    /* target_name */
+       4,                                              /* thread_count_width; */
+       4,                                              /* pointer_width; */
+       16,                                             /* list_next_offset; */
+       20,                                             /* list_width; */
+       8,                                              /* list_elem_next_offset; */
+       12,                                             /* list_elem_content_offset */
+       0,                                              /* thread_stack_offset; */
+       52,                                             /* thread_name_offset; */
+       &rtos_standard_Cortex_M3_stacking,      /* stacking_info */
+       }
 };
 
-
 #define FREERTOS_NUM_PARAMS ((int)(sizeof(FreeRTOS_params_list)/sizeof(struct FreeRTOS_params)))
 
-static int FreeRTOS_detect_rtos( struct target* target );
-static int FreeRTOS_create( struct target* target );
-static int FreeRTOS_update_threads( struct rtos *rtos );
-static int FreeRTOS_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, char ** hex_reg_list );
-static int FreeRTOS_get_symbol_list_to_lookup(symbol_table_elem_t * symbol_list[]);
-
-
+static int FreeRTOS_detect_rtos(struct target *target);
+static int FreeRTOS_create(struct target *target);
+static int FreeRTOS_update_threads(struct rtos *rtos);
+static int FreeRTOS_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, char **hex_reg_list);
+static int FreeRTOS_get_symbol_list_to_lookup(symbol_table_elem_t *symbol_list[]);
 
+struct rtos_type FreeRTOS_rtos = {
+       .name = "FreeRTOS",
 
-struct rtos_type FreeRTOS_rtos =
-{
-       .name                       = "FreeRTOS",
-
-       .detect_rtos                = FreeRTOS_detect_rtos,
-       .create                     = FreeRTOS_create,
-       .update_threads            = FreeRTOS_update_threads,
-       .get_thread_reg_list        = FreeRTOS_get_thread_reg_list,
-       .get_symbol_list_to_lookup  = FreeRTOS_get_symbol_list_to_lookup,
+       .detect_rtos = FreeRTOS_detect_rtos,
+       .create = FreeRTOS_create,
+       .update_threads = FreeRTOS_update_threads,
+       .get_thread_reg_list = FreeRTOS_get_thread_reg_list,
+       .get_symbol_list_to_lookup = FreeRTOS_get_symbol_list_to_lookup,
 };
 
-enum FreeRTOS_symbol_values
-{
-       FreeRTOS_VAL_pxCurrentTCB              = 0,
-       FreeRTOS_VAL_pxReadyTasksLists         = 1,
-       FreeRTOS_VAL_xDelayedTaskList1         = 2,
-       FreeRTOS_VAL_xDelayedTaskList2         = 3,
-       FreeRTOS_VAL_pxDelayedTaskList         = 4,
+enum FreeRTOS_symbol_values {
+       FreeRTOS_VAL_pxCurrentTCB = 0,
+       FreeRTOS_VAL_pxReadyTasksLists = 1,
+       FreeRTOS_VAL_xDelayedTaskList1 = 2,
+       FreeRTOS_VAL_xDelayedTaskList2 = 3,
+       FreeRTOS_VAL_pxDelayedTaskList = 4,
        FreeRTOS_VAL_pxOverflowDelayedTaskList = 5,
-       FreeRTOS_VAL_xPendingReadyList         = 6,
-       FreeRTOS_VAL_xTasksWaitingTermination  = 7,
-       FreeRTOS_VAL_xSuspendedTaskList        = 8,
-       FreeRTOS_VAL_uxCurrentNumberOfTasks    = 9,
-       FreeRTOS_VAL_uxTopUsedPriority         = 10,
+       FreeRTOS_VAL_xPendingReadyList = 6,
+       FreeRTOS_VAL_xTasksWaitingTermination = 7,
+       FreeRTOS_VAL_xSuspendedTaskList = 8,
+       FreeRTOS_VAL_uxCurrentNumberOfTasks = 9,
+       FreeRTOS_VAL_uxTopUsedPriority = 10,
 };
 
-static char* FreeRTOS_symbol_list[] =
-{
-               "pxCurrentTCB",
-               "pxReadyTasksLists",
-               "xDelayedTaskList1",
-               "xDelayedTaskList2",
-               "pxDelayedTaskList",
-               "pxOverflowDelayedTaskList",
-               "xPendingReadyList",
-               "xTasksWaitingTermination",
-               "xSuspendedTaskList",
-               "uxCurrentNumberOfTasks",
-               "uxTopUsedPriority",
-               NULL
+static char *FreeRTOS_symbol_list[] = {
+       "pxCurrentTCB",
+       "pxReadyTasksLists",
+       "xDelayedTaskList1",
+       "xDelayedTaskList2",
+       "pxDelayedTaskList",
+       "pxOverflowDelayedTaskList",
+       "xPendingReadyList",
+       "xTasksWaitingTermination",
+       "xSuspendedTaskList",
+       "uxCurrentNumberOfTasks",
+       "uxTopUsedPriority",
+       NULL
 };
 
-#define FREERTOS_NUM_SYMBOLS (sizeof(FreeRTOS_symbol_list)/sizeof(char*))
+#define FREERTOS_NUM_SYMBOLS (sizeof(FreeRTOS_symbol_list)/sizeof(char *))
 
-// TODO:
-// this is not safe for little endian yet
-// may be problems reading if sizes are not 32 bit long integers.
-// test mallocs for failure
+/* TODO: */
+/* this is not safe for little endian yet */
+/* may be problems reading if sizes are not 32 bit long integers. */
+/* test mallocs for failure */
 
-static int FreeRTOS_update_threads( struct rtos *rtos )
+static int FreeRTOS_update_threads(struct rtos *rtos)
 {
        int i = 0;
        int retval;
        int tasks_found = 0;
-       const struct FreeRTOS_paramsparam;
+       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_paramsparam;
+       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_paramsparam;
+       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;
 }
-
index 1ce47a23dcb10b2e96672f6da4672c14280b3435..a9e313bf2ef44bbe1ae2c4ca6ed45c6d086e07f0 100644 (file)
 #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_paramsparam;
+       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_paramsparam;
+       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_paramsparam;
+       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;
index cd04d9d94ffa861b4cb91ab0a95caf0096a9f86b..5c18916a12ee58908413bd4410f8ede84cb08d7c 100644 (file)
 #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_paramsparam;
+       const struct eCos_params *param;
 
-       if ( rtos == NULL )
-       {
+       if (rtos == NULL)
                return -1;
-       }
 
-       if (rtos->rtos_specific_params == NULL )
-       {
+       if (rtos->rtos_specific_params == NULL)
                return -3;
-       }
 
-       param = (const struct eCos_params*) rtos->rtos_specific_params;
+       param = (const struct eCos_params *) rtos->rtos_specific_params;
 
-       if ( rtos->symbols == NULL )
-       {
+       if (rtos->symbols == NULL) {
                LOG_OUTPUT("No symbols for eCos\r\n");
                return -4;
        }
 
-       if ( rtos->symbols[eCos_VAL_thread_list].address == 0 )
-       {
+       if (rtos->symbols[eCos_VAL_thread_list].address == 0) {
                LOG_OUTPUT("Don't have the thread list head\r\n");
                return -2;
        }
 
-
-       // wipe out previous thread details if any
-       if ( rtos->thread_details != NULL )
-       {
+       /* wipe out previous thread details if any */
+       if (rtos->thread_details != NULL) {
                int j;
-               for( j = 0; j < rtos->thread_count; j++ )
-               {
-                       if ( rtos->thread_details[j].display_str != NULL )
-                       {
-                               free( rtos->thread_details[j].display_str );
+               for (j = 0; j < rtos->thread_count; j++) {
+                       if (rtos->thread_details[j].display_str != NULL) {
+                               free(rtos->thread_details[j].display_str);
                                rtos->thread_details[j].display_str = NULL;
                        }
-                       if ( rtos->thread_details[j].thread_name_str != NULL )
-                       {
-                               free( rtos->thread_details[j].thread_name_str );
+                       if (rtos->thread_details[j].thread_name_str != NULL) {
+                               free(rtos->thread_details[j].thread_name_str);
                                rtos->thread_details[j].thread_name_str = NULL;
                        }
-                       if ( rtos->thread_details[j].extra_info_str != NULL )
-                       {
-                               free( rtos->thread_details[j].extra_info_str );
+                       if (rtos->thread_details[j].extra_info_str != NULL) {
+                               free(rtos->thread_details[j].extra_info_str);
                                rtos->thread_details[j].extra_info_str = NULL;
                        }
                }
-               free( rtos->thread_details );
+               free(rtos->thread_details);
                rtos->thread_details = NULL;
        }
 
-
-       // determine the number of current threads
+       /* determine the number of current threads */
        uint32_t thread_list_head = rtos->symbols[eCos_VAL_thread_list].address;
        uint32_t thread_index;
-       target_read_buffer( rtos->target, thread_list_head, param->pointer_width, (uint8_t *) &thread_index );
+       target_read_buffer(rtos->target,
+               thread_list_head,
+               param->pointer_width,
+               (uint8_t *) &thread_index);
        uint32_t first_thread = thread_index;
-       do
-       {
+       do {
                thread_list_size++;
-               retval = target_read_buffer( rtos->target, thread_index + param->thread_next_offset, param->pointer_width, (uint8_t *) &thread_index );
+               retval = target_read_buffer(rtos->target,
+                               thread_index + param->thread_next_offset,
+                               param->pointer_width,
+                               (uint8_t *) &thread_index);
                if (retval != ERROR_OK)
                        return retval;
-       } while( thread_index!=first_thread );
+       } while (thread_index != first_thread);
 
-       // read the current thread id
+       /* read the current thread id */
        uint32_t current_thread_addr;
-       retval = target_read_buffer( rtos->target, rtos->symbols[eCos_VAL_current_thread_ptr].address, 4, (uint8_t *)&current_thread_addr);
+       retval = target_read_buffer(rtos->target,
+                       rtos->symbols[eCos_VAL_current_thread_ptr].address,
+                       4,
+                       (uint8_t *)&current_thread_addr);
        if (retval != ERROR_OK)
                return retval;
        rtos->current_thread = 0;
-       retval = target_read_buffer( rtos->target, current_thread_addr + param->thread_uniqueid_offset, 2, (uint8_t *)&rtos->current_thread);
-       if ( retval != ERROR_OK )
-       {
+       retval = target_read_buffer(rtos->target,
+                       current_thread_addr + param->thread_uniqueid_offset,
+                       2,
+                       (uint8_t *)&rtos->current_thread);
+       if (retval != ERROR_OK) {
                LOG_OUTPUT("Could not read eCos current thread from target\r\n");
                return retval;
        }
 
-       if ( ( thread_list_size  == 0 ) || ( rtos->current_thread == 0 ) )
-       {
-               // Either : No RTOS threads - there is always at least the current execution though
-               // OR     : No current thread - all threads suspended - show the current execution of idling
+       if ((thread_list_size  == 0) || (rtos->current_thread == 0)) {
+               /* Either : No RTOS threads - there is always at least the current execution though */
+               /* OR     : No current thread - all threads suspended - show the current execution
+                * of idling */
                char tmp_str[] = "Current Execution";
                thread_list_size++;
                tasks_found++;
-               rtos->thread_details = (struct thread_detail*) malloc( sizeof( struct thread_detail ) * thread_list_size );
+               rtos->thread_details = (struct thread_detail *) malloc(
+                               sizeof(struct thread_detail) * thread_list_size);
                rtos->thread_details->threadid = 1;
                rtos->thread_details->exists = true;
                rtos->thread_details->display_str = NULL;
                rtos->thread_details->extra_info_str = NULL;
-               rtos->thread_details->thread_name_str = (char*) malloc( sizeof(tmp_str) );
-               strcpy( rtos->thread_details->thread_name_str, tmp_str );
-
+               rtos->thread_details->thread_name_str = (char *) malloc(sizeof(tmp_str));
+               strcpy(rtos->thread_details->thread_name_str, tmp_str);
 
-               if ( thread_list_size == 0 )
-               {
+               if (thread_list_size == 0) {
                        rtos->thread_count = 1;
                        return ERROR_OK;
                }
-       }
-       else
-       {
-               // create space for new thread details
-               rtos->thread_details = (struct thread_detail*) malloc( sizeof( struct thread_detail ) * thread_list_size );
+       } else {
+               /* create space for new thread details */
+               rtos->thread_details = (struct thread_detail *) malloc(
+                               sizeof(struct thread_detail) * thread_list_size);
        }
 
-       // loop over all threads
+       /* loop over all threads */
        thread_index = first_thread;
-       do
-       {
+       do {
 
                #define ECOS_THREAD_NAME_STR_SIZE (200)
                char tmp_str[ECOS_THREAD_NAME_STR_SIZE];
@@ -235,196 +218,198 @@ static int eCos_update_threads( struct rtos* rtos)
                uint32_t name_ptr = 0;
                uint32_t prev_thread_ptr;
 
-               // Save the thread pointer
+               /* Save the thread pointer */
                uint16_t thread_id;
-               retval = target_read_buffer( rtos->target, thread_index + param->thread_uniqueid_offset, 2, (uint8_t *)&thread_id);
-               if ( retval != ERROR_OK )
-               {
+               retval = target_read_buffer(rtos->target,
+                               thread_index + param->thread_uniqueid_offset,
+                               2,
+                               (uint8_t *)&thread_id);
+               if (retval != ERROR_OK) {
                        LOG_OUTPUT("Could not read eCos thread id from target\r\n");
                        return retval;
                }
                rtos->thread_details[tasks_found].threadid = thread_id;
 
-               // read the name pointer
-               retval = target_read_buffer( rtos->target, thread_index + param->thread_name_offset, param->pointer_width, (uint8_t *)&name_ptr);
-               if ( retval != ERROR_OK )
-               {
+               /* read the name pointer */
+               retval = target_read_buffer(rtos->target,
+                               thread_index + param->thread_name_offset,
+                               param->pointer_width,
+                               (uint8_t *)&name_ptr);
+               if (retval != ERROR_OK) {
                        LOG_OUTPUT("Could not read eCos thread name pointer from target\r\n");
                        return retval;
                }
 
-               // Read the thread name
-               retval = target_read_buffer( rtos->target, name_ptr, ECOS_THREAD_NAME_STR_SIZE, (uint8_t *)&tmp_str);
-               if ( retval != ERROR_OK )
-               {
+               /* Read the thread name */
+               retval =
+                       target_read_buffer(rtos->target,
+                               name_ptr,
+                               ECOS_THREAD_NAME_STR_SIZE,
+                               (uint8_t *)&tmp_str);
+               if (retval != ERROR_OK) {
                        LOG_OUTPUT("Error reading thread name from eCos target\r\n");
                        return retval;
                }
                tmp_str[ECOS_THREAD_NAME_STR_SIZE-1] = '\x00';
 
-               if ( tmp_str[0] == '\x00' )
-               {
-                       strcpy(tmp_str,"No Name");
-               }
+               if (tmp_str[0] == '\x00')
+                       strcpy(tmp_str, "No Name");
 
-               rtos->thread_details[tasks_found].thread_name_str = (char*)malloc( strlen(tmp_str)+1 );
-               strcpy( rtos->thread_details[tasks_found].thread_name_str, tmp_str );
+               rtos->thread_details[tasks_found].thread_name_str =
+                       (char *)malloc(strlen(tmp_str)+1);
+               strcpy(rtos->thread_details[tasks_found].thread_name_str, tmp_str);
 
-               // Read the thread status
+               /* Read the thread status */
                int64_t thread_status = 0;
-               retval = target_read_buffer( rtos->target, thread_index + param->thread_state_offset, 4, (uint8_t *)&thread_status);
-               if ( retval != ERROR_OK )
-               {
+               retval = target_read_buffer(rtos->target,
+                               thread_index + param->thread_state_offset,
+                               4,
+                               (uint8_t *)&thread_status);
+               if (retval != ERROR_OK) {
                        LOG_OUTPUT("Error reading thread state from eCos target\r\n");
                        return retval;
                }
 
-               for( i = 0; (i < ECOS_NUM_STATES) && (eCos_thread_states[i].value!=thread_status); i++ )
-               {
+               for (i = 0; (i < ECOS_NUM_STATES) && (eCos_thread_states[i].value != thread_status); i++) {
+                       /*
+                        * empty
+                        */
                }
 
-               char * state_desc;
+               char *state_desc;
                if  (i < ECOS_NUM_STATES)
-               {
                        state_desc = eCos_thread_states[i].desc;
-               }
                else
-               {
                        state_desc = "Unknown state";
-               }
 
-               rtos->thread_details[tasks_found].extra_info_str = (char*)malloc( strlen(state_desc)+1 );
-               strcpy( rtos->thread_details[tasks_found].extra_info_str, state_desc );
+               rtos->thread_details[tasks_found].extra_info_str = (char *)malloc(strlen(
+                                       state_desc)+1);
+               strcpy(rtos->thread_details[tasks_found].extra_info_str, state_desc);
 
                rtos->thread_details[tasks_found].exists = true;
 
                rtos->thread_details[tasks_found].display_str = NULL;
 
-
                tasks_found++;
                prev_thread_ptr = thread_index;
 
-               // Get the location of the next thread structure.
+               /* Get the location of the next thread structure. */
                thread_index = rtos->symbols[eCos_VAL_thread_list].address;
-               retval = target_read_buffer( rtos->target, prev_thread_ptr + param->thread_next_offset, param->pointer_width, (uint8_t *) &thread_index );
-               if ( retval != ERROR_OK )
-               {
+               retval = target_read_buffer(rtos->target,
+                               prev_thread_ptr + param->thread_next_offset,
+                               param->pointer_width,
+                               (uint8_t *) &thread_index);
+               if (retval != ERROR_OK) {
                        LOG_OUTPUT("Error reading next thread pointer in eCos thread list\r\n");
                        return retval;
                }
-       }
-       while( thread_index!=first_thread );
+       } while (thread_index != first_thread);
 
        rtos->thread_count = tasks_found;
        return 0;
 }
 
-static int eCos_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, char ** hex_reg_list )
+static int eCos_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, char **hex_reg_list)
 {
-
        int retval;
-       const struct eCos_paramsparam;
+       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;
index 2ea33122258663f0fe5af770486949bae08d362d..e249ff49e96217f53816de3ea73a0ff32ae188ce 100644 (file)
@@ -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, &reg_list, &reg_list_size);
+                       target_get_gdb_reg_list(target, &reg_list, &reg_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, &reg_list,
-                                                     &reg_list_size) !=
-                   ERROR_OK)
+                               &reg_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 *)&registers[0]);
+               target_buffer_get_u32(target, (const uint8_t *)&registers[0]);
        context->R5 =
-           target_buffer_get_u32(target, (const uint8_t *)&registers[1]);
+               target_buffer_get_u32(target, (const uint8_t *)&registers[1]);
        context->R6 =
-           target_buffer_get_u32(target, (const uint8_t *)&registers[2]);
+               target_buffer_get_u32(target, (const uint8_t *)&registers[2]);
        context->R7 =
-           target_buffer_get_u32(target, (const uint8_t *)&registers[3]);
+               target_buffer_get_u32(target, (const uint8_t *)&registers[3]);
        context->R8 =
-           target_buffer_get_u32(target, (const uint8_t *)&registers[4]);
+               target_buffer_get_u32(target, (const uint8_t *)&registers[4]);
        context->R9 =
-           target_buffer_get_u32(target, (const uint8_t *)&registers[5]);
+               target_buffer_get_u32(target, (const uint8_t *)&registers[5]);
        context->IP =
-           target_buffer_get_u32(target, (const uint8_t *)&registers[6]);
+               target_buffer_get_u32(target, (const uint8_t *)&registers[6]);
        context->FP =
-           target_buffer_get_u32(target, (const uint8_t *)&registers[7]);
+               target_buffer_get_u32(target, (const uint8_t *)&registers[7]);
        context->SP =
-           target_buffer_get_u32(target, (const uint8_t *)&registers[8]);
+               target_buffer_get_u32(target, (const uint8_t *)&registers[8]);
        context->PC =
-           target_buffer_get_u32(target, (const uint8_t *)&registers[9]);
+               target_buffer_get_u32(target, (const uint8_t *)&registers[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, &current_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;
index 3deeb68e7237309897f956d3d02670ce43ec7ba5..07e44eae0d5fe2d204b891c5fd91bf94af8bfc88 100644 (file)
 #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_detaildetail = &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);
-                       chartmp_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;
 }
index 80ba0e269426721aed6ce7b2626af8966b68b5d2..a93daeef974fa85f014a281199f77f6d00fd1855 100644 (file)
@@ -21,7 +21,6 @@
 #ifndef RTOS_H
 #define RTOS_H
 
-
 #include "server/server.h"
 #include <helper/types.h>
 #include <jim-nvp.h>
@@ -34,83 +33,75 @@ struct reg;
 /**
  * Table should be terminated by an element with NULL in symbol_name
  */
-typedef struct symbol_table_elem_struct
-{
-       char * symbol_name;
+typedef struct symbol_table_elem_struct {
+       char *symbol_name;
        symbol_address_t address;
 
 } symbol_table_elem_t;
 
-struct thread_detail
-{
+struct thread_detail {
        threadid_t threadid;
        bool exists;
-       char * display_str;
-       char * thread_name_str;
-       char * extra_info_str;
+       char *display_str;
+       char *thread_name_str;
+       char *extra_info_str;
 };
 
-struct rtos
-{
+struct rtos {
        const struct rtos_type *type;
 
-
-       symbol_table_elem_t * symbols;
+       symbol_table_elem_t *symbols;
        struct target *target;
        /*  add a context variable instead of global variable */
        int64_t current_threadid;
        threadid_t current_thread;
-       struct thread_detailthread_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 */
index 995c113894fc5cbf73d7452ae1a02f5f4741f887..4f9c4059e710d499072823f37083be7150a78269 100644 (file)
 #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 */
 };
-
-
index 82f085534ab31d3e89e47f6764a443cae927a1b1..034251c7c84add2ac33c723916b6ad9d7edb61ce 100644 (file)
@@ -27,4 +27,4 @@
 
 extern const struct rtos_register_stacking rtos_eCos_Cortex_M3_stacking;
 
-#endif //ifndef INCLUDED_RTOS_STANDARD_STACKINGS_H_
+#endif /* ifndef INCLUDED_RTOS_STANDARD_STACKINGS_H_ */
index 278d3efe5fa9f63cb249e0eb0ac656443d8a14a5..30d9cd963702314e7571fa223349f673780f6620 100644 (file)
 #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 */
 };
-
-
index 1e8568ceeafff03069033bb18a580c0b0c9d88c7..9f26b8e62c2fc3b558ac1734670beb9c43e6e70e 100644 (file)
@@ -29,4 +29,4 @@
 
 extern const struct rtos_register_stacking rtos_standard_Cortex_M3_stacking;
 
-#endif //ifndef INCLUDED_RTOS_STANDARD_STACKINGS_H_
+#endif /* ifndef INCLUDED_RTOS_STANDARD_STACKINGS_H_ */