OpenOCD
ThreadX.c
Go to the documentation of this file.
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"
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 
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)
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)
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 
103 {
105  .stack_growth_direction = -1,
106  .num_output_registers = 17,
108 },
109 {
110  .stack_registers_size = ARM926EJS_REGISTERS_SIZE_INTERRUPT,
111  .stack_growth_direction = -1,
112  .num_output_registers = 17,
114 },
115 };
116 
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;
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 
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 
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 
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 
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,
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 */
296 
297  /* read the current thread id */
298  retval = target_read_buffer(rtos->target,
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);
318  rtos->thread_details->exists = true;
320  rtos->thread_details->thread_name_str = malloc(sizeof(tmp_str));
321  strcpy(rtos->thread_details->thread_name_str, tmp_str);
322 
323  /* If we just invented thread 1 to represent the current execution, we
324  * need to make sure the RTOS object also claims it's the current thread
325  * so that threadx_get_thread_reg_list() doesn't attempt to read a
326  * thread control block at 0x00000001. */
327  rtos->current_thread = 1;
328 
329  if (thread_list_size == 0) {
330  rtos->thread_count = 1;
331  return ERROR_OK;
332  }
333  } else {
334  /* create space for new thread details */
335  rtos->thread_details = malloc(
336  sizeof(struct thread_detail) * thread_list_size);
337  }
338 
339  /* Read the pointer to the first thread */
340  int64_t thread_ptr = 0;
341  retval = target_read_buffer(rtos->target,
343  param->pointer_width,
344  (uint8_t *)&thread_ptr);
345  if (retval != ERROR_OK) {
346  LOG_ERROR("Could not read ThreadX thread location from target");
347  return retval;
348  }
349 
350  /* loop over all threads */
351  int64_t prev_thread_ptr = 0;
352  while ((thread_ptr != prev_thread_ptr) && (tasks_found < thread_list_size)) {
353 
354  #define THREADX_THREAD_NAME_STR_SIZE (200)
355  char tmp_str[THREADX_THREAD_NAME_STR_SIZE];
356  unsigned int i = 0;
357  int64_t name_ptr = 0;
358 
359  /* Save the thread pointer */
360  rtos->thread_details[tasks_found].threadid = thread_ptr;
361 
362  /* read the name pointer */
363  retval = target_read_buffer(rtos->target,
364  thread_ptr + param->thread_name_offset,
365  param->pointer_width,
366  (uint8_t *)&name_ptr);
367  if (retval != ERROR_OK) {
368  LOG_ERROR("Could not read ThreadX thread name pointer from target");
369  return retval;
370  }
371 
372  /* Read the thread name */
373  tmp_str[0] = '\x00';
374 
375  /* Check if thread has a valid name */
376  if (name_ptr != 0) {
377  retval =
379  name_ptr,
381  (uint8_t *)&tmp_str);
382  if (retval != ERROR_OK) {
383  LOG_ERROR("Error reading thread name from ThreadX target");
384  return retval;
385  }
386  tmp_str[THREADX_THREAD_NAME_STR_SIZE - 1] = '\x00';
387  }
388 
389  if (tmp_str[0] == '\x00')
390  strcpy(tmp_str, "No Name");
391 
392  rtos->thread_details[tasks_found].thread_name_str =
393  malloc(strlen(tmp_str)+1);
394  strcpy(rtos->thread_details[tasks_found].thread_name_str, tmp_str);
395 
396  /* Read the thread status */
397  int64_t thread_status = 0;
398  retval = target_read_buffer(rtos->target,
399  thread_ptr + param->thread_state_offset,
400  4,
401  (uint8_t *)&thread_status);
402  if (retval != ERROR_OK) {
403  LOG_ERROR("Error reading thread state from ThreadX target");
404  return retval;
405  }
406 
407  for (i = 0; (i < THREADX_NUM_STATES) &&
408  (threadx_thread_states[i].value != thread_status); i++) {
409  /* empty */
410  }
411 
412  const char *state_desc;
413  if (i < THREADX_NUM_STATES)
414  state_desc = threadx_thread_states[i].desc;
415  else
416  state_desc = "Unknown state";
417 
418  rtos->thread_details[tasks_found].extra_info_str = malloc(strlen(
419  state_desc)+8);
420  sprintf(rtos->thread_details[tasks_found].extra_info_str, "State: %s", state_desc);
421 
422  rtos->thread_details[tasks_found].exists = true;
423 
424  tasks_found++;
425  prev_thread_ptr = thread_ptr;
426 
427  /* Get the location of the next thread structure. */
428  thread_ptr = 0;
429  retval = target_read_buffer(rtos->target,
430  prev_thread_ptr + param->thread_next_offset,
431  param->pointer_width,
432  (uint8_t *) &thread_ptr);
433  if (retval != ERROR_OK) {
434  LOG_ERROR("Error reading next thread pointer in ThreadX thread list");
435  return retval;
436  }
437  }
438 
439  rtos->thread_count = tasks_found;
440 
441  return 0;
442 }
443 
444 static int threadx_get_thread_reg_list(struct rtos *rtos, int64_t thread_id,
445  struct rtos_reg **reg_list, int *num_regs)
446 {
447  int retval;
448  const struct threadx_params *param;
449 
450  if (!rtos)
451  return -1;
452 
453  if (!is_thread_id_valid(rtos, thread_id))
454  return -2;
455 
457  return -3;
458 
459  param = (const struct threadx_params *) rtos->rtos_specific_params;
460 
461  /* Read the stack pointer */
462  int64_t stack_ptr = 0;
463  retval = target_read_buffer(rtos->target,
464  thread_id + param->thread_stack_offset,
465  param->pointer_width,
466  (uint8_t *)&stack_ptr);
467  if (retval != ERROR_OK) {
468  LOG_ERROR("Error reading stack frame from ThreadX thread");
469  return retval;
470  }
471 
472  LOG_INFO("thread: 0x%" PRIx64 ", stack_ptr=0x%" PRIx64, (uint64_t)thread_id, (uint64_t)stack_ptr);
473 
474  if (stack_ptr == 0) {
475  LOG_ERROR("null stack pointer in thread");
476  return -5;
477  }
478 
479  const struct rtos_register_stacking *stacking_info =
480  get_stacking_info(rtos, stack_ptr);
481 
482  if (!stacking_info) {
483  LOG_ERROR("Unknown stacking info for thread id=0x%" PRIx64, (uint64_t)thread_id);
484  return -6;
485  }
486 
487  return rtos_generic_stack_read(rtos->target, stacking_info, stack_ptr, reg_list, num_regs);
488 }
489 
490 static int threadx_get_symbol_list_to_lookup(struct symbol_table_elem *symbol_list[])
491 {
492  unsigned int i;
493  *symbol_list = calloc(
495 
496  for (i = 0; i < ARRAY_SIZE(threadx_symbol_list); i++)
497  (*symbol_list)[i].symbol_name = threadx_symbol_list[i];
498 
499  return 0;
500 }
501 
502 static bool threadx_detect_rtos(struct target *target)
503 {
504  if ((target->rtos->symbols) &&
506  /* looks like ThreadX */
507  return true;
508  }
509  return false;
510 }
511 
512 #if 0
513 
514 static int threadx_set_current_thread(struct rtos *rtos, threadid_t thread_id)
515 {
516  return 0;
517 }
518 
519 static int threadx_get_thread_detail(struct rtos *rtos,
520  threadid_t thread_id,
521  struct thread_detail *detail)
522 {
523  unsigned int i = 0;
524  int retval;
525 
526 #define THREADX_THREAD_NAME_STR_SIZE (200)
527  char tmp_str[THREADX_THREAD_NAME_STR_SIZE];
528 
529  const struct threadx_params *param;
530 
531  if (!rtos)
532  return -1;
533 
534  if (thread_id == 0)
535  return -2;
536 
538  return -3;
539 
540  param = (const struct threadx_params *) rtos->rtos_specific_params;
541 
542  if (!rtos->symbols) {
543  LOG_ERROR("No symbols for ThreadX");
544  return -3;
545  }
546 
547  detail->threadid = thread_id;
548 
549  int64_t name_ptr = 0;
550  /* read the name pointer */
551  retval = target_read_buffer(rtos->target,
552  thread_id + param->thread_name_offset,
553  param->pointer_width,
554  (uint8_t *)&name_ptr);
555  if (retval != ERROR_OK) {
556  LOG_ERROR("Could not read ThreadX thread name pointer from target");
557  return retval;
558  }
559 
560  /* Read the thread name */
561  retval = target_read_buffer(rtos->target,
562  name_ptr,
564  (uint8_t *)&tmp_str);
565  if (retval != ERROR_OK) {
566  LOG_ERROR("Error reading thread name from ThreadX target");
567  return retval;
568  }
569  tmp_str[THREADX_THREAD_NAME_STR_SIZE-1] = '\x00';
570 
571  if (tmp_str[0] == '\x00')
572  strcpy(tmp_str, "No Name");
573 
574  detail->thread_name_str = malloc(strlen(tmp_str)+1);
575 
576  /* Read the thread status */
577  int64_t thread_status = 0;
578  retval =
580  thread_id + param->thread_state_offset,
581  4,
582  (uint8_t *)&thread_status);
583  if (retval != ERROR_OK) {
584  LOG_ERROR("Error reading thread state from ThreadX target");
585  return retval;
586  }
587 
588  for (i = 0; (i < THREADX_NUM_STATES) &&
589  (threadx_thread_states[i].value != thread_status); i++) {
590  /* empty */
591  }
592 
593  char *state_desc;
594  if (i < THREADX_NUM_STATES)
595  state_desc = threadx_thread_states[i].desc;
596  else
597  state_desc = "Unknown state";
598 
599  detail->extra_info_str = malloc(strlen(state_desc)+1);
600 
601  detail->exists = true;
602 
603  return 0;
604 }
605 
606 #endif
607 
608 static int threadx_create(struct target *target)
609 {
610  for (unsigned int i = 0; i < ARRAY_SIZE(threadx_params_list); i++)
611  if (strcmp(threadx_params_list[i].target_name, target->type->name) == 0) {
613  target->rtos->current_thread = 0;
615  return 0;
616  }
617 
618  LOG_ERROR("Could not find target in ThreadX compatibility list");
619  return -1;
620 }
static const struct rtos_register_stacking * get_stacking_info(const struct rtos *rtos, int64_t stack_ptr)
Definition: ThreadX.c:204
static const struct threadx_params threadx_params_list[]
Definition: ThreadX.c:130
#define ARM926EJS_REGISTERS_SIZE_SOLICITED
Definition: ThreadX.c:59
#define THREADX_THREAD_NAME_STR_SIZE
static int threadx_create(struct target *target)
Definition: ThreadX.c:608
static const struct rtos_register_stacking * get_stacking_info_arm926ejs(const struct rtos *rtos, int64_t stack_ptr)
Definition: ThreadX.c:229
static const char *const threadx_symbol_list[]
Definition: ThreadX.c:187
#define ARM926EJS_REGISTERS_SIZE_INTERRUPT
Definition: ThreadX.c:81
const struct rtos_type threadx_rtos
Definition: ThreadX.c:194
static bool threadx_detect_rtos(struct target *target)
Definition: ThreadX.c:502
static const struct rtos_register_stacking rtos_threadx_arm926ejs_stacking[]
Definition: ThreadX.c:102
static const struct stack_register_offset rtos_threadx_arm926ejs_stack_offsets_solicited[]
Definition: ThreadX.c:60
static int threadx_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, struct rtos_reg **reg_list, int *num_regs)
Definition: ThreadX.c:444
static int threadx_get_symbol_list_to_lookup(struct symbol_table_elem *symbol_list[])
Definition: ThreadX.c:490
static int is_thread_id_valid_arm926ejs(const struct rtos *rtos, int64_t thread_id)
Definition: ThreadX.c:253
static int threadx_update_threads(struct rtos *rtos)
Definition: ThreadX.c:258
threadx_symbol_values
Definition: ThreadX.c:181
@ THREADX_VAL_TX_THREAD_CREATED_PTR
Definition: ThreadX.c:183
@ THREADX_VAL_TX_THREAD_CURRENT_PTR
Definition: ThreadX.c:182
@ THREADX_VAL_TX_THREAD_CREATED_COUNT
Definition: ThreadX.c:184
static const struct threadx_thread_state threadx_thread_states[]
Definition: ThreadX.c:40
static const struct stack_register_offset rtos_threadx_arm926ejs_stack_offsets_interrupt[]
Definition: ThreadX.c:82
#define THREADX_NUM_STATES
Definition: ThreadX.c:57
static int is_thread_id_valid(const struct rtos *rtos, int64_t thread_id)
Definition: ThreadX.c:214
static struct aice_port_param_s param
The JTAG interface can be implemented with a software or hardware fifo.
#define LOG_ERROR(expr ...)
Definition: log.h:123
#define LOG_INFO(expr ...)
Definition: log.h:117
#define LOG_DEBUG(expr ...)
Definition: log.h:109
#define ERROR_OK
Definition: log.h:155
int flag
Definition: mips32.c:41
static const struct rtos_register_stacking * stacking_info
Definition: riot.c:73
int rtos_generic_stack_read(struct target *target, const struct rtos_register_stacking *stacking, int64_t stack_ptr, struct rtos_reg **reg_list, int *num_regs)
Definition: rtos.c:617
void rtos_free_threadlist(struct rtos *rtos)
Definition: rtos.c:707
int64_t threadid_t
Definition: rtos.h:15
const struct rtos_register_stacking rtos_standard_cortex_m3_stacking
const struct rtos_register_stacking rtos_standard_cortex_r4_stacking
Definition: rtos.h:53
unsigned char stack_registers_size
Definition: rtos.h:92
Definition: rtos.h:59
const char * name
Definition: rtos.h:60
Definition: rtos.h:36
int thread_count
Definition: rtos.h:47
struct thread_detail * thread_details
Definition: rtos.h:46
struct symbol_table_elem * symbols
Definition: rtos.h:39
struct target * target
Definition: rtos.h:40
void * rtos_specific_params
Definition: rtos.h:50
threadid_t current_thread
Definition: rtos.h:45
Table should be terminated by an element with NULL in symbol_name.
Definition: rtos.h:23
symbol_address_t address
Definition: rtos.h:25
const char * name
Name of this type of target.
Definition: target_type.h:31
Definition: target.h:120
struct rtos * rtos
Definition: target.h:188
struct target_type * type
Definition: target.h:121
char * extra_info_str
Definition: rtos.h:33
char * thread_name_str
Definition: rtos.h:32
bool exists
Definition: rtos.h:31
threadid_t threadid
Definition: rtos.h:30
unsigned char thread_state_offset
Definition: ThreadX.c:122
unsigned char pointer_width
Definition: ThreadX.c:119
size_t stacking_info_nb
Definition: ThreadX.c:125
const struct rtos_register_stacking * stacking_info
Definition: ThreadX.c:124
unsigned char thread_next_offset
Definition: ThreadX.c:123
const char * target_name
Definition: ThreadX.c:118
int(* fn_is_thread_id_valid)(const struct rtos *rtos, int64_t thread_id)
Definition: ThreadX.c:127
unsigned char thread_stack_offset
Definition: ThreadX.c:120
unsigned char thread_name_offset
Definition: ThreadX.c:121
const char * desc
Definition: ThreadX.c:37
int target_read_buffer(struct target *target, target_addr_t address, uint32_t size, uint8_t *buffer)
Definition: target.c:2473
static const char * target_name(struct target *target)
Returns the instance-specific name of the specified target.
Definition: target.h:234
#define ARRAY_SIZE(x)
Compute the number of elements of a variable length array.
Definition: types.h:57
#define NULL
Definition: usb.h:16