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