1 /***************************************************************************
2 * Copyright (C) 2011 by Broadcom Corporation *
3 * Evan Hunter - ehunter@broadcom.com *
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 ***************************************************************************/
24 #include "target/target.h"
25 #include "helper/log.h"
26 #include "helper/binarybuffer.h"
27 #include "server/gdb_server.h"
30 extern struct rtos_type freertos_rtos
;
31 extern struct rtos_type threadx_rtos
;
32 extern struct rtos_type ecos_rtos
;
33 extern struct rtos_type linux_rtos
;
34 extern struct rtos_type chibios_rtos
;
35 extern struct rtos_type chromium_ec_rtos
;
36 extern struct rtos_type embkernel_rtos
;
37 extern struct rtos_type mqx_rtos
;
38 extern struct rtos_type ucos_iii_rtos
;
39 extern struct rtos_type nuttx_rtos
;
40 extern struct rtos_type hwthread_rtos
;
41 extern struct rtos_type riot_rtos
;
42 extern struct rtos_type zephyr_rtos
;
44 static struct rtos_type
*rtos_types
[] = {
57 /* keep this as last, as it always matches with rtos auto */
62 static int rtos_try_next(struct target
*target
);
64 int rtos_thread_packet(struct connection
*connection
, const char *packet
, int packet_size
);
66 int rtos_smp_init(struct target
*target
)
68 if (target
->rtos
->type
->smp_init
)
69 return target
->rtos
->type
->smp_init(target
);
70 return ERROR_TARGET_INIT_FAILED
;
73 static int rtos_target_for_threadid(struct connection
*connection
, int64_t threadid
, struct target
**t
)
75 struct target
*curr
= get_target_from_connection(connection
);
82 static int os_alloc(struct target
*target
, struct rtos_type
*ostype
)
84 struct rtos
*os
= target
->rtos
= calloc(1, sizeof(struct rtos
));
90 os
->current_threadid
= -1;
91 os
->current_thread
= 0;
95 /* RTOS drivers can override the packet handler in _create(). */
96 os
->gdb_thread_packet
= rtos_thread_packet
;
97 os
->gdb_target_for_threadid
= rtos_target_for_threadid
;
102 static void os_free(struct target
*target
)
107 free(target
->rtos
->symbols
);
112 static int os_alloc_create(struct target
*target
, struct rtos_type
*ostype
)
114 int ret
= os_alloc(target
, ostype
);
117 ret
= target
->rtos
->type
->create(target
);
125 int rtos_create(struct jim_getopt_info
*goi
, struct target
*target
)
132 if (!goi
->isconfigure
&& goi
->argc
!= 0) {
133 Jim_WrongNumArgs(goi
->interp
, goi
->argc
, goi
->argv
, "NO PARAMS");
139 e
= jim_getopt_string(goi
, &cp
, NULL
);
143 if (strcmp(cp
, "auto") == 0) {
144 /* Auto detect tries to look up all symbols for each RTOS,
145 * and runs the RTOS driver's _detect() function when GDB
146 * finds all symbols for any RTOS. See rtos_qsymbol(). */
147 target
->rtos_auto_detect
= true;
149 /* rtos_qsymbol() will iterate over all RTOSes. Allocate
150 * target->rtos here, and set it to the first RTOS type. */
151 return os_alloc(target
, rtos_types
[0]);
154 for (x
= 0; rtos_types
[x
]; x
++)
155 if (strcmp(cp
, rtos_types
[x
]->name
) == 0)
156 return os_alloc_create(target
, rtos_types
[x
]);
158 Jim_SetResultFormatted(goi
->interp
, "Unknown RTOS type %s, try one of: ", cp
);
159 res
= Jim_GetResult(goi
->interp
);
160 for (x
= 0; rtos_types
[x
]; x
++)
161 Jim_AppendStrings(goi
->interp
, res
, rtos_types
[x
]->name
, ", ", NULL
);
162 Jim_AppendStrings(goi
->interp
, res
, " or auto", NULL
);
167 void rtos_destroy(struct target
*target
)
172 int gdb_thread_packet(struct connection
*connection
, char const *packet
, int packet_size
)
174 struct target
*target
= get_target_from_connection(connection
);
176 return rtos_thread_packet(connection
, packet
, packet_size
); /* thread not
178 return target
->rtos
->gdb_thread_packet(connection
, packet
, packet_size
);
181 static struct symbol_table_elem
*next_symbol(struct rtos
*os
, char *cur_symbol
, uint64_t cur_addr
)
183 struct symbol_table_elem
*s
;
186 os
->type
->get_symbol_list_to_lookup(&os
->symbols
);
189 return &os
->symbols
[0];
191 for (s
= os
->symbols
; s
->symbol_name
; s
++)
192 if (!strcmp(s
->symbol_name
, cur_symbol
)) {
193 s
->address
= cur_addr
;
201 /* searches for 'symbol' in the lookup table for 'os' and returns TRUE,
202 * if 'symbol' is not declared optional */
203 static bool is_symbol_mandatory(const struct rtos
*os
, const char *symbol
)
205 for (struct symbol_table_elem
*s
= os
->symbols
; s
->symbol_name
; ++s
) {
206 if (!strcmp(s
->symbol_name
, symbol
))
212 /* rtos_qsymbol() processes and replies to all qSymbol packets from GDB.
214 * GDB sends a qSymbol:: packet (empty address, empty name) to notify
215 * that it can now answer qSymbol::hexcodedname queries, to look up symbols.
217 * If the qSymbol packet has no address that means GDB did not find the
218 * symbol, in which case auto-detect will move on to try the next RTOS.
220 * rtos_qsymbol() then calls the next_symbol() helper function, which
221 * iterates over symbol names for the current RTOS until it finds the
222 * symbol in the received GDB packet, and then returns the next entry
223 * in the list of symbols.
225 * If GDB replied about the last symbol for the RTOS and the RTOS was
226 * specified explicitly, then no further symbol lookup is done. When
227 * auto-detecting, the RTOS driver _detect() function must return success.
229 * rtos_qsymbol() returns 1 if an RTOS has been detected, or 0 otherwise.
231 int rtos_qsymbol(struct connection
*connection
, char const *packet
, int packet_size
)
233 int rtos_detected
= 0;
236 char reply
[GDB_BUFFER_SIZE
+ 1], cur_sym
[GDB_BUFFER_SIZE
/ 2 + 1] = ""; /* Extra byte for null-termination */
237 struct symbol_table_elem
*next_sym
;
238 struct target
*target
= get_target_from_connection(connection
);
239 struct rtos
*os
= target
->rtos
;
241 reply_len
= sprintf(reply
, "OK");
246 /* Decode any symbol name in the packet*/
247 size_t len
= unhexify((uint8_t *)cur_sym
, strchr(packet
+ 8, ':') + 1, strlen(strchr(packet
+ 8, ':') + 1));
250 if ((strcmp(packet
, "qSymbol::") != 0) && /* GDB is not offering symbol lookup for the first time */
251 (!sscanf(packet
, "qSymbol:%" SCNx64
":", &addr
)) && /* GDB did not find an address for a symbol */
252 is_symbol_mandatory(os
, cur_sym
)) { /* the symbol is mandatory for this RTOS */
254 /* GDB could not find an address for the previous symbol */
255 if (!target
->rtos_auto_detect
) {
256 LOG_WARNING("RTOS %s not detected. (GDB could not find symbol \'%s\')", os
->type
->name
, cur_sym
);
259 /* Autodetecting RTOS - try next RTOS */
260 if (!rtos_try_next(target
)) {
261 LOG_WARNING("No RTOS could be auto-detected!");
265 /* Next RTOS selected - invalidate current symbol */
270 LOG_DEBUG("RTOS: Address of symbol '%s' is 0x%" PRIx64
, cur_sym
, addr
);
272 next_sym
= next_symbol(os
, cur_sym
, addr
);
274 /* Should never happen unless the debugger misbehaves */
276 LOG_WARNING("RTOS: Debugger sent us qSymbol with '%s' that we did not ask for", cur_sym
);
280 if (!next_sym
->symbol_name
) {
281 /* No more symbols need looking up */
283 if (!target
->rtos_auto_detect
) {
288 if (os
->type
->detect_rtos(target
)) {
289 LOG_INFO("Auto-detected RTOS: %s", os
->type
->name
);
293 LOG_WARNING("No RTOS could be auto-detected!");
298 if (8 + (strlen(next_sym
->symbol_name
) * 2) + 1 > sizeof(reply
)) {
299 LOG_ERROR("ERROR: RTOS symbol '%s' name is too long for GDB!", next_sym
->symbol_name
);
303 LOG_DEBUG("RTOS: Requesting symbol lookup of '%s' from the debugger", next_sym
->symbol_name
);
305 reply_len
= snprintf(reply
, sizeof(reply
), "qSymbol:");
306 reply_len
+= hexify(reply
+ reply_len
,
307 (const uint8_t *)next_sym
->symbol_name
, strlen(next_sym
->symbol_name
),
308 sizeof(reply
) - reply_len
);
311 gdb_put_packet(connection
, reply
, reply_len
);
312 return rtos_detected
;
315 int rtos_thread_packet(struct connection
*connection
, char const *packet
, int packet_size
)
317 struct target
*target
= get_target_from_connection(connection
);
319 if (strncmp(packet
, "qThreadExtraInfo,", 17) == 0) {
320 if ((target
->rtos
) && (target
->rtos
->thread_details
) &&
321 (target
->rtos
->thread_count
!= 0)) {
322 threadid_t threadid
= 0;
324 sscanf(packet
, "qThreadExtraInfo,%" SCNx64
, &threadid
);
326 if ((target
->rtos
) && (target
->rtos
->thread_details
)) {
328 for (thread_num
= 0; thread_num
< target
->rtos
->thread_count
; thread_num
++) {
329 if (target
->rtos
->thread_details
[thread_num
].threadid
== threadid
) {
330 if (target
->rtos
->thread_details
[thread_num
].exists
)
336 gdb_put_packet(connection
, "E01", 3); /* thread not found */
340 struct thread_detail
*detail
= &target
->rtos
->thread_details
[found
];
343 if (detail
->thread_name_str
)
344 str_size
+= strlen(detail
->thread_name_str
);
345 if (detail
->extra_info_str
)
346 str_size
+= strlen(detail
->extra_info_str
);
348 char *tmp_str
= calloc(str_size
+ 9, sizeof(char));
349 char *tmp_str_ptr
= tmp_str
;
351 if (detail
->thread_name_str
)
352 tmp_str_ptr
+= sprintf(tmp_str_ptr
, "Name: %s", detail
->thread_name_str
);
353 if (detail
->extra_info_str
) {
354 if (tmp_str_ptr
!= tmp_str
)
355 tmp_str_ptr
+= sprintf(tmp_str_ptr
, ", ");
356 tmp_str_ptr
+= sprintf(tmp_str_ptr
, "%s", detail
->extra_info_str
);
359 assert(strlen(tmp_str
) ==
360 (size_t) (tmp_str_ptr
- tmp_str
));
362 char *hex_str
= malloc(strlen(tmp_str
) * 2 + 1);
363 size_t pkt_len
= hexify(hex_str
, (const uint8_t *)tmp_str
,
364 strlen(tmp_str
), strlen(tmp_str
) * 2 + 1);
366 gdb_put_packet(connection
, hex_str
, pkt_len
);
372 gdb_put_packet(connection
, "", 0);
374 } else if (strncmp(packet
, "qSymbol", 7) == 0) {
375 if (rtos_qsymbol(connection
, packet
, packet_size
) == 1) {
376 if (target
->rtos_auto_detect
== true) {
377 target
->rtos_auto_detect
= false;
378 target
->rtos
->type
->create(target
);
380 target
->rtos
->type
->update_threads(target
->rtos
);
383 } else if (strncmp(packet
, "qfThreadInfo", 12) == 0) {
386 if (target
->rtos
->thread_count
== 0) {
387 gdb_put_packet(connection
, "l", 1);
389 /*thread id are 16 char +1 for ',' */
390 char *out_str
= malloc(17 * target
->rtos
->thread_count
+ 1);
391 char *tmp_str
= out_str
;
392 for (i
= 0; i
< target
->rtos
->thread_count
; i
++) {
393 tmp_str
+= sprintf(tmp_str
, "%c%016" PRIx64
, i
== 0 ? 'm' : ',',
394 target
->rtos
->thread_details
[i
].threadid
);
396 gdb_put_packet(connection
, out_str
, strlen(out_str
));
400 gdb_put_packet(connection
, "l", 1);
403 } else if (strncmp(packet
, "qsThreadInfo", 12) == 0) {
404 gdb_put_packet(connection
, "l", 1);
406 } else if (strncmp(packet
, "qAttached", 9) == 0) {
407 gdb_put_packet(connection
, "1", 1);
409 } else if (strncmp(packet
, "qOffsets", 8) == 0) {
410 char offsets
[] = "Text=0;Data=0;Bss=0";
411 gdb_put_packet(connection
, offsets
, sizeof(offsets
)-1);
413 } else if (strncmp(packet
, "qCRC:", 5) == 0) {
414 /* make sure we check this before "qC" packet below
415 * otherwise it gets incorrectly handled */
416 return GDB_THREAD_PACKET_NOT_CONSUMED
;
417 } else if (strncmp(packet
, "qC", 2) == 0) {
421 size
= snprintf(buffer
, 19, "QC%016" PRIx64
, target
->rtos
->current_thread
);
422 gdb_put_packet(connection
, buffer
, size
);
424 gdb_put_packet(connection
, "QC0", 3);
426 } else if (packet
[0] == 'T') { /* Is thread alive? */
429 sscanf(packet
, "T%" SCNx64
, &threadid
);
430 if ((target
->rtos
) && (target
->rtos
->thread_details
)) {
432 for (thread_num
= 0; thread_num
< target
->rtos
->thread_count
; thread_num
++) {
433 if (target
->rtos
->thread_details
[thread_num
].threadid
== threadid
) {
434 if (target
->rtos
->thread_details
[thread_num
].exists
)
440 gdb_put_packet(connection
, "OK", 2); /* thread alive */
442 gdb_put_packet(connection
, "E01", 3); /* thread not found */
444 } else if (packet
[0] == 'H') { /* Set current thread ( 'c' for step and continue, 'g' for
445 * all other operations ) */
446 if ((packet
[1] == 'g') && (target
->rtos
)) {
448 sscanf(packet
, "Hg%16" SCNx64
, &threadid
);
449 LOG_DEBUG("RTOS: GDB requested to set current thread to 0x%" PRIx64
, threadid
);
450 /* threadid of 0 indicates target should choose */
452 target
->rtos
->current_threadid
= target
->rtos
->current_thread
;
454 target
->rtos
->current_threadid
= threadid
;
456 gdb_put_packet(connection
, "OK", 2);
460 return GDB_THREAD_PACKET_NOT_CONSUMED
;
463 static int rtos_put_gdb_reg_list(struct connection
*connection
,
464 struct rtos_reg
*reg_list
, int num_regs
)
466 size_t num_bytes
= 1; /* NUL */
467 for (int i
= 0; i
< num_regs
; ++i
)
468 num_bytes
+= DIV_ROUND_UP(reg_list
[i
].size
, 8) * 2;
470 char *hex
= malloc(num_bytes
);
473 for (int i
= 0; i
< num_regs
; ++i
) {
474 size_t count
= DIV_ROUND_UP(reg_list
[i
].size
, 8);
475 size_t n
= hexify(hex_p
, reg_list
[i
].value
, count
, num_bytes
);
480 gdb_put_packet(connection
, hex
, strlen(hex
));
486 /** Look through all registers to find this register. */
487 int rtos_get_gdb_reg(struct connection
*connection
, int reg_num
)
489 struct target
*target
= get_target_from_connection(connection
);
490 int64_t current_threadid
= target
->rtos
->current_threadid
;
491 if ((target
->rtos
) && (current_threadid
!= -1) &&
492 (current_threadid
!= 0) &&
493 ((current_threadid
!= target
->rtos
->current_thread
) ||
494 (target
->smp
))) { /* in smp several current thread are possible */
495 struct rtos_reg
*reg_list
;
498 LOG_DEBUG("getting register %d for thread 0x%" PRIx64
499 ", target->rtos->current_thread=0x%" PRIx64
,
502 target
->rtos
->current_thread
);
505 if (target
->rtos
->type
->get_thread_reg
) {
506 reg_list
= calloc(1, sizeof(*reg_list
));
508 retval
= target
->rtos
->type
->get_thread_reg(target
->rtos
,
509 current_threadid
, reg_num
, ®_list
[0]);
510 if (retval
!= ERROR_OK
) {
511 LOG_ERROR("RTOS: failed to get register %d", reg_num
);
515 retval
= target
->rtos
->type
->get_thread_reg_list(target
->rtos
,
519 if (retval
!= ERROR_OK
) {
520 LOG_ERROR("RTOS: failed to get register list");
525 for (int i
= 0; i
< num_regs
; ++i
) {
526 if (reg_list
[i
].number
== (uint32_t)reg_num
) {
527 rtos_put_gdb_reg_list(connection
, reg_list
+ i
, 1);
538 /** Return a list of general registers. */
539 int rtos_get_gdb_reg_list(struct connection
*connection
)
541 struct target
*target
= get_target_from_connection(connection
);
542 int64_t current_threadid
= target
->rtos
->current_threadid
;
543 if ((target
->rtos
) && (current_threadid
!= -1) &&
544 (current_threadid
!= 0) &&
545 ((current_threadid
!= target
->rtos
->current_thread
) ||
546 (target
->smp
))) { /* in smp several current thread are possible */
547 struct rtos_reg
*reg_list
;
550 LOG_DEBUG("RTOS: getting register list for thread 0x%" PRIx64
551 ", target->rtos->current_thread=0x%" PRIx64
"\r\n",
553 target
->rtos
->current_thread
);
555 int retval
= target
->rtos
->type
->get_thread_reg_list(target
->rtos
,
559 if (retval
!= ERROR_OK
) {
560 LOG_ERROR("RTOS: failed to get register list");
564 rtos_put_gdb_reg_list(connection
, reg_list
, num_regs
);
572 int rtos_set_reg(struct connection
*connection
, int reg_num
,
575 struct target
*target
= get_target_from_connection(connection
);
576 int64_t current_threadid
= target
->rtos
->current_threadid
;
577 if ((target
->rtos
) &&
578 (target
->rtos
->type
->set_reg
) &&
579 (current_threadid
!= -1) &&
580 (current_threadid
!= 0)) {
581 return target
->rtos
->type
->set_reg(target
->rtos
, reg_num
, reg_value
);
586 int rtos_generic_stack_read(struct target
*target
,
587 const struct rtos_register_stacking
*stacking
,
589 struct rtos_reg
**reg_list
,
594 if (stack_ptr
== 0) {
595 LOG_ERROR("Error: null stack pointer in thread");
599 uint8_t *stack_data
= malloc(stacking
->stack_registers_size
);
600 uint32_t address
= stack_ptr
;
602 if (stacking
->stack_growth_direction
== 1)
603 address
-= stacking
->stack_registers_size
;
604 retval
= target_read_buffer(target
, address
, stacking
->stack_registers_size
, stack_data
);
605 if (retval
!= ERROR_OK
) {
607 LOG_ERROR("Error reading stack frame from thread");
610 LOG_DEBUG("RTOS: Read stack frame at 0x%" PRIx32
, address
);
613 LOG_OUTPUT("Stack Data :");
614 for (i
= 0; i
< stacking
->stack_registers_size
; i
++)
615 LOG_OUTPUT("%02X", stack_data
[i
]);
619 int64_t new_stack_ptr
;
620 if (stacking
->calculate_process_stack
) {
621 new_stack_ptr
= stacking
->calculate_process_stack(target
,
622 stack_data
, stacking
, stack_ptr
);
624 new_stack_ptr
= stack_ptr
- stacking
->stack_growth_direction
*
625 stacking
->stack_registers_size
;
628 *reg_list
= calloc(stacking
->num_output_registers
, sizeof(struct rtos_reg
));
629 *num_regs
= stacking
->num_output_registers
;
631 for (int i
= 0; i
< stacking
->num_output_registers
; ++i
) {
632 (*reg_list
)[i
].number
= stacking
->register_offsets
[i
].number
;
633 (*reg_list
)[i
].size
= stacking
->register_offsets
[i
].width_bits
;
635 int offset
= stacking
->register_offsets
[i
].offset
;
637 buf_cpy(&new_stack_ptr
, (*reg_list
)[i
].value
, (*reg_list
)[i
].size
);
638 else if (offset
!= -1)
639 buf_cpy(stack_data
+ offset
, (*reg_list
)[i
].value
, (*reg_list
)[i
].size
);
643 /* LOG_OUTPUT("Output register string: %s\r\n", *hex_reg_list); */
647 static int rtos_try_next(struct target
*target
)
649 struct rtos
*os
= target
->rtos
;
650 struct rtos_type
**type
= rtos_types
;
655 while (*type
&& os
->type
!= *type
)
658 if (!*type
|| !*(++type
))
669 int rtos_update_threads(struct target
*target
)
671 if ((target
->rtos
) && (target
->rtos
->type
))
672 target
->rtos
->type
->update_threads(target
->rtos
);
676 void rtos_free_threadlist(struct rtos
*rtos
)
678 if (rtos
->thread_details
) {
681 for (j
= 0; j
< rtos
->thread_count
; j
++) {
682 struct thread_detail
*current_thread
= &rtos
->thread_details
[j
];
683 free(current_thread
->thread_name_str
);
684 free(current_thread
->extra_info_str
);
686 free(rtos
->thread_details
);
687 rtos
->thread_details
= NULL
;
688 rtos
->thread_count
= 0;
689 rtos
->current_threadid
= -1;
690 rtos
->current_thread
= 0;
694 int rtos_read_buffer(struct target
*target
, target_addr_t address
,
695 uint32_t size
, uint8_t *buffer
)
697 if (target
->rtos
->type
->read_buffer
)
698 return target
->rtos
->type
->read_buffer(target
->rtos
, address
, size
, buffer
);
699 return ERROR_NOT_IMPLEMENTED
;
702 int rtos_write_buffer(struct target
*target
, target_addr_t address
,
703 uint32_t size
, const uint8_t *buffer
)
705 if (target
->rtos
->type
->write_buffer
)
706 return target
->rtos
->type
->write_buffer(target
->rtos
, address
, size
, buffer
);
707 return ERROR_NOT_IMPLEMENTED
;
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)