Code Review / openocd.git / blob
? search:


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