git.gag.com Git - fw/openocd/blob - 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_xSuspendedTaskList].address;
 248         list_of_lists[num_lists++] =  rtos->symbols[FreeRTOS_VAL_xTasksWaitingTermination].address;
 249
 250
 251         for( i = 0; i < num_lists; i++ )
 252         {
 253                 if ( list_of_lists[i] == 0 )
 254                 {
 255                         continue;
 256                 }
 257
 258                 // Read the number of threads in this list
 259                 int64_t list_thread_count = 0;
 260                 retval = target_read_buffer( rtos->target, list_of_lists[i], param->thread_count_width, (uint8_t *)&list_thread_count);
 261                 if ( retval != ERROR_OK )
 262                 {
 263                         LOG_OUTPUT("Error reading number of threads in FreeRTOS thread list\r\n");
 264                         return retval;
 265                 }
 266
 267                 if ( list_thread_count == 0 )
 268                 {
 269                         continue;
 270                 }
 271
 272                 // Read the location of first list item
 273                 uint64_t prev_list_elem_ptr = -1;
 274                 uint64_t list_elem_ptr = 0;
 275                 retval = target_read_buffer( rtos->target, list_of_lists[i] + param->list_next_offset, param->pointer_width, (uint8_t *)&list_elem_ptr);
 276                 if ( retval != ERROR_OK )
 277                 {
 278                         LOG_OUTPUT("Error reading first thread item location in FreeRTOS thread list\r\n");
 279                         return retval;
 280                 }
 281
 282
 283                 while ( (list_thread_count > 0) && ( list_elem_ptr != 0) && ( list_elem_ptr != prev_list_elem_ptr ) && ( tasks_found < thread_list_size ) )
 284                 {
 285                         // Get the location of the thread structure.
 286                         rtos->thread_details[tasks_found].threadid = 0;
 287                         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));
 288                         if ( retval != ERROR_OK )
 289                         {
 290                                 LOG_OUTPUT("Error reading thread list item object in FreeRTOS thread list\r\n");
 291                                 return retval;
 292                         }
 293
 294
 295                         // get thread name
 296
 297                         #define FREERTOS_THREAD_NAME_STR_SIZE (200)
 298                         char tmp_str[FREERTOS_THREAD_NAME_STR_SIZE];
 299
 300                         // Read the thread name
 301                         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);
 302                         if ( retval != ERROR_OK )
 303                         {
 304                                 LOG_OUTPUT("Error reading first thread item location in FreeRTOS thread list\r\n");
 305                                 return retval;
 306                         }
 307                         tmp_str[FREERTOS_THREAD_NAME_STR_SIZE-1] = '\x00';
 308
 309                         if ( tmp_str[0] == '\x00' )
 310                         {
 311                                 strcpy(tmp_str,"No Name");
 312                         }
 313
 314                         rtos->thread_details[tasks_found].thread_name_str = (char*)malloc( strlen(tmp_str)+1 );
 315                         strcpy( rtos->thread_details[tasks_found].thread_name_str, tmp_str );
 316                         rtos->thread_details[tasks_found].display_str = NULL;
 317                         rtos->thread_details[tasks_found].exists = true;
 318
 319                         if ( rtos->thread_details[tasks_found].threadid == rtos->current_thread )
 320                         {
 321                                 char running_str[] = "Running";
 322                                 rtos->thread_details[tasks_found].extra_info_str = (char*) malloc( sizeof(running_str) );
 323                                 strcpy( rtos->thread_details[tasks_found].extra_info_str, running_str );
 324                         }
 325                         else
 326                         {
 327                                 rtos->thread_details[tasks_found].extra_info_str = NULL;
 328                         }
 329
 330
 331                         tasks_found++;
 332                         list_thread_count--;
 333
 334                         prev_list_elem_ptr = list_elem_ptr;
 335                         list_elem_ptr = 0;
 336                         retval = target_read_buffer( rtos->target, prev_list_elem_ptr + param->list_elem_next_offset, param->pointer_width, (uint8_t *)&list_elem_ptr);
 337                         if ( retval != ERROR_OK )
 338                         {
 339                                 LOG_OUTPUT("Error reading next thread item location in FreeRTOS thread list\r\n");
 340                                 return retval;
 341                         }
 342                 }
 343
 344
 345         }
 346         free( list_of_lists );
 347         rtos->thread_count = tasks_found;
 348         return 0;
 349 }
 350
 351 static int FreeRTOS_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, char ** hex_reg_list )
 352 {
 353         int retval;
 354         const struct FreeRTOS_params* param;
 355         int64_t stack_ptr = 0;
 356
 357
 358         *hex_reg_list = NULL;
 359         if ( rtos == NULL )
 360         {
 361                 return -1;
 362         }
 363
 364         if ( thread_id == 0 )
 365         {
 366                 return -2;
 367         }
 368
 369         if (rtos->rtos_specific_params == NULL )
 370         {
 371                 return -1;
 372         }
 373
 374         param = (const struct FreeRTOS_params*) rtos->rtos_specific_params;
 375
 376         // Read the stack pointer
 377         retval = target_read_buffer( rtos->target, thread_id + param->thread_stack_offset, param->pointer_width, (uint8_t*)&stack_ptr);
 378         if ( retval != ERROR_OK )
 379         {
 380                 LOG_OUTPUT("Error reading stack frame from FreeRTOS thread\r\n");
 381                 return retval;
 382         }
 383
 384         return rtos_generic_stack_read( rtos->target, param->stacking_info, stack_ptr, hex_reg_list );
 385
 386 }
 387
 388 static int FreeRTOS_get_symbol_list_to_lookup(symbol_table_elem_t * symbol_list[])
 389 {
 390         unsigned int i;
 391         *symbol_list = (symbol_table_elem_t *) malloc( sizeof( symbol_table_elem_t ) * FREERTOS_NUM_SYMBOLS );
 392
 393         for( i = 0; i < FREERTOS_NUM_SYMBOLS; i++ )
 394         {
 395                 (*symbol_list)[i].symbol_name = FreeRTOS_symbol_list[i];
 396         }
 397
 398         return 0;
 399 }
 400
 401 #if 0
 402
 403 static int FreeRTOS_set_current_thread(struct rtos *rtos, threadid_t thread_id)
 404 {
 405         return 0;
 406 }
 407
 408
 409
 410 static int FreeRTOS_get_thread_ascii_info( struct rtos*   rtos, threadid_t   thread_id, char ** info )
 411 {
 412         int retval;
 413         const struct FreeRTOS_params* param;
 414
 415         if ( rtos == NULL )
 416         {
 417                 return -1;
 418         }
 419
 420         if ( thread_id == 0 )
 421         {
 422                 return -2;
 423         }
 424
 425         if (rtos->rtos_specific_params == NULL )
 426         {
 427                 return -3;
 428         }
 429
 430         param = (const struct FreeRTOS_params*) rtos->rtos_specific_params;
 431
 432 #define FREERTOS_THREAD_NAME_STR_SIZE (200)
 433         char tmp_str[FREERTOS_THREAD_NAME_STR_SIZE];
 434
 435         // Read the thread name
 436         retval = target_read_buffer( rtos->target, thread_id + param->thread_name_offset, FREERTOS_THREAD_NAME_STR_SIZE, (uint8_t *)&tmp_str);
 437         if ( retval != ERROR_OK )
 438         {
 439                 LOG_OUTPUT("Error reading first thread item location in FreeRTOS thread list\r\n");
 440                 return retval;
 441         }
 442         tmp_str[FREERTOS_THREAD_NAME_STR_SIZE-1] = '\x00';
 443
 444         if ( tmp_str[0] == '\x00' )
 445         {
 446                 strcpy(tmp_str,"No Name");
 447         }
 448
 449         *info = (char*)malloc( strlen(tmp_str)+1 );
 450         strcpy( *info, tmp_str );
 451         return 0;
 452 }
 453
 454 #endif
 455
 456 static int FreeRTOS_detect_rtos( struct target* target )
 457 {
 458         if ( ( target->rtos->symbols != NULL ) &&
 459                  ( target->rtos->symbols[FreeRTOS_VAL_pxReadyTasksLists].address != 0 ) )
 460         {
 461                 // looks like FreeRTOS
 462                 return 1;
 463         }
 464         return 0;
 465         return 0;
 466 }
 467
 468
 469 static int FreeRTOS_create( struct target* target )
 470 {
 471         int i = 0;
 472         while ( ( i < FREERTOS_NUM_PARAMS ) && ( 0 != strcmp( FreeRTOS_params_list[i].target_name, target->type->name ) ) )
 473         {
 474                 i++;
 475         }
 476         if ( i >= FREERTOS_NUM_PARAMS )
 477         {
 478                 LOG_OUTPUT("Could not find target in FreeRTOS compatibility list\r\n");
 479                 return -1;
 480         }
 481
 482         target->rtos->rtos_specific_params = (void*) &FreeRTOS_params_list[i];
 483         return 0;
 484 }
 485