1 /***************************************************************************
2 * Copyright (C) 2012 by Matthias Blaicher *
3 * Matthias Blaicher - matthias@blaicher.com *
5 * Copyright (C) 2011 by Broadcom Corporation *
6 * Evan Hunter - ehunter@broadcom.com *
8 * This program is free software; you can redistribute it and/or modify *
9 * it under the terms of the GNU General Public License as published by *
10 * the Free Software Foundation; either version 2 of the License, or *
11 * (at your option) any later version. *
13 * This program is distributed in the hope that it will be useful, *
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16 * GNU General Public License for more details. *
18 * You should have received a copy of the GNU General Public License *
19 * along with this program. If not, see <http://www.gnu.org/licenses/>. *
20 ***************************************************************************/
26 #include <helper/time_support.h>
27 #include <jtag/jtag.h>
28 #include "target/target.h"
29 #include "target/target_type.h"
30 #include "target/armv7m.h"
31 #include "target/cortex_m.h"
33 #include "helper/log.h"
34 #include "helper/types.h"
35 #include "rtos_chibios_stackings.h"
38 * @brief ChibiOS/RT memory signature record.
40 * @details Definition copied from os/kernel/include/chregistry.h of ChibiOS/RT.
42 struct chibios_chdebug
{
43 char ch_identifier
[4]; /**< @brief Always set to "main". */
44 uint8_t ch_zero
; /**< @brief Must be zero. */
45 uint8_t ch_size
; /**< @brief Size of this structure. */
46 uint16_t ch_version
; /**< @brief Encoded ChibiOS/RT version. */
47 uint8_t ch_ptrsize
; /**< @brief Size of a pointer. */
48 uint8_t ch_timesize
; /**< @brief Size of a @p systime_t. */
49 uint8_t ch_threadsize
; /**< @brief Size of a @p Thread struct. */
50 uint8_t cf_off_prio
; /**< @brief Offset of @p p_prio field. */
51 uint8_t cf_off_ctx
; /**< @brief Offset of @p p_ctx field. */
52 uint8_t cf_off_newer
; /**< @brief Offset of @p p_newer field. */
53 uint8_t cf_off_older
; /**< @brief Offset of @p p_older field. */
54 uint8_t cf_off_name
; /**< @brief Offset of @p p_name field. */
55 uint8_t cf_off_stklimit
; /**< @brief Offset of @p p_stklimit
57 uint8_t cf_off_state
; /**< @brief Offset of @p p_state field. */
58 uint8_t cf_off_flags
; /**< @brief Offset of @p p_flags field. */
59 uint8_t cf_off_refs
; /**< @brief Offset of @p p_refs field. */
60 uint8_t cf_off_preempt
; /**< @brief Offset of @p p_preempt
62 uint8_t cf_off_time
; /**< @brief Offset of @p p_time field. */
65 #define GET_CH_KERNEL_MAJOR(coded_version) ((coded_version >> 11) & 0x1f)
66 #define GET_CH_KERNEL_MINOR(coded_version) ((coded_version >> 6) & 0x1f)
67 #define GET_CH_KERNEL_PATCH(coded_version) ((coded_version >> 0) & 0x3f)
70 * @brief ChibiOS thread states.
72 static const char * const chibios_thread_states
[] = { "READY", "CURRENT",
73 "WTSTART", "SUSPENDED", "QUEUED", "WTSEM", "WTMTX", "WTCOND", "SLEEPING",
74 "WTEXIT", "WTOREVT", "WTANDEVT", "SNDMSGQ", "SNDMSG", "WTMSG", "FINAL"
77 #define CHIBIOS_NUM_STATES ARRAY_SIZE(chibios_thread_states)
79 /* Maximum ChibiOS thread name. There is no real limit set by ChibiOS but 64
80 * chars ought to be enough.
82 #define CHIBIOS_THREAD_NAME_STR_SIZE (64)
84 struct chibios_params
{
85 const char *target_name
;
87 struct chibios_chdebug
*signature
;
88 const struct rtos_register_stacking
*stacking_info
;
91 static struct chibios_params chibios_params_list
[] = {
93 "cortex_m", /* target_name */
95 NULL
, /* stacking_info */
98 "hla_target", /* target_name */
100 NULL
, /* stacking_info */
104 static bool chibios_detect_rtos(struct target
*target
);
105 static int chibios_create(struct target
*target
);
106 static int chibios_update_threads(struct rtos
*rtos
);
107 static int chibios_get_thread_reg_list(struct rtos
*rtos
, int64_t thread_id
,
108 struct rtos_reg
**reg_list
, int *num_regs
);
109 static int chibios_get_symbol_list_to_lookup(struct symbol_table_elem
*symbol_list
[]);
111 struct rtos_type chibios_rtos
= {
114 .detect_rtos
= chibios_detect_rtos
,
115 .create
= chibios_create
,
116 .update_threads
= chibios_update_threads
,
117 .get_thread_reg_list
= chibios_get_thread_reg_list
,
118 .get_symbol_list_to_lookup
= chibios_get_symbol_list_to_lookup
,
122 /* In ChibiOS/RT 3.0 the rlist structure has become part of a system
123 * data structure ch. We declare both symbols as optional and later
124 * use whatever is available.
127 enum chibios_symbol_values
{
128 CHIBIOS_VAL_RLIST
= 0,
130 CHIBIOS_VAL_CH_DEBUG
= 2
133 static struct symbol_table_elem chibios_symbol_list
[] = {
134 { "rlist", 0, true}, /* Thread ready list */
135 { "ch", 0, true}, /* System data structure */
136 { "ch_debug", 0, false}, /* Memory Signature containing offsets of fields in rlist */
140 /* Offset of the rlist structure within the system data structure (ch) */
141 #define CH_RLIST_OFFSET 0x00
143 static int chibios_update_memory_signature(struct rtos
*rtos
)
146 struct chibios_params
*param
;
147 struct chibios_chdebug
*signature
;
149 param
= (struct chibios_params
*) rtos
->rtos_specific_params
;
151 /* Free existing memory description.*/
152 free(param
->signature
);
153 param
->signature
= NULL
;
155 signature
= malloc(sizeof(*signature
));
157 LOG_ERROR("Could not allocate space for ChibiOS/RT memory signature");
161 retval
= target_read_buffer(rtos
->target
,
162 rtos
->symbols
[CHIBIOS_VAL_CH_DEBUG
].address
,
164 (uint8_t *) signature
);
165 if (retval
!= ERROR_OK
) {
166 LOG_ERROR("Could not read ChibiOS/RT memory signature from target");
170 if (strncmp(signature
->ch_identifier
, "main", 4) != 0) {
171 LOG_ERROR("Memory signature identifier does not contain magic bytes.");
175 if (signature
->ch_size
< sizeof(*signature
)) {
176 LOG_ERROR("ChibiOS/RT memory signature claims to be smaller "
181 if (signature
->ch_size
> sizeof(*signature
)) {
182 LOG_WARNING("ChibiOS/RT memory signature claims to be bigger than"
183 " expected. Assuming compatibility...");
186 /* Convert endianness of version field */
187 const uint8_t *versiontarget
= (const uint8_t *)
188 &signature
->ch_version
;
189 signature
->ch_version
= rtos
->target
->endianness
== TARGET_LITTLE_ENDIAN
?
190 le_to_h_u32(versiontarget
) : be_to_h_u32(versiontarget
);
192 const uint16_t ch_version
= signature
->ch_version
;
193 LOG_INFO("Successfully loaded memory map of ChibiOS/RT target "
194 "running version %i.%i.%i", GET_CH_KERNEL_MAJOR(ch_version
),
195 GET_CH_KERNEL_MINOR(ch_version
), GET_CH_KERNEL_PATCH(ch_version
));
197 /* Currently, we have the inherent assumption that all address pointers
198 * are 32 bit wide. */
199 if (signature
->ch_ptrsize
!= sizeof(uint32_t)) {
200 LOG_ERROR("ChibiOS/RT target memory signature claims an address "
201 "width unequal to 32 bits!");
206 param
->signature
= signature
;
210 /* Error reading the ChibiOS memory structure */
212 param
->signature
= 0;
217 static int chibios_update_stacking(struct rtos
*rtos
)
219 /* Sometimes the stacking can not be determined only by looking at the
220 * target name but only a runtime.
222 * For example, this is the case for Cortex-M4 targets and ChibiOS which
223 * only stack the FPU registers if it is enabled during ChibiOS build.
225 * Terminating which stacking is used is target depending.
228 * - Once ChibiOS is actually initialized, the stacking is fixed.
229 * - During startup code, the FPU might not be initialized and the
230 * detection might fail.
231 * - Since no threads are running during startup, the problem is solved
232 * by delaying stacking detection until there are more threads
233 * available than the current execution. In which case
234 * chibios_get_thread_reg_list is called.
238 if (!rtos
->rtos_specific_params
)
241 struct chibios_params
*param
;
242 param
= (struct chibios_params
*) rtos
->rtos_specific_params
;
244 /* Check for armv7m with *enabled* FPU, i.e. a Cortex-M4 */
245 struct armv7m_common
*armv7m_target
= target_to_armv7m(rtos
->target
);
246 if (is_armv7m(armv7m_target
)) {
247 if (armv7m_target
->fp_feature
!= FP_NONE
) {
248 /* Found ARM v7m target which includes a FPU */
251 retval
= target_read_u32(rtos
->target
, FPU_CPACR
, &cpacr
);
252 if (retval
!= ERROR_OK
) {
253 LOG_ERROR("Could not read CPACR register to check FPU state");
257 /* Check if CP10 and CP11 are set to full access.
258 * In ChibiOS this is done in ResetHandler() in crt0.c */
259 if (cpacr
& 0x00F00000) {
260 LOG_DEBUG("Enabled FPU detected.");
261 param
->stacking_info
= &rtos_chibios_arm_v7m_stacking_w_fpu
;
266 /* Found ARM v7m target with no or disabled FPU */
267 param
->stacking_info
= &rtos_chibios_arm_v7m_stacking
;
274 static int chibios_update_threads(struct rtos
*rtos
)
277 const struct chibios_params
*param
;
281 if (!rtos
->rtos_specific_params
)
284 if (!rtos
->symbols
) {
285 LOG_ERROR("No symbols for ChibiOS");
289 param
= (const struct chibios_params
*) rtos
->rtos_specific_params
;
290 /* Update the memory signature saved in the target memory */
291 if (!param
->signature
) {
292 retval
= chibios_update_memory_signature(rtos
);
293 if (retval
!= ERROR_OK
) {
294 LOG_ERROR("Reading the memory signature of ChibiOS/RT failed");
299 /* wipe out previous thread details if any */
300 rtos_free_threadlist(rtos
);
302 /* ChibiOS does not save the current thread count. We have to first
303 * parse the double linked thread list to check for errors and the number of
305 const uint32_t rlist
= rtos
->symbols
[CHIBIOS_VAL_RLIST
].address
?
306 rtos
->symbols
[CHIBIOS_VAL_RLIST
].address
:
307 rtos
->symbols
[CHIBIOS_VAL_CH
].address
+ CH_RLIST_OFFSET
/* ChibiOS3 */;
308 const struct chibios_chdebug
*signature
= param
->signature
;
316 retval
= target_read_u32(rtos
->target
,
317 current
+ signature
->cf_off_newer
, ¤t
);
318 if (retval
!= ERROR_OK
) {
319 LOG_ERROR("Could not read next ChibiOS thread");
322 /* Could be NULL if the kernel is not initialized yet or if the
323 * registry is corrupted. */
325 LOG_ERROR("ChibiOS registry integrity check failed, NULL pointer");
330 /* Fetch previous thread in the list as a integrity check. */
331 retval
= target_read_u32(rtos
->target
,
332 current
+ signature
->cf_off_older
, &older
);
333 if ((retval
!= ERROR_OK
) || (older
== 0) || (older
!= previous
)) {
334 LOG_ERROR("ChibiOS registry integrity check failed, "
335 "double linked list violation");
339 /* Check for full iteration of the linked list. */
340 if (current
== rlist
)
346 /* No RTOS, there is always at least the current execution, though */
347 LOG_INFO("Only showing current execution because of a broken "
348 "ChibiOS thread registry.");
350 const char tmp_thread_name
[] = "Current Execution";
351 const char tmp_thread_extra_info
[] = "No RTOS thread";
353 rtos
->thread_details
= malloc(
354 sizeof(struct thread_detail
));
355 rtos
->thread_details
->threadid
= 1;
356 rtos
->thread_details
->exists
= true;
358 rtos
->thread_details
->extra_info_str
= malloc(
359 sizeof(tmp_thread_extra_info
));
360 strcpy(rtos
->thread_details
->extra_info_str
, tmp_thread_extra_info
);
362 rtos
->thread_details
->thread_name_str
= malloc(
363 sizeof(tmp_thread_name
));
364 strcpy(rtos
->thread_details
->thread_name_str
, tmp_thread_name
);
366 rtos
->current_thread
= 1;
367 rtos
->thread_count
= 1;
371 /* create space for new thread details */
372 rtos
->thread_details
= malloc(
373 sizeof(struct thread_detail
) * tasks_found
);
374 if (!rtos
->thread_details
) {
375 LOG_ERROR("Could not allocate space for thread details");
379 rtos
->thread_count
= tasks_found
;
380 /* Loop through linked list. */
381 struct thread_detail
*curr_thrd_details
= rtos
->thread_details
;
382 while (curr_thrd_details
< rtos
->thread_details
+ tasks_found
) {
383 uint32_t name_ptr
= 0;
384 char tmp_str
[CHIBIOS_THREAD_NAME_STR_SIZE
];
386 retval
= target_read_u32(rtos
->target
,
387 current
+ signature
->cf_off_newer
, ¤t
);
388 if (retval
!= ERROR_OK
) {
389 LOG_ERROR("Could not read next ChibiOS thread");
393 /* Check for full iteration of the linked list. */
394 if (current
== rlist
)
397 /* Save the thread pointer */
398 curr_thrd_details
->threadid
= current
;
400 /* read the name pointer */
401 retval
= target_read_u32(rtos
->target
,
402 current
+ signature
->cf_off_name
, &name_ptr
);
403 if (retval
!= ERROR_OK
) {
404 LOG_ERROR("Could not read ChibiOS thread name pointer from target");
408 /* Read the thread name */
409 retval
= target_read_buffer(rtos
->target
, name_ptr
,
410 CHIBIOS_THREAD_NAME_STR_SIZE
,
411 (uint8_t *)&tmp_str
);
412 if (retval
!= ERROR_OK
) {
413 LOG_ERROR("Error reading thread name from ChibiOS target");
416 tmp_str
[CHIBIOS_THREAD_NAME_STR_SIZE
- 1] = '\x00';
418 if (tmp_str
[0] == '\x00')
419 strcpy(tmp_str
, "No Name");
421 curr_thrd_details
->thread_name_str
= malloc(
422 strlen(tmp_str
) + 1);
423 strcpy(curr_thrd_details
->thread_name_str
, tmp_str
);
426 uint8_t thread_state
;
427 const char *state_desc
;
429 retval
= target_read_u8(rtos
->target
,
430 current
+ signature
->cf_off_state
, &thread_state
);
431 if (retval
!= ERROR_OK
) {
432 LOG_ERROR("Error reading thread state from ChibiOS target");
437 if (thread_state
< CHIBIOS_NUM_STATES
)
438 state_desc
= chibios_thread_states
[thread_state
];
440 state_desc
= "Unknown";
442 curr_thrd_details
->extra_info_str
= malloc(strlen(
444 sprintf(curr_thrd_details
->extra_info_str
, "State: %s", state_desc
);
446 curr_thrd_details
->exists
= true;
451 uint32_t current_thrd
;
452 /* NOTE: By design, cf_off_name equals readylist_current_offset */
453 retval
= target_read_u32(rtos
->target
,
454 rlist
+ signature
->cf_off_name
,
456 if (retval
!= ERROR_OK
) {
457 LOG_ERROR("Could not read current Thread from ChibiOS target");
460 rtos
->current_thread
= current_thrd
;
465 static int chibios_get_thread_reg_list(struct rtos
*rtos
, int64_t thread_id
,
466 struct rtos_reg
**reg_list
, int *num_regs
)
469 const struct chibios_params
*param
;
470 uint32_t stack_ptr
= 0;
472 if ((!rtos
) || (thread_id
== 0) ||
473 (!rtos
->rtos_specific_params
))
476 param
= (const struct chibios_params
*) rtos
->rtos_specific_params
;
478 if (!param
->signature
)
481 /* Update stacking if it can only be determined from runtime information */
482 if ((param
->stacking_info
== 0) &&
483 (chibios_update_stacking(rtos
) != ERROR_OK
)) {
484 LOG_ERROR("Failed to determine exact stacking for the target type %s", rtos
->target
->type
->name
);
488 /* Read the stack pointer */
489 retval
= target_read_u32(rtos
->target
,
490 thread_id
+ param
->signature
->cf_off_ctx
, &stack_ptr
);
491 if (retval
!= ERROR_OK
) {
492 LOG_ERROR("Error reading stack frame from ChibiOS thread");
496 return rtos_generic_stack_read(rtos
->target
, param
->stacking_info
, stack_ptr
, reg_list
, num_regs
);
499 static int chibios_get_symbol_list_to_lookup(struct symbol_table_elem
*symbol_list
[])
501 *symbol_list
= malloc(sizeof(chibios_symbol_list
));
506 memcpy(*symbol_list
, chibios_symbol_list
, sizeof(chibios_symbol_list
));
510 static bool chibios_detect_rtos(struct target
*target
)
512 if ((target
->rtos
->symbols
) &&
513 ((target
->rtos
->symbols
[CHIBIOS_VAL_RLIST
].address
!= 0) ||
514 (target
->rtos
->symbols
[CHIBIOS_VAL_CH
].address
!= 0))) {
516 if (target
->rtos
->symbols
[CHIBIOS_VAL_CH_DEBUG
].address
== 0) {
517 LOG_INFO("It looks like the target may be running ChibiOS "
518 "without ch_debug.");
522 /* looks like ChibiOS with memory map enabled.*/
529 static int chibios_create(struct target
*target
)
531 for (unsigned int i
= 0; i
< ARRAY_SIZE(chibios_params_list
); i
++)
532 if (strcmp(chibios_params_list
[i
].target_name
, target
->type
->name
) == 0) {
533 target
->rtos
->rtos_specific_params
= (void *)&chibios_params_list
[i
];
537 LOG_WARNING("Could not find target \"%s\" in ChibiOS compatibility "
538 "list", target
->type
->name
);
Linking to existing account procedure
If you already have an account and want to add another login method
you
MUST first sign in with your existing account and
then change URL to read
https://review.openocd.org/login/?link
to get to this page again but this time it'll work for linking. Thank you.
SSH host keys fingerprints
1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=.. |
|+o.. . |
|*.o . . |
|+B . . . |
|Bo. = o S |
|Oo.+ + = |
|oB=.* = . o |
| =+=.+ + E |
|. .=o . o |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)