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

Linking to existing account procedure

If you already have an account and want to add another login method you MUST first sign in with your existing account and then change URL to read https://review.openocd.org/login/?link to get to this page again but this time it'll work for linking. Thank you.

SSH host keys fingerprints

1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=..              |
|+o..   .         |
|*.o   . .        |
|+B . . .         |
|Bo. = o S        |
|Oo.+ + =         |
|oB=.* = . o      |
| =+=.+   + E     |
|. .=o   . o      |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)