Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
gdb_server: fix memory leaks in users of get_reg_features_list()
[openocd.git] / src / server / gdb_server.c
1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
4 * *
5 * Copyright (C) 2007-2010 Øyvind Harboe *
6 * oyvind.harboe@zylin.com *
7 * *
8 * Copyright (C) 2008 by Spencer Oliver *
9 * spen@spen-soft.co.uk *
10 * *
11 * Copyright (C) 2011 by Broadcom Corporation *
12 * Evan Hunter - ehunter@broadcom.com *
13 * *
14 * Copyright (C) ST-Ericsson SA 2011 *
15 * michel.jaouen@stericsson.com : smp minimum support *
16 * *
17 * Copyright (C) 2013 Andes Technology *
18 * Hsiangkai Wang <hkwang@andestech.com> *
19 * *
20 * Copyright (C) 2013 Franck Jullien *
21 * elec4fun@gmail.com *
22 * *
23 * This program is free software; you can redistribute it and/or modify *
24 * it under the terms of the GNU General Public License as published by *
25 * the Free Software Foundation; either version 2 of the License, or *
26 * (at your option) any later version. *
27 * *
28 * This program is distributed in the hope that it will be useful, *
29 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
30 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
31 * GNU General Public License for more details. *
32 * *
33 * You should have received a copy of the GNU General Public License *
34 * along with this program; if not, write to the *
35 * Free Software Foundation, Inc., *
36 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. *
37 ***************************************************************************/
38
39 #ifdef HAVE_CONFIG_H
40 #include "config.h"
41 #endif
42
43 #include <target/breakpoints.h>
44 #include <target/target_request.h>
45 #include <target/register.h>
46 #include "server.h"
47 #include <flash/nor/core.h>
48 #include "gdb_server.h"
49 #include <target/image.h>
50 #include <jtag/jtag.h>
51 #include "rtos/rtos.h"
52 #include "target/smp.h"
53
54 /**
55 * @file
56 * GDB server implementation.
57 *
58 * This implements the GDB Remote Serial Protocol, over TCP connections,
59 * giving GDB access to the JTAG or other hardware debugging facilities
60 * found in most modern embedded processors.
61 */
62
63 struct target_desc_format {
64 char *tdesc;
65 uint32_t tdesc_length;
66 };
67
68 /* private connection data for GDB */
69 struct gdb_connection {
70 char buffer[GDB_BUFFER_SIZE];
71 char *buf_p;
72 int buf_cnt;
73 int ctrl_c;
74 enum target_state frontend_state;
75 struct image *vflash_image;
76 int closed;
77 int busy;
78 int noack_mode;
79 /* set flag to true if you want the next stepi to return immediately.
80 * allowing GDB to pick up a fresh set of register values from the target
81 * without modifying the target state. */
82 bool sync;
83 /* We delay reporting memory write errors until next step/continue or memory
84 * write. This improves performance of gdb load significantly as the GDB packet
85 * can be replied immediately and a new GDB packet will be ready without delay
86 * (ca. 10% or so...). */
87 bool mem_write_error;
88 /* with extended-remote it seems we need to better emulate attach/detach.
89 * what this means is we reply with a W stop reply after a kill packet,
90 * normally we reply with a S reply via gdb_last_signal_packet.
91 * as a side note this behaviour only effects gdb > 6.8 */
92 bool attached;
93 /* temporarily used for target description support */
94 struct target_desc_format target_desc;
95 };
96
97 #if 0
98 #define _DEBUG_GDB_IO_
99 #endif
100
101 static struct gdb_connection *current_gdb_connection;
102
103 static int gdb_breakpoint_override;
104 static enum breakpoint_type gdb_breakpoint_override_type;
105
106 static int gdb_error(struct connection *connection, int retval);
107 static char *gdb_port;
108 static char *gdb_port_next;
109
110 static void gdb_log_callback(void *priv, const char *file, unsigned line,
111 const char *function, const char *string);
112
113 /* number of gdb connections, mainly to suppress gdb related debugging spam
114 * in helper/log.c when no gdb connections are actually active */
115 int gdb_actual_connections;
116
117 /* set if we are sending a memory map to gdb
118 * via qXfer:memory-map:read packet */
119 /* enabled by default*/
120 static int gdb_use_memory_map = 1;
121 /* enabled by default*/
122 static int gdb_flash_program = 1;
123
124 /* if set, data aborts cause an error to be reported in memory read packets
125 * see the code in gdb_read_memory_packet() for further explanations.
126 * Disabled by default.
127 */
128 static int gdb_report_data_abort;
129
130 /* set if we are sending target descriptions to gdb
131 * via qXfer:features:read packet */
132 /* enabled by default */
133 static int gdb_use_target_description = 1;
134
135 /* current processing free-run type, used by file-I/O */
136 static char gdb_running_type;
137
138 static int gdb_last_signal(struct target *target)
139 {
140 switch (target->debug_reason) {
141 case DBG_REASON_DBGRQ:
142 return 0x2; /* SIGINT */
143 case DBG_REASON_BREAKPOINT:
144 case DBG_REASON_WATCHPOINT:
145 case DBG_REASON_WPTANDBKPT:
146 return 0x05; /* SIGTRAP */
147 case DBG_REASON_SINGLESTEP:
148 return 0x05; /* SIGTRAP */
149 case DBG_REASON_NOTHALTED:
150 return 0x0; /* no signal... shouldn't happen */
151 default:
152 LOG_USER("undefined debug reason %d - target needs reset",
153 target->debug_reason);
154 return 0x0;
155 }
156 }
157
158 static int check_pending(struct connection *connection,
159 int timeout_s, int *got_data)
160 {
161 /* a non-blocking socket will block if there is 0 bytes available on the socket,
162 * but return with as many bytes as are available immediately
163 */
164 struct timeval tv;
165 fd_set read_fds;
166 struct gdb_connection *gdb_con = connection->priv;
167 int t;
168 if (got_data == NULL)
169 got_data = &t;
170 *got_data = 0;
171
172 if (gdb_con->buf_cnt > 0) {
173 *got_data = 1;
174 return ERROR_OK;
175 }
176
177 FD_ZERO(&read_fds);
178 FD_SET(connection->fd, &read_fds);
179
180 tv.tv_sec = timeout_s;
181 tv.tv_usec = 0;
182 if (socket_select(connection->fd + 1, &read_fds, NULL, NULL, &tv) == 0) {
183 /* This can typically be because a "monitor" command took too long
184 * before printing any progress messages
185 */
186 if (timeout_s > 0)
187 return ERROR_GDB_TIMEOUT;
188 else
189 return ERROR_OK;
190 }
191 *got_data = FD_ISSET(connection->fd, &read_fds) != 0;
192 return ERROR_OK;
193 }
194
195 static int gdb_get_char_inner(struct connection *connection, int *next_char)
196 {
197 struct gdb_connection *gdb_con = connection->priv;
198 int retval = ERROR_OK;
199
200 #ifdef _DEBUG_GDB_IO_
201 char *debug_buffer;
202 #endif
203 for (;; ) {
204 if (connection->service->type != CONNECTION_TCP)
205 gdb_con->buf_cnt = read(connection->fd, gdb_con->buffer, GDB_BUFFER_SIZE);
206 else {
207 retval = check_pending(connection, 1, NULL);
208 if (retval != ERROR_OK)
209 return retval;
210 gdb_con->buf_cnt = read_socket(connection->fd,
211 gdb_con->buffer,
212 GDB_BUFFER_SIZE);
213 }
214
215 if (gdb_con->buf_cnt > 0)
216 break;
217 if (gdb_con->buf_cnt == 0) {
218 gdb_con->closed = 1;
219 return ERROR_SERVER_REMOTE_CLOSED;
220 }
221
222 #ifdef _WIN32
223 errno = WSAGetLastError();
224
225 switch (errno) {
226 case WSAEWOULDBLOCK:
227 usleep(1000);
228 break;
229 case WSAECONNABORTED:
230 gdb_con->closed = 1;
231 return ERROR_SERVER_REMOTE_CLOSED;
232 case WSAECONNRESET:
233 gdb_con->closed = 1;
234 return ERROR_SERVER_REMOTE_CLOSED;
235 default:
236 LOG_ERROR("read: %d", errno);
237 exit(-1);
238 }
239 #else
240 switch (errno) {
241 case EAGAIN:
242 usleep(1000);
243 break;
244 case ECONNABORTED:
245 gdb_con->closed = 1;
246 return ERROR_SERVER_REMOTE_CLOSED;
247 case ECONNRESET:
248 gdb_con->closed = 1;
249 return ERROR_SERVER_REMOTE_CLOSED;
250 default:
251 LOG_ERROR("read: %s", strerror(errno));
252 gdb_con->closed = 1;
253 return ERROR_SERVER_REMOTE_CLOSED;
254 }
255 #endif
256 }
257
258 #ifdef _DEBUG_GDB_IO_
259 debug_buffer = strndup(gdb_con->buffer, gdb_con->buf_cnt);
260 LOG_DEBUG("received '%s'", debug_buffer);
261 free(debug_buffer);
262 #endif
263
264 gdb_con->buf_p = gdb_con->buffer;
265 gdb_con->buf_cnt--;
266 *next_char = *(gdb_con->buf_p++);
267 if (gdb_con->buf_cnt > 0)
268 connection->input_pending = 1;
269 else
270 connection->input_pending = 0;
271 #ifdef _DEBUG_GDB_IO_
272 LOG_DEBUG("returned char '%c' (0x%2.2x)", *next_char, *next_char);
273 #endif
274
275 return retval;
276 }
277
278 /**
279 * The cool thing about this fn is that it allows buf_p and buf_cnt to be
280 * held in registers in the inner loop.
281 *
282 * For small caches and embedded systems this is important!
283 */
284 static inline int gdb_get_char_fast(struct connection *connection,
285 int *next_char, char **buf_p, int *buf_cnt)
286 {
287 int retval = ERROR_OK;
288
289 if ((*buf_cnt)-- > 0) {
290 *next_char = **buf_p;
291 (*buf_p)++;
292 if (*buf_cnt > 0)
293 connection->input_pending = 1;
294 else
295 connection->input_pending = 0;
296
297 #ifdef _DEBUG_GDB_IO_
298 LOG_DEBUG("returned char '%c' (0x%2.2x)", *next_char, *next_char);
299 #endif
300
301 return ERROR_OK;
302 }
303
304 struct gdb_connection *gdb_con = connection->priv;
305 gdb_con->buf_p = *buf_p;
306 gdb_con->buf_cnt = *buf_cnt;
307 retval = gdb_get_char_inner(connection, next_char);
308 *buf_p = gdb_con->buf_p;
309 *buf_cnt = gdb_con->buf_cnt;
310
311 return retval;
312 }
313
314 static int gdb_get_char(struct connection *connection, int *next_char)
315 {
316 struct gdb_connection *gdb_con = connection->priv;
317 return gdb_get_char_fast(connection, next_char, &gdb_con->buf_p, &gdb_con->buf_cnt);
318 }
319
320 static int gdb_putback_char(struct connection *connection, int last_char)
321 {
322 struct gdb_connection *gdb_con = connection->priv;
323
324 if (gdb_con->buf_p > gdb_con->buffer) {
325 *(--gdb_con->buf_p) = last_char;
326 gdb_con->buf_cnt++;
327 } else
328 LOG_ERROR("BUG: couldn't put character back");
329
330 return ERROR_OK;
331 }
332
333 /* The only way we can detect that the socket is closed is the first time
334 * we write to it, we will fail. Subsequent write operations will
335 * succeed. Shudder! */
336 static int gdb_write(struct connection *connection, void *data, int len)
337 {
338 struct gdb_connection *gdb_con = connection->priv;
339 if (gdb_con->closed)
340 return ERROR_SERVER_REMOTE_CLOSED;
341
342 if (connection_write(connection, data, len) == len)
343 return ERROR_OK;
344 gdb_con->closed = 1;
345 return ERROR_SERVER_REMOTE_CLOSED;
346 }
347
348 static int gdb_put_packet_inner(struct connection *connection,
349 char *buffer, int len)
350 {
351 int i;
352 unsigned char my_checksum = 0;
353 #ifdef _DEBUG_GDB_IO_
354 char *debug_buffer;
355 #endif
356 int reply;
357 int retval;
358 struct gdb_connection *gdb_con = connection->priv;
359
360 for (i = 0; i < len; i++)
361 my_checksum += buffer[i];
362
363 #ifdef _DEBUG_GDB_IO_
364 /*
365 * At this point we should have nothing in the input queue from GDB,
366 * however sometimes '-' is sent even though we've already received
367 * an ACK (+) for everything we've sent off.
368 */
369 int gotdata;
370 for (;; ) {
371 retval = check_pending(connection, 0, &gotdata);
372 if (retval != ERROR_OK)
373 return retval;
374 if (!gotdata)
375 break;
376 retval = gdb_get_char(connection, &reply);
377 if (retval != ERROR_OK)
378 return retval;
379 if (reply == '$') {
380 /* fix a problem with some IAR tools */
381 gdb_putback_char(connection, reply);
382 LOG_DEBUG("Unexpected start of new packet");
383 break;
384 }
385
386 LOG_WARNING("Discard unexpected char %c", reply);
387 }
388 #endif
389
390 while (1) {
391 #ifdef _DEBUG_GDB_IO_
392 debug_buffer = strndup(buffer, len);
393 LOG_DEBUG("sending packet '$%s#%2.2x'", debug_buffer, my_checksum);
394 free(debug_buffer);
395 #endif
396
397 char local_buffer[1024];
398 local_buffer[0] = '$';
399 if ((size_t)len + 4 <= sizeof(local_buffer)) {
400 /* performance gain on smaller packets by only a single call to gdb_write() */
401 memcpy(local_buffer + 1, buffer, len++);
402 len += snprintf(local_buffer + len, sizeof(local_buffer) - len, "#%02x", my_checksum);
403 retval = gdb_write(connection, local_buffer, len);
404 if (retval != ERROR_OK)
405 return retval;
406 } else {
407 /* larger packets are transmitted directly from caller supplied buffer
408 * by several calls to gdb_write() to avoid dynamic allocation */
409 snprintf(local_buffer + 1, sizeof(local_buffer) - 1, "#%02x", my_checksum);
410 retval = gdb_write(connection, local_buffer, 1);
411 if (retval != ERROR_OK)
412 return retval;
413 retval = gdb_write(connection, buffer, len);
414 if (retval != ERROR_OK)
415 return retval;
416 retval = gdb_write(connection, local_buffer + 1, 3);
417 if (retval != ERROR_OK)
418 return retval;
419 }
420
421 if (gdb_con->noack_mode)
422 break;
423
424 retval = gdb_get_char(connection, &reply);
425 if (retval != ERROR_OK)
426 return retval;
427
428 if (reply == '+')
429 break;
430 else if (reply == '-') {
431 /* Stop sending output packets for now */
432 log_remove_callback(gdb_log_callback, connection);
433 LOG_WARNING("negative reply, retrying");
434 } else if (reply == 0x3) {
435 gdb_con->ctrl_c = 1;
436 retval = gdb_get_char(connection, &reply);
437 if (retval != ERROR_OK)
438 return retval;
439 if (reply == '+')
440 break;
441 else if (reply == '-') {
442 /* Stop sending output packets for now */
443 log_remove_callback(gdb_log_callback, connection);
444 LOG_WARNING("negative reply, retrying");
445 } else if (reply == '$') {
446 LOG_ERROR("GDB missing ack(1) - assumed good");
447 gdb_putback_char(connection, reply);
448 return ERROR_OK;
449 } else {
450 LOG_ERROR("unknown character(1) 0x%2.2x in reply, dropping connection", reply);
451 gdb_con->closed = 1;
452 return ERROR_SERVER_REMOTE_CLOSED;
453 }
454 } else if (reply == '$') {
455 LOG_ERROR("GDB missing ack(2) - assumed good");
456 gdb_putback_char(connection, reply);
457 return ERROR_OK;
458 } else {
459 LOG_ERROR("unknown character(2) 0x%2.2x in reply, dropping connection",
460 reply);
461 gdb_con->closed = 1;
462 return ERROR_SERVER_REMOTE_CLOSED;
463 }
464 }
465 if (gdb_con->closed)
466 return ERROR_SERVER_REMOTE_CLOSED;
467
468 return ERROR_OK;
469 }
470
471 int gdb_put_packet(struct connection *connection, char *buffer, int len)
472 {
473 struct gdb_connection *gdb_con = connection->priv;
474 gdb_con->busy = 1;
475 int retval = gdb_put_packet_inner(connection, buffer, len);
476 gdb_con->busy = 0;
477
478 /* we sent some data, reset timer for keep alive messages */
479 kept_alive();
480
481 return retval;
482 }
483
484 static inline int fetch_packet(struct connection *connection,
485 int *checksum_ok, int noack, int *len, char *buffer)
486 {
487 unsigned char my_checksum = 0;
488 char checksum[3];
489 int character;
490 int retval = ERROR_OK;
491
492 struct gdb_connection *gdb_con = connection->priv;
493 my_checksum = 0;
494 int count = 0;
495 count = 0;
496
497 /* move this over into local variables to use registers and give the
498 * more freedom to optimize */
499 char *buf_p = gdb_con->buf_p;
500 int buf_cnt = gdb_con->buf_cnt;
501
502 for (;; ) {
503 /* The common case is that we have an entire packet with no escape chars.
504 * We need to leave at least 2 bytes in the buffer to have
505 * gdb_get_char() update various bits and bobs correctly.
506 */
507 if ((buf_cnt > 2) && ((buf_cnt + count) < *len)) {
508 /* The compiler will struggle a bit with constant propagation and
509 * aliasing, so we help it by showing that these values do not
510 * change inside the loop
511 */
512 int i;
513 char *buf = buf_p;
514 int run = buf_cnt - 2;
515 i = 0;
516 int done = 0;
517 while (i < run) {
518 character = *buf++;
519 i++;
520 if (character == '#') {
521 /* Danger! character can be '#' when esc is
522 * used so we need an explicit boolean for done here. */
523 done = 1;
524 break;
525 }
526
527 if (character == '}') {
528 /* data transmitted in binary mode (X packet)
529 * uses 0x7d as escape character */
530 my_checksum += character & 0xff;
531 character = *buf++;
532 i++;
533 my_checksum += character & 0xff;
534 buffer[count++] = (character ^ 0x20) & 0xff;
535 } else {
536 my_checksum += character & 0xff;
537 buffer[count++] = character & 0xff;
538 }
539 }
540 buf_p += i;
541 buf_cnt -= i;
542 if (done)
543 break;
544 }
545 if (count > *len) {
546 LOG_ERROR("packet buffer too small");
547 retval = ERROR_GDB_BUFFER_TOO_SMALL;
548 break;
549 }
550
551 retval = gdb_get_char_fast(connection, &character, &buf_p, &buf_cnt);
552 if (retval != ERROR_OK)
553 break;
554
555 if (character == '#')
556 break;
557
558 if (character == '}') {
559 /* data transmitted in binary mode (X packet)
560 * uses 0x7d as escape character */
561 my_checksum += character & 0xff;
562
563 retval = gdb_get_char_fast(connection, &character, &buf_p, &buf_cnt);
564 if (retval != ERROR_OK)
565 break;
566
567 my_checksum += character & 0xff;
568 buffer[count++] = (character ^ 0x20) & 0xff;
569 } else {
570 my_checksum += character & 0xff;
571 buffer[count++] = character & 0xff;
572 }
573 }
574
575 gdb_con->buf_p = buf_p;
576 gdb_con->buf_cnt = buf_cnt;
577
578 if (retval != ERROR_OK)
579 return retval;
580
581 *len = count;
582
583 retval = gdb_get_char(connection, &character);
584 if (retval != ERROR_OK)
585 return retval;
586 checksum[0] = character;
587 retval = gdb_get_char(connection, &character);
588 if (retval != ERROR_OK)
589 return retval;
590 checksum[1] = character;
591 checksum[2] = 0;
592
593 if (!noack)
594 *checksum_ok = (my_checksum == strtoul(checksum, NULL, 16));
595
596 return ERROR_OK;
597 }
598
599 static int gdb_get_packet_inner(struct connection *connection,
600 char *buffer, int *len)
601 {
602 int character;
603 int retval;
604 struct gdb_connection *gdb_con = connection->priv;
605
606 while (1) {
607 do {
608 retval = gdb_get_char(connection, &character);
609 if (retval != ERROR_OK)
610 return retval;
611
612 #ifdef _DEBUG_GDB_IO_
613 LOG_DEBUG("character: '%c'", character);
614 #endif
615
616 switch (character) {
617 case '$':
618 break;
619 case '+':
620 /* According to the GDB documentation
621 * (https://sourceware.org/gdb/onlinedocs/gdb/Packet-Acknowledgment.html):
622 * "gdb sends a final `+` acknowledgment of the stub's `OK`
623 * response, which can be safely ignored by the stub."
624 * However OpenOCD server already is in noack mode at this
625 * point and instead of ignoring this it was emitting a
626 * warning. This code makes server ignore the first ACK
627 * that will be received after going into noack mode,
628 * warning only about subsequent ACK's. */
629 if (gdb_con->noack_mode > 1) {
630 LOG_WARNING("acknowledgment received, but no packet pending");
631 } else {
632 LOG_DEBUG("Received first acknowledgment after entering noack mode. Ignoring it.");
633 gdb_con->noack_mode = 2;
634 }
635 break;
636 case '-':
637 LOG_WARNING("negative acknowledgment, but no packet pending");
638 break;
639 case 0x3:
640 gdb_con->ctrl_c = 1;
641 *len = 0;
642 return ERROR_OK;
643 default:
644 LOG_WARNING("ignoring character 0x%x", character);
645 break;
646 }
647 } while (character != '$');
648
649 int checksum_ok = 0;
650 /* explicit code expansion here to get faster inlined code in -O3 by not
651 * calculating checksum */
652 if (gdb_con->noack_mode) {
653 retval = fetch_packet(connection, &checksum_ok, 1, len, buffer);
654 if (retval != ERROR_OK)
655 return retval;
656 } else {
657 retval = fetch_packet(connection, &checksum_ok, 0, len, buffer);
658 if (retval != ERROR_OK)
659 return retval;
660 }
661
662 if (gdb_con->noack_mode) {
663 /* checksum is not checked in noack mode */
664 break;
665 }
666 if (checksum_ok) {
667 retval = gdb_write(connection, "+", 1);
668 if (retval != ERROR_OK)
669 return retval;
670 break;
671 }
672 }
673 if (gdb_con->closed)
674 return ERROR_SERVER_REMOTE_CLOSED;
675
676 return ERROR_OK;
677 }
678
679 static int gdb_get_packet(struct connection *connection, char *buffer, int *len)
680 {
681 struct gdb_connection *gdb_con = connection->priv;
682 gdb_con->busy = 1;
683 int retval = gdb_get_packet_inner(connection, buffer, len);
684 gdb_con->busy = 0;
685 return retval;
686 }
687
688 static int gdb_output_con(struct connection *connection, const char *line)
689 {
690 char *hex_buffer;
691 int bin_size;
692
693 bin_size = strlen(line);
694
695 hex_buffer = malloc(bin_size * 2 + 2);
696 if (hex_buffer == NULL)
697 return ERROR_GDB_BUFFER_TOO_SMALL;
698
699 hex_buffer[0] = 'O';
700 int pkt_len = hexify(hex_buffer + 1, line, bin_size, bin_size * 2 + 1);
701 int retval = gdb_put_packet(connection, hex_buffer, pkt_len + 1);
702
703 free(hex_buffer);
704 return retval;
705 }
706
707 static int gdb_output(struct command_context *context, const char *line)
708 {
709 /* this will be dumped to the log and also sent as an O packet if possible */
710 LOG_USER_N("%s", line);
711 return ERROR_OK;
712 }
713
714 static void gdb_signal_reply(struct target *target, struct connection *connection)
715 {
716 struct gdb_connection *gdb_connection = connection->priv;
717 char sig_reply[20];
718 char stop_reason[20];
719 int sig_reply_len;
720 int signal_var;
721
722 if (target->debug_reason == DBG_REASON_EXIT) {
723 sig_reply_len = snprintf(sig_reply, sizeof(sig_reply), "W00");
724 } else {
725 if (gdb_connection->ctrl_c) {
726 signal_var = 0x2;
727 gdb_connection->ctrl_c = 0;
728 } else
729 signal_var = gdb_last_signal(target);
730
731 stop_reason[0] = '\0';
732 if (target->debug_reason == DBG_REASON_WATCHPOINT) {
733 enum watchpoint_rw hit_wp_type;
734 uint32_t hit_wp_address;
735
736 if (watchpoint_hit(target, &hit_wp_type, &hit_wp_address) == ERROR_OK) {
737
738 switch (hit_wp_type) {
739 case WPT_WRITE:
740 snprintf(stop_reason, sizeof(stop_reason),
741 "watch:%08" PRIx32 ";", hit_wp_address);
742 break;
743 case WPT_READ:
744 snprintf(stop_reason, sizeof(stop_reason),
745 "rwatch:%08" PRIx32 ";", hit_wp_address);
746 break;
747 case WPT_ACCESS:
748 snprintf(stop_reason, sizeof(stop_reason),
749 "awatch:%08" PRIx32 ";", hit_wp_address);
750 break;
751 default:
752 break;
753 }
754 }
755 }
756
757 sig_reply_len = snprintf(sig_reply, sizeof(sig_reply), "T%2.2x%s",
758 signal_var, stop_reason);
759 }
760
761 gdb_put_packet(connection, sig_reply, sig_reply_len);
762 gdb_connection->frontend_state = TARGET_HALTED;
763 rtos_update_threads(target);
764 }
765
766 static void gdb_fileio_reply(struct target *target, struct connection *connection)
767 {
768 struct gdb_connection *gdb_connection = connection->priv;
769 char fileio_command[256];
770 int command_len;
771 bool program_exited = false;
772
773 if (strcmp(target->fileio_info->identifier, "open") == 0)
774 sprintf(fileio_command, "F%s,%" PRIx32 "/%" PRIx32 ",%" PRIx32 ",%" PRIx32, target->fileio_info->identifier,
775 target->fileio_info->param_1,
776 target->fileio_info->param_2,
777 target->fileio_info->param_3,
778 target->fileio_info->param_4);
779 else if (strcmp(target->fileio_info->identifier, "close") == 0)
780 sprintf(fileio_command, "F%s,%" PRIx32, target->fileio_info->identifier,
781 target->fileio_info->param_1);
782 else if (strcmp(target->fileio_info->identifier, "read") == 0)
783 sprintf(fileio_command, "F%s,%" PRIx32 ",%" PRIx32 ",%" PRIx32, target->fileio_info->identifier,
784 target->fileio_info->param_1,
785 target->fileio_info->param_2,
786 target->fileio_info->param_3);
787 else if (strcmp(target->fileio_info->identifier, "write") == 0)
788 sprintf(fileio_command, "F%s,%" PRIx32 ",%" PRIx32 ",%" PRIx32, target->fileio_info->identifier,
789 target->fileio_info->param_1,
790 target->fileio_info->param_2,
791 target->fileio_info->param_3);
792 else if (strcmp(target->fileio_info->identifier, "lseek") == 0)
793 sprintf(fileio_command, "F%s,%" PRIx32 ",%" PRIx32 ",%" PRIx32, target->fileio_info->identifier,
794 target->fileio_info->param_1,
795 target->fileio_info->param_2,
796 target->fileio_info->param_3);
797 else if (strcmp(target->fileio_info->identifier, "rename") == 0)
798 sprintf(fileio_command, "F%s,%" PRIx32 "/%" PRIx32 ",%" PRIx32 "/%" PRIx32, target->fileio_info->identifier,
799 target->fileio_info->param_1,
800 target->fileio_info->param_2,
801 target->fileio_info->param_3,
802 target->fileio_info->param_4);
803 else if (strcmp(target->fileio_info->identifier, "unlink") == 0)
804 sprintf(fileio_command, "F%s,%" PRIx32 "/%" PRIx32, target->fileio_info->identifier,
805 target->fileio_info->param_1,
806 target->fileio_info->param_2);
807 else if (strcmp(target->fileio_info->identifier, "stat") == 0)
808 sprintf(fileio_command, "F%s,%" PRIx32 "/%" PRIx32 ",%" PRIx32, target->fileio_info->identifier,
809 target->fileio_info->param_1,
810 target->fileio_info->param_2,
811 target->fileio_info->param_3);
812 else if (strcmp(target->fileio_info->identifier, "fstat") == 0)
813 sprintf(fileio_command, "F%s,%" PRIx32 ",%" PRIx32, target->fileio_info->identifier,
814 target->fileio_info->param_1,
815 target->fileio_info->param_2);
816 else if (strcmp(target->fileio_info->identifier, "gettimeofday") == 0)
817 sprintf(fileio_command, "F%s,%" PRIx32 ",%" PRIx32, target->fileio_info->identifier,
818 target->fileio_info->param_1,
819 target->fileio_info->param_2);
820 else if (strcmp(target->fileio_info->identifier, "isatty") == 0)
821 sprintf(fileio_command, "F%s,%" PRIx32, target->fileio_info->identifier,
822 target->fileio_info->param_1);
823 else if (strcmp(target->fileio_info->identifier, "system") == 0)
824 sprintf(fileio_command, "F%s,%" PRIx32 "/%" PRIx32, target->fileio_info->identifier,
825 target->fileio_info->param_1,
826 target->fileio_info->param_2);
827 else if (strcmp(target->fileio_info->identifier, "exit") == 0) {
828 /* If target hits exit syscall, report to GDB the program is terminated.
829 * In addition, let target run its own exit syscall handler. */
830 program_exited = true;
831 sprintf(fileio_command, "W%02" PRIx32, target->fileio_info->param_1);
832 } else {
833 LOG_DEBUG("Unknown syscall: %s", target->fileio_info->identifier);
834
835 /* encounter unknown syscall, continue */
836 gdb_connection->frontend_state = TARGET_RUNNING;
837 target_resume(target, 1, 0x0, 0, 0);
838 return;
839 }
840
841 command_len = strlen(fileio_command);
842 gdb_put_packet(connection, fileio_command, command_len);
843
844 if (program_exited) {
845 /* Use target_resume() to let target run its own exit syscall handler. */
846 gdb_connection->frontend_state = TARGET_RUNNING;
847 target_resume(target, 1, 0x0, 0, 0);
848 } else {
849 gdb_connection->frontend_state = TARGET_HALTED;
850 rtos_update_threads(target);
851 }
852 }
853
854 static void gdb_frontend_halted(struct target *target, struct connection *connection)
855 {
856 struct gdb_connection *gdb_connection = connection->priv;
857
858 /* In the GDB protocol when we are stepping or continuing execution,
859 * we have a lingering reply. Upon receiving a halted event
860 * when we have that lingering packet, we reply to the original
861 * step or continue packet.
862 *
863 * Executing monitor commands can bring the target in and
864 * out of the running state so we'll see lots of TARGET_EVENT_XXX
865 * that are to be ignored.
866 */
867 if (gdb_connection->frontend_state == TARGET_RUNNING) {
868 /* stop forwarding log packets! */
869 log_remove_callback(gdb_log_callback, connection);
870
871 /* check fileio first */
872 if (target_get_gdb_fileio_info(target, target->fileio_info) == ERROR_OK)
873 gdb_fileio_reply(target, connection);
874 else
875 gdb_signal_reply(target, connection);
876 }
877 }
878
879 static int gdb_target_callback_event_handler(struct target *target,
880 enum target_event event, void *priv)
881 {
882 int retval;
883 struct connection *connection = priv;
884 struct gdb_service *gdb_service = connection->service->priv;
885
886 if (gdb_service->target != target)
887 return ERROR_OK;
888
889 switch (event) {
890 case TARGET_EVENT_GDB_HALT:
891 gdb_frontend_halted(target, connection);
892 break;
893 case TARGET_EVENT_HALTED:
894 target_call_event_callbacks(target, TARGET_EVENT_GDB_END);
895 break;
896 case TARGET_EVENT_GDB_FLASH_ERASE_START:
897 retval = jtag_execute_queue();
898 if (retval != ERROR_OK)
899 return retval;
900 break;
901 default:
902 break;
903 }
904
905 return ERROR_OK;
906 }
907
908 static int gdb_new_connection(struct connection *connection)
909 {
910 struct gdb_connection *gdb_connection = malloc(sizeof(struct gdb_connection));
911 struct gdb_service *gdb_service = connection->service->priv;
912 int retval;
913 int initial_ack;
914
915 connection->priv = gdb_connection;
916
917 /* initialize gdb connection information */
918 gdb_connection->buf_p = gdb_connection->buffer;
919 gdb_connection->buf_cnt = 0;
920 gdb_connection->ctrl_c = 0;
921 gdb_connection->frontend_state = TARGET_HALTED;
922 gdb_connection->vflash_image = NULL;
923 gdb_connection->closed = 0;
924 gdb_connection->busy = 0;
925 gdb_connection->noack_mode = 0;
926 gdb_connection->sync = false;
927 gdb_connection->mem_write_error = false;
928 gdb_connection->attached = true;
929 gdb_connection->target_desc.tdesc = NULL;
930 gdb_connection->target_desc.tdesc_length = 0;
931
932 /* send ACK to GDB for debug request */
933 gdb_write(connection, "+", 1);
934
935 /* output goes through gdb connection */
936 command_set_output_handler(connection->cmd_ctx, gdb_output, connection);
937
938 /* we must remove all breakpoints registered to the target as a previous
939 * GDB session could leave dangling breakpoints if e.g. communication
940 * timed out.
941 */
942 breakpoint_clear_target(gdb_service->target);
943 watchpoint_clear_target(gdb_service->target);
944
945 /* clean previous rtos session if supported*/
946 if ((gdb_service->target->rtos) && (gdb_service->target->rtos->type->clean))
947 gdb_service->target->rtos->type->clean(gdb_service->target);
948
949 /* remove the initial ACK from the incoming buffer */
950 retval = gdb_get_char(connection, &initial_ack);
951 if (retval != ERROR_OK)
952 return retval;
953
954 /* FIX!!!??? would we actually ever receive a + here???
955 * Not observed.
956 */
957 if (initial_ack != '+')
958 gdb_putback_char(connection, initial_ack);
959 target_call_event_callbacks(gdb_service->target, TARGET_EVENT_GDB_ATTACH);
960
961 if (gdb_use_memory_map) {
962 /* Connect must fail if the memory map can't be set up correctly.
963 *
964 * This will cause an auto_probe to be invoked, which is either
965 * a no-op or it will fail when the target isn't ready(e.g. not halted).
966 */
967 int i;
968 for (i = 0; i < flash_get_bank_count(); i++) {
969 struct flash_bank *p;
970 p = get_flash_bank_by_num_noprobe(i);
971 if (p->target != gdb_service->target)
972 continue;
973 retval = get_flash_bank_by_num(i, &p);
974 if (retval != ERROR_OK) {
975 LOG_ERROR("Connect failed. Consider setting up a gdb-attach event for the target " \
976 "to prepare target for GDB connect, or use 'gdb_memory_map disable'.");
977 return retval;
978 }
979 }
980 }
981
982 gdb_actual_connections++;
983 LOG_DEBUG("New GDB Connection: %d, Target %s, state: %s",
984 gdb_actual_connections,
985 target_name(gdb_service->target),
986 target_state_name(gdb_service->target));
987
988 /* DANGER! If we fail subsequently, we must remove this handler,
989 * otherwise we occasionally see crashes as the timer can invoke the
990 * callback fn.
991 *
992 * register callback to be informed about target events */
993 target_register_event_callback(gdb_target_callback_event_handler, connection);
994
995 return ERROR_OK;
996 }
997
998 static int gdb_connection_closed(struct connection *connection)
999 {
1000 struct gdb_service *gdb_service = connection->service->priv;
1001 struct gdb_connection *gdb_connection = connection->priv;
1002
1003 /* we're done forwarding messages. Tear down callback before
1004 * cleaning up connection.
1005 */
1006 log_remove_callback(gdb_log_callback, connection);
1007
1008 gdb_actual_connections--;
1009 LOG_DEBUG("GDB Close, Target: %s, state: %s, gdb_actual_connections=%d",
1010 target_name(gdb_service->target),
1011 target_state_name(gdb_service->target),
1012 gdb_actual_connections);
1013
1014 /* see if an image built with vFlash commands is left */
1015 if (gdb_connection->vflash_image) {
1016 image_close(gdb_connection->vflash_image);
1017 free(gdb_connection->vflash_image);
1018 gdb_connection->vflash_image = NULL;
1019 }
1020
1021 /* if this connection registered a debug-message receiver delete it */
1022 delete_debug_msg_receiver(connection->cmd_ctx, gdb_service->target);
1023
1024 if (connection->priv) {
1025 free(connection->priv);
1026 connection->priv = NULL;
1027 } else
1028 LOG_ERROR("BUG: connection->priv == NULL");
1029
1030 target_unregister_event_callback(gdb_target_callback_event_handler, connection);
1031
1032 target_call_event_callbacks(gdb_service->target, TARGET_EVENT_GDB_END);
1033
1034 target_call_event_callbacks(gdb_service->target, TARGET_EVENT_GDB_DETACH);
1035
1036 return ERROR_OK;
1037 }
1038
1039 static void gdb_send_error(struct connection *connection, uint8_t the_error)
1040 {
1041 char err[4];
1042 snprintf(err, 4, "E%2.2X", the_error);
1043 gdb_put_packet(connection, err, 3);
1044 }
1045
1046 static int gdb_last_signal_packet(struct connection *connection,
1047 char const *packet, int packet_size)
1048 {
1049 struct target *target = get_target_from_connection(connection);
1050 struct gdb_connection *gdb_con = connection->priv;
1051 char sig_reply[4];
1052 int signal_var;
1053
1054 if (!gdb_con->attached) {
1055 /* if we are here we have received a kill packet
1056 * reply W stop reply otherwise gdb gets very unhappy */
1057 gdb_put_packet(connection, "W00", 3);
1058 return ERROR_OK;
1059 }
1060
1061 signal_var = gdb_last_signal(target);
1062
1063 snprintf(sig_reply, 4, "S%2.2x", signal_var);
1064 gdb_put_packet(connection, sig_reply, 3);
1065
1066 return ERROR_OK;
1067 }
1068
1069 static inline int gdb_reg_pos(struct target *target, int pos, int len)
1070 {
1071 if (target->endianness == TARGET_LITTLE_ENDIAN)
1072 return pos;
1073 else
1074 return len - 1 - pos;
1075 }
1076
1077 /* Convert register to string of bytes. NB! The # of bits in the
1078 * register might be non-divisible by 8(a byte), in which
1079 * case an entire byte is shown.
1080 *
1081 * NB! the format on the wire is the target endianness
1082 *
1083 * The format of reg->value is little endian
1084 *
1085 */
1086 static void gdb_str_to_target(struct target *target,
1087 char *tstr, struct reg *reg)
1088 {
1089 int i;
1090
1091 uint8_t *buf;
1092 int buf_len;
1093 buf = reg->value;
1094 buf_len = DIV_ROUND_UP(reg->size, 8);
1095
1096 for (i = 0; i < buf_len; i++) {
1097 int j = gdb_reg_pos(target, i, buf_len);
1098 tstr += sprintf(tstr, "%02x", buf[j]);
1099 }
1100 }
1101
1102 /* copy over in register buffer */
1103 static void gdb_target_to_reg(struct target *target,
1104 char const *tstr, int str_len, uint8_t *bin)
1105 {
1106 if (str_len % 2) {
1107 LOG_ERROR("BUG: gdb value with uneven number of characters encountered");
1108 exit(-1);
1109 }
1110
1111 int i;
1112 for (i = 0; i < str_len; i += 2) {
1113 unsigned t;
1114 if (sscanf(tstr + i, "%02x", &t) != 1) {
1115 LOG_ERROR("BUG: unable to convert register value");
1116 exit(-1);
1117 }
1118
1119 int j = gdb_reg_pos(target, i/2, str_len/2);
1120 bin[j] = t;
1121 }
1122 }
1123
1124 static int gdb_get_registers_packet(struct connection *connection,
1125 char const *packet, int packet_size)
1126 {
1127 struct target *target = get_target_from_connection(connection);
1128 struct reg **reg_list;
1129 int reg_list_size;
1130 int retval;
1131 int reg_packet_size = 0;
1132 char *reg_packet;
1133 char *reg_packet_p;
1134 int i;
1135
1136 #ifdef _DEBUG_GDB_IO_
1137 LOG_DEBUG("-");
1138 #endif
1139
1140 if ((target->rtos != NULL) && (ERROR_OK == rtos_get_gdb_reg_list(connection)))
1141 return ERROR_OK;
1142
1143 retval = target_get_gdb_reg_list(target, &reg_list, &reg_list_size,
1144 REG_CLASS_GENERAL);
1145 if (retval != ERROR_OK)
1146 return gdb_error(connection, retval);
1147
1148 for (i = 0; i < reg_list_size; i++)
1149 reg_packet_size += DIV_ROUND_UP(reg_list[i]->size, 8) * 2;
1150
1151 assert(reg_packet_size > 0);
1152
1153 reg_packet = malloc(reg_packet_size + 1); /* plus one for string termination null */
1154 reg_packet_p = reg_packet;
1155
1156 for (i = 0; i < reg_list_size; i++) {
1157 if (!reg_list[i]->valid)
1158 reg_list[i]->type->get(reg_list[i]);
1159 gdb_str_to_target(target, reg_packet_p, reg_list[i]);
1160 reg_packet_p += DIV_ROUND_UP(reg_list[i]->size, 8) * 2;
1161 }
1162
1163 #ifdef _DEBUG_GDB_IO_
1164 {
1165 char *reg_packet_p_debug;
1166 reg_packet_p_debug = strndup(reg_packet, reg_packet_size);
1167 LOG_DEBUG("reg_packet: %s", reg_packet_p_debug);
1168 free(reg_packet_p_debug);
1169 }
1170 #endif
1171
1172 gdb_put_packet(connection, reg_packet, reg_packet_size);
1173 free(reg_packet);
1174
1175 free(reg_list);
1176
1177 return ERROR_OK;
1178 }
1179
1180 static int gdb_set_registers_packet(struct connection *connection,
1181 char const *packet, int packet_size)
1182 {
1183 struct target *target = get_target_from_connection(connection);
1184 int i;
1185 struct reg **reg_list;
1186 int reg_list_size;
1187 int retval;
1188 char const *packet_p;
1189
1190 #ifdef _DEBUG_GDB_IO_
1191 LOG_DEBUG("-");
1192 #endif
1193
1194 /* skip command character */
1195 packet++;
1196 packet_size--;
1197
1198 if (packet_size % 2) {
1199 LOG_WARNING("GDB set_registers packet with uneven characters received, dropping connection");
1200 return ERROR_SERVER_REMOTE_CLOSED;
1201 }
1202
1203 retval = target_get_gdb_reg_list(target, &reg_list, &reg_list_size,
1204 REG_CLASS_GENERAL);
1205 if (retval != ERROR_OK)
1206 return gdb_error(connection, retval);
1207
1208 packet_p = packet;
1209 for (i = 0; i < reg_list_size; i++) {
1210 uint8_t *bin_buf;
1211 int chars = (DIV_ROUND_UP(reg_list[i]->size, 8) * 2);
1212
1213 if (packet_p + chars > packet + packet_size)
1214 LOG_ERROR("BUG: register packet is too small for registers");
1215
1216 bin_buf = malloc(DIV_ROUND_UP(reg_list[i]->size, 8));
1217 gdb_target_to_reg(target, packet_p, chars, bin_buf);
1218
1219 reg_list[i]->type->set(reg_list[i], bin_buf);
1220
1221 /* advance packet pointer */
1222 packet_p += chars;
1223
1224 free(bin_buf);
1225 }
1226
1227 /* free struct reg *reg_list[] array allocated by get_gdb_reg_list */
1228 free(reg_list);
1229
1230 gdb_put_packet(connection, "OK", 2);
1231
1232 return ERROR_OK;
1233 }
1234
1235 static int gdb_get_register_packet(struct connection *connection,
1236 char const *packet, int packet_size)
1237 {
1238 struct target *target = get_target_from_connection(connection);
1239 char *reg_packet;
1240 int reg_num = strtoul(packet + 1, NULL, 16);
1241 struct reg **reg_list;
1242 int reg_list_size;
1243 int retval;
1244
1245 #ifdef _DEBUG_GDB_IO_
1246 LOG_DEBUG("-");
1247 #endif
1248
1249 retval = target_get_gdb_reg_list(target, &reg_list, &reg_list_size,
1250 REG_CLASS_ALL);
1251 if (retval != ERROR_OK)
1252 return gdb_error(connection, retval);
1253
1254 if (reg_list_size <= reg_num) {
1255 LOG_ERROR("gdb requested a non-existing register");
1256 return ERROR_SERVER_REMOTE_CLOSED;
1257 }
1258
1259 if (!reg_list[reg_num]->valid)
1260 reg_list[reg_num]->type->get(reg_list[reg_num]);
1261
1262 reg_packet = malloc(DIV_ROUND_UP(reg_list[reg_num]->size, 8) * 2 + 1); /* plus one for string termination null */
1263
1264 gdb_str_to_target(target, reg_packet, reg_list[reg_num]);
1265
1266 gdb_put_packet(connection, reg_packet, DIV_ROUND_UP(reg_list[reg_num]->size, 8) * 2);
1267
1268 free(reg_list);
1269 free(reg_packet);
1270
1271 return ERROR_OK;
1272 }
1273
1274 static int gdb_set_register_packet(struct connection *connection,
1275 char const *packet, int packet_size)
1276 {
1277 struct target *target = get_target_from_connection(connection);
1278 char *separator;
1279 uint8_t *bin_buf;
1280 int reg_num = strtoul(packet + 1, &separator, 16);
1281 struct reg **reg_list;
1282 int reg_list_size;
1283 int retval;
1284
1285 LOG_DEBUG("-");
1286
1287 retval = target_get_gdb_reg_list(target, &reg_list, &reg_list_size,
1288 REG_CLASS_ALL);
1289 if (retval != ERROR_OK)
1290 return gdb_error(connection, retval);
1291
1292 if (reg_list_size <= reg_num) {
1293 LOG_ERROR("gdb requested a non-existing register");
1294 return ERROR_SERVER_REMOTE_CLOSED;
1295 }
1296
1297 if (*separator != '=') {
1298 LOG_ERROR("GDB 'set register packet', but no '=' following the register number");
1299 return ERROR_SERVER_REMOTE_CLOSED;
1300 }
1301
1302 /* convert from GDB-string (target-endian) to hex-string (big-endian) */
1303 bin_buf = malloc(DIV_ROUND_UP(reg_list[reg_num]->size, 8));
1304 int chars = (DIV_ROUND_UP(reg_list[reg_num]->size, 8) * 2);
1305
1306 if ((unsigned int)chars != strlen(separator + 1)) {
1307 LOG_ERROR("gdb sent a packet with wrong register size");
1308 free(bin_buf);
1309 return ERROR_SERVER_REMOTE_CLOSED;
1310 }
1311
1312 gdb_target_to_reg(target, separator + 1, chars, bin_buf);
1313
1314 reg_list[reg_num]->type->set(reg_list[reg_num], bin_buf);
1315
1316 gdb_put_packet(connection, "OK", 2);
1317
1318 free(bin_buf);
1319 free(reg_list);
1320
1321 return ERROR_OK;
1322 }
1323
1324 /* No attempt is made to translate the "retval" to
1325 * GDB speak. This has to be done at the calling
1326 * site as no mapping really exists.
1327 */
1328 static int gdb_error(struct connection *connection, int retval)
1329 {
1330 LOG_DEBUG("Reporting %i to GDB as generic error", retval);
1331 gdb_send_error(connection, EFAULT);
1332 return ERROR_OK;
1333 }
1334
1335 /* We don't have to worry about the default 2 second timeout for GDB packets,
1336 * because GDB breaks up large memory reads into smaller reads.
1337 *
1338 * 8191 bytes by the looks of it. Why 8191 bytes instead of 8192?????
1339 */
1340 static int gdb_read_memory_packet(struct connection *connection,
1341 char const *packet, int packet_size)
1342 {
1343 struct target *target = get_target_from_connection(connection);
1344 char *separator;
1345 uint32_t addr = 0;
1346 uint32_t len = 0;
1347
1348 uint8_t *buffer;
1349 char *hex_buffer;
1350
1351 int retval = ERROR_OK;
1352
1353 /* skip command character */
1354 packet++;
1355
1356 addr = strtoul(packet, &separator, 16);
1357
1358 if (*separator != ',') {
1359 LOG_ERROR("incomplete read memory packet received, dropping connection");
1360 return ERROR_SERVER_REMOTE_CLOSED;
1361 }
1362
1363 len = strtoul(separator + 1, NULL, 16);
1364
1365 if (!len) {
1366 LOG_WARNING("invalid read memory packet received (len == 0)");
1367 gdb_put_packet(connection, NULL, 0);
1368 return ERROR_OK;
1369 }
1370
1371 buffer = malloc(len);
1372
1373 LOG_DEBUG("addr: 0x%8.8" PRIx32 ", len: 0x%8.8" PRIx32 "", addr, len);
1374
1375 retval = target_read_buffer(target, addr, len, buffer);
1376
1377 if ((retval != ERROR_OK) && !gdb_report_data_abort) {
1378 /* TODO : Here we have to lie and send back all zero's lest stack traces won't work.
1379 * At some point this might be fixed in GDB, in which case this code can be removed.
1380 *
1381 * OpenOCD developers are acutely aware of this problem, but there is nothing
1382 * gained by involving the user in this problem that hopefully will get resolved
1383 * eventually
1384 *
1385 * http://sourceware.org/cgi-bin/gnatsweb.pl? \
1386 * cmd = view%20audit-trail&database = gdb&pr = 2395
1387 *
1388 * For now, the default is to fix up things to make current GDB versions work.
1389 * This can be overwritten using the gdb_report_data_abort <'enable'|'disable'> command.
1390 */
1391 memset(buffer, 0, len);
1392 retval = ERROR_OK;
1393 }
1394
1395 if (retval == ERROR_OK) {
1396 hex_buffer = malloc(len * 2 + 1);
1397
1398 int pkt_len = hexify(hex_buffer, (char *)buffer, len, len * 2 + 1);
1399
1400 gdb_put_packet(connection, hex_buffer, pkt_len);
1401
1402 free(hex_buffer);
1403 } else
1404 retval = gdb_error(connection, retval);
1405
1406 free(buffer);
1407
1408 return retval;
1409 }
1410
1411 static int gdb_write_memory_packet(struct connection *connection,
1412 char const *packet, int packet_size)
1413 {
1414 struct target *target = get_target_from_connection(connection);
1415 char *separator;
1416 uint32_t addr = 0;
1417 uint32_t len = 0;
1418
1419 uint8_t *buffer;
1420 int retval;
1421
1422 /* skip command character */
1423 packet++;
1424
1425 addr = strtoul(packet, &separator, 16);
1426
1427 if (*separator != ',') {
1428 LOG_ERROR("incomplete write memory packet received, dropping connection");
1429 return ERROR_SERVER_REMOTE_CLOSED;
1430 }
1431
1432 len = strtoul(separator + 1, &separator, 16);
1433
1434 if (*(separator++) != ':') {
1435 LOG_ERROR("incomplete write memory packet received, dropping connection");
1436 return ERROR_SERVER_REMOTE_CLOSED;
1437 }
1438
1439 buffer = malloc(len);
1440
1441 LOG_DEBUG("addr: 0x%8.8" PRIx32 ", len: 0x%8.8" PRIx32 "", addr, len);
1442
1443 if (unhexify((char *)buffer, separator, len) != (int)len)
1444 LOG_ERROR("unable to decode memory packet");
1445
1446 retval = target_write_buffer(target, addr, len, buffer);
1447
1448 if (retval == ERROR_OK)
1449 gdb_put_packet(connection, "OK", 2);
1450 else
1451 retval = gdb_error(connection, retval);
1452
1453 free(buffer);
1454
1455 return retval;
1456 }
1457
1458 static int gdb_write_memory_binary_packet(struct connection *connection,
1459 char const *packet, int packet_size)
1460 {
1461 struct target *target = get_target_from_connection(connection);
1462 char *separator;
1463 uint32_t addr = 0;
1464 uint32_t len = 0;
1465
1466 int retval = ERROR_OK;
1467
1468 /* skip command character */
1469 packet++;
1470
1471 addr = strtoul(packet, &separator, 16);
1472
1473 if (*separator != ',') {
1474 LOG_ERROR("incomplete write memory binary packet received, dropping connection");
1475 return ERROR_SERVER_REMOTE_CLOSED;
1476 }
1477
1478 len = strtoul(separator + 1, &separator, 16);
1479
1480 if (*(separator++) != ':') {
1481 LOG_ERROR("incomplete write memory binary packet received, dropping connection");
1482 return ERROR_SERVER_REMOTE_CLOSED;
1483 }
1484
1485 struct gdb_connection *gdb_connection = connection->priv;
1486
1487 if (gdb_connection->mem_write_error) {
1488 retval = ERROR_FAIL;
1489 /* now that we have reported the memory write error, we can clear the condition */
1490 gdb_connection->mem_write_error = false;
1491 }
1492
1493 /* By replying the packet *immediately* GDB will send us a new packet
1494 * while we write the last one to the target.
1495 */
1496 if (retval == ERROR_OK)
1497 gdb_put_packet(connection, "OK", 2);
1498 else {
1499 retval = gdb_error(connection, retval);
1500 if (retval != ERROR_OK)
1501 return retval;
1502 }
1503
1504 if (len) {
1505 LOG_DEBUG("addr: 0x%8.8" PRIx32 ", len: 0x%8.8" PRIx32 "", addr, len);
1506
1507 retval = target_write_buffer(target, addr, len, (uint8_t *)separator);
1508 if (retval != ERROR_OK)
1509 gdb_connection->mem_write_error = true;
1510 }
1511
1512 return ERROR_OK;
1513 }
1514
1515 static int gdb_step_continue_packet(struct connection *connection,
1516 char const *packet, int packet_size)
1517 {
1518 struct target *target = get_target_from_connection(connection);
1519 int current = 0;
1520 uint32_t address = 0x0;
1521 int retval = ERROR_OK;
1522
1523 LOG_DEBUG("-");
1524
1525 if (packet_size > 1)
1526 address = strtoul(packet + 1, NULL, 16);
1527 else
1528 current = 1;
1529
1530 gdb_running_type = packet[0];
1531 if (packet[0] == 'c') {
1532 LOG_DEBUG("continue");
1533 /* resume at current address, don't handle breakpoints, not debugging */
1534 retval = target_resume(target, current, address, 0, 0);
1535 } else if (packet[0] == 's') {
1536 LOG_DEBUG("step");
1537 /* step at current or address, don't handle breakpoints */
1538 retval = target_step(target, current, address, 0);
1539 }
1540 return retval;
1541 }
1542
1543 static int gdb_breakpoint_watchpoint_packet(struct connection *connection,
1544 char const *packet, int packet_size)
1545 {
1546 struct target *target = get_target_from_connection(connection);
1547 int type;
1548 enum breakpoint_type bp_type = BKPT_SOFT /* dummy init to avoid warning */;
1549 enum watchpoint_rw wp_type = WPT_READ /* dummy init to avoid warning */;
1550 uint32_t address;
1551 uint32_t size;
1552 char *separator;
1553 int retval;
1554
1555 LOG_DEBUG("-");
1556
1557 type = strtoul(packet + 1, &separator, 16);
1558
1559 if (type == 0) /* memory breakpoint */
1560 bp_type = BKPT_SOFT;
1561 else if (type == 1) /* hardware breakpoint */
1562 bp_type = BKPT_HARD;
1563 else if (type == 2) /* write watchpoint */
1564 wp_type = WPT_WRITE;
1565 else if (type == 3) /* read watchpoint */
1566 wp_type = WPT_READ;
1567 else if (type == 4) /* access watchpoint */
1568 wp_type = WPT_ACCESS;
1569 else {
1570 LOG_ERROR("invalid gdb watch/breakpoint type(%d), dropping connection", type);
1571 return ERROR_SERVER_REMOTE_CLOSED;
1572 }
1573
1574 if (gdb_breakpoint_override && ((bp_type == BKPT_SOFT) || (bp_type == BKPT_HARD)))
1575 bp_type = gdb_breakpoint_override_type;
1576
1577 if (*separator != ',') {
1578 LOG_ERROR("incomplete breakpoint/watchpoint packet received, dropping connection");
1579 return ERROR_SERVER_REMOTE_CLOSED;
1580 }
1581
1582 address = strtoul(separator + 1, &separator, 16);
1583
1584 if (*separator != ',') {
1585 LOG_ERROR("incomplete breakpoint/watchpoint packet received, dropping connection");
1586 return ERROR_SERVER_REMOTE_CLOSED;
1587 }
1588
1589 size = strtoul(separator + 1, &separator, 16);
1590
1591 switch (type) {
1592 case 0:
1593 case 1:
1594 if (packet[0] == 'Z') {
1595 retval = breakpoint_add(target, address, size, bp_type);
1596 if (retval != ERROR_OK) {
1597 retval = gdb_error(connection, retval);
1598 if (retval != ERROR_OK)
1599 return retval;
1600 } else
1601 gdb_put_packet(connection, "OK", 2);
1602 } else {
1603 breakpoint_remove(target, address);
1604 gdb_put_packet(connection, "OK", 2);
1605 }
1606 break;
1607 case 2:
1608 case 3:
1609 case 4:
1610 {
1611 if (packet[0] == 'Z') {
1612 retval = watchpoint_add(target, address, size, wp_type, 0, 0xffffffffu);
1613 if (retval != ERROR_OK) {
1614 retval = gdb_error(connection, retval);
1615 if (retval != ERROR_OK)
1616 return retval;
1617 } else
1618 gdb_put_packet(connection, "OK", 2);
1619 } else {
1620 watchpoint_remove(target, address);
1621 gdb_put_packet(connection, "OK", 2);
1622 }
1623 break;
1624 }
1625 default:
1626 break;
1627 }
1628
1629 return ERROR_OK;
1630 }
1631
1632 /* print out a string and allocate more space as needed,
1633 * mainly used for XML at this point
1634 */
1635 static void xml_printf(int *retval, char **xml, int *pos, int *size,
1636 const char *fmt, ...)
1637 {
1638 if (*retval != ERROR_OK)
1639 return;
1640 int first = 1;
1641
1642 for (;; ) {
1643 if ((*xml == NULL) || (!first)) {
1644 /* start by 0 to exercise all the code paths.
1645 * Need minimum 2 bytes to fit 1 char and 0 terminator. */
1646
1647 *size = *size * 2 + 2;
1648 char *t = *xml;
1649 *xml = realloc(*xml, *size);
1650 if (*xml == NULL) {
1651 if (t)
1652 free(t);
1653 *retval = ERROR_SERVER_REMOTE_CLOSED;
1654 return;
1655 }
1656 }
1657
1658 va_list ap;
1659 int ret;
1660 va_start(ap, fmt);
1661 ret = vsnprintf(*xml + *pos, *size - *pos, fmt, ap);
1662 va_end(ap);
1663 if ((ret > 0) && ((ret + 1) < *size - *pos)) {
1664 *pos += ret;
1665 return;
1666 }
1667 /* there was just enough or not enough space, allocate more. */
1668 first = 0;
1669 }
1670 }
1671
1672 static int decode_xfer_read(char const *_buf, char **annex, int *ofs, unsigned int *len)
1673 {
1674 int ret = 0;
1675 char *buf = strdup(_buf);
1676 char *_annex;
1677 char *separator;
1678
1679 /* Extract and NUL-terminate the annex. */
1680 _annex = buf;
1681 while (*buf && *buf != ':')
1682 buf++;
1683 if (*buf == '\0') {
1684 ret = -1;
1685 goto out;
1686 }
1687 *buf++ = 0;
1688
1689 /* Return annex as copy because "buf" will be freed in this function */
1690 *annex = strdup(_annex);
1691
1692 /* After the read marker and annex, qXfer looks like a
1693 * traditional 'm' packet. */
1694
1695 *ofs = strtoul(buf, &separator, 16);
1696
1697 if (*separator != ',') {
1698 ret = -1;
1699 goto out;
1700 }
1701
1702 *len = strtoul(separator + 1, NULL, 16);
1703
1704 out:
1705 free(buf);
1706 return ret;
1707 }
1708
1709 static int compare_bank(const void *a, const void *b)
1710 {
1711 struct flash_bank *b1, *b2;
1712 b1 = *((struct flash_bank **)a);
1713 b2 = *((struct flash_bank **)b);
1714
1715 if (b1->base == b2->base)
1716 return 0;
1717 else if (b1->base > b2->base)
1718 return 1;
1719 else
1720 return -1;
1721 }
1722
1723 static int gdb_memory_map(struct connection *connection,
1724 char const *packet, int packet_size)
1725 {
1726 /* We get away with only specifying flash here. Regions that are not
1727 * specified are treated as if we provided no memory map(if not we
1728 * could detect the holes and mark them as RAM).
1729 * Normally we only execute this code once, but no big deal if we
1730 * have to regenerate it a couple of times.
1731 */
1732
1733 struct target *target = get_target_from_connection(connection);
1734 struct flash_bank *p;
1735 char *xml = NULL;
1736 int size = 0;
1737 int pos = 0;
1738 int retval = ERROR_OK;
1739 struct flash_bank **banks;
1740 int offset;
1741 int length;
1742 char *separator;
1743 uint32_t ram_start = 0;
1744 int i;
1745 int target_flash_banks = 0;
1746
1747 /* skip command character */
1748 packet += 23;
1749
1750 offset = strtoul(packet, &separator, 16);
1751 length = strtoul(separator + 1, &separator, 16);
1752
1753 xml_printf(&retval, &xml, &pos, &size, "<memory-map>\n");
1754
1755 /* Sort banks in ascending order. We need to report non-flash
1756 * memory as ram (or rather read/write) by default for GDB, since
1757 * it has no concept of non-cacheable read/write memory (i/o etc).
1758 *
1759 * FIXME Most non-flash addresses are *NOT* RAM! Don't lie.
1760 * Current versions of GDB assume unlisted addresses are RAM...
1761 */
1762 banks = malloc(sizeof(struct flash_bank *)*flash_get_bank_count());
1763
1764 for (i = 0; i < flash_get_bank_count(); i++) {
1765 p = get_flash_bank_by_num_noprobe(i);
1766 if (p->target != target)
1767 continue;
1768 retval = get_flash_bank_by_num(i, &p);
1769 if (retval != ERROR_OK) {
1770 free(banks);
1771 gdb_error(connection, retval);
1772 return retval;
1773 }
1774 banks[target_flash_banks++] = p;
1775 }
1776
1777 qsort(banks, target_flash_banks, sizeof(struct flash_bank *),
1778 compare_bank);
1779
1780 for (i = 0; i < target_flash_banks; i++) {
1781 int j;
1782 unsigned sector_size = 0;
1783 uint32_t start;
1784
1785 p = banks[i];
1786 start = p->base;
1787
1788 if (ram_start < p->base)
1789 xml_printf(&retval, &xml, &pos, &size,
1790 "<memory type=\"ram\" start=\"0x%x\" "
1791 "length=\"0x%x\"/>\n",
1792 ram_start, p->base - ram_start);
1793
1794 /* Report adjacent groups of same-size sectors. So for
1795 * example top boot CFI flash will list an initial region
1796 * with several large sectors (maybe 128KB) and several
1797 * smaller ones at the end (maybe 32KB). STR7 will have
1798 * regions with 8KB, 32KB, and 64KB sectors; etc.
1799 */
1800 for (j = 0; j < p->num_sectors; j++) {
1801 unsigned group_len;
1802
1803 /* Maybe start a new group of sectors. */
1804 if (sector_size == 0) {
1805 start = p->base + p->sectors[j].offset;
1806 xml_printf(&retval, &xml, &pos, &size,
1807 "<memory type=\"flash\" "
1808 "start=\"0x%x\" ",
1809 start);
1810 sector_size = p->sectors[j].size;
1811 }
1812
1813 /* Does this finish a group of sectors?
1814 * If not, continue an already-started group.
1815 */
1816 if (j == p->num_sectors - 1)
1817 group_len = (p->base + p->size) - start;
1818 else if (p->sectors[j + 1].size != sector_size)
1819 group_len = p->base + p->sectors[j + 1].offset
1820 - start;
1821 else
1822 continue;
1823
1824 xml_printf(&retval, &xml, &pos, &size,
1825 "length=\"0x%x\">\n"
1826 "<property name=\"blocksize\">"
1827 "0x%x</property>\n"
1828 "</memory>\n",
1829 group_len,
1830 sector_size);
1831 sector_size = 0;
1832 }
1833
1834 ram_start = p->base + p->size;
1835 }
1836
1837 if (ram_start != 0)
1838 xml_printf(&retval, &xml, &pos, &size,
1839 "<memory type=\"ram\" start=\"0x%x\" "
1840 "length=\"0x%x\"/>\n",
1841 ram_start, 0-ram_start);
1842 /* ELSE a flash chip could be at the very end of the 32 bit address
1843 * space, in which case ram_start will be precisely 0
1844 */
1845
1846 free(banks);
1847 banks = NULL;
1848
1849 xml_printf(&retval, &xml, &pos, &size, "</memory-map>\n");
1850
1851 if (retval != ERROR_OK) {
1852 gdb_error(connection, retval);
1853 return retval;
1854 }
1855
1856 if (offset + length > pos)
1857 length = pos - offset;
1858
1859 char *t = malloc(length + 1);
1860 t[0] = 'l';
1861 memcpy(t + 1, xml + offset, length);
1862 gdb_put_packet(connection, t, length + 1);
1863
1864 free(t);
1865 free(xml);
1866 return ERROR_OK;
1867 }
1868
1869 static const char *gdb_get_reg_type_name(enum reg_type type)
1870 {
1871 switch (type) {
1872 case REG_TYPE_INT:
1873 return "int";
1874 case REG_TYPE_INT8:
1875 return "int8";
1876 case REG_TYPE_INT16:
1877 return "int16";
1878 case REG_TYPE_INT32:
1879 return "int32";
1880 case REG_TYPE_INT64:
1881 return "int64";
1882 case REG_TYPE_INT128:
1883 return "int128";
1884 case REG_TYPE_UINT8:
1885 return "uint8";
1886 case REG_TYPE_UINT16:
1887 return "uint16";
1888 case REG_TYPE_UINT32:
1889 return "uint32";
1890 case REG_TYPE_UINT64:
1891 return "uint64";
1892 case REG_TYPE_UINT128:
1893 return "uint128";
1894 case REG_TYPE_CODE_PTR:
1895 return "code_ptr";
1896 case REG_TYPE_DATA_PTR:
1897 return "data_ptr";
1898 case REG_TYPE_FLOAT:
1899 return "float";
1900 case REG_TYPE_IEEE_SINGLE:
1901 return "ieee_single";
1902 case REG_TYPE_IEEE_DOUBLE:
1903 return "ieee_double";
1904 case REG_TYPE_ARCH_DEFINED:
1905 return "int"; /* return arbitrary string to avoid compile warning. */
1906 }
1907
1908 return "int"; /* "int" as default value */
1909 }
1910
1911 static int gdb_generate_reg_type_description(struct target *target,
1912 char **tdesc, int *pos, int *size, struct reg_data_type *type)
1913 {
1914 int retval = ERROR_OK;
1915
1916 if (type->type_class == REG_TYPE_CLASS_VECTOR) {
1917 /* <vector id="id" type="type" count="count"/> */
1918 xml_printf(&retval, tdesc, pos, size,
1919 "<vector id=\"%s\" type=\"%s\" count=\"%d\"/>\n",
1920 type->id, type->reg_type_vector->type->id,
1921 type->reg_type_vector->count);
1922
1923 } else if (type->type_class == REG_TYPE_CLASS_UNION) {
1924 /* <union id="id">
1925 * <field name="name" type="type"/> ...
1926 * </union> */
1927 xml_printf(&retval, tdesc, pos, size,
1928 "<union id=\"%s\">\n",
1929 type->id);
1930
1931 struct reg_data_type_union_field *field;
1932 field = type->reg_type_union->fields;
1933 while (field != NULL) {
1934 xml_printf(&retval, tdesc, pos, size,
1935 "<field name=\"%s\" type=\"%s\"/>\n",
1936 field->name, field->type->id);
1937
1938 field = field->next;
1939 }
1940
1941 xml_printf(&retval, tdesc, pos, size,
1942 "</union>\n");
1943
1944 } else if (type->type_class == REG_TYPE_CLASS_STRUCT) {
1945 struct reg_data_type_struct_field *field;
1946 field = type->reg_type_struct->fields;
1947
1948 if (field->use_bitfields) {
1949 /* <struct id="id" size="size">
1950 * <field name="name" start="start" end="end"/> ...
1951 * </struct> */
1952 xml_printf(&retval, tdesc, pos, size,
1953 "<struct id=\"%s\" size=\"%d\">\n",
1954 type->id, type->reg_type_struct->size);
1955 while (field != NULL) {
1956 xml_printf(&retval, tdesc, pos, size,
1957 "<field name=\"%s\" start=\"%d\" end=\"%d\"/>\n",
1958 field->name, field->bitfield->start,
1959 field->bitfield->end);
1960
1961 field = field->next;
1962 }
1963 } else {
1964 /* <struct id="id">
1965 * <field name="name" type="type"/> ...
1966 * </struct> */
1967 xml_printf(&retval, tdesc, pos, size,
1968 "<struct id=\"%s\">\n",
1969 type->id);
1970 while (field != NULL) {
1971 xml_printf(&retval, tdesc, pos, size,
1972 "<field name=\"%s\" type=\"%s\"/>\n",
1973 field->name, field->type->id);
1974
1975 field = field->next;
1976 }
1977 }
1978
1979 xml_printf(&retval, tdesc, pos, size,
1980 "</struct>\n");
1981
1982 } else if (type->type_class == REG_TYPE_CLASS_FLAGS) {
1983 /* <flags id="id" size="size">
1984 * <field name="name" start="start" end="end"/> ...
1985 * </flags> */
1986 xml_printf(&retval, tdesc, pos, size,
1987 "<flags id=\"%s\" size=\"%d\">\n",
1988 type->id, type->reg_type_flags->size);
1989
1990 struct reg_data_type_flags_field *field;
1991 field = type->reg_type_flags->fields;
1992 while (field != NULL) {
1993 xml_printf(&retval, tdesc, pos, size,
1994 "<field name=\"%s\" start=\"%d\" end=\"%d\"/>\n",
1995 field->name, field->bitfield->start, field->bitfield->end);
1996
1997 field = field->next;
1998 }
1999
2000 xml_printf(&retval, tdesc, pos, size,
2001 "</flags>\n");
2002
2003 }
2004
2005 return ERROR_OK;
2006 }
2007
2008 /* Get a list of available target registers features. feature_list must
2009 * be freed by caller.
2010 */
2011 static int get_reg_features_list(struct target *target, char **feature_list[], int *feature_list_size,
2012 struct reg **reg_list, int reg_list_size)
2013 {
2014 int tbl_sz = 0;
2015
2016 /* Start with only one element */
2017 *feature_list = calloc(1, sizeof(char *));
2018
2019 for (int i = 0; i < reg_list_size; i++) {
2020 if (reg_list[i]->exist == false)
2021 continue;
2022
2023 if (reg_list[i]->feature != NULL
2024 && reg_list[i]->feature->name != NULL
2025 && (strcmp(reg_list[i]->feature->name, ""))) {
2026 /* We found a feature, check if the feature is already in the
2027 * table. If not, allocate a new entry for the table and
2028 * put the new feature in it.
2029 */
2030 for (int j = 0; j < (tbl_sz + 1); j++) {
2031 if (!((*feature_list)[j])) {
2032 (*feature_list)[tbl_sz++] = strdup(reg_list[i]->feature->name);
2033 *feature_list = realloc(*feature_list, sizeof(char *) * (tbl_sz + 1));
2034 (*feature_list)[tbl_sz] = NULL;
2035 break;
2036 } else {
2037 if (!strcmp((*feature_list)[j], reg_list[i]->feature->name))
2038 break;
2039 }
2040 }
2041 }
2042 }
2043
2044 if (feature_list_size)
2045 *feature_list_size = tbl_sz;
2046
2047 return ERROR_OK;
2048 }
2049
2050 static int gdb_generate_target_description(struct target *target, char **tdesc_out)
2051 {
2052 int retval = ERROR_OK;
2053 struct reg **reg_list = NULL;
2054 int reg_list_size;
2055 char **features = NULL;
2056 int feature_list_size = 0;
2057 char *tdesc = NULL;
2058 int pos = 0;
2059 int size = 0;
2060
2061 retval = target_get_gdb_reg_list(target, &reg_list,
2062 &reg_list_size, REG_CLASS_ALL);
2063
2064 if (retval != ERROR_OK) {
2065 LOG_ERROR("get register list failed");
2066 retval = ERROR_FAIL;
2067 goto error;
2068 }
2069
2070 if (reg_list_size <= 0) {
2071 LOG_ERROR("get register list failed");
2072 retval = ERROR_FAIL;
2073 goto error;
2074 }
2075
2076 /* Get a list of available target registers features */
2077 retval = get_reg_features_list(target, &features, &feature_list_size, reg_list, reg_list_size);
2078 if (retval != ERROR_OK) {
2079 LOG_ERROR("Can't get the registers feature list");
2080 retval = ERROR_FAIL;
2081 goto error;
2082 }
2083
2084 /* If we found some features associated with registers, create sections */
2085 int current_feature = 0;
2086
2087 xml_printf(&retval, &tdesc, &pos, &size,
2088 "<?xml version=\"1.0\"?>\n"
2089 "<!DOCTYPE target SYSTEM \"gdb-target.dtd\">\n"
2090 "<target version=\"1.0\">\n");
2091
2092 /* generate target description according to register list */
2093 if (features != NULL) {
2094 while (features[current_feature]) {
2095
2096 xml_printf(&retval, &tdesc, &pos, &size,
2097 "<feature name=\"%s\">\n",
2098 features[current_feature]);
2099
2100 int i;
2101 for (i = 0; i < reg_list_size; i++) {
2102
2103 if (reg_list[i]->exist == false)
2104 continue;
2105
2106 if (strcmp(reg_list[i]->feature->name, features[current_feature]))
2107 continue;
2108
2109 const char *type_str;
2110 if (reg_list[i]->reg_data_type != NULL) {
2111 if (reg_list[i]->reg_data_type->type == REG_TYPE_ARCH_DEFINED) {
2112 /* generate <type... first, if there are architecture-defined types. */
2113 gdb_generate_reg_type_description(target, &tdesc, &pos, &size,
2114 reg_list[i]->reg_data_type);
2115
2116 type_str = reg_list[i]->reg_data_type->id;
2117 } else {
2118 /* predefined type */
2119 type_str = gdb_get_reg_type_name(
2120 reg_list[i]->reg_data_type->type);
2121 }
2122 } else {
2123 /* Default type is "int" */
2124 type_str = "int";
2125 }
2126
2127 xml_printf(&retval, &tdesc, &pos, &size,
2128 "<reg name=\"%s\"", reg_list[i]->name);
2129 xml_printf(&retval, &tdesc, &pos, &size,
2130 " bitsize=\"%d\"", reg_list[i]->size);
2131 xml_printf(&retval, &tdesc, &pos, &size,
2132 " regnum=\"%d\"", reg_list[i]->number);
2133 if (reg_list[i]->caller_save)
2134 xml_printf(&retval, &tdesc, &pos, &size,
2135 " save-restore=\"yes\"");
2136 else
2137 xml_printf(&retval, &tdesc, &pos, &size,
2138 " save-restore=\"no\"");
2139
2140 xml_printf(&retval, &tdesc, &pos, &size,
2141 " type=\"%s\"", type_str);
2142
2143 if (reg_list[i]->group != NULL)
2144 xml_printf(&retval, &tdesc, &pos, &size,
2145 " group=\"%s\"", reg_list[i]->group);
2146
2147 xml_printf(&retval, &tdesc, &pos, &size,
2148 "/>\n");
2149 }
2150
2151 xml_printf(&retval, &tdesc, &pos, &size,
2152 "</feature>\n");
2153
2154 current_feature++;
2155 }
2156 }
2157
2158 xml_printf(&retval, &tdesc, &pos, &size,
2159 "</target>\n");
2160
2161 error:
2162
2163 /* note: features[] contains (feature_list_size + 1) elements */
2164 for (int j = feature_list_size; j >= 0; j--)
2165 free(features[j]);
2166 free(features);
2167 free(reg_list);
2168
2169 if (retval == ERROR_OK)
2170 *tdesc_out = tdesc;
2171 else
2172 free(tdesc);
2173
2174 return retval;
2175 }
2176
2177 static int gdb_get_target_description_chunk(struct target *target, struct target_desc_format *target_desc,
2178 char **chunk, int32_t offset, uint32_t length)
2179 {
2180 if (target_desc == NULL) {
2181 LOG_ERROR("Unable to Generate Target Description");
2182 return ERROR_FAIL;
2183 }
2184
2185 char *tdesc = target_desc->tdesc;
2186 uint32_t tdesc_length = target_desc->tdesc_length;
2187
2188 if (tdesc == NULL) {
2189 int retval = gdb_generate_target_description(target, &tdesc);
2190 if (retval != ERROR_OK) {
2191 LOG_ERROR("Unable to Generate Target Description");
2192 return ERROR_FAIL;
2193 }
2194
2195 tdesc_length = strlen(tdesc);
2196 }
2197
2198 char transfer_type;
2199
2200 if (length < (tdesc_length - offset))
2201 transfer_type = 'm';
2202 else
2203 transfer_type = 'l';
2204
2205 *chunk = malloc(length + 2);
2206 if (*chunk == NULL) {
2207 LOG_ERROR("Unable to allocate memory");
2208 return ERROR_FAIL;
2209 }
2210
2211 (*chunk)[0] = transfer_type;
2212 if (transfer_type == 'm') {
2213 strncpy((*chunk) + 1, tdesc + offset, length);
2214 (*chunk)[1 + length] = '\0';
2215 } else {
2216 strncpy((*chunk) + 1, tdesc + offset, tdesc_length - offset);
2217 (*chunk)[1 + (tdesc_length - offset)] = '\0';
2218
2219 /* After gdb-server sends out last chunk, invalidate tdesc. */
2220 free(tdesc);
2221 tdesc = NULL;
2222 tdesc_length = 0;
2223 }
2224
2225 target_desc->tdesc = tdesc;
2226 target_desc->tdesc_length = tdesc_length;
2227
2228 return ERROR_OK;
2229 }
2230
2231 static int gdb_target_description_supported(struct target *target, int *supported)
2232 {
2233 int retval = ERROR_OK;
2234 struct reg **reg_list = NULL;
2235 int reg_list_size = 0;
2236 char **features = NULL;
2237 int feature_list_size = 0;
2238 char **features = NULL;
2239
2240 retval = target_get_gdb_reg_list(target, &reg_list,
2241 &reg_list_size, REG_CLASS_ALL);
2242 if (retval != ERROR_OK) {
2243 LOG_ERROR("get register list failed");
2244 goto error;
2245 }
2246
2247 if (reg_list_size <= 0) {
2248 LOG_ERROR("get register list failed");
2249 retval = ERROR_FAIL;
2250 goto error;
2251 }
2252
2253 /* Get a list of available target registers features */
2254 retval = get_reg_features_list(target, &features, &feature_list_size, reg_list, reg_list_size);
2255 if (retval != ERROR_OK) {
2256 LOG_ERROR("Can't get the registers feature list");
2257 goto error;
2258 }
2259
2260 if (supported) {
2261 if (feature_list_size)
2262 *supported = 1;
2263 else
2264 *supported = 0;
2265 }
2266
2267 error:
2268
2269 /* note: features[] contains (feature_list_size + 1) elements */
2270 for (int j = feature_list_size; j >= 0; j--)
2271 free(features[j]);
2272 free(features);
2273
2274 free(reg_list);
2275
2276 return retval;
2277 }
2278
2279 static int gdb_query_packet(struct connection *connection,
2280 char const *packet, int packet_size)
2281 {
2282 struct command_context *cmd_ctx = connection->cmd_ctx;
2283 struct gdb_connection *gdb_connection = connection->priv;
2284 struct target *target = get_target_from_connection(connection);
2285
2286 if (strncmp(packet, "qRcmd,", 6) == 0) {
2287 if (packet_size > 6) {
2288 char *cmd;
2289 cmd = malloc((packet_size - 6) / 2 + 1);
2290 int len = unhexify(cmd, packet + 6, (packet_size - 6) / 2);
2291 cmd[len] = 0;
2292
2293 /* We want to print all debug output to GDB connection */
2294 log_add_callback(gdb_log_callback, connection);
2295 target_call_timer_callbacks_now();
2296 /* some commands need to know the GDB connection, make note of current
2297 * GDB connection. */
2298 current_gdb_connection = gdb_connection;
2299 command_run_line(cmd_ctx, cmd);
2300 current_gdb_connection = NULL;
2301 target_call_timer_callbacks_now();
2302 log_remove_callback(gdb_log_callback, connection);
2303 free(cmd);
2304 }
2305 gdb_put_packet(connection, "OK", 2);
2306 return ERROR_OK;
2307 } else if (strncmp(packet, "qCRC:", 5) == 0) {
2308 if (packet_size > 5) {
2309 int retval;
2310 char gdb_reply[10];
2311 char *separator;
2312 uint32_t checksum;
2313 uint32_t addr = 0;
2314 uint32_t len = 0;
2315
2316 /* skip command character */
2317 packet += 5;
2318
2319 addr = strtoul(packet, &separator, 16);
2320
2321 if (*separator != ',') {
2322 LOG_ERROR("incomplete read memory packet received, dropping connection");
2323 return ERROR_SERVER_REMOTE_CLOSED;
2324 }
2325
2326 len = strtoul(separator + 1, NULL, 16);
2327
2328 retval = target_checksum_memory(target, addr, len, &checksum);
2329
2330 if (retval == ERROR_OK) {
2331 snprintf(gdb_reply, 10, "C%8.8" PRIx32 "", checksum);
2332 gdb_put_packet(connection, gdb_reply, 9);
2333 } else {
2334 retval = gdb_error(connection, retval);
2335 if (retval != ERROR_OK)
2336 return retval;
2337 }
2338
2339 return ERROR_OK;
2340 }
2341 } else if (strncmp(packet, "qSupported", 10) == 0) {
2342 /* we currently support packet size and qXfer:memory-map:read (if enabled)
2343 * qXfer:features:read is supported for some targets */
2344 int retval = ERROR_OK;
2345 char *buffer = NULL;
2346 int pos = 0;
2347 int size = 0;
2348 int gdb_target_desc_supported = 0;
2349
2350 /* we need to test that the target supports target descriptions */
2351 retval = gdb_target_description_supported(target, &gdb_target_desc_supported);
2352 if (retval != ERROR_OK) {
2353 LOG_INFO("Failed detecting Target Description Support, disabling");
2354 gdb_target_desc_supported = 0;
2355 }
2356
2357 /* support may be disabled globally */
2358 if (gdb_use_target_description == 0) {
2359 if (gdb_target_desc_supported)
2360 LOG_WARNING("Target Descriptions Supported, but disabled");
2361 gdb_target_desc_supported = 0;
2362 }
2363
2364 xml_printf(&retval,
2365 &buffer,
2366 &pos,
2367 &size,
2368 "PacketSize=%x;qXfer:memory-map:read%c;qXfer:features:read%c;QStartNoAckMode+",
2369 (GDB_BUFFER_SIZE - 1),
2370 ((gdb_use_memory_map == 1) && (flash_get_bank_count() > 0)) ? '+' : '-',
2371 (gdb_target_desc_supported == 1) ? '+' : '-');
2372
2373 if (retval != ERROR_OK) {
2374 gdb_send_error(connection, 01);
2375 return ERROR_OK;
2376 }
2377
2378 gdb_put_packet(connection, buffer, strlen(buffer));
2379 free(buffer);
2380
2381 return ERROR_OK;
2382 } else if ((strncmp(packet, "qXfer:memory-map:read::", 23) == 0)
2383 && (flash_get_bank_count() > 0))
2384 return gdb_memory_map(connection, packet, packet_size);
2385 else if (strncmp(packet, "qXfer:features:read:", 20) == 0) {
2386 char *xml = NULL;
2387 int retval = ERROR_OK;
2388
2389 int offset;
2390 unsigned int length;
2391 char *annex = NULL;
2392
2393 /* skip command character */
2394 packet += 20;
2395
2396 if (decode_xfer_read(packet, &annex, &offset, &length) < 0) {
2397 gdb_send_error(connection, 01);
2398 return ERROR_OK;
2399 }
2400 free(annex);
2401
2402 /* Target should prepare correct target description for annex.
2403 * The first character of returned xml is 'm' or 'l'. 'm' for
2404 * there are *more* chunks to transfer. 'l' for it is the *last*
2405 * chunk of target description.
2406 */
2407 retval = gdb_get_target_description_chunk(target, &gdb_connection->target_desc,
2408 &xml, offset, length);
2409 if (retval != ERROR_OK) {
2410 gdb_error(connection, retval);
2411 return retval;
2412 }
2413
2414 gdb_put_packet(connection, xml, strlen(xml));
2415
2416 free(xml);
2417 return ERROR_OK;
2418 } else if (strncmp(packet, "QStartNoAckMode", 15) == 0) {
2419 gdb_connection->noack_mode = 1;
2420 gdb_put_packet(connection, "OK", 2);
2421 return ERROR_OK;
2422 }
2423
2424 gdb_put_packet(connection, "", 0);
2425 return ERROR_OK;
2426 }
2427
2428 static int gdb_v_packet(struct connection *connection,
2429 char const *packet, int packet_size)
2430 {
2431 struct gdb_connection *gdb_connection = connection->priv;
2432 struct gdb_service *gdb_service = connection->service->priv;
2433 int result;
2434
2435 /* if flash programming disabled - send a empty reply */
2436
2437 if (gdb_flash_program == 0) {
2438 gdb_put_packet(connection, "", 0);
2439 return ERROR_OK;
2440 }
2441
2442 if (strncmp(packet, "vFlashErase:", 12) == 0) {
2443 unsigned long addr;
2444 unsigned long length;
2445
2446 char const *parse = packet + 12;
2447 if (*parse == '\0') {
2448 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
2449 return ERROR_SERVER_REMOTE_CLOSED;
2450 }
2451
2452 addr = strtoul(parse, (char **)&parse, 16);
2453
2454 if (*(parse++) != ',' || *parse == '\0') {
2455 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
2456 return ERROR_SERVER_REMOTE_CLOSED;
2457 }
2458
2459 length = strtoul(parse, (char **)&parse, 16);
2460
2461 if (*parse != '\0') {
2462 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
2463 return ERROR_SERVER_REMOTE_CLOSED;
2464 }
2465
2466 /* assume all sectors need erasing - stops any problems
2467 * when flash_write is called multiple times */
2468 flash_set_dirty();
2469
2470 /* perform any target specific operations before the erase */
2471 target_call_event_callbacks(gdb_service->target,
2472 TARGET_EVENT_GDB_FLASH_ERASE_START);
2473
2474 /* vFlashErase:addr,length messages require region start and
2475 * end to be "block" aligned ... if padding is ever needed,
2476 * GDB will have become dangerously confused.
2477 */
2478 result = flash_erase_address_range(gdb_service->target,
2479 false, addr, length);
2480
2481 /* perform any target specific operations after the erase */
2482 target_call_event_callbacks(gdb_service->target,
2483 TARGET_EVENT_GDB_FLASH_ERASE_END);
2484
2485 /* perform erase */
2486 if (result != ERROR_OK) {
2487 /* GDB doesn't evaluate the actual error number returned,
2488 * treat a failed erase as an I/O error
2489 */
2490 gdb_send_error(connection, EIO);
2491 LOG_ERROR("flash_erase returned %i", result);
2492 } else
2493 gdb_put_packet(connection, "OK", 2);
2494
2495 return ERROR_OK;
2496 }
2497
2498 if (strncmp(packet, "vFlashWrite:", 12) == 0) {
2499 int retval;
2500 unsigned long addr;
2501 unsigned long length;
2502 char const *parse = packet + 12;
2503
2504 if (*parse == '\0') {
2505 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
2506 return ERROR_SERVER_REMOTE_CLOSED;
2507 }
2508 addr = strtoul(parse, (char **)&parse, 16);
2509 if (*(parse++) != ':') {
2510 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
2511 return ERROR_SERVER_REMOTE_CLOSED;
2512 }
2513 length = packet_size - (parse - packet);
2514
2515 /* create a new image if there isn't already one */
2516 if (gdb_connection->vflash_image == NULL) {
2517 gdb_connection->vflash_image = malloc(sizeof(struct image));
2518 image_open(gdb_connection->vflash_image, "", "build");
2519 }
2520
2521 /* create new section with content from packet buffer */
2522 retval = image_add_section(gdb_connection->vflash_image,
2523 addr, length, 0x0, (uint8_t const *)parse);
2524 if (retval != ERROR_OK)
2525 return retval;
2526
2527 gdb_put_packet(connection, "OK", 2);
2528
2529 return ERROR_OK;
2530 }
2531
2532 if (strncmp(packet, "vFlashDone", 10) == 0) {
2533 uint32_t written;
2534
2535 /* process the flashing buffer. No need to erase as GDB
2536 * always issues a vFlashErase first. */
2537 target_call_event_callbacks(gdb_service->target,
2538 TARGET_EVENT_GDB_FLASH_WRITE_START);
2539 result = flash_write(gdb_service->target, gdb_connection->vflash_image, &written, 0);
2540 target_call_event_callbacks(gdb_service->target, TARGET_EVENT_GDB_FLASH_WRITE_END);
2541 if (result != ERROR_OK) {
2542 if (result == ERROR_FLASH_DST_OUT_OF_BANK)
2543 gdb_put_packet(connection, "E.memtype", 9);
2544 else
2545 gdb_send_error(connection, EIO);
2546 } else {
2547 LOG_DEBUG("wrote %u bytes from vFlash image to flash", (unsigned)written);
2548 gdb_put_packet(connection, "OK", 2);
2549 }
2550
2551 image_close(gdb_connection->vflash_image);
2552 free(gdb_connection->vflash_image);
2553 gdb_connection->vflash_image = NULL;
2554
2555 return ERROR_OK;
2556 }
2557
2558 gdb_put_packet(connection, "", 0);
2559 return ERROR_OK;
2560 }
2561
2562 static int gdb_detach(struct connection *connection)
2563 {
2564 struct gdb_service *gdb_service = connection->service->priv;
2565
2566 target_call_event_callbacks(gdb_service->target, TARGET_EVENT_GDB_DETACH);
2567
2568 return gdb_put_packet(connection, "OK", 2);
2569 }
2570
2571 /* The format of 'F' response packet is
2572 * Fretcode,errno,Ctrl-C flag;call-specific attachment
2573 */
2574 static int gdb_fileio_response_packet(struct connection *connection,
2575 char const *packet, int packet_size)
2576 {
2577 struct target *target = get_target_from_connection(connection);
2578 char *separator;
2579 char *parsing_point;
2580 int fileio_retcode = strtoul(packet + 1, &separator, 16);
2581 int fileio_errno = 0;
2582 bool fileio_ctrl_c = false;
2583 int retval;
2584
2585 LOG_DEBUG("-");
2586
2587 if (*separator == ',') {
2588 parsing_point = separator + 1;
2589 fileio_errno = strtoul(parsing_point, &separator, 16);
2590 if (*separator == ',') {
2591 if (*(separator + 1) == 'C') {
2592 /* TODO: process ctrl-c */
2593 fileio_ctrl_c = true;
2594 }
2595 }
2596 }
2597
2598 LOG_DEBUG("File-I/O response, retcode: 0x%x, errno: 0x%x, ctrl-c: %s",
2599 fileio_retcode, fileio_errno, fileio_ctrl_c ? "true" : "false");
2600
2601 retval = target_gdb_fileio_end(target, fileio_retcode, fileio_errno, fileio_ctrl_c);
2602 if (retval != ERROR_OK)
2603 return ERROR_FAIL;
2604
2605 /* After File-I/O ends, keep continue or step */
2606 if (gdb_running_type == 'c')
2607 retval = target_resume(target, 1, 0x0, 0, 0);
2608 else if (gdb_running_type == 's')
2609 retval = target_step(target, 1, 0x0, 0);
2610 else
2611 retval = ERROR_FAIL;
2612
2613 if (retval != ERROR_OK)
2614 return ERROR_FAIL;
2615
2616 return ERROR_OK;
2617 }
2618
2619 static void gdb_log_callback(void *priv, const char *file, unsigned line,
2620 const char *function, const char *string)
2621 {
2622 struct connection *connection = priv;
2623 struct gdb_connection *gdb_con = connection->priv;
2624
2625 if (gdb_con->busy) {
2626 /* do not reply this using the O packet */
2627 return;
2628 }
2629
2630 gdb_output_con(connection, string);
2631 }
2632
2633 static void gdb_sig_halted(struct connection *connection)
2634 {
2635 char sig_reply[4];
2636 snprintf(sig_reply, 4, "T%2.2x", 2);
2637 gdb_put_packet(connection, sig_reply, 3);
2638 }
2639
2640 static int gdb_input_inner(struct connection *connection)
2641 {
2642 /* Do not allocate this on the stack */
2643 static char gdb_packet_buffer[GDB_BUFFER_SIZE];
2644
2645 struct gdb_service *gdb_service = connection->service->priv;
2646 struct target *target = gdb_service->target;
2647 char const *packet = gdb_packet_buffer;
2648 int packet_size;
2649 int retval;
2650 struct gdb_connection *gdb_con = connection->priv;
2651 static int extended_protocol;
2652
2653 /* drain input buffer. If one of the packets fail, then an error
2654 * packet is replied, if applicable.
2655 *
2656 * This loop will terminate and the error code is returned.
2657 *
2658 * The calling fn will check if this error is something that
2659 * can be recovered from, or if the connection must be closed.
2660 *
2661 * If the error is recoverable, this fn is called again to
2662 * drain the rest of the buffer.
2663 */
2664 do {
2665 packet_size = GDB_BUFFER_SIZE-1;
2666 retval = gdb_get_packet(connection, gdb_packet_buffer, &packet_size);
2667 if (retval != ERROR_OK)
2668 return retval;
2669
2670 /* terminate with zero */
2671 gdb_packet_buffer[packet_size] = '\0';
2672
2673 if (LOG_LEVEL_IS(LOG_LVL_DEBUG)) {
2674 if (packet[0] == 'X') {
2675 /* binary packets spew junk into the debug log stream */
2676 char buf[50];
2677 int x;
2678 for (x = 0; (x < 49) && (packet[x] != ':'); x++)
2679 buf[x] = packet[x];
2680 buf[x] = 0;
2681 LOG_DEBUG("received packet: '%s:<binary-data>'", buf);
2682 } else
2683 LOG_DEBUG("received packet: '%s'", packet);
2684 }
2685
2686 if (packet_size > 0) {
2687 retval = ERROR_OK;
2688 switch (packet[0]) {
2689 case 'T': /* Is thread alive? */
2690 gdb_thread_packet(connection, packet, packet_size);
2691 break;
2692 case 'H': /* Set current thread ( 'c' for step and continue,
2693 * 'g' for all other operations ) */
2694 gdb_thread_packet(connection, packet, packet_size);
2695 break;
2696 case 'q':
2697 case 'Q':
2698 retval = gdb_thread_packet(connection, packet, packet_size);
2699 if (retval == GDB_THREAD_PACKET_NOT_CONSUMED)
2700 retval = gdb_query_packet(connection, packet, packet_size);
2701 break;
2702 case 'g':
2703 retval = gdb_get_registers_packet(connection, packet, packet_size);
2704 break;
2705 case 'G':
2706 retval = gdb_set_registers_packet(connection, packet, packet_size);
2707 break;
2708 case 'p':
2709 retval = gdb_get_register_packet(connection, packet, packet_size);
2710 break;
2711 case 'P':
2712 retval = gdb_set_register_packet(connection, packet, packet_size);
2713 break;
2714 case 'm':
2715 retval = gdb_read_memory_packet(connection, packet, packet_size);
2716 break;
2717 case 'M':
2718 retval = gdb_write_memory_packet(connection, packet, packet_size);
2719 break;
2720 case 'z':
2721 case 'Z':
2722 retval = gdb_breakpoint_watchpoint_packet(connection, packet, packet_size);
2723 break;
2724 case '?':
2725 gdb_last_signal_packet(connection, packet, packet_size);
2726 break;
2727 case 'c':
2728 case 's':
2729 {
2730 gdb_thread_packet(connection, packet, packet_size);
2731 log_add_callback(gdb_log_callback, connection);
2732
2733 if (gdb_con->mem_write_error) {
2734 LOG_ERROR("Memory write failure!");
2735
2736 /* now that we have reported the memory write error,
2737 * we can clear the condition */
2738 gdb_con->mem_write_error = false;
2739 }
2740
2741 bool nostep = false;
2742 bool already_running = false;
2743 if (target->state == TARGET_RUNNING) {
2744 LOG_WARNING("WARNING! The target is already running. "
2745 "All changes GDB did to registers will be discarded! "
2746 "Waiting for target to halt.");
2747 already_running = true;
2748 } else if (target->state != TARGET_HALTED) {
2749 LOG_WARNING("The target is not in the halted nor running stated, " \
2750 "stepi/continue ignored.");
2751 nostep = true;
2752 } else if ((packet[0] == 's') && gdb_con->sync) {
2753 /* Hmm..... when you issue a continue in GDB, then a "stepi" is
2754 * sent by GDB first to OpenOCD, thus defeating the check to
2755 * make only the single stepping have the sync feature...
2756 */
2757 nostep = true;
2758 LOG_WARNING("stepi ignored. GDB will now fetch the register state " \
2759 "from the target.");
2760 }
2761 gdb_con->sync = false;
2762
2763 if (!already_running && nostep) {
2764 /* Either the target isn't in the halted state, then we can't
2765 * step/continue. This might be early setup, etc.
2766 *
2767 * Or we want to allow GDB to pick up a fresh set of
2768 * register values without modifying the target state.
2769 *
2770 */
2771 gdb_sig_halted(connection);
2772
2773 /* stop forwarding log packets! */
2774 log_remove_callback(gdb_log_callback, connection);
2775 } else {
2776 /* We're running/stepping, in which case we can
2777 * forward log output until the target is halted
2778 */
2779 gdb_con->frontend_state = TARGET_RUNNING;
2780 target_call_event_callbacks(target, TARGET_EVENT_GDB_START);
2781
2782 if (!already_running) {
2783 /* Here we don't want packet processing to stop even if this fails,
2784 * so we use a local variable instead of retval. */
2785 retval = gdb_step_continue_packet(connection, packet, packet_size);
2786 if (retval != ERROR_OK) {
2787 /* we'll never receive a halted
2788 * condition... issue a false one..
2789 */
2790 gdb_frontend_halted(target, connection);
2791 }
2792 }
2793 }
2794 }
2795 break;
2796 case 'v':
2797 retval = gdb_v_packet(connection, packet, packet_size);
2798 break;
2799 case 'D':
2800 retval = gdb_detach(connection);
2801 extended_protocol = 0;
2802 break;
2803 case 'X':
2804 retval = gdb_write_memory_binary_packet(connection, packet, packet_size);
2805 if (retval != ERROR_OK)
2806 return retval;
2807 break;
2808 case 'k':
2809 if (extended_protocol != 0) {
2810 gdb_con->attached = false;
2811 break;
2812 }
2813 gdb_put_packet(connection, "OK", 2);
2814 return ERROR_SERVER_REMOTE_CLOSED;
2815 case '!':
2816 /* handle extended remote protocol */
2817 extended_protocol = 1;
2818 gdb_put_packet(connection, "OK", 2);
2819 break;
2820 case 'R':
2821 /* handle extended restart packet */
2822 breakpoint_clear_target(gdb_service->target);
2823 watchpoint_clear_target(gdb_service->target);
2824 command_run_linef(connection->cmd_ctx, "ocd_gdb_restart %s",
2825 target_name(target));
2826 /* set connection as attached after reset */
2827 gdb_con->attached = true;
2828 /* info rtos parts */
2829 gdb_thread_packet(connection, packet, packet_size);
2830 break;
2831
2832 case 'j':
2833 /* packet supported only by smp target i.e cortex_a.c*/
2834 /* handle smp packet replying coreid played to gbd */
2835 gdb_read_smp_packet(connection, packet, packet_size);
2836 break;
2837
2838 case 'J':
2839 /* packet supported only by smp target i.e cortex_a.c */
2840 /* handle smp packet setting coreid to be played at next
2841 * resume to gdb */
2842 gdb_write_smp_packet(connection, packet, packet_size);
2843 break;
2844
2845 case 'F':
2846 /* File-I/O extension */
2847 /* After gdb uses host-side syscall to complete target file
2848 * I/O, gdb sends host-side syscall return value to target
2849 * by 'F' packet.
2850 * The format of 'F' response packet is
2851 * Fretcode,errno,Ctrl-C flag;call-specific attachment
2852 */
2853 gdb_con->frontend_state = TARGET_RUNNING;
2854 log_add_callback(gdb_log_callback, connection);
2855 gdb_fileio_response_packet(connection, packet, packet_size);
2856 break;
2857
2858 default:
2859 /* ignore unknown packets */
2860 LOG_DEBUG("ignoring 0x%2.2x packet", packet[0]);
2861 gdb_put_packet(connection, NULL, 0);
2862 break;
2863 }
2864
2865 /* if a packet handler returned an error, exit input loop */
2866 if (retval != ERROR_OK)
2867 return retval;
2868 }
2869
2870 if (gdb_con->ctrl_c) {
2871 if (target->state == TARGET_RUNNING) {
2872 retval = target_halt(target);
2873 if (retval != ERROR_OK)
2874 target_call_event_callbacks(target, TARGET_EVENT_GDB_HALT);
2875 gdb_con->ctrl_c = 0;
2876 } else {
2877 LOG_INFO("The target is not running when halt was requested, stopping GDB.");
2878 target_call_event_callbacks(target, TARGET_EVENT_GDB_HALT);
2879 }
2880 }
2881
2882 } while (gdb_con->buf_cnt > 0);
2883
2884 return ERROR_OK;
2885 }
2886
2887 static int gdb_input(struct connection *connection)
2888 {
2889 int retval = gdb_input_inner(connection);
2890 struct gdb_connection *gdb_con = connection->priv;
2891 if (retval == ERROR_SERVER_REMOTE_CLOSED)
2892 return retval;
2893
2894 /* logging does not propagate the error, yet can set the gdb_con->closed flag */
2895 if (gdb_con->closed)
2896 return ERROR_SERVER_REMOTE_CLOSED;
2897
2898 /* we'll recover from any other errors(e.g. temporary timeouts, etc.) */
2899 return ERROR_OK;
2900 }
2901
2902 static int gdb_target_start(struct target *target, const char *port)
2903 {
2904 struct gdb_service *gdb_service;
2905 int ret;
2906 gdb_service = malloc(sizeof(struct gdb_service));
2907
2908 if (NULL == gdb_service)
2909 return -ENOMEM;
2910
2911 gdb_service->target = target;
2912 gdb_service->core[0] = -1;
2913 gdb_service->core[1] = -1;
2914 target->gdb_service = gdb_service;
2915
2916 ret = add_service("gdb",
2917 port, 1, &gdb_new_connection, &gdb_input,
2918 &gdb_connection_closed, gdb_service);
2919 /* initialialize all targets gdb service with the same pointer */
2920 {
2921 struct target_list *head;
2922 struct target *curr;
2923 head = target->head;
2924 while (head != (struct target_list *)NULL) {
2925 curr = head->target;
2926 if (curr != target)
2927 curr->gdb_service = gdb_service;
2928 head = head->next;
2929 }
2930 }
2931 return ret;
2932 }
2933
2934 static int gdb_target_add_one(struct target *target)
2935 {
2936 /* one gdb instance per smp list */
2937 if ((target->smp) && (target->gdb_service))
2938 return ERROR_OK;
2939 int retval = gdb_target_start(target, gdb_port_next);
2940 if (retval == ERROR_OK) {
2941 long portnumber;
2942 /* If we can parse the port number
2943 * then we increment the port number for the next target.
2944 */
2945 char *end;
2946 portnumber = strtol(gdb_port_next, &end, 0);
2947 if (!*end) {
2948 if (parse_long(gdb_port_next, &portnumber) == ERROR_OK) {
2949 free(gdb_port_next);
2950 gdb_port_next = alloc_printf("%d", portnumber+1);
2951 }
2952 }
2953 }
2954 return retval;
2955 }
2956
2957 int gdb_target_add_all(struct target *target)
2958 {
2959 if (NULL == target) {
2960 LOG_WARNING("gdb services need one or more targets defined");
2961 return ERROR_OK;
2962 }
2963
2964 while (NULL != target) {
2965 int retval = gdb_target_add_one(target);
2966 if (ERROR_OK != retval)
2967 return retval;
2968
2969 target = target->next;
2970 }
2971
2972 return ERROR_OK;
2973 }
2974
2975 COMMAND_HANDLER(handle_gdb_sync_command)
2976 {
2977 if (CMD_ARGC != 0)
2978 return ERROR_COMMAND_SYNTAX_ERROR;
2979
2980 if (current_gdb_connection == NULL) {
2981 command_print(CMD_CTX,
2982 "gdb_sync command can only be run from within gdb using \"monitor gdb_sync\"");
2983 return ERROR_FAIL;
2984 }
2985
2986 current_gdb_connection->sync = true;
2987
2988 return ERROR_OK;
2989 }
2990
2991 /* daemon configuration command gdb_port */
2992 COMMAND_HANDLER(handle_gdb_port_command)
2993 {
2994 int retval = CALL_COMMAND_HANDLER(server_pipe_command, &gdb_port);
2995 if (ERROR_OK == retval) {
2996 free(gdb_port_next);
2997 gdb_port_next = strdup(gdb_port);
2998 }
2999 return retval;
3000 }
3001
3002 COMMAND_HANDLER(handle_gdb_memory_map_command)
3003 {
3004 if (CMD_ARGC != 1)
3005 return ERROR_COMMAND_SYNTAX_ERROR;
3006
3007 COMMAND_PARSE_ENABLE(CMD_ARGV[0], gdb_use_memory_map);
3008 return ERROR_OK;
3009 }
3010
3011 COMMAND_HANDLER(handle_gdb_flash_program_command)
3012 {
3013 if (CMD_ARGC != 1)
3014 return ERROR_COMMAND_SYNTAX_ERROR;
3015
3016 COMMAND_PARSE_ENABLE(CMD_ARGV[0], gdb_flash_program);
3017 return ERROR_OK;
3018 }
3019
3020 COMMAND_HANDLER(handle_gdb_report_data_abort_command)
3021 {
3022 if (CMD_ARGC != 1)
3023 return ERROR_COMMAND_SYNTAX_ERROR;
3024
3025 COMMAND_PARSE_ENABLE(CMD_ARGV[0], gdb_report_data_abort);
3026 return ERROR_OK;
3027 }
3028
3029 /* gdb_breakpoint_override */
3030 COMMAND_HANDLER(handle_gdb_breakpoint_override_command)
3031 {
3032 if (CMD_ARGC == 0) {
3033 /* nothing */
3034 } else if (CMD_ARGC == 1) {
3035 gdb_breakpoint_override = 1;
3036 if (strcmp(CMD_ARGV[0], "hard") == 0)
3037 gdb_breakpoint_override_type = BKPT_HARD;
3038 else if (strcmp(CMD_ARGV[0], "soft") == 0)
3039 gdb_breakpoint_override_type = BKPT_SOFT;
3040 else if (strcmp(CMD_ARGV[0], "disable") == 0)
3041 gdb_breakpoint_override = 0;
3042 } else
3043 return ERROR_COMMAND_SYNTAX_ERROR;
3044 if (gdb_breakpoint_override)
3045 LOG_USER("force %s breakpoints",
3046 (gdb_breakpoint_override_type == BKPT_HARD) ? "hard" : "soft");
3047 else
3048 LOG_USER("breakpoint type is not overridden");
3049
3050 return ERROR_OK;
3051 }
3052
3053 COMMAND_HANDLER(handle_gdb_target_description_command)
3054 {
3055 if (CMD_ARGC != 1)
3056 return ERROR_COMMAND_SYNTAX_ERROR;
3057
3058 COMMAND_PARSE_ENABLE(CMD_ARGV[0], gdb_use_target_description);
3059 return ERROR_OK;
3060 }
3061
3062 COMMAND_HANDLER(handle_gdb_save_tdesc_command)
3063 {
3064 char *tdesc;
3065 uint32_t tdesc_length;
3066 struct target *target = get_current_target(CMD_CTX);
3067
3068 int retval = gdb_generate_target_description(target, &tdesc);
3069 if (retval != ERROR_OK) {
3070 LOG_ERROR("Unable to Generate Target Description");
3071 return ERROR_FAIL;
3072 }
3073
3074 tdesc_length = strlen(tdesc);
3075
3076 struct fileio fileio;
3077 size_t size_written;
3078
3079 char *tdesc_filename = alloc_printf("%s.xml", target_type_name(target));
3080 if (tdesc_filename == NULL) {
3081 retval = ERROR_FAIL;
3082 goto out;
3083 }
3084
3085 retval = fileio_open(&fileio, tdesc_filename, FILEIO_WRITE, FILEIO_TEXT);
3086
3087 if (retval != ERROR_OK) {
3088 LOG_ERROR("Can't open %s for writing", tdesc_filename);
3089 goto out;
3090 }
3091
3092 retval = fileio_write(&fileio, tdesc_length, tdesc, &size_written);
3093
3094 fileio_close(&fileio);
3095
3096 if (retval != ERROR_OK)
3097 LOG_ERROR("Error while writing the tdesc file");
3098
3099 out:
3100 free(tdesc_filename);
3101 free(tdesc);
3102
3103 return retval;
3104 }
3105
3106 static const struct command_registration gdb_command_handlers[] = {
3107 {
3108 .name = "gdb_sync",
3109 .handler = handle_gdb_sync_command,
3110 .mode = COMMAND_ANY,
3111 .help = "next stepi will return immediately allowing "
3112 "GDB to fetch register state without affecting "
3113 "target state",
3114 .usage = ""
3115 },
3116 {
3117 .name = "gdb_port",
3118 .handler = handle_gdb_port_command,
3119 .mode = COMMAND_ANY,
3120 .help = "Normally gdb listens to a TCP/IP port. Each subsequent GDB "
3121 "server listens for the next port number after the "
3122 "base port number specified. "
3123 "No arguments reports GDB port. \"pipe\" means listen to stdin "
3124 "output to stdout, an integer is base port number, \"disable\" disables "
3125 "port. Any other string is are interpreted as named pipe to listen to. "
3126 "Output pipe is the same name as input pipe, but with 'o' appended.",
3127 .usage = "[port_num]",
3128 },
3129 {
3130 .name = "gdb_memory_map",
3131 .handler = handle_gdb_memory_map_command,
3132 .mode = COMMAND_CONFIG,
3133 .help = "enable or disable memory map",
3134 .usage = "('enable'|'disable')"
3135 },
3136 {
3137 .name = "gdb_flash_program",
3138 .handler = handle_gdb_flash_program_command,
3139 .mode = COMMAND_CONFIG,
3140 .help = "enable or disable flash program",
3141 .usage = "('enable'|'disable')"
3142 },
3143 {
3144 .name = "gdb_report_data_abort",
3145 .handler = handle_gdb_report_data_abort_command,
3146 .mode = COMMAND_CONFIG,
3147 .help = "enable or disable reporting data aborts",
3148 .usage = "('enable'|'disable')"
3149 },
3150 {
3151 .name = "gdb_breakpoint_override",
3152 .handler = handle_gdb_breakpoint_override_command,
3153 .mode = COMMAND_ANY,
3154 .help = "Display or specify type of breakpoint "
3155 "to be used by gdb 'break' commands.",
3156 .usage = "('hard'|'soft'|'disable')"
3157 },
3158 {
3159 .name = "gdb_target_description",
3160 .handler = handle_gdb_target_description_command,
3161 .mode = COMMAND_CONFIG,
3162 .help = "enable or disable target description",
3163 .usage = "('enable'|'disable')"
3164 },
3165 {
3166 .name = "gdb_save_tdesc",
3167 .handler = handle_gdb_save_tdesc_command,
3168 .mode = COMMAND_EXEC,
3169 .help = "Save the target description file",
3170 },
3171 COMMAND_REGISTRATION_DONE
3172 };
3173
3174 int gdb_register_commands(struct command_context *cmd_ctx)
3175 {
3176 gdb_port = strdup("3333");
3177 gdb_port_next = strdup("3333");
3178 return register_commands(cmd_ctx, NULL, gdb_command_handlers);
3179 }
Open On-Chip Debugger

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)