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_os
;
34 extern struct rtos_type ChibiOS_rtos
;
35 extern struct rtos_type embKernel_rtos
;
36 extern struct rtos_type mqx_rtos
;
38 static struct rtos_type
*rtos_types
[] = {
49 int rtos_thread_packet(struct connection
*connection
, const char *packet
, int packet_size
);
51 int rtos_smp_init(struct target
*target
)
53 if (target
->rtos
->type
->smp_init
)
54 return target
->rtos
->type
->smp_init(target
);
55 return ERROR_TARGET_INIT_FAILED
;
58 static int os_alloc(struct target
*target
, struct rtos_type
*ostype
)
60 struct rtos
*os
= target
->rtos
= calloc(1, sizeof(struct rtos
));
66 os
->current_threadid
= -1;
67 os
->current_thread
= 0;
71 /* RTOS drivers can override the packet handler in _create(). */
72 os
->gdb_thread_packet
= rtos_thread_packet
;
77 static void os_free(struct target
*target
)
82 if (target
->rtos
->symbols
)
83 free(target
->rtos
->symbols
);
89 static int os_alloc_create(struct target
*target
, struct rtos_type
*ostype
)
91 int ret
= os_alloc(target
, ostype
);
94 ret
= target
->rtos
->type
->create(target
);
102 int rtos_create(Jim_GetOptInfo
*goi
, struct target
*target
)
109 if (!goi
->isconfigure
&& goi
->argc
!= 0) {
110 Jim_WrongNumArgs(goi
->interp
, goi
->argc
, goi
->argv
, "NO PARAMS");
116 e
= Jim_GetOpt_String(goi
, &cp
, NULL
);
120 if (0 == strcmp(cp
, "auto")) {
121 /* Auto detect tries to look up all symbols for each RTOS,
122 * and runs the RTOS driver's _detect() function when GDB
123 * finds all symbols for any RTOS. See rtos_qsymbol(). */
124 target
->rtos_auto_detect
= true;
126 /* rtos_qsymbol() will iterate over all RTOSes. Allocate
127 * target->rtos here, and set it to the first RTOS type. */
128 return os_alloc(target
, rtos_types
[0]);
131 for (x
= 0; rtos_types
[x
]; x
++)
132 if (0 == strcmp(cp
, rtos_types
[x
]->name
))
133 return os_alloc_create(target
, rtos_types
[x
]);
135 Jim_SetResultFormatted(goi
->interp
, "Unknown RTOS type %s, try one of: ", cp
);
136 res
= Jim_GetResult(goi
->interp
);
137 for (x
= 0; rtos_types
[x
]; x
++)
138 Jim_AppendStrings(goi
->interp
, res
, rtos_types
[x
]->name
, ", ", NULL
);
139 Jim_AppendStrings(goi
->interp
, res
, " or auto", NULL
);
144 int gdb_thread_packet(struct connection
*connection
, char const *packet
, int packet_size
)
146 struct target
*target
= get_target_from_connection(connection
);
147 if (target
->rtos
== NULL
)
148 return rtos_thread_packet(connection
, packet
, packet_size
); /* thread not
150 return target
->rtos
->gdb_thread_packet(connection
, packet
, packet_size
);
153 static symbol_table_elem_t
*next_symbol(struct rtos
*os
, char *cur_symbol
, uint64_t cur_addr
)
155 symbol_table_elem_t
*s
;
158 os
->type
->get_symbol_list_to_lookup(&os
->symbols
);
161 return &os
->symbols
[0];
163 for (s
= os
->symbols
; s
->symbol_name
; s
++)
164 if (!strcmp(s
->symbol_name
, cur_symbol
)) {
165 s
->address
= cur_addr
;
173 /* searches for 'symbol' in the lookup table for 'os' and returns TRUE,
174 * if 'symbol' is not declared optional */
175 static bool is_symbol_mandatory(const struct rtos
*os
, const char *symbol
)
177 for (symbol_table_elem_t
*s
= os
->symbols
; s
->symbol_name
; ++s
) {
178 if (!strcmp(s
->symbol_name
, symbol
))
184 /* rtos_qsymbol() processes and replies to all qSymbol packets from GDB.
186 * GDB sends a qSymbol:: packet (empty address, empty name) to notify
187 * that it can now answer qSymbol::hexcodedname queries, to look up symbols.
189 * If the qSymbol packet has no address that means GDB did not find the
190 * symbol, in which case auto-detect will move on to try the next RTOS.
192 * rtos_qsymbol() then calls the next_symbol() helper function, which
193 * iterates over symbol names for the current RTOS until it finds the
194 * symbol in the received GDB packet, and then returns the next entry
195 * in the list of symbols.
197 * If GDB replied about the last symbol for the RTOS and the RTOS was
198 * specified explicitly, then no further symbol lookup is done. When
199 * auto-detecting, the RTOS driver _detect() function must return success.
201 * rtos_qsymbol() returns 1 if an RTOS has been detected, or 0 otherwise.
203 int rtos_qsymbol(struct connection
*connection
, char const *packet
, int packet_size
)
205 int rtos_detected
= 0;
208 char reply
[GDB_BUFFER_SIZE
], cur_sym
[GDB_BUFFER_SIZE
/ 2] = "";
209 symbol_table_elem_t
*next_sym
= NULL
;
210 struct target
*target
= get_target_from_connection(connection
);
211 struct rtos
*os
= target
->rtos
;
213 reply_len
= sprintf(reply
, "OK");
218 /* Decode any symbol name in the packet*/
219 size_t len
= unhexify((uint8_t *)cur_sym
, strchr(packet
+ 8, ':') + 1, strlen(strchr(packet
+ 8, ':') + 1));
222 if ((strcmp(packet
, "qSymbol::") != 0) && /* GDB is not offering symbol lookup for the first time */
223 (!sscanf(packet
, "qSymbol:%" SCNx64
":", &addr
)) && /* GDB did not find an address for a symbol */
224 is_symbol_mandatory(os
, cur_sym
)) { /* the symbol is mandatory for this RTOS */
226 /* GDB could not find an address for the previous symbol */
227 if (!target
->rtos_auto_detect
) {
228 LOG_WARNING("RTOS %s not detected. (GDB could not find symbol \'%s\')", os
->type
->name
, cur_sym
);
231 /* Autodetecting RTOS - try next RTOS */
232 if (!rtos_try_next(target
)) {
233 LOG_WARNING("No RTOS could be auto-detected!");
237 /* Next RTOS selected - invalidate current symbol */
241 next_sym
= next_symbol(os
, cur_sym
, addr
);
243 if (!next_sym
->symbol_name
) {
244 /* No more symbols need looking up */
246 if (!target
->rtos_auto_detect
) {
251 if (os
->type
->detect_rtos(target
)) {
252 LOG_INFO("Auto-detected RTOS: %s", os
->type
->name
);
256 LOG_WARNING("No RTOS could be auto-detected!");
261 if (8 + (strlen(next_sym
->symbol_name
) * 2) + 1 > sizeof(reply
)) {
262 LOG_ERROR("ERROR: RTOS symbol '%s' name is too long for GDB!", next_sym
->symbol_name
);
266 reply_len
= snprintf(reply
, sizeof(reply
), "qSymbol:");
267 reply_len
+= hexify(reply
+ reply_len
, next_sym
->symbol_name
, 0, sizeof(reply
) - reply_len
);
270 gdb_put_packet(connection
, reply
, reply_len
);
271 return rtos_detected
;
274 int rtos_thread_packet(struct connection
*connection
, char const *packet
, int packet_size
)
276 struct target
*target
= get_target_from_connection(connection
);
278 if (strncmp(packet
, "qThreadExtraInfo,", 17) == 0) {
279 if ((target
->rtos
!= NULL
) && (target
->rtos
->thread_details
!= NULL
) &&
280 (target
->rtos
->thread_count
!= 0)) {
281 threadid_t threadid
= 0;
283 sscanf(packet
, "qThreadExtraInfo,%" SCNx64
, &threadid
);
285 if ((target
->rtos
!= NULL
) && (target
->rtos
->thread_details
!= NULL
)) {
287 for (thread_num
= 0; thread_num
< target
->rtos
->thread_count
; thread_num
++) {
288 if (target
->rtos
->thread_details
[thread_num
].threadid
== threadid
) {
289 if (target
->rtos
->thread_details
[thread_num
].exists
)
295 gdb_put_packet(connection
, "E01", 3); /* thread not found */
299 struct thread_detail
*detail
= &target
->rtos
->thread_details
[found
];
302 if (detail
->thread_name_str
!= NULL
)
303 str_size
+= strlen(detail
->thread_name_str
);
304 if (detail
->extra_info_str
!= NULL
)
305 str_size
+= strlen(detail
->extra_info_str
);
307 char *tmp_str
= calloc(str_size
+ 4, sizeof(char));
308 char *tmp_str_ptr
= tmp_str
;
310 if (detail
->thread_name_str
!= NULL
)
311 tmp_str_ptr
+= sprintf(tmp_str_ptr
, "%s", detail
->thread_name_str
);
312 if (detail
->extra_info_str
!= NULL
) {
313 if (tmp_str_ptr
!= tmp_str
)
314 tmp_str_ptr
+= sprintf(tmp_str_ptr
, " : ");
315 tmp_str_ptr
+= sprintf(tmp_str_ptr
, "%s", detail
->extra_info_str
);
318 assert(strlen(tmp_str
) ==
319 (size_t) (tmp_str_ptr
- tmp_str
));
321 char *hex_str
= malloc(strlen(tmp_str
) * 2 + 1);
322 int pkt_len
= hexify(hex_str
, tmp_str
, 0, strlen(tmp_str
) * 2 + 1);
324 gdb_put_packet(connection
, hex_str
, pkt_len
);
330 gdb_put_packet(connection
, "", 0);
332 } else if (strncmp(packet
, "qSymbol", 7) == 0) {
333 if (rtos_qsymbol(connection
, packet
, packet_size
) == 1) {
334 target
->rtos_auto_detect
= false;
335 target
->rtos
->type
->create(target
);
336 target
->rtos
->type
->update_threads(target
->rtos
);
339 } else if (strncmp(packet
, "qfThreadInfo", 12) == 0) {
341 if (target
->rtos
!= NULL
) {
342 if (target
->rtos
->thread_count
== 0) {
343 gdb_put_packet(connection
, "l", 1);
345 /*thread id are 16 char +1 for ',' */
346 char *out_str
= malloc(17 * target
->rtos
->thread_count
+ 1);
347 char *tmp_str
= out_str
;
348 for (i
= 0; i
< target
->rtos
->thread_count
; i
++) {
349 tmp_str
+= sprintf(tmp_str
, "%c%016" PRIx64
, i
== 0 ? 'm' : ',',
350 target
->rtos
->thread_details
[i
].threadid
);
352 gdb_put_packet(connection
, out_str
, strlen(out_str
));
356 gdb_put_packet(connection
, "l", 1);
359 } else if (strncmp(packet
, "qsThreadInfo", 12) == 0) {
360 gdb_put_packet(connection
, "l", 1);
362 } else if (strncmp(packet
, "qAttached", 9) == 0) {
363 gdb_put_packet(connection
, "1", 1);
365 } else if (strncmp(packet
, "qOffsets", 8) == 0) {
366 char offsets
[] = "Text=0;Data=0;Bss=0";
367 gdb_put_packet(connection
, offsets
, sizeof(offsets
)-1);
369 } else if (strncmp(packet
, "qCRC:", 5) == 0) {
370 /* make sure we check this before "qC" packet below
371 * otherwise it gets incorrectly handled */
372 return GDB_THREAD_PACKET_NOT_CONSUMED
;
373 } else if (strncmp(packet
, "qC", 2) == 0) {
374 if (target
->rtos
!= NULL
) {
377 size
= snprintf(buffer
, 19, "QC%016" PRIx64
, target
->rtos
->current_thread
);
378 gdb_put_packet(connection
, buffer
, size
);
380 gdb_put_packet(connection
, "QC0", 3);
382 } else if (packet
[0] == 'T') { /* Is thread alive? */
385 sscanf(packet
, "T%" SCNx64
, &threadid
);
386 if ((target
->rtos
!= NULL
) && (target
->rtos
->thread_details
!= NULL
)) {
388 for (thread_num
= 0; thread_num
< target
->rtos
->thread_count
; thread_num
++) {
389 if (target
->rtos
->thread_details
[thread_num
].threadid
== threadid
) {
390 if (target
->rtos
->thread_details
[thread_num
].exists
)
396 gdb_put_packet(connection
, "OK", 2); /* thread alive */
398 gdb_put_packet(connection
, "E01", 3); /* thread not found */
400 } else if (packet
[0] == 'H') { /* Set current thread ( 'c' for step and continue, 'g' for
401 * all other operations ) */
402 if ((packet
[1] == 'g') && (target
->rtos
!= NULL
)) {
403 sscanf(packet
, "Hg%16" SCNx64
, &target
->rtos
->current_threadid
);
404 LOG_DEBUG("RTOS: GDB requested to set current thread to 0x%" PRIx64
"\r\n",
405 target
->rtos
->current_threadid
);
407 gdb_put_packet(connection
, "OK", 2);
411 return GDB_THREAD_PACKET_NOT_CONSUMED
;
414 int rtos_get_gdb_reg_list(struct connection
*connection
)
416 struct target
*target
= get_target_from_connection(connection
);
417 int64_t current_threadid
= target
->rtos
->current_threadid
;
418 if ((target
->rtos
!= NULL
) && (current_threadid
!= -1) &&
419 (current_threadid
!= 0) &&
420 ((current_threadid
!= target
->rtos
->current_thread
) ||
421 (target
->smp
))) { /* in smp several current thread are possible */
424 LOG_DEBUG("RTOS: getting register list for thread 0x%" PRIx64
425 ", target->rtos->current_thread=0x%" PRIx64
"\r\n",
427 target
->rtos
->current_thread
);
429 target
->rtos
->type
->get_thread_reg_list(target
->rtos
,
433 if (hex_reg_list
!= NULL
) {
434 gdb_put_packet(connection
, hex_reg_list
, strlen(hex_reg_list
));
442 int rtos_generic_stack_read(struct target
*target
,
443 const struct rtos_register_stacking
*stacking
,
449 int64_t new_stack_ptr
;
453 if (stack_ptr
== 0) {
454 LOG_ERROR("Error: null stack pointer in thread");
458 uint8_t *stack_data
= malloc(stacking
->stack_registers_size
);
459 uint32_t address
= stack_ptr
;
461 if (stacking
->stack_growth_direction
== 1)
462 address
-= stacking
->stack_registers_size
;
463 retval
= target_read_buffer(target
, address
, stacking
->stack_registers_size
, stack_data
);
464 if (retval
!= ERROR_OK
) {
466 LOG_ERROR("Error reading stack frame from thread");
469 LOG_DEBUG("RTOS: Read stack frame at 0x%" PRIx32
, address
);
472 LOG_OUTPUT("Stack Data :");
473 for (i
= 0; i
< stacking
->stack_registers_size
; i
++)
474 LOG_OUTPUT("%02X", stack_data
[i
]);
477 for (i
= 0; i
< stacking
->num_output_registers
; i
++)
478 list_size
+= stacking
->register_offsets
[i
].width_bits
/8;
479 *hex_reg_list
= malloc(list_size
*2 + 1);
480 tmp_str_ptr
= *hex_reg_list
;
481 if (stacking
->calculate_process_stack
!= NULL
) {
482 new_stack_ptr
= stacking
->calculate_process_stack(target
,
483 stack_data
, stacking
, stack_ptr
);
485 new_stack_ptr
= stack_ptr
- stacking
->stack_growth_direction
*
486 stacking
->stack_registers_size
;
488 for (i
= 0; i
< stacking
->num_output_registers
; i
++) {
490 for (j
= 0; j
< stacking
->register_offsets
[i
].width_bits
/8; j
++) {
491 if (stacking
->register_offsets
[i
].offset
== -1)
492 tmp_str_ptr
+= sprintf(tmp_str_ptr
, "%02x", 0);
493 else if (stacking
->register_offsets
[i
].offset
== -2)
494 tmp_str_ptr
+= sprintf(tmp_str_ptr
, "%02x",
495 ((uint8_t *)&new_stack_ptr
)[j
]);
497 tmp_str_ptr
+= sprintf(tmp_str_ptr
, "%02x",
498 stack_data
[stacking
->register_offsets
[i
].offset
+ j
]);
502 /* LOG_OUTPUT("Output register string: %s\r\n", *hex_reg_list); */
506 int rtos_try_next(struct target
*target
)
508 struct rtos
*os
= target
->rtos
;
509 struct rtos_type
**type
= rtos_types
;
514 while (*type
&& os
->type
!= *type
)
517 if (!*type
|| !*(++type
))
529 int rtos_update_threads(struct target
*target
)
531 if ((target
->rtos
!= NULL
) && (target
->rtos
->type
!= NULL
))
532 target
->rtos
->type
->update_threads(target
->rtos
);
536 void rtos_free_threadlist(struct rtos
*rtos
)
538 if (rtos
->thread_details
) {
541 for (j
= 0; j
< rtos
->thread_count
; j
++) {
542 struct thread_detail
*current_thread
= &rtos
->thread_details
[j
];
543 free(current_thread
->thread_name_str
);
544 free(current_thread
->extra_info_str
);
546 free(rtos
->thread_details
);
547 rtos
->thread_details
= NULL
;
548 rtos
->thread_count
= 0;
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)