?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
openocd: fix for polling during "expr" computation
[openocd.git] / src / rtos / ThreadX.c
bloba60d5f8bb0a2b1792ddfebb603f0ada3c9c8eb90
1 /* SPDX-License-Identifier: GPL-2.0-or-later */
2
3 /***************************************************************************
4 * Copyright (C) 2011 by Broadcom Corporation *
5 * Evan Hunter - ehunter@broadcom.com *
6 ***************************************************************************/
7
8 #ifdef HAVE_CONFIG_H
9 #include "config.h"
10 #endif
11
12 #include <helper/time_support.h>
13 #include <jtag/jtag.h>
14 #include "target/target.h"
15 #include "target/target_type.h"
16 #include "rtos.h"
17 #include "helper/log.h"
18 #include "helper/types.h"
19 #include "rtos_standard_stackings.h"
20
21 static const struct rtos_register_stacking *get_stacking_info(const struct rtos *rtos, int64_t stack_ptr);
22 static const struct rtos_register_stacking *get_stacking_info_arm926ejs(const struct rtos *rtos, int64_t stack_ptr);
23
24 static int is_thread_id_valid(const struct rtos *rtos, int64_t thread_id);
25 static int is_thread_id_valid_arm926ejs(const struct rtos *rtos, int64_t thread_id);
26
27 static bool threadx_detect_rtos(struct target *target);
28 static int threadx_create(struct target *target);
29 static int threadx_update_threads(struct rtos *rtos);
30 static int threadx_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, struct rtos_reg **reg_list, int *num_regs);
31 static int threadx_get_symbol_list_to_lookup(struct symbol_table_elem *symbol_list[]);
32
33
34
35 struct threadx_thread_state {
36 int value;
37 const char *desc;
38 };
39
40 static const struct threadx_thread_state threadx_thread_states[] = {
41 { 0, "Ready" },
42 { 1, "Completed" },
43 { 2, "Terminated" },
44 { 3, "Suspended" },
45 { 4, "Sleeping" },
46 { 5, "Waiting - Queue" },
47 { 6, "Waiting - Semaphore" },
48 { 7, "Waiting - Event flag" },
49 { 8, "Waiting - Memory" },
50 { 9, "Waiting - Memory" },
51 { 10, "Waiting - I/O" },
52 { 11, "Waiting - Filesystem" },
53 { 12, "Waiting - Network" },
54 { 13, "Waiting - Mutex" },
55 };
56
57 #define THREADX_NUM_STATES ARRAY_SIZE(threadx_thread_states)
58
59 #define ARM926EJS_REGISTERS_SIZE_SOLICITED (11 * 4)
60 static const struct stack_register_offset rtos_threadx_arm926ejs_stack_offsets_solicited[] = {
61 { 0, -1, 32 }, /* r0 */
62 { 1, -1, 32 }, /* r1 */
63 { 2, -1, 32 }, /* r2 */
64 { 3, -1, 32 }, /* r3 */
65 { 4, 0x08, 32 }, /* r4 */
66 { 5, 0x0C, 32 }, /* r5 */
67 { 6, 0x10, 32 }, /* r6 */
68 { 7, 0x14, 32 }, /* r7 */
69 { 8, 0x18, 32 }, /* r8 */
70 { 9, 0x1C, 32 }, /* r9 */
71 { 10, 0x20, 32 }, /* r10 */
72 { 11, 0x24, 32 }, /* r11 */
73 { 12, -1, 32 }, /* r12 */
74 { 13, -2, 32 }, /* sp (r13) */
75 { 14, 0x28, 32 }, /* lr (r14) */
76 { 15, -1, 32 }, /* pc (r15) */
77 /*{ 16, -1, 32 },*/ /* lr (r14) */
78 /*{ 17, 0x28, 32 },*/ /* pc (r15) */
79 { 16, 0x04, 32 }, /* xPSR */
80 };
81 #define ARM926EJS_REGISTERS_SIZE_INTERRUPT (17 * 4)
82 static const struct stack_register_offset rtos_threadx_arm926ejs_stack_offsets_interrupt[] = {
83 { 0, 0x08, 32 }, /* r0 */
84 { 1, 0x0C, 32 }, /* r1 */
85 { 2, 0x10, 32 }, /* r2 */
86 { 3, 0x14, 32 }, /* r3 */
87 { 4, 0x18, 32 }, /* r4 */
88 { 5, 0x1C, 32 }, /* r5 */
89 { 6, 0x20, 32 }, /* r6 */
90 { 7, 0x24, 32 }, /* r7 */
91 { 8, 0x28, 32 }, /* r8 */
92 { 9, 0x2C, 32 }, /* r9 */
93 { 10, 0x30, 32 }, /* r10 */
94 { 11, 0x34, 32 }, /* r11 */
95 { 12, 0x38, 32 }, /* r12 */
96 { 13, -2, 32 }, /* sp (r13) */
97 { 14, 0x3C, 32 }, /* lr (r14) */
98 { 15, 0x40, 32 }, /* pc (r15) */
99 { 16, 0x04, 32 }, /* xPSR */
100 };
101
102 static const struct rtos_register_stacking rtos_threadx_arm926ejs_stacking[] = {
103 {
104 .stack_registers_size = ARM926EJS_REGISTERS_SIZE_SOLICITED,
105 .stack_growth_direction = -1,
106 .num_output_registers = 17,
107 .register_offsets = rtos_threadx_arm926ejs_stack_offsets_solicited
108 },
109 {
110 .stack_registers_size = ARM926EJS_REGISTERS_SIZE_INTERRUPT,
111 .stack_growth_direction = -1,
112 .num_output_registers = 17,
113 .register_offsets = rtos_threadx_arm926ejs_stack_offsets_interrupt
114 },
115 };
116
117 struct threadx_params {
118 const char *target_name;
119 unsigned char pointer_width;
120 unsigned char thread_stack_offset;
121 unsigned char thread_name_offset;
122 unsigned char thread_state_offset;
123 unsigned char thread_next_offset;
124 const struct rtos_register_stacking *stacking_info;
125 size_t stacking_info_nb;
126 const struct rtos_register_stacking* (*fn_get_stacking_info)(const struct rtos *rtos, int64_t stack_ptr);
127 int (*fn_is_thread_id_valid)(const struct rtos *rtos, int64_t thread_id);
128 };
129
130 static const struct threadx_params threadx_params_list[] = {
131 {
132 "cortex_m", /* target_name */
133 4, /* pointer_width; */
134 8, /* thread_stack_offset; */
135 40, /* thread_name_offset; */
136 48, /* thread_state_offset; */
137 136, /* thread_next_offset */
138 &rtos_standard_cortex_m3_stacking, /* stacking_info */
139 1, /* stacking_info_nb */
140 NULL, /* fn_get_stacking_info */
141 NULL, /* fn_is_thread_id_valid */
142 },
143 {
144 "cortex_r4", /* target_name */
145 4, /* pointer_width; */
146 8, /* thread_stack_offset; */
147 40, /* thread_name_offset; */
148 48, /* thread_state_offset; */
149 136, /* thread_next_offset */
150 &rtos_standard_cortex_r4_stacking, /* stacking_info */
151 1, /* stacking_info_nb */
152 NULL, /* fn_get_stacking_info */
153 NULL, /* fn_is_thread_id_valid */
154 },
155 {
156 "arm926ejs", /* target_name */
157 4, /* pointer_width; */
158 8, /* thread_stack_offset; */
159 40, /* thread_name_offset; */
160 48, /* thread_state_offset; */
161 136, /* thread_next_offset */
162 rtos_threadx_arm926ejs_stacking, /* stacking_info */
163 2, /* stacking_info_nb */
164 get_stacking_info_arm926ejs, /* fn_get_stacking_info */
165 is_thread_id_valid_arm926ejs, /* fn_is_thread_id_valid */
166 },
167 {
168 "hla_target", /* target_name */
169 4, /* pointer_width; */
170 8, /* thread_stack_offset; */
171 40, /* thread_name_offset; */
172 48, /* thread_state_offset; */
173 136, /* thread_next_offset */
174 &rtos_standard_cortex_m3_stacking, /* stacking_info */
175 1, /* stacking_info_nb */
176 NULL, /* fn_get_stacking_info */
177 NULL, /* fn_is_thread_id_valid */
178 },
179 };
180
181 enum threadx_symbol_values {
182 THREADX_VAL_TX_THREAD_CURRENT_PTR = 0,
183 THREADX_VAL_TX_THREAD_CREATED_PTR = 1,
184 THREADX_VAL_TX_THREAD_CREATED_COUNT = 2,
185 };
186
187 static const char * const threadx_symbol_list[] = {
188 "_tx_thread_current_ptr",
189 "_tx_thread_created_ptr",
190 "_tx_thread_created_count",
191 NULL
192 };
193
194 const struct rtos_type threadx_rtos = {
195 .name = "ThreadX",
196
197 .detect_rtos = threadx_detect_rtos,
198 .create = threadx_create,
199 .update_threads = threadx_update_threads,
200 .get_thread_reg_list = threadx_get_thread_reg_list,
201 .get_symbol_list_to_lookup = threadx_get_symbol_list_to_lookup,
202 };
203
204 static const struct rtos_register_stacking *get_stacking_info(const struct rtos *rtos, int64_t stack_ptr)
205 {
206 const struct threadx_params *param = (const struct threadx_params *) rtos->rtos_specific_params;
207
208 if (param->fn_get_stacking_info)
209 return param->fn_get_stacking_info(rtos, stack_ptr);
210
211 return param->stacking_info + 0;
212 }
213
214 static int is_thread_id_valid(const struct rtos *rtos, int64_t thread_id)
215 {
216 const struct threadx_params *param;
217
218 if (!rtos->rtos_specific_params)
219 return 0; /* invalid */
220
221 param = (const struct threadx_params *) rtos->rtos_specific_params;
222
223 if (param->fn_is_thread_id_valid)
224 return param->fn_is_thread_id_valid(rtos, thread_id);
225
226 return (thread_id != 0);
227 }
228
229 static const struct rtos_register_stacking *get_stacking_info_arm926ejs(const struct rtos *rtos, int64_t stack_ptr)
230 {
231 const struct threadx_params *param = (const struct threadx_params *) rtos->rtos_specific_params;
232 int retval;
233 uint32_t flag;
234
235 retval = target_read_buffer(rtos->target,
236 stack_ptr,
237 sizeof(flag),
238 (uint8_t *)&flag);
239 if (retval != ERROR_OK) {
240 LOG_ERROR("Error reading stack data from ThreadX thread: stack_ptr=0x%" PRIx64, stack_ptr);
241 return NULL;
242 }
243
244 if (flag == 0) {
245 LOG_DEBUG(" solicited stack");
246 return param->stacking_info + 0;
247 } else {
248 LOG_DEBUG(" interrupt stack: %" PRIu32, flag);
249 return param->stacking_info + 1;
250 }
251 }
252
253 static int is_thread_id_valid_arm926ejs(const struct rtos *rtos, int64_t thread_id)
254 {
255 return (thread_id != 0 && thread_id != 1);
256 }
257
258 static int threadx_update_threads(struct rtos *rtos)
259 {
260 int retval;
261 int tasks_found = 0;
262 int thread_list_size = 0;
263 const struct threadx_params *param;
264
265 if (!rtos)
266 return -1;
267
268 if (!rtos->rtos_specific_params)
269 return -3;
270
271 param = (const struct threadx_params *) rtos->rtos_specific_params;
272
273 if (!rtos->symbols) {
274 LOG_ERROR("No symbols for ThreadX");
275 return -4;
276 }
277
278 if (rtos->symbols[THREADX_VAL_TX_THREAD_CREATED_COUNT].address == 0) {
279 LOG_ERROR("Don't have the number of threads in ThreadX");
280 return -2;
281 }
282
283 /* read the number of threads */
284 retval = target_read_buffer(rtos->target,
285 rtos->symbols[THREADX_VAL_TX_THREAD_CREATED_COUNT].address,
286 4,
287 (uint8_t *)&thread_list_size);
288
289 if (retval != ERROR_OK) {
290 LOG_ERROR("Could not read ThreadX thread count from target");
291 return retval;
292 }
293
294 /* wipe out previous thread details if any */
295 rtos_free_threadlist(rtos);
296
297 /* read the current thread id */
298 retval = target_read_buffer(rtos->target,
299 rtos->symbols[THREADX_VAL_TX_THREAD_CURRENT_PTR].address,
300 4,
301 (uint8_t *)&rtos->current_thread);
302
303 if (retval != ERROR_OK) {
304 LOG_ERROR("Could not read ThreadX current thread from target");
305 return retval;
306 }
307
308 if ((thread_list_size == 0) || (rtos->current_thread == 0)) {
309 /* Either : No RTOS threads - there is always at least the current execution though */
310 /* OR : No current thread - all threads suspended - show the current execution
311 * of idling */
312 char tmp_str[] = "Current Execution";
313 thread_list_size++;
314 tasks_found++;
315 rtos->thread_details = malloc(
316 sizeof(struct thread_detail) * thread_list_size);
317 rtos->thread_details->threadid = 1;
318 rtos->thread_details->exists = true;
319 rtos->thread_details->extra_info_str = NULL;
320 rtos->thread_details->thread_name_str = malloc(sizeof(tmp_str));
321 strcpy(rtos->thread_details->thread_name_str, tmp_str);
322
323 if (thread_list_size == 0) {
324 rtos->thread_count = 1;
325 return ERROR_OK;
326 }
327 } else {
328 /* create space for new thread details */
329 rtos->thread_details = malloc(
330 sizeof(struct thread_detail) * thread_list_size);
331 }
332
333 /* Read the pointer to the first thread */
334 int64_t thread_ptr = 0;
335 retval = target_read_buffer(rtos->target,
336 rtos->symbols[THREADX_VAL_TX_THREAD_CREATED_PTR].address,
337 param->pointer_width,
338 (uint8_t *)&thread_ptr);
339 if (retval != ERROR_OK) {
340 LOG_ERROR("Could not read ThreadX thread location from target");
341 return retval;
342 }
343
344 /* loop over all threads */
345 int64_t prev_thread_ptr = 0;
346 while ((thread_ptr != prev_thread_ptr) && (tasks_found < thread_list_size)) {
347
348 #define THREADX_THREAD_NAME_STR_SIZE (200)
349 char tmp_str[THREADX_THREAD_NAME_STR_SIZE];
350 unsigned int i = 0;
351 int64_t name_ptr = 0;
352
353 /* Save the thread pointer */
354 rtos->thread_details[tasks_found].threadid = thread_ptr;
355
356 /* read the name pointer */
357 retval = target_read_buffer(rtos->target,
358 thread_ptr + param->thread_name_offset,
359 param->pointer_width,
360 (uint8_t *)&name_ptr);
361 if (retval != ERROR_OK) {
362 LOG_ERROR("Could not read ThreadX thread name pointer from target");
363 return retval;
364 }
365
366 /* Read the thread name */
367 retval =
368 target_read_buffer(rtos->target,
369 name_ptr,
370 THREADX_THREAD_NAME_STR_SIZE,
371 (uint8_t *)&tmp_str);
372 if (retval != ERROR_OK) {
373 LOG_ERROR("Error reading thread name from ThreadX target");
374 return retval;
375 }
376 tmp_str[THREADX_THREAD_NAME_STR_SIZE-1] = '\x00';
377
378 if (tmp_str[0] == '\x00')
379 strcpy(tmp_str, "No Name");
380
381 rtos->thread_details[tasks_found].thread_name_str =
382 malloc(strlen(tmp_str)+1);
383 strcpy(rtos->thread_details[tasks_found].thread_name_str, tmp_str);
384
385 /* Read the thread status */
386 int64_t thread_status = 0;
387 retval = target_read_buffer(rtos->target,
388 thread_ptr + param->thread_state_offset,
389 4,
390 (uint8_t *)&thread_status);
391 if (retval != ERROR_OK) {
392 LOG_ERROR("Error reading thread state from ThreadX target");
393 return retval;
394 }
395
396 for (i = 0; (i < THREADX_NUM_STATES) &&
397 (threadx_thread_states[i].value != thread_status); i++) {
398 /* empty */
399 }
400
401 const char *state_desc;
402 if (i < THREADX_NUM_STATES)
403 state_desc = threadx_thread_states[i].desc;
404 else
405 state_desc = "Unknown state";
406
407 rtos->thread_details[tasks_found].extra_info_str = malloc(strlen(
408 state_desc)+8);
409 sprintf(rtos->thread_details[tasks_found].extra_info_str, "State: %s", state_desc);
410
411 rtos->thread_details[tasks_found].exists = true;
412
413 tasks_found++;
414 prev_thread_ptr = thread_ptr;
415
416 /* Get the location of the next thread structure. */
417 thread_ptr = 0;
418 retval = target_read_buffer(rtos->target,
419 prev_thread_ptr + param->thread_next_offset,
420 param->pointer_width,
421 (uint8_t *) &thread_ptr);
422 if (retval != ERROR_OK) {
423 LOG_ERROR("Error reading next thread pointer in ThreadX thread list");
424 return retval;
425 }
426 }
427
428 rtos->thread_count = tasks_found;
429
430 return 0;
431 }
432
433 static int threadx_get_thread_reg_list(struct rtos *rtos, int64_t thread_id,
434 struct rtos_reg **reg_list, int *num_regs)
435 {
436 int retval;
437 const struct threadx_params *param;
438
439 if (!rtos)
440 return -1;
441
442 if (!is_thread_id_valid(rtos, thread_id))
443 return -2;
444
445 if (!rtos->rtos_specific_params)
446 return -3;
447
448 param = (const struct threadx_params *) rtos->rtos_specific_params;
449
450 /* Read the stack pointer */
451 int64_t stack_ptr = 0;
452 retval = target_read_buffer(rtos->target,
453 thread_id + param->thread_stack_offset,
454 param->pointer_width,
455 (uint8_t *)&stack_ptr);
456 if (retval != ERROR_OK) {
457 LOG_ERROR("Error reading stack frame from ThreadX thread");
458 return retval;
459 }
460
461 LOG_INFO("thread: 0x%" PRIx64 ", stack_ptr=0x%" PRIx64, (uint64_t)thread_id, (uint64_t)stack_ptr);
462
463 if (stack_ptr == 0) {
464 LOG_ERROR("null stack pointer in thread");
465 return -5;
466 }
467
468 const struct rtos_register_stacking *stacking_info =
469 get_stacking_info(rtos, stack_ptr);
470
471 if (!stacking_info) {
472 LOG_ERROR("Unknown stacking info for thread id=0x%" PRIx64, (uint64_t)thread_id);
473 return -6;
474 }
475
476 return rtos_generic_stack_read(rtos->target, stacking_info, stack_ptr, reg_list, num_regs);
477 }
478
479 static int threadx_get_symbol_list_to_lookup(struct symbol_table_elem *symbol_list[])
480 {
481 unsigned int i;
482 *symbol_list = calloc(
483 ARRAY_SIZE(threadx_symbol_list), sizeof(struct symbol_table_elem));
484
485 for (i = 0; i < ARRAY_SIZE(threadx_symbol_list); i++)
486 (*symbol_list)[i].symbol_name = threadx_symbol_list[i];
487
488 return 0;
489 }
490
491 static bool threadx_detect_rtos(struct target *target)
492 {
493 if ((target->rtos->symbols) &&
494 (target->rtos->symbols[THREADX_VAL_TX_THREAD_CREATED_PTR].address != 0)) {
495 /* looks like ThreadX */
496 return true;
497 }
498 return false;
499 }
500
501 #if 0
502
503 static int threadx_set_current_thread(struct rtos *rtos, threadid_t thread_id)
504 {
505 return 0;
506 }
507
508 static int threadx_get_thread_detail(struct rtos *rtos,
509 threadid_t thread_id,
510 struct thread_detail *detail)
511 {
512 unsigned int i = 0;
513 int retval;
514
515 #define THREADX_THREAD_NAME_STR_SIZE (200)
516 char tmp_str[THREADX_THREAD_NAME_STR_SIZE];
517
518 const struct threadx_params *param;
519
520 if (!rtos)
521 return -1;
522
523 if (thread_id == 0)
524 return -2;
525
526 if (!rtos->rtos_specific_params)
527 return -3;
528
529 param = (const struct threadx_params *) rtos->rtos_specific_params;
530
531 if (!rtos->symbols) {
532 LOG_ERROR("No symbols for ThreadX");
533 return -3;
534 }
535
536 detail->threadid = thread_id;
537
538 int64_t name_ptr = 0;
539 /* read the name pointer */
540 retval = target_read_buffer(rtos->target,
541 thread_id + param->thread_name_offset,
542 param->pointer_width,
543 (uint8_t *)&name_ptr);
544 if (retval != ERROR_OK) {
545 LOG_ERROR("Could not read ThreadX thread name pointer from target");
546 return retval;
547 }
548
549 /* Read the thread name */
550 retval = target_read_buffer(rtos->target,
551 name_ptr,
552 THREADX_THREAD_NAME_STR_SIZE,
553 (uint8_t *)&tmp_str);
554 if (retval != ERROR_OK) {
555 LOG_ERROR("Error reading thread name from ThreadX target");
556 return retval;
557 }
558 tmp_str[THREADX_THREAD_NAME_STR_SIZE-1] = '\x00';
559
560 if (tmp_str[0] == '\x00')
561 strcpy(tmp_str, "No Name");
562
563 detail->thread_name_str = malloc(strlen(tmp_str)+1);
564
565 /* Read the thread status */
566 int64_t thread_status = 0;
567 retval =
568 target_read_buffer(rtos->target,
569 thread_id + param->thread_state_offset,
570 4,
571 (uint8_t *)&thread_status);
572 if (retval != ERROR_OK) {
573 LOG_ERROR("Error reading thread state from ThreadX target");
574 return retval;
575 }
576
577 for (i = 0; (i < THREADX_NUM_STATES) &&
578 (threadx_thread_states[i].value != thread_status); i++) {
579 /* empty */
580 }
581
582 char *state_desc;
583 if (i < THREADX_NUM_STATES)
584 state_desc = threadx_thread_states[i].desc;
585 else
586 state_desc = "Unknown state";
587
588 detail->extra_info_str = malloc(strlen(state_desc)+1);
589
590 detail->exists = true;
591
592 return 0;
593 }
594
595 #endif
596
597 static int threadx_create(struct target *target)
598 {
599 for (unsigned int i = 0; i < ARRAY_SIZE(threadx_params_list); i++)
600 if (strcmp(threadx_params_list[i].target_name, target->type->name) == 0) {
601 target->rtos->rtos_specific_params = (void *)&threadx_params_list[i];
602 target->rtos->current_thread = 0;
603 target->rtos->thread_details = NULL;
604 return 0;
605 }
606
607 LOG_ERROR("Could not find target in ThreadX compatibility list");
608 return -1;
609 }
Official OpenOCD Mirror