?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Upstream a whole host of RISC-V changes.
[openocd.git] / src / rtos / uCOS-III.c
blob385c8d84117997e565ed1232097537e78ba914f7
1 /***************************************************************************
2 * Copyright (C) 2017 by Square, Inc. *
3 * Steven Stallion <stallion@squareup.com> *
4 * *
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. *
9 * *
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. *
14 * *
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 ***************************************************************************/
18
19 #ifdef HAVE_CONFIG_H
20 #include "config.h"
21 #endif
22
23 #include <helper/log.h>
24 #include <helper/time_support.h>
25 #include <helper/types.h>
26 #include <rtos/rtos.h>
27 #include <target/target.h>
28 #include <target/target_type.h>
29
30 #include "rtos_ucos_iii_stackings.h"
31
32 #ifndef UCOS_III_MAX_STRLEN
33 #define UCOS_III_MAX_STRLEN 64
34 #endif
35
36 #ifndef UCOS_III_MAX_THREADS
37 #define UCOS_III_MAX_THREADS 256
38 #endif
39
40 struct ucos_iii_params {
41 const char *target_name;
42 const unsigned char pointer_width;
43 symbol_address_t thread_stack_offset;
44 symbol_address_t thread_name_offset;
45 symbol_address_t thread_state_offset;
46 symbol_address_t thread_priority_offset;
47 symbol_address_t thread_prev_offset;
48 symbol_address_t thread_next_offset;
49 bool thread_offsets_updated;
50 size_t threadid_start;
51 const struct rtos_register_stacking *stacking_info;
52 size_t num_threads;
53 symbol_address_t threads[];
54 };
55
56 static const struct ucos_iii_params ucos_iii_params_list[] = {
57 {
58 "cortex_m", /* target_name */
59 sizeof(uint32_t), /* pointer_width */
60 0, /* thread_stack_offset */
61 0, /* thread_name_offset */
62 0, /* thread_state_offset */
63 0, /* thread_priority_offset */
64 0, /* thread_prev_offset */
65 0, /* thread_next_offset */
66 false, /* thread_offsets_updated */
67 1, /* threadid_start */
68 &rtos_ucos_iii_cortex_m_stacking, /* stacking_info */
69 0, /* num_threads */
70 },
71 {
72 "esirisc", /* target_name */
73 sizeof(uint32_t), /* pointer_width */
74 0, /* thread_stack_offset */
75 0, /* thread_name_offset */
76 0, /* thread_state_offset */
77 0, /* thread_priority_offset */
78 0, /* thread_prev_offset */
79 0, /* thread_next_offset */
80 false, /* thread_offsets_updated */
81 1, /* threadid_start */
82 &rtos_ucos_iii_esi_risc_stacking, /* stacking_info */
83 0, /* num_threads */
84 },
85 };
86
87 static const char * const ucos_iii_symbol_list[] = {
88 "OSRunning",
89 "OSTCBCurPtr",
90 "OSTaskDbgListPtr",
91 "OSTaskQty",
92
93 /* also see: contrib/rtos-helpers/uCOS-III-openocd.c */
94 "openocd_OS_TCB_StkPtr_offset",
95 "openocd_OS_TCB_NamePtr_offset",
96 "openocd_OS_TCB_TaskState_offset",
97 "openocd_OS_TCB_Prio_offset",
98 "openocd_OS_TCB_DbgPrevPtr_offset",
99 "openocd_OS_TCB_DbgNextPtr_offset",
100 NULL
101 };
102
103 enum ucos_iii_symbol_values {
104 UCOS_III_VAL_OS_RUNNING,
105 UCOS_III_VAL_OS_TCB_CUR_PTR,
106 UCOS_III_VAL_OS_TASK_DBG_LIST_PTR,
107 UCOS_III_VAL_OS_TASK_QTY,
108
109 /* also see: contrib/rtos-helpers/uCOS-III-openocd.c */
110 UCOS_III_VAL_OS_TCB_STK_PTR_OFFSET,
111 UCOS_III_VAL_OS_TCB_NAME_PTR_OFFSET,
112 UCOS_III_VAL_OS_TCB_TASK_STATE_OFFSET,
113 UCOS_III_VAL_OS_TCB_PRIO_OFFSET,
114 UCOS_III_VAL_OS_TCB_DBG_PREV_PTR_OFFSET,
115 UCOS_III_VAL_OS_TCB_DBG_NEXT_PTR_OFFSET,
116 };
117
118 static const char * const ucos_iii_thread_state_list[] = {
119 "Ready",
120 "Delay",
121 "Pend",
122 "Pend Timeout",
123 "Suspended",
124 "Delay Suspended",
125 "Pend Suspended",
126 "Pend Timeout Suspended",
127 };
128
129 static int ucos_iii_find_or_create_thread(struct rtos *rtos, symbol_address_t thread_address,
130 threadid_t *threadid)
131 {
132 struct ucos_iii_params *params = rtos->rtos_specific_params;
133 size_t thread_index;
134
135 for (thread_index = 0; thread_index < params->num_threads; thread_index++)
136 if (params->threads[thread_index] == thread_address)
137 goto found;
138
139 if (params->num_threads == UCOS_III_MAX_THREADS) {
140 LOG_WARNING("uCOS-III: too many threads; increase UCOS_III_MAX_THREADS");
141 return ERROR_FAIL;
142 }
143
144 params->threads[thread_index] = thread_address;
145 params->num_threads++;
146 found:
147 *threadid = thread_index + params->threadid_start;
148 return ERROR_OK;
149 }
150
151 static int ucos_iii_find_thread_address(struct rtos *rtos, threadid_t threadid,
152 symbol_address_t *thread_address)
153 {
154 struct ucos_iii_params *params = rtos->rtos_specific_params;
155 size_t thread_index;
156
157 thread_index = threadid - params->threadid_start;
158 if (thread_index >= params->num_threads) {
159 LOG_ERROR("uCOS-III: failed to find thread address");
160 return ERROR_FAIL;
161 }
162
163 *thread_address = params->threads[thread_index];
164 return ERROR_OK;
165 }
166
167 static int ucos_iii_find_last_thread_address(struct rtos *rtos, symbol_address_t *thread_address)
168 {
169 struct ucos_iii_params *params = rtos->rtos_specific_params;
170 int retval;
171
172 /* read the thread list head */
173 symbol_address_t thread_list_address = 0;
174
175 retval = target_read_memory(rtos->target,
176 rtos->symbols[UCOS_III_VAL_OS_TASK_DBG_LIST_PTR].address,
177 params->pointer_width,
178 1,
179 (void *)&thread_list_address);
180 if (retval != ERROR_OK) {
181 LOG_ERROR("uCOS-III: failed to read thread list address");
182 return retval;
183 }
184
185 /* advance to end of thread list */
186 do {
187 *thread_address = thread_list_address;
188
189 retval = target_read_memory(rtos->target,
190 thread_list_address + params->thread_next_offset,
191 params->pointer_width,
192 1,
193 (void *)&thread_list_address);
194 if (retval != ERROR_OK) {
195 LOG_ERROR("uCOS-III: failed to read next thread address");
196 return retval;
197 }
198 } while (thread_list_address != 0);
199
200 return ERROR_OK;
201 }
202
203 static int ucos_iii_update_thread_offsets(struct rtos *rtos)
204 {
205 struct ucos_iii_params *params = rtos->rtos_specific_params;
206
207 if (params->thread_offsets_updated)
208 return ERROR_OK;
209
210 const struct thread_offset_map {
211 enum ucos_iii_symbol_values symbol_value;
212 symbol_address_t *thread_offset;
213 } thread_offset_maps[] = {
214 {
215 UCOS_III_VAL_OS_TCB_STK_PTR_OFFSET,
216 &params->thread_stack_offset,
217 },
218 {
219 UCOS_III_VAL_OS_TCB_NAME_PTR_OFFSET,
220 &params->thread_name_offset,
221 },
222 {
223 UCOS_III_VAL_OS_TCB_TASK_STATE_OFFSET,
224 &params->thread_state_offset,
225 },
226 {
227 UCOS_III_VAL_OS_TCB_PRIO_OFFSET,
228 &params->thread_priority_offset,
229 },
230 {
231 UCOS_III_VAL_OS_TCB_DBG_PREV_PTR_OFFSET,
232 &params->thread_prev_offset,
233 },
234 {
235 UCOS_III_VAL_OS_TCB_DBG_NEXT_PTR_OFFSET,
236 &params->thread_next_offset,
237 },
238 };
239
240 for (size_t i = 0; i < ARRAY_SIZE(thread_offset_maps); i++) {
241 const struct thread_offset_map *thread_offset_map = &thread_offset_maps[i];
242
243 int retval = target_read_memory(rtos->target,
244 rtos->symbols[thread_offset_map->symbol_value].address,
245 params->pointer_width,
246 1,
247 (void *)thread_offset_map->thread_offset);
248 if (retval != ERROR_OK) {
249 LOG_ERROR("uCOS-III: failed to read thread offset");
250 return retval;
251 }
252 }
253
254 params->thread_offsets_updated = true;
255 return ERROR_OK;
256 }
257
258 static bool ucos_iii_detect_rtos(struct target *target)
259 {
260 return target->rtos->symbols &&
261 target->rtos->symbols[UCOS_III_VAL_OS_RUNNING].address != 0;
262 }
263
264 static int ucos_iii_reset_handler(struct target *target, enum target_reset_mode reset_mode, void *priv)
265 {
266 struct ucos_iii_params *params = target->rtos->rtos_specific_params;
267
268 params->thread_offsets_updated = false;
269 params->num_threads = 0;
270
271 return ERROR_OK;
272 }
273
274 static int ucos_iii_create(struct target *target)
275 {
276 struct ucos_iii_params *params;
277
278 for (size_t i = 0; i < ARRAY_SIZE(ucos_iii_params_list); i++)
279 if (strcmp(ucos_iii_params_list[i].target_name, target->type->name) == 0) {
280 params = malloc(sizeof(*params) + (UCOS_III_MAX_THREADS * sizeof(*params->threads)));
281 if (!params) {
282 LOG_ERROR("uCOS-III: out of memory");
283 return ERROR_FAIL;
284 }
285
286 memcpy(params, &ucos_iii_params_list[i], sizeof(ucos_iii_params_list[i]));
287 target->rtos->rtos_specific_params = (void *)params;
288
289 target_register_reset_callback(ucos_iii_reset_handler, NULL);
290
291 return ERROR_OK;
292 }
293
294 LOG_ERROR("uCOS-III: target not supported: %s", target->type->name);
295 return ERROR_FAIL;
296 }
297
298 static int ucos_iii_update_threads(struct rtos *rtos)
299 {
300 struct ucos_iii_params *params = rtos->rtos_specific_params;
301 int retval;
302
303 if (!rtos->symbols) {
304 LOG_ERROR("uCOS-III: symbol list not loaded");
305 return ERROR_FAIL;
306 }
307
308 /* free previous thread details */
309 rtos_free_threadlist(rtos);
310
311 /* verify RTOS is running */
312 uint8_t rtos_running;
313
314 retval = target_read_u8(rtos->target,
315 rtos->symbols[UCOS_III_VAL_OS_RUNNING].address,
316 &rtos_running);
317 if (retval != ERROR_OK) {
318 LOG_ERROR("uCOS-III: failed to read RTOS running");
319 return retval;
320 }
321
322 if (rtos_running != 1 && rtos_running != 0) {
323 LOG_ERROR("uCOS-III: invalid RTOS running value");
324 return ERROR_FAIL;
325 }
326
327 if (!rtos_running) {
328 rtos->thread_details = calloc(1, sizeof(struct thread_detail));
329 if (!rtos->thread_details) {
330 LOG_ERROR("uCOS-III: out of memory");
331 return ERROR_FAIL;
332 }
333
334 rtos->thread_count = 1;
335 rtos->thread_details->threadid = 0;
336 rtos->thread_details->exists = true;
337 rtos->current_thread = 0;
338
339 return ERROR_OK;
340 }
341
342 /* update thread offsets */
343 retval = ucos_iii_update_thread_offsets(rtos);
344 if (retval != ERROR_OK) {
345 LOG_ERROR("uCOS-III: failed to update thread offsets");
346 return retval;
347 }
348
349 /* read current thread address */
350 symbol_address_t current_thread_address = 0;
351
352 retval = target_read_memory(rtos->target,
353 rtos->symbols[UCOS_III_VAL_OS_TCB_CUR_PTR].address,
354 params->pointer_width,
355 1,
356 (void *)&current_thread_address);
357 if (retval != ERROR_OK) {
358 LOG_ERROR("uCOS-III: failed to read current thread address");
359 return retval;
360 }
361
362 /* read number of tasks */
363 retval = target_read_u16(rtos->target,
364 rtos->symbols[UCOS_III_VAL_OS_TASK_QTY].address,
365 (void *)&rtos->thread_count);
366 if (retval != ERROR_OK) {
367 LOG_ERROR("uCOS-III: failed to read thread count");
368 return retval;
369 }
370
371 rtos->thread_details = calloc(rtos->thread_count, sizeof(struct thread_detail));
372 if (!rtos->thread_details) {
373 LOG_ERROR("uCOS-III: out of memory");
374 return ERROR_FAIL;
375 }
376
377 /*
378 * uC/OS-III adds tasks in LIFO order; advance to the end of the
379 * list and work backwards to preserve the intended order.
380 */
381 symbol_address_t thread_address = 0;
382
383 retval = ucos_iii_find_last_thread_address(rtos, &thread_address);
384 if (retval != ERROR_OK) {
385 LOG_ERROR("uCOS-III: failed to find last thread address");
386 return retval;
387 }
388
389 for (int i = 0; i < rtos->thread_count; i++) {
390 struct thread_detail *thread_detail = &rtos->thread_details[i];
391 char thread_str_buffer[UCOS_III_MAX_STRLEN + 1];
392
393 /* find or create new threadid */
394 retval = ucos_iii_find_or_create_thread(rtos, thread_address, &thread_detail->threadid);
395 if (retval != ERROR_OK) {
396 LOG_ERROR("uCOS-III: failed to find or create thread");
397 return retval;
398 }
399
400 if (thread_address == current_thread_address)
401 rtos->current_thread = thread_detail->threadid;
402
403 thread_detail->exists = true;
404
405 /* read thread name */
406 symbol_address_t thread_name_address = 0;
407
408 retval = target_read_memory(rtos->target,
409 thread_address + params->thread_name_offset,
410 params->pointer_width,
411 1,
412 (void *)&thread_name_address);
413 if (retval != ERROR_OK) {
414 LOG_ERROR("uCOS-III: failed to name address");
415 return retval;
416 }
417
418 retval = target_read_buffer(rtos->target,
419 thread_name_address,
420 sizeof(thread_str_buffer),
421 (void *)thread_str_buffer);
422 if (retval != ERROR_OK) {
423 LOG_ERROR("uCOS-III: failed to read thread name");
424 return retval;
425 }
426
427 thread_str_buffer[sizeof(thread_str_buffer) - 1] = '\0';
428 thread_detail->thread_name_str = strdup(thread_str_buffer);
429
430 /* read thread extra info */
431 uint8_t thread_state;
432 uint8_t thread_priority;
433
434 retval = target_read_u8(rtos->target,
435 thread_address + params->thread_state_offset,
436 &thread_state);
437 if (retval != ERROR_OK) {
438 LOG_ERROR("uCOS-III: failed to read thread state");
439 return retval;
440 }
441
442 retval = target_read_u8(rtos->target,
443 thread_address + params->thread_priority_offset,
444 &thread_priority);
445 if (retval != ERROR_OK) {
446 LOG_ERROR("uCOS-III: failed to read thread priority");
447 return retval;
448 }
449
450 const char *thread_state_str;
451
452 if (thread_state < ARRAY_SIZE(ucos_iii_thread_state_list))
453 thread_state_str = ucos_iii_thread_state_list[thread_state];
454 else
455 thread_state_str = "Unknown";
456
457 snprintf(thread_str_buffer, sizeof(thread_str_buffer), "State: %s, Priority: %d",
458 thread_state_str, thread_priority);
459 thread_detail->extra_info_str = strdup(thread_str_buffer);
460
461 /* read previous thread address */
462 retval = target_read_memory(rtos->target,
463 thread_address + params->thread_prev_offset,
464 params->pointer_width,
465 1,
466 (void *)&thread_address);
467 if (retval != ERROR_OK) {
468 LOG_ERROR("uCOS-III: failed to read previous thread address");
469 return retval;
470 }
471 }
472
473 return ERROR_OK;
474 }
475
476 static int ucos_iii_get_thread_reg_list(struct rtos *rtos, threadid_t threadid,
477 struct rtos_reg **reg_list, int *num_regs)
478 {
479 struct ucos_iii_params *params = rtos->rtos_specific_params;
480 int retval;
481
482 /* find thread address for threadid */
483 symbol_address_t thread_address = 0;
484
485 retval = ucos_iii_find_thread_address(rtos, threadid, &thread_address);
486 if (retval != ERROR_OK) {
487 LOG_ERROR("uCOS-III: failed to find thread address");
488 return retval;
489 }
490
491 /* read thread stack address */
492 symbol_address_t stack_address = 0;
493
494 retval = target_read_memory(rtos->target,
495 thread_address + params->thread_stack_offset,
496 params->pointer_width,
497 1,
498 (void *)&stack_address);
499 if (retval != ERROR_OK) {
500 LOG_ERROR("uCOS-III: failed to read stack address");
501 return retval;
502 }
503
504 return rtos_generic_stack_read(rtos->target,
505 params->stacking_info,
506 stack_address,
507 reg_list,
508 num_regs);
509 }
510
511 static int ucos_iii_get_symbol_list_to_lookup(struct symbol_table_elem *symbol_list[])
512 {
513 *symbol_list = calloc(ARRAY_SIZE(ucos_iii_symbol_list), sizeof(struct symbol_table_elem));
514 if (!*symbol_list) {
515 LOG_ERROR("uCOS-III: out of memory");
516 return ERROR_FAIL;
517 }
518
519 for (size_t i = 0; i < ARRAY_SIZE(ucos_iii_symbol_list); i++)
520 (*symbol_list)[i].symbol_name = ucos_iii_symbol_list[i];
521
522 return ERROR_OK;
523 }
524
525 const struct rtos_type ucos_iii_rtos = {
526 .name = "uCOS-III",
527 .detect_rtos = ucos_iii_detect_rtos,
528 .create = ucos_iii_create,
529 .update_threads = ucos_iii_update_threads,
530 .get_thread_reg_list = ucos_iii_get_thread_reg_list,
531 .get_symbol_list_to_lookup = ucos_iii_get_symbol_list_to_lookup,
532 };
Official OpenOCD Mirror