src/rtos/FreeRTOS.c

   1 /***************************************************************************
   2  *   Copyright (C) 2011 by Broadcom Corporation                            *
   3  *   Evan Hunter - ehunter@broadcom.com                                    *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  19  ***************************************************************************/
  20
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include "config.h"
  24 #endif
  25
  26 #include <helper/time_support.h>
  27 #include <jtag/jtag.h>
  28 #include "target/target.h"
  29 #include "target/target_type.h"
  30 #include "rtos.h"
  31 #include "helper/log.h"
  32 #include "rtos_standard_stackings.h"
  33
  34 #define FreeRTOS_STRUCT( int_type, ptr_type, list_prev_offset )
  35
  36
  37 struct FreeRTOS_params
  38 {
  39         const char *                         target_name;
  40         const unsigned char                  thread_count_width;
  41         const unsigned char                  pointer_width;
  42         const unsigned char                  list_next_offset;
  43         const unsigned char                  list_width;
  44         const unsigned char                  list_elem_next_offset;
  45         const unsigned char                  list_elem_content_offset;
  46         const unsigned char                  thread_stack_offset;
  47         const unsigned char                  thread_name_offset;
  48         const struct rtos_register_stacking* stacking_info;
  49 };
  50
  51
  52
  53
  54 const struct FreeRTOS_params FreeRTOS_params_list[] =
  55 {
  56                 { "cortex_m3",                      // target_name
  57           4,                                // thread_count_width;
  58           4,                                // pointer_width;
  59           16,                               // list_next_offset;
  60           20,                               // list_width;
  61           8,                                // list_elem_next_offset;
  62           12,                               // list_elem_content_offset
  63           0,                                // thread_stack_offset;
  64           52,                               // thread_name_offset;
  65           &rtos_standard_Cortex_M3_stacking, // stacking_info
  66                 }
  67
  68 };
  69
  70
  71 #define FREERTOS_NUM_PARAMS ((int)(sizeof(FreeRTOS_params_list)/sizeof(struct FreeRTOS_params)))
  72
  73 static int FreeRTOS_detect_rtos( struct target* target );
  74 static int FreeRTOS_create( struct target* target );
  75 static int FreeRTOS_update_threads( struct rtos *rtos );
  76 static int FreeRTOS_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, char ** hex_reg_list );
  77 static int FreeRTOS_get_symbol_list_to_lookup(symbol_table_elem_t * symbol_list[]);
  78
  79
  80
  81
  82 struct rtos_type FreeRTOS_rtos =
  83 {
  84         .name                       = "FreeRTOS",
  85
  86         .detect_rtos                = FreeRTOS_detect_rtos,
  87         .create                     = FreeRTOS_create,
  88         .update_threads            = FreeRTOS_update_threads,
  89         .get_thread_reg_list        = FreeRTOS_get_thread_reg_list,
  90         .get_symbol_list_to_lookup  = FreeRTOS_get_symbol_list_to_lookup,
  91 };
  92
  93 enum FreeRTOS_symbol_values
  94 {
  95         FreeRTOS_VAL_pxCurrentTCB              = 0,
  96         FreeRTOS_VAL_pxReadyTasksLists         = 1,
  97         FreeRTOS_VAL_xDelayedTaskList1         = 2,
  98         FreeRTOS_VAL_xDelayedTaskList2         = 3,
  99         FreeRTOS_VAL_pxDelayedTaskList         = 4,
 100         FreeRTOS_VAL_pxOverflowDelayedTaskList = 5,
 101         FreeRTOS_VAL_xPendingReadyList         = 6,
 102         FreeRTOS_VAL_xTasksWaitingTermination  = 7,
 103         FreeRTOS_VAL_xSuspendedTaskList        = 8,
 104         FreeRTOS_VAL_uxCurrentNumberOfTasks    = 9,
 105         FreeRTOS_VAL_uxTopUsedPriority         = 10,
 106 };
 107
 108 static char* FreeRTOS_symbol_list[] =
 109 {
 110                 "pxCurrentTCB",
 111                 "pxReadyTasksLists",
 112                 "xDelayedTaskList1",
 113                 "xDelayedTaskList2",
 114                 "pxDelayedTaskList",
 115                 "pxOverflowDelayedTaskList",
 116                 "xPendingReadyList",
 117                 "xTasksWaitingTermination",
 118                 "xSuspendedTaskList",
 119                 "uxCurrentNumberOfTasks",
 120                 "uxTopUsedPriority",
 121                 NULL
 122 };
 123
 124 #define FREERTOS_NUM_SYMBOLS (sizeof(FreeRTOS_symbol_list)/sizeof(char*))
 125
 126 // TODO:
 127 // this is not safe for little endian yet
 128 // may be problems reading if sizes are not 32 bit long integers.
 129 // test mallocs for failure
 130
 131 static int FreeRTOS_update_threads( struct rtos *rtos )
 132 {
 133         int i = 0;
 134         int retval;
 135         int tasks_found = 0;
 136         const struct FreeRTOS_params* param;
 137
 138         if (rtos->rtos_specific_params == NULL )
 139         {
 140                 return -1;
 141         }
 142
 143         param = (const struct FreeRTOS_params*) rtos->rtos_specific_params;
 144
 145         if ( rtos->symbols == NULL )
 146         {
 147                 LOG_OUTPUT("No symbols for FreeRTOS\r\n");
 148                 return -3;
 149         }
 150
 151         if ( rtos->symbols[FreeRTOS_VAL_uxCurrentNumberOfTasks].address == 0 )
 152         {
 153                 LOG_OUTPUT("Don't have the number of threads in FreeRTOS \r\n");
 154                 return -2;
 155         }
 156
 157         int thread_list_size = 0;
 158         retval = target_read_buffer( rtos->target, rtos->symbols[FreeRTOS_VAL_uxCurrentNumberOfTasks].address, param->thread_count_width, (uint8_t *)&thread_list_size);
 159
 160         if ( retval != ERROR_OK )
 161         {
 162                 LOG_OUTPUT("Could not read FreeRTOS thread count from target\r\n");
 163                 return retval;
 164         }
 165
 166
 167         // wipe out previous thread details if any
 168         if ( rtos->thread_details != NULL )
 169         {
 170                 int j;
 171                 for( j = 0; j < rtos->thread_count; j++ )
 172                 {
 173                         if ( rtos->thread_details[j].display_str != NULL )
 174                         {
 175                                 free( rtos->thread_details[j].display_str );
 176                                 rtos->thread_details[j].display_str = NULL;
 177                         }
 178                         if ( rtos->thread_details[j].thread_name_str != NULL )
 179                         {
 180                                 free( rtos->thread_details[j].thread_name_str );
 181                                 rtos->thread_details[j].thread_name_str = NULL;
 182                         }
 183                         if ( rtos->thread_details[j].extra_info_str != NULL )
 184                         {
 185                                 free( rtos->thread_details[j].extra_info_str );
 186                                 rtos->thread_details[j].extra_info_str = NULL;
 187                         }
 188                 }
 189                 free( rtos->thread_details );
 190                 rtos->thread_details = NULL;
 191         }
 192
 193
 194         // read the current thread
 195         retval = target_read_buffer( rtos->target, rtos->symbols[FreeRTOS_VAL_pxCurrentTCB].address, param->pointer_width, (uint8_t *)&rtos->current_thread );
 196         if ( retval != ERROR_OK )
 197         {
 198                 LOG_OUTPUT("Error reading current thread in FreeRTOS thread list\r\n");
 199                 return retval;
 200         }
 201
 202         if ( ( thread_list_size  == 0 ) || ( rtos->current_thread == 0 ) )
 203         {
 204                 // Either : No RTOS threads - there is always at least the current execution though
 205                 // OR     : No current thread - all threads suspended - show the current execution of idling
 206                 char tmp_str[] = "Current Execution";
 207                 thread_list_size++;
 208                 tasks_found++;
 209                 rtos->thread_details = (struct thread_detail*) malloc( sizeof( struct thread_detail ) * thread_list_size );
 210                 rtos->thread_details->threadid = 1;
 211                 rtos->thread_details->exists = true;
 212                 rtos->thread_details->display_str = NULL;
 213                 rtos->thread_details->extra_info_str = NULL;
 214                 rtos->thread_details->thread_name_str = (char*) malloc( sizeof(tmp_str) );
 215                 strcpy( rtos->thread_details->thread_name_str, tmp_str );
 216
 217
 218                 if ( thread_list_size == 1 )
 219                 {
 220                         rtos->thread_count = 1;
 221                         return ERROR_OK;
 222                 }
 223         }
 224         else
 225         {
 226                 // create space for new thread details
 227                 rtos->thread_details = (struct thread_detail*) malloc( sizeof( struct thread_detail ) * thread_list_size );
 228         }
 229
 230
 231         // Find out how many lists are needed to be read from pxReadyTasksLists,
 232         int64_t max_used_priority = 0;
 233         retval = target_read_buffer( rtos->target, rtos->symbols[FreeRTOS_VAL_uxTopUsedPriority].address, param->pointer_width, (uint8_t *)&max_used_priority );
 234
 235
 236         symbol_address_t* list_of_lists = (symbol_address_t *)malloc( sizeof( symbol_address_t ) * ( max_used_priority + 5 ) );
 237
 238         int num_lists;
 239         for( num_lists = 0; num_lists < max_used_priority; num_lists++ )
 240         {
 241                 list_of_lists[num_lists] =  rtos->symbols[FreeRTOS_VAL_pxReadyTasksLists].address + num_lists * param->list_width;
 242         }
 243
 244         list_of_lists[num_lists++] =  rtos->symbols[FreeRTOS_VAL_xDelayedTaskList1].address;
 245         list_of_lists[num_lists++] =  rtos->symbols[FreeRTOS_VAL_xDelayedTaskList2].address;
 246         list_of_lists[num_lists++] =  rtos->symbols[FreeRTOS_VAL_xPendingReadyList].address;
 247         list_of_lists[num_lists++] =  rtos->symbols[FreeRTOS_VAL_xTasksWaitingTermination].address;
 248
 249
 250         for( i = 0; i < num_lists; i++ )
 251         {
 252                 if ( list_of_lists[i] == 0 )
 253                 {
 254                         continue;
 255                 }
 256
 257                 // Read the number of threads in this list
 258                 int64_t list_thread_count = 0;
 259                 retval = target_read_buffer( rtos->target, list_of_lists[i], param->thread_count_width, (uint8_t *)&list_thread_count);
 260                 if ( retval != ERROR_OK )
 261                 {
 262                         LOG_OUTPUT("Error reading number of threads in FreeRTOS thread list\r\n");
 263                         return retval;
 264                 }
 265
 266                 if ( list_thread_count == 0 )
 267                 {
 268                         continue;
 269                 }
 270
 271                 // Read the location of first list item
 272                 uint64_t prev_list_elem_ptr = -1;
 273                 uint64_t list_elem_ptr = 0;
 274                 retval = target_read_buffer( rtos->target, list_of_lists[i] + param->list_next_offset, param->pointer_width, (uint8_t *)&list_elem_ptr);
 275                 if ( retval != ERROR_OK )
 276                 {
 277                         LOG_OUTPUT("Error reading first thread item location in FreeRTOS thread list\r\n");
 278                         return retval;
 279                 }
 280
 281
 282                 while ( (list_thread_count > 0) && ( list_elem_ptr != 0) && ( list_elem_ptr != prev_list_elem_ptr ) && ( tasks_found < thread_list_size ) )
 283                 {
 284                         // Get the location of the thread structure.
 285                         rtos->thread_details[tasks_found].threadid = 0;
 286                         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));
 287                         if ( retval != ERROR_OK )
 288                         {
 289                                 LOG_OUTPUT("Error reading thread list item object in FreeRTOS thread list\r\n");
 290                                 return retval;
 291                         }
 292
 293
 294                         // get thread name
 295
 296                         #define FREERTOS_THREAD_NAME_STR_SIZE (200)
 297                         char tmp_str[FREERTOS_THREAD_NAME_STR_SIZE];
 298
 299                         // Read the thread name
 300                         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);
 301                         if ( retval != ERROR_OK )
 302                         {
 303                                 LOG_OUTPUT("Error reading first thread item location in FreeRTOS thread list\r\n");
 304                                 return retval;
 305                         }
 306                         tmp_str[FREERTOS_THREAD_NAME_STR_SIZE-1] = '\x00';
 307
 308                         if ( tmp_str[0] == '\x00' )
 309                         {
 310                                 strcpy(tmp_str,"No Name");
 311                         }
 312
 313                         rtos->thread_details[tasks_found].thread_name_str = (char*)malloc( strlen(tmp_str)+1 );
 314                         strcpy( rtos->thread_details[tasks_found].thread_name_str, tmp_str );
 315                         rtos->thread_details[tasks_found].display_str = NULL;
 316                         rtos->thread_details[tasks_found].exists = true;
 317
 318                         if ( rtos->thread_details[tasks_found].threadid == rtos->current_thread )
 319                         {
 320                                 char running_str[] = "Running";
 321                                 rtos->thread_details[tasks_found].extra_info_str = (char*) malloc( sizeof(running_str) );
 322                                 strcpy( rtos->thread_details[tasks_found].extra_info_str, running_str );
 323                         }
 324                         else
 325                         {
 326                                 rtos->thread_details[tasks_found].extra_info_str = NULL;
 327                         }
 328
 329
 330                         tasks_found++;
 331                         list_thread_count--;
 332
 333                         prev_list_elem_ptr = list_elem_ptr;
 334                         list_elem_ptr = 0;
 335                         retval = target_read_buffer( rtos->target, prev_list_elem_ptr + param->list_elem_next_offset, param->pointer_width, (uint8_t *)&list_elem_ptr);
 336                         if ( retval != ERROR_OK )
 337                         {
 338                                 LOG_OUTPUT("Error reading next thread item location in FreeRTOS thread list\r\n");
 339                                 return retval;
 340                         }
 341                 }
 342
 343
 344         }
 345         free( list_of_lists );
 346         rtos->thread_count = tasks_found;
 347         return 0;
 348 }
 349
 350 static int FreeRTOS_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, char ** hex_reg_list )
 351 {
 352         int retval;
 353         const struct FreeRTOS_params* param;
 354         int64_t stack_ptr = 0;
 355
 356
 357         *hex_reg_list = NULL;
 358         if ( rtos == NULL )
 359         {
 360                 return -1;
 361         }
 362
 363         if ( thread_id == 0 )
 364         {
 365                 return -2;
 366         }
 367
 368         if (rtos->rtos_specific_params == NULL )
 369         {
 370                 return -1;
 371         }
 372
 373         param = (const struct FreeRTOS_params*) rtos->rtos_specific_params;
 374
 375         // Read the stack pointer
 376         retval = target_read_buffer( rtos->target, thread_id + param->thread_stack_offset, param->pointer_width, (uint8_t*)&stack_ptr);
 377         if ( retval != ERROR_OK )
 378         {
 379                 LOG_OUTPUT("Error reading stack frame from FreeRTOS thread\r\n");
 380                 return retval;
 381         }
 382
 383         return rtos_generic_stack_read( rtos->target, param->stacking_info, stack_ptr, hex_reg_list );
 384
 385 }
 386
 387 static int FreeRTOS_get_symbol_list_to_lookup(symbol_table_elem_t * symbol_list[])
 388 {
 389         unsigned int i;
 390         *symbol_list = (symbol_table_elem_t *) malloc( sizeof( symbol_table_elem_t ) * FREERTOS_NUM_SYMBOLS );
 391
 392         for( i = 0; i < FREERTOS_NUM_SYMBOLS; i++ )
 393         {
 394                 (*symbol_list)[i].symbol_name = FreeRTOS_symbol_list[i];
 395         }
 396
 397         return 0;
 398 }
 399
 400 #if 0
 401
 402 static int FreeRTOS_set_current_thread(struct rtos *rtos, threadid_t thread_id)
 403 {
 404         return 0;
 405 }
 406
 407
 408
 409 static int FreeRTOS_get_thread_ascii_info( struct rtos*   rtos, threadid_t   thread_id, char ** info )
 410 {
 411         int retval;
 412         const struct FreeRTOS_params* param;
 413
 414         if ( rtos == NULL )
 415         {
 416                 return -1;
 417         }
 418
 419         if ( thread_id == 0 )
 420         {
 421                 return -2;
 422         }
 423
 424         if (rtos->rtos_specific_params == NULL )
 425         {
 426                 return -3;
 427         }
 428
 429         param = (const struct FreeRTOS_params*) rtos->rtos_specific_params;
 430
 431 #define FREERTOS_THREAD_NAME_STR_SIZE (200)
 432         char tmp_str[FREERTOS_THREAD_NAME_STR_SIZE];
 433
 434         // Read the thread name
 435         retval = target_read_buffer( rtos->target, thread_id + param->thread_name_offset, FREERTOS_THREAD_NAME_STR_SIZE, (uint8_t *)&tmp_str);
 436         if ( retval != ERROR_OK )
 437         {
 438                 LOG_OUTPUT("Error reading first thread item location in FreeRTOS thread list\r\n");
 439                 return retval;
 440         }
 441         tmp_str[FREERTOS_THREAD_NAME_STR_SIZE-1] = '\x00';
 442
 443         if ( tmp_str[0] == '\x00' )
 444         {
 445                 strcpy(tmp_str,"No Name");
 446         }
 447
 448         *info = (char*)malloc( strlen(tmp_str)+1 );
 449         strcpy( *info, tmp_str );
 450         return 0;
 451 }
 452
 453 #endif
 454
 455 static int FreeRTOS_detect_rtos( struct target* target )
 456 {
 457         if ( ( target->rtos->symbols != NULL ) &&
 458                  ( target->rtos->symbols[FreeRTOS_VAL_pxReadyTasksLists].address != 0 ) )
 459         {
 460                 // looks like FreeRTOS
 461                 return 1;
 462         }
 463         return 0;
 464         return 0;
 465 }
 466
 467
 468 static int FreeRTOS_create( struct target* target )
 469 {
 470         int i = 0;
 471         while ( ( i < FREERTOS_NUM_PARAMS ) && ( 0 != strcmp( FreeRTOS_params_list[i].target_name, target->type->name ) ) )
 472         {
 473                 i++;
 474         }
 475         if ( i >= FREERTOS_NUM_PARAMS )
 476         {
 477                 LOG_OUTPUT("Could not find target in FreeRTOS compatibility list\r\n");
 478                 return -1;
 479         }
 480
 481         target->rtos->rtos_specific_params = (void*) &FreeRTOS_params_list[i];
 482         return 0;
 483 }
 484