1 /***************************************************************************
2 * Copyright (C) 2011 by Broadcom Corporation *
3 * Evan Hunter - ehunter@broadcom.com *
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. *
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. *
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 ***************************************************************************/
26 #include <helper/time_support.h>
27 #include <jtag/jtag.h>
28 #include "target/target.h"
29 #include "target/target_type.h"
31 #include "helper/log.h"
32 #include "rtos_standard_stackings.h"
34 #define FreeRTOS_STRUCT( int_type, ptr_type, list_prev_offset )
37 struct FreeRTOS_params
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
;
54 const struct FreeRTOS_params FreeRTOS_params_list
[] =
56 { "cortex_m3", // target_name
57 4, // thread_count_width;
59 16, // list_next_offset;
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
71 #define FREERTOS_NUM_PARAMS ((int)(sizeof(FreeRTOS_params_list)/sizeof(struct FreeRTOS_params)))
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
[]);
82 struct rtos_type FreeRTOS_rtos
=
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
,
93 enum FreeRTOS_symbol_values
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,
108 static char* FreeRTOS_symbol_list
[] =
115 "pxOverflowDelayedTaskList",
117 "xTasksWaitingTermination",
118 "xSuspendedTaskList",
119 "uxCurrentNumberOfTasks",
124 #define FREERTOS_NUM_SYMBOLS (sizeof(FreeRTOS_symbol_list)/sizeof(char*))
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
131 static int FreeRTOS_update_threads( struct rtos
*rtos
)
136 const struct FreeRTOS_params
* param
;
138 if (rtos
->rtos_specific_params
== NULL
)
143 param
= (const struct FreeRTOS_params
*) rtos
->rtos_specific_params
;
145 if ( rtos
->symbols
== NULL
)
147 LOG_OUTPUT("No symbols for FreeRTOS\r\n");
151 if ( rtos
->symbols
[FreeRTOS_VAL_uxCurrentNumberOfTasks
].address
== 0 )
153 LOG_OUTPUT("Don't have the number of threads in FreeRTOS \r\n");
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
);
160 if ( retval
!= ERROR_OK
)
162 LOG_OUTPUT("Could not read FreeRTOS thread count from target\r\n");
167 // wipe out previous thread details if any
168 if ( rtos
->thread_details
!= NULL
)
171 for( j
= 0; j
< rtos
->thread_count
; j
++ )
173 if ( rtos
->thread_details
[j
].display_str
!= NULL
)
175 free( rtos
->thread_details
[j
].display_str
);
176 rtos
->thread_details
[j
].display_str
= NULL
;
178 if ( rtos
->thread_details
[j
].thread_name_str
!= NULL
)
180 free( rtos
->thread_details
[j
].thread_name_str
);
181 rtos
->thread_details
[j
].thread_name_str
= NULL
;
183 if ( rtos
->thread_details
[j
].extra_info_str
!= NULL
)
185 free( rtos
->thread_details
[j
].extra_info_str
);
186 rtos
->thread_details
[j
].extra_info_str
= NULL
;
189 free( rtos
->thread_details
);
190 rtos
->thread_details
= NULL
;
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
)
198 LOG_OUTPUT("Error reading current thread in FreeRTOS thread list\r\n");
202 if ( ( thread_list_size
== 0 ) || ( rtos
->current_thread
== 0 ) )
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";
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
);
218 if ( thread_list_size
== 1 )
220 rtos
->thread_count
= 1;
226 // create space for new thread details
227 rtos
->thread_details
= (struct thread_detail
*) malloc( sizeof( struct thread_detail
) * thread_list_size
);
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 if (retval
!= ERROR_OK
)
237 symbol_address_t
* list_of_lists
= (symbol_address_t
*)malloc( sizeof( symbol_address_t
) * ( max_used_priority
+1 + 5 ) );
240 for( num_lists
= 0; num_lists
<= max_used_priority
; num_lists
++ )
242 list_of_lists
[num_lists
] = rtos
->symbols
[FreeRTOS_VAL_pxReadyTasksLists
].address
+ num_lists
* param
->list_width
;
245 list_of_lists
[num_lists
++] = rtos
->symbols
[FreeRTOS_VAL_xDelayedTaskList1
].address
;
246 list_of_lists
[num_lists
++] = rtos
->symbols
[FreeRTOS_VAL_xDelayedTaskList2
].address
;
247 list_of_lists
[num_lists
++] = rtos
->symbols
[FreeRTOS_VAL_xPendingReadyList
].address
;
248 list_of_lists
[num_lists
++] = rtos
->symbols
[FreeRTOS_VAL_xSuspendedTaskList
].address
;
249 list_of_lists
[num_lists
++] = rtos
->symbols
[FreeRTOS_VAL_xTasksWaitingTermination
].address
;
252 for( i
= 0; i
< num_lists
; i
++ )
254 if ( list_of_lists
[i
] == 0 )
259 // Read the number of threads in this list
260 int64_t list_thread_count
= 0;
261 retval
= target_read_buffer( rtos
->target
, list_of_lists
[i
], param
->thread_count_width
, (uint8_t *)&list_thread_count
);
262 if ( retval
!= ERROR_OK
)
264 LOG_OUTPUT("Error reading number of threads in FreeRTOS thread list\r\n");
268 if ( list_thread_count
== 0 )
273 // Read the location of first list item
274 uint64_t prev_list_elem_ptr
= -1;
275 uint64_t list_elem_ptr
= 0;
276 retval
= target_read_buffer( rtos
->target
, list_of_lists
[i
] + param
->list_next_offset
, param
->pointer_width
, (uint8_t *)&list_elem_ptr
);
277 if ( retval
!= ERROR_OK
)
279 LOG_OUTPUT("Error reading first thread item location in FreeRTOS thread list\r\n");
284 while ( (list_thread_count
> 0) && ( list_elem_ptr
!= 0) && ( list_elem_ptr
!= prev_list_elem_ptr
) && ( tasks_found
< thread_list_size
) )
286 // Get the location of the thread structure.
287 rtos
->thread_details
[tasks_found
].threadid
= 0;
288 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
));
289 if ( retval
!= ERROR_OK
)
291 LOG_OUTPUT("Error reading thread list item object in FreeRTOS thread list\r\n");
298 #define FREERTOS_THREAD_NAME_STR_SIZE (200)
299 char tmp_str
[FREERTOS_THREAD_NAME_STR_SIZE
];
301 // Read the thread name
302 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
);
303 if ( retval
!= ERROR_OK
)
305 LOG_OUTPUT("Error reading first thread item location in FreeRTOS thread list\r\n");
308 tmp_str
[FREERTOS_THREAD_NAME_STR_SIZE
-1] = '\x00';
310 if ( tmp_str
[0] == '\x00' )
312 strcpy(tmp_str
,"No Name");
315 rtos
->thread_details
[tasks_found
].thread_name_str
= (char*)malloc( strlen(tmp_str
)+1 );
316 strcpy( rtos
->thread_details
[tasks_found
].thread_name_str
, tmp_str
);
317 rtos
->thread_details
[tasks_found
].display_str
= NULL
;
318 rtos
->thread_details
[tasks_found
].exists
= true;
320 if ( rtos
->thread_details
[tasks_found
].threadid
== rtos
->current_thread
)
322 char running_str
[] = "Running";
323 rtos
->thread_details
[tasks_found
].extra_info_str
= (char*) malloc( sizeof(running_str
) );
324 strcpy( rtos
->thread_details
[tasks_found
].extra_info_str
, running_str
);
328 rtos
->thread_details
[tasks_found
].extra_info_str
= NULL
;
335 prev_list_elem_ptr
= list_elem_ptr
;
337 retval
= target_read_buffer( rtos
->target
, prev_list_elem_ptr
+ param
->list_elem_next_offset
, param
->pointer_width
, (uint8_t *)&list_elem_ptr
);
338 if ( retval
!= ERROR_OK
)
340 LOG_OUTPUT("Error reading next thread item location in FreeRTOS thread list\r\n");
347 free( list_of_lists
);
348 rtos
->thread_count
= tasks_found
;
352 static int FreeRTOS_get_thread_reg_list(struct rtos
*rtos
, int64_t thread_id
, char ** hex_reg_list
)
355 const struct FreeRTOS_params
* param
;
356 int64_t stack_ptr
= 0;
359 *hex_reg_list
= NULL
;
365 if ( thread_id
== 0 )
370 if (rtos
->rtos_specific_params
== NULL
)
375 param
= (const struct FreeRTOS_params
*) rtos
->rtos_specific_params
;
377 // Read the stack pointer
378 retval
= target_read_buffer( rtos
->target
, thread_id
+ param
->thread_stack_offset
, param
->pointer_width
, (uint8_t*)&stack_ptr
);
379 if ( retval
!= ERROR_OK
)
381 LOG_OUTPUT("Error reading stack frame from FreeRTOS thread\r\n");
385 return rtos_generic_stack_read( rtos
->target
, param
->stacking_info
, stack_ptr
, hex_reg_list
);
389 static int FreeRTOS_get_symbol_list_to_lookup(symbol_table_elem_t
* symbol_list
[])
392 *symbol_list
= (symbol_table_elem_t
*) malloc( sizeof( symbol_table_elem_t
) * FREERTOS_NUM_SYMBOLS
);
394 for( i
= 0; i
< FREERTOS_NUM_SYMBOLS
; i
++ )
396 (*symbol_list
)[i
].symbol_name
= FreeRTOS_symbol_list
[i
];
404 static int FreeRTOS_set_current_thread(struct rtos
*rtos
, threadid_t thread_id
)
411 static int FreeRTOS_get_thread_ascii_info( struct rtos
* rtos
, threadid_t thread_id
, char ** info
)
414 const struct FreeRTOS_params
* param
;
421 if ( thread_id
== 0 )
426 if (rtos
->rtos_specific_params
== NULL
)
431 param
= (const struct FreeRTOS_params
*) rtos
->rtos_specific_params
;
433 #define FREERTOS_THREAD_NAME_STR_SIZE (200)
434 char tmp_str
[FREERTOS_THREAD_NAME_STR_SIZE
];
436 // Read the thread name
437 retval
= target_read_buffer( rtos
->target
, thread_id
+ param
->thread_name_offset
, FREERTOS_THREAD_NAME_STR_SIZE
, (uint8_t *)&tmp_str
);
438 if ( retval
!= ERROR_OK
)
440 LOG_OUTPUT("Error reading first thread item location in FreeRTOS thread list\r\n");
443 tmp_str
[FREERTOS_THREAD_NAME_STR_SIZE
-1] = '\x00';
445 if ( tmp_str
[0] == '\x00' )
447 strcpy(tmp_str
,"No Name");
450 *info
= (char*)malloc( strlen(tmp_str
)+1 );
451 strcpy( *info
, tmp_str
);
457 static int FreeRTOS_detect_rtos( struct target
* target
)
459 if ( ( target
->rtos
->symbols
!= NULL
) &&
460 ( target
->rtos
->symbols
[FreeRTOS_VAL_pxReadyTasksLists
].address
!= 0 ) )
462 // looks like FreeRTOS
470 static int FreeRTOS_create( struct target
* target
)
473 while ( ( i
< FREERTOS_NUM_PARAMS
) && ( 0 != strcmp( FreeRTOS_params_list
[i
].target_name
, target
->type
->name
) ) )
477 if ( i
>= FREERTOS_NUM_PARAMS
)
479 LOG_OUTPUT("Could not find target in FreeRTOS compatibility list\r\n");
483 target
->rtos
->rtos_specific_params
= (void*) &FreeRTOS_params_list
[i
];