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