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