1 /***************************************************************************
2 * Copyright (C) 2015 by Daniel Krebs *
3 * Daniel Krebs - github@daniel-krebs.net *
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, see <http://www.gnu.org/licenses/>. *
17 ***************************************************************************/
23 #include <helper/time_support.h>
24 #include <jtag/jtag.h>
25 #include "target/target.h"
26 #include "target/target_type.h"
28 #include "helper/log.h"
29 #include "helper/types.h"
30 #include "target/armv7m.h"
31 #include "rtos_riot_stackings.h"
33 static bool riot_detect_rtos(struct target *target);
34 static int riot_create(struct target *target);
35 static int riot_update_threads(struct rtos *rtos);
36 static int riot_get_thread_reg_list(struct rtos *rtos, int64_t thread_id,
37 struct rtos_reg **reg_list, int *num_regs);
38 static int riot_get_symbol_list_to_lookup(struct symbol_table_elem *symbol_list[]);
40 struct riot_thread_state {
45 /* refer RIOT sched.h */
46 static const struct riot_thread_state riot_thread_states[] = {
50 { 3, "Blocked mutex" },
51 { 4, "Blocked receive" },
52 { 5, "Blocked send" },
53 { 6, "Blocked reply" },
54 { 7, "Blocked any flag" },
55 { 8, "Blocked all flags" },
56 { 9, "Blocked mbox" },
57 { 10, "Blocked condition" },
61 #define RIOT_NUM_STATES ARRAY_SIZE(riot_thread_states)
64 const char *target_name;
65 unsigned char thread_sp_offset;
66 unsigned char thread_status_offset;
69 static const struct riot_params riot_params_list[] = {
71 "cortex_m", /* target_name */
72 0x00, /* thread_sp_offset */
73 0x04, /* thread_status_offset */
76 "hla_target", /* target_name */
77 0x00, /* thread_sp_offset */
78 0x04, /* thread_status_offset */
81 #define RIOT_NUM_PARAMS ARRAY_SIZE(riot_params_list)
83 /* Initialize in riot_create() depending on architecture */
84 static const struct rtos_register_stacking *stacking_info;
86 enum riot_symbol_values {
87 RIOT_THREADS_BASE = 0,
94 /* refer RIOT core/sched.c */
95 static const char *const riot_symbol_list[] = {
104 /* Define which symbols are not mandatory */
105 static const enum riot_symbol_values riot_optional_symbols[] = {
109 const struct rtos_type riot_rtos = {
111 .detect_rtos = riot_detect_rtos,
112 .create = riot_create,
113 .update_threads = riot_update_threads,
114 .get_thread_reg_list = riot_get_thread_reg_list,
115 .get_symbol_list_to_lookup = riot_get_symbol_list_to_lookup,
118 static int riot_update_threads(struct rtos *rtos)
121 unsigned int tasks_found = 0;
122 const struct riot_params *param;
127 if (rtos->rtos_specific_params == NULL)
130 param = (const struct riot_params *)rtos->rtos_specific_params;
132 if (rtos->symbols == NULL) {
133 LOG_ERROR("No symbols for RIOT");
137 if (rtos->symbols[RIOT_THREADS_BASE].address == 0) {
138 LOG_ERROR("Can't find symbol `%s`",
139 riot_symbol_list[RIOT_THREADS_BASE]);
143 /* wipe out previous thread details if any */
144 rtos_free_threadlist(rtos);
147 rtos->current_thread = 0;
148 rtos->thread_count = 0;
150 /* read the current thread id */
151 int16_t active_pid = 0;
152 retval = target_read_u16(rtos->target,
153 rtos->symbols[RIOT_ACTIVE_PID].address,
154 (uint16_t *)&active_pid);
155 if (retval != ERROR_OK) {
156 LOG_ERROR("Can't read symbol `%s`",
157 riot_symbol_list[RIOT_ACTIVE_PID]);
160 rtos->current_thread = active_pid;
162 /* read the current thread count
163 * It's `int` in RIOT, but this is Cortex M* only anyway */
164 int32_t thread_count = 0;
165 retval = target_read_u16(rtos->target,
166 rtos->symbols[RIOT_NUM_THREADS].address,
167 (uint16_t *)&thread_count);
168 if (retval != ERROR_OK) {
169 LOG_ERROR("Can't read symbol `%s`",
170 riot_symbol_list[RIOT_NUM_THREADS]);
173 rtos->thread_count = thread_count;
175 /* read the maximum number of threads */
176 uint8_t max_threads = 0;
177 retval = target_read_u8(rtos->target,
178 rtos->symbols[RIOT_MAX_THREADS].address,
180 if (retval != ERROR_OK) {
181 LOG_ERROR("Can't read symbol `%s`",
182 riot_symbol_list[RIOT_MAX_THREADS]);
186 /* Base address of thread array */
187 uint32_t threads_base = rtos->symbols[RIOT_THREADS_BASE].address;
189 /* Try to get the offset of tcb_t::name, if absent RIOT wasn't compiled
190 * with DEVELHELP, so there are no thread names */
191 uint8_t name_offset = 0;
192 if (rtos->symbols[RIOT_NAME_OFFSET].address != 0) {
193 retval = target_read_u8(rtos->target,
194 rtos->symbols[RIOT_NAME_OFFSET].address,
196 if (retval != ERROR_OK) {
197 LOG_ERROR("Can't read symbol `%s`",
198 riot_symbol_list[RIOT_NAME_OFFSET]);
203 /* Allocate memory for thread description */
204 rtos->thread_details = calloc(thread_count, sizeof(struct thread_detail));
205 if (rtos->thread_details == NULL) {
206 LOG_ERROR("RIOT: out of memory");
210 /* Buffer for thread names, maximum to display is 32 */
213 for (unsigned int i = 0; i < max_threads; i++) {
214 /* get pointer to tcb_t */
215 uint32_t tcb_pointer = 0;
216 retval = target_read_u32(rtos->target,
217 threads_base + (i * 4),
219 if (retval != ERROR_OK) {
220 LOG_ERROR("Can't parse `%s`", riot_symbol_list[RIOT_THREADS_BASE]);
224 if (tcb_pointer == 0) {
230 rtos->thread_details[tasks_found].threadid = i;
232 /* read thread state */
234 retval = target_read_u8(rtos->target,
235 tcb_pointer + param->thread_status_offset,
237 if (retval != ERROR_OK) {
238 LOG_ERROR("Can't parse `%s`", riot_symbol_list[RIOT_THREADS_BASE]);
242 /* Search for state */
244 for (k = 0; k < RIOT_NUM_STATES; k++) {
245 if (riot_thread_states[k].value == status)
249 /* Copy state string */
250 if (k >= RIOT_NUM_STATES) {
251 rtos->thread_details[tasks_found].extra_info_str =
252 strdup("unknown state");
254 rtos->thread_details[tasks_found].extra_info_str =
255 strdup(riot_thread_states[k].desc);
258 if (rtos->thread_details[tasks_found].extra_info_str == NULL) {
259 LOG_ERROR("RIOT: out of memory");
264 /* Thread names are only available if compiled with DEVELHELP */
265 if (name_offset != 0) {
266 uint32_t name_pointer = 0;
267 retval = target_read_u32(rtos->target,
268 tcb_pointer + name_offset,
270 if (retval != ERROR_OK) {
271 LOG_ERROR("Can't parse `%s`",
272 riot_symbol_list[RIOT_THREADS_BASE]);
276 /* read thread name */
277 retval = target_read_buffer(rtos->target,
281 if (retval != ERROR_OK) {
282 LOG_ERROR("Can't parse `%s`",
283 riot_symbol_list[RIOT_THREADS_BASE]);
287 /* Make sure the string in the buffer terminates */
288 if (buffer[sizeof(buffer) - 1] != 0)
289 buffer[sizeof(buffer) - 1] = 0;
291 /* Copy thread name */
292 rtos->thread_details[tasks_found].thread_name_str =
296 rtos->thread_details[tasks_found].thread_name_str =
297 strdup("Enable DEVELHELP to see task names");
300 if (rtos->thread_details[tasks_found].thread_name_str == NULL) {
301 LOG_ERROR("RIOT: out of memory");
306 rtos->thread_details[tasks_found].exists = true;
314 rtos_free_threadlist(rtos);
318 static int riot_get_thread_reg_list(struct rtos *rtos, int64_t thread_id,
319 struct rtos_reg **reg_list, int *num_regs)
322 const struct riot_params *param;
330 if (rtos->rtos_specific_params == NULL)
333 param = (const struct riot_params *)rtos->rtos_specific_params;
335 /* find the thread with given thread id */
336 uint32_t threads_base = rtos->symbols[RIOT_THREADS_BASE].address;
337 uint32_t tcb_pointer = 0;
338 retval = target_read_u32(rtos->target,
339 threads_base + (thread_id * 4),
341 if (retval != ERROR_OK) {
342 LOG_ERROR("Can't parse `%s`", riot_symbol_list[RIOT_THREADS_BASE]);
346 /* read stack pointer for that thread */
347 uint32_t stackptr = 0;
348 retval = target_read_u32(rtos->target,
349 tcb_pointer + param->thread_sp_offset,
351 if (retval != ERROR_OK) {
352 LOG_ERROR("Can't parse `%s`", riot_symbol_list[RIOT_THREADS_BASE]);
356 return rtos_generic_stack_read(rtos->target,
363 static int riot_get_symbol_list_to_lookup(struct symbol_table_elem *symbol_list[])
365 *symbol_list = calloc(ARRAY_SIZE(riot_symbol_list), sizeof(struct symbol_table_elem));
367 if (*symbol_list == NULL) {
368 LOG_ERROR("RIOT: out of memory");
372 for (unsigned int i = 0; i < ARRAY_SIZE(riot_symbol_list); i++) {
373 (*symbol_list)[i].symbol_name = riot_symbol_list[i];
374 (*symbol_list)[i].optional = false;
376 /* Lookup if symbol is optional */
377 for (unsigned int k = 0; k < sizeof(riot_optional_symbols); k++) {
378 if (i == riot_optional_symbols[k]) {
379 (*symbol_list)[i].optional = true;
388 static bool riot_detect_rtos(struct target *target)
390 if ((target->rtos->symbols != NULL) &&
391 (target->rtos->symbols[RIOT_THREADS_BASE].address != 0)) {
392 /* looks like RIOT */
398 static int riot_create(struct target *target)
402 /* lookup if target is supported by RIOT */
403 while ((i < RIOT_NUM_PARAMS) &&
404 (0 != strcmp(riot_params_list[i].target_name, target->type->name))) {
407 if (i >= RIOT_NUM_PARAMS) {
408 LOG_ERROR("Could not find target in RIOT compatibility list");
412 target->rtos->rtos_specific_params = (void *)&riot_params_list[i];
413 target->rtos->current_thread = 0;
414 target->rtos->thread_details = NULL;
416 /* Stacking is different depending on architecture */
417 struct armv7m_common *armv7m_target = target_to_armv7m(target);
419 if (armv7m_target->arm.is_armv6m)
420 stacking_info = &rtos_riot_cortex_m0_stacking;
421 else if (is_armv7m(armv7m_target))
422 stacking_info = &rtos_riot_cortex_m34_stacking;
424 LOG_ERROR("No stacking info for architecture");