Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
gdb_server: sanity check the gdb register size
[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 target_handle_event(target, TARGET_EVENT_OLD_gdb_program_config);
739 retval = jtag_execute_queue();
740 if (retval != ERROR_OK)
741 return retval;
742 break;
743 default:
744 break;
745 }
746
747 return ERROR_OK;
748 }
749
750 static int gdb_new_connection(struct connection *connection)
751 {
752 struct gdb_connection *gdb_connection = malloc(sizeof(struct gdb_connection));
753 struct gdb_service *gdb_service = connection->service->priv;
754 int retval;
755 int initial_ack;
756
757 connection->priv = gdb_connection;
758
759 /* initialize gdb connection information */
760 gdb_connection->buf_p = gdb_connection->buffer;
761 gdb_connection->buf_cnt = 0;
762 gdb_connection->ctrl_c = 0;
763 gdb_connection->frontend_state = TARGET_HALTED;
764 gdb_connection->vflash_image = NULL;
765 gdb_connection->closed = 0;
766 gdb_connection->busy = 0;
767 gdb_connection->noack_mode = 0;
768 gdb_connection->sync = true;
769 gdb_connection->mem_write_error = false;
770
771 /* send ACK to GDB for debug request */
772 gdb_write(connection, "+", 1);
773
774 /* output goes through gdb connection */
775 command_set_output_handler(connection->cmd_ctx, gdb_output, connection);
776
777 /* we must remove all breakpoints registered to the target as a previous
778 * GDB session could leave dangling breakpoints if e.g. communication
779 * timed out.
780 */
781 breakpoint_clear_target(gdb_service->target);
782 watchpoint_clear_target(gdb_service->target);
783
784 /* clean previous rtos session if supported*/
785 if ((gdb_service->target->rtos) && (gdb_service->target->rtos->type->clean))
786 gdb_service->target->rtos->type->clean(gdb_service->target);
787
788 /* remove the initial ACK from the incoming buffer */
789 retval = gdb_get_char(connection, &initial_ack);
790 if (retval != ERROR_OK)
791 return retval;
792
793 /* FIX!!!??? would we actually ever receive a + here???
794 * Not observed.
795 */
796 if (initial_ack != '+')
797 gdb_putback_char(connection, initial_ack);
798 target_call_event_callbacks(gdb_service->target, TARGET_EVENT_GDB_ATTACH);
799
800 if (gdb_use_memory_map) {
801 /* Connect must fail if the memory map can't be set up correctly.
802 *
803 * This will cause an auto_probe to be invoked, which is either
804 * a no-op or it will fail when the target isn't ready(e.g. not halted).
805 */
806 int i;
807 for (i = 0; i < flash_get_bank_count(); i++) {
808 struct flash_bank *p;
809 retval = get_flash_bank_by_num(i, &p);
810 if (retval != ERROR_OK) {
811 LOG_ERROR(
812 "Connect failed. Consider setting up a gdb-attach event for the target to prepare target for GDB connect, or use 'gdb_memory_map disable'.");
813 return retval;
814 }
815 }
816 }
817
818 gdb_actual_connections++;
819 LOG_DEBUG("New GDB Connection: %d, Target %s, state: %s",
820 gdb_actual_connections,
821 target_name(gdb_service->target),
822 target_state_name(gdb_service->target));
823
824 /* DANGER! If we fail subsequently, we must remove this handler,
825 * otherwise we occasionally see crashes as the timer can invoke the
826 * callback fn.
827 *
828 * register callback to be informed about target events */
829 target_register_event_callback(gdb_target_callback_event_handler, connection);
830
831 return ERROR_OK;
832 }
833
834 static int gdb_connection_closed(struct connection *connection)
835 {
836 struct gdb_service *gdb_service = connection->service->priv;
837 struct gdb_connection *gdb_connection = connection->priv;
838
839 /* we're done forwarding messages. Tear down callback before
840 * cleaning up connection.
841 */
842 log_remove_callback(gdb_log_callback, connection);
843
844 gdb_actual_connections--;
845 LOG_DEBUG("GDB Close, Target: %s, state: %s, gdb_actual_connections=%d",
846 target_name(gdb_service->target),
847 target_state_name(gdb_service->target),
848 gdb_actual_connections);
849
850 /* see if an image built with vFlash commands is left */
851 if (gdb_connection->vflash_image) {
852 image_close(gdb_connection->vflash_image);
853 free(gdb_connection->vflash_image);
854 gdb_connection->vflash_image = NULL;
855 }
856
857 /* if this connection registered a debug-message receiver delete it */
858 delete_debug_msg_receiver(connection->cmd_ctx, gdb_service->target);
859
860 if (connection->priv) {
861 free(connection->priv);
862 connection->priv = NULL;
863 } else
864 LOG_ERROR("BUG: connection->priv == NULL");
865
866 target_unregister_event_callback(gdb_target_callback_event_handler, connection);
867
868 target_call_event_callbacks(gdb_service->target, TARGET_EVENT_GDB_END);
869
870 target_call_event_callbacks(gdb_service->target, TARGET_EVENT_GDB_DETACH);
871
872 return ERROR_OK;
873 }
874
875 static void gdb_send_error(struct connection *connection, uint8_t the_error)
876 {
877 char err[4];
878 snprintf(err, 4, "E%2.2X", the_error);
879 gdb_put_packet(connection, err, 3);
880 }
881
882 static int gdb_last_signal_packet(struct connection *connection,
883 char *packet, int packet_size)
884 {
885 struct target *target = get_target_from_connection(connection);
886 char sig_reply[4];
887 int signal_var;
888
889 signal_var = gdb_last_signal(target);
890
891 snprintf(sig_reply, 4, "S%2.2x", signal_var);
892 gdb_put_packet(connection, sig_reply, 3);
893
894 return ERROR_OK;
895 }
896
897 static int gdb_reg_pos(struct target *target, int pos, int len)
898 {
899 if (target->endianness == TARGET_LITTLE_ENDIAN)
900 return pos;
901 else
902 return len - 1 - pos;
903 }
904
905 /* Convert register to string of bytes. NB! The # of bits in the
906 * register might be non-divisible by 8(a byte), in which
907 * case an entire byte is shown.
908 *
909 * NB! the format on the wire is the target endianness
910 *
911 * The format of reg->value is little endian
912 *
913 */
914 static void gdb_str_to_target(struct target *target,
915 char *tstr, struct reg *reg)
916 {
917 int i;
918
919 uint8_t *buf;
920 int buf_len;
921 buf = reg->value;
922 buf_len = DIV_ROUND_UP(reg->size, 8);
923
924 for (i = 0; i < buf_len; i++) {
925 int j = gdb_reg_pos(target, i, buf_len);
926 tstr[i*2] = DIGITS[(buf[j]>>4) & 0xf];
927 tstr[i*2 + 1] = DIGITS[buf[j]&0xf];
928 }
929 }
930
931 static int hextoint(int c)
932 {
933 if (c >= '0' && c <= '9')
934 return c - '0';
935 c = toupper(c);
936 if (c >= 'A' && c <= 'F')
937 return c - 'A' + 10;
938 LOG_ERROR("BUG: invalid register value %08x", c);
939 return 0;
940 }
941
942 /* copy over in register buffer */
943 static void gdb_target_to_reg(struct target *target,
944 char *tstr, int str_len, uint8_t *bin)
945 {
946 if (str_len % 2) {
947 LOG_ERROR("BUG: gdb value with uneven number of characters encountered");
948 exit(-1);
949 }
950
951 int i;
952 for (i = 0; i < str_len; i += 2) {
953 uint8_t t = hextoint(tstr[i]) << 4;
954 t |= hextoint(tstr[i + 1]);
955
956 int j = gdb_reg_pos(target, i/2, str_len/2);
957 bin[j] = t;
958 }
959 }
960
961 static int gdb_get_registers_packet(struct connection *connection,
962 char *packet, int packet_size)
963 {
964 struct target *target = get_target_from_connection(connection);
965 struct reg **reg_list;
966 int reg_list_size;
967 int retval;
968 int reg_packet_size = 0;
969 char *reg_packet;
970 char *reg_packet_p;
971 int i;
972
973 #ifdef _DEBUG_GDB_IO_
974 LOG_DEBUG("-");
975 #endif
976
977 if ((target->rtos != NULL) && (ERROR_OK == rtos_get_gdb_reg_list(connection)))
978 return ERROR_OK;
979
980 retval = target_get_gdb_reg_list(target, &reg_list, &reg_list_size);
981 if (retval != ERROR_OK)
982 return gdb_error(connection, retval);
983
984 for (i = 0; i < reg_list_size; i++)
985 reg_packet_size += DIV_ROUND_UP(reg_list[i]->size, 8) * 2;
986
987 assert(reg_packet_size > 0);
988
989 reg_packet = malloc(reg_packet_size);
990 reg_packet_p = reg_packet;
991
992 for (i = 0; i < reg_list_size; i++) {
993 if (!reg_list[i]->valid)
994 reg_list[i]->type->get(reg_list[i]);
995 gdb_str_to_target(target, reg_packet_p, reg_list[i]);
996 reg_packet_p += DIV_ROUND_UP(reg_list[i]->size, 8) * 2;
997 }
998
999 #ifdef _DEBUG_GDB_IO_
1000 {
1001 char *reg_packet_p_debug;
1002 reg_packet_p_debug = strndup(reg_packet, reg_packet_size);
1003 LOG_DEBUG("reg_packet: %s", reg_packet_p_debug);
1004 free(reg_packet_p_debug);
1005 }
1006 #endif
1007
1008 gdb_put_packet(connection, reg_packet, reg_packet_size);
1009 free(reg_packet);
1010
1011 free(reg_list);
1012
1013 return ERROR_OK;
1014 }
1015
1016 static int gdb_set_registers_packet(struct connection *connection,
1017 char *packet, int packet_size)
1018 {
1019 struct target *target = get_target_from_connection(connection);
1020 int i;
1021 struct reg **reg_list;
1022 int reg_list_size;
1023 int retval;
1024 char *packet_p;
1025
1026 #ifdef _DEBUG_GDB_IO_
1027 LOG_DEBUG("-");
1028 #endif
1029
1030 /* skip command character */
1031 packet++;
1032 packet_size--;
1033
1034 if (packet_size % 2) {
1035 LOG_WARNING(
1036 "GDB set_registers packet with uneven characters received, dropping connection");
1037 return ERROR_SERVER_REMOTE_CLOSED;
1038 }
1039
1040 retval = target_get_gdb_reg_list(target, &reg_list, &reg_list_size);
1041 if (retval != ERROR_OK)
1042 return gdb_error(connection, retval);
1043
1044 packet_p = packet;
1045 for (i = 0; i < reg_list_size; i++) {
1046 uint8_t *bin_buf;
1047 int chars = (DIV_ROUND_UP(reg_list[i]->size, 8) * 2);
1048
1049 if (packet_p + chars > packet + packet_size)
1050 LOG_ERROR("BUG: register packet is too small for registers");
1051
1052 bin_buf = malloc(DIV_ROUND_UP(reg_list[i]->size, 8));
1053 gdb_target_to_reg(target, packet_p, chars, bin_buf);
1054
1055 reg_list[i]->type->set(reg_list[i], bin_buf);
1056
1057 /* advance packet pointer */
1058 packet_p += chars;
1059
1060 free(bin_buf);
1061 }
1062
1063 /* free struct reg *reg_list[] array allocated by get_gdb_reg_list */
1064 free(reg_list);
1065
1066 gdb_put_packet(connection, "OK", 2);
1067
1068 return ERROR_OK;
1069 }
1070
1071 static int gdb_get_register_packet(struct connection *connection,
1072 char *packet, int packet_size)
1073 {
1074 struct target *target = get_target_from_connection(connection);
1075 char *reg_packet;
1076 int reg_num = strtoul(packet + 1, NULL, 16);
1077 struct reg **reg_list;
1078 int reg_list_size;
1079 int retval;
1080
1081 #ifdef _DEBUG_GDB_IO_
1082 LOG_DEBUG("-");
1083 #endif
1084
1085 retval = target_get_gdb_reg_list(target, &reg_list, &reg_list_size);
1086 if (retval != ERROR_OK)
1087 return gdb_error(connection, retval);
1088
1089 if (reg_list_size <= reg_num) {
1090 LOG_ERROR("gdb requested a non-existing register");
1091 exit(-1);
1092 }
1093
1094 if (!reg_list[reg_num]->valid)
1095 reg_list[reg_num]->type->get(reg_list[reg_num]);
1096
1097 reg_packet = malloc(DIV_ROUND_UP(reg_list[reg_num]->size, 8) * 2);
1098
1099 gdb_str_to_target(target, reg_packet, reg_list[reg_num]);
1100
1101 gdb_put_packet(connection, reg_packet, DIV_ROUND_UP(reg_list[reg_num]->size, 8) * 2);
1102
1103 free(reg_list);
1104 free(reg_packet);
1105
1106 return ERROR_OK;
1107 }
1108
1109 static int gdb_set_register_packet(struct connection *connection,
1110 char *packet, int packet_size)
1111 {
1112 struct target *target = get_target_from_connection(connection);
1113 char *separator;
1114 uint8_t *bin_buf;
1115 int reg_num = strtoul(packet + 1, &separator, 16);
1116 struct reg **reg_list;
1117 int reg_list_size;
1118 int retval;
1119
1120 LOG_DEBUG("-");
1121
1122 retval = target_get_gdb_reg_list(target, &reg_list, &reg_list_size);
1123 if (retval != ERROR_OK)
1124 return gdb_error(connection, retval);
1125
1126 if (reg_list_size < reg_num) {
1127 LOG_ERROR("gdb requested a non-existing register");
1128 return ERROR_SERVER_REMOTE_CLOSED;
1129 }
1130
1131 if (*separator != '=') {
1132 LOG_ERROR("GDB 'set register packet', but no '=' following the register number");
1133 return ERROR_SERVER_REMOTE_CLOSED;
1134 }
1135
1136 /* convert from GDB-string (target-endian) to hex-string (big-endian) */
1137 bin_buf = malloc(DIV_ROUND_UP(reg_list[reg_num]->size, 8));
1138 int chars = (DIV_ROUND_UP(reg_list[reg_num]->size, 8) * 2);
1139
1140 if ((unsigned int)chars != strlen(separator + 1)) {
1141 LOG_ERROR("gdb sent a packet with wrong register size");
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 target_handle_event(target, TARGET_EVENT_OLD_pre_resume);
1371 retval = target_resume(target, current, address, 0, 0); /* resume at current
1372 *address, don't handle
1373 *breakpoints, not debugging
1374 **/
1375 } else if (packet[0] == 's') {
1376 LOG_DEBUG("step");
1377 /* step at current or address, don't handle breakpoints */
1378 retval = target_step(target, current, address, 0);
1379 }
1380 return retval;
1381 }
1382
1383 static int gdb_breakpoint_watchpoint_packet(struct connection *connection,
1384 char *packet, int packet_size)
1385 {
1386 struct target *target = get_target_from_connection(connection);
1387 int type;
1388 enum breakpoint_type bp_type = BKPT_SOFT /* dummy init to avoid warning */;
1389 enum watchpoint_rw wp_type = WPT_READ /* dummy init to avoid warning */;
1390 uint32_t address;
1391 uint32_t size;
1392 char *separator;
1393 int retval;
1394
1395 LOG_DEBUG("-");
1396
1397 type = strtoul(packet + 1, &separator, 16);
1398
1399 if (type == 0) /* memory breakpoint */
1400 bp_type = BKPT_SOFT;
1401 else if (type == 1) /* hardware breakpoint */
1402 bp_type = BKPT_HARD;
1403 else if (type == 2) /* write watchpoint */
1404 wp_type = WPT_WRITE;
1405 else if (type == 3) /* read watchpoint */
1406 wp_type = WPT_READ;
1407 else if (type == 4) /* access watchpoint */
1408 wp_type = WPT_ACCESS;
1409 else {
1410 LOG_ERROR("invalid gdb watch/breakpoint type(%d), dropping connection", type);
1411 return ERROR_SERVER_REMOTE_CLOSED;
1412 }
1413
1414 if (gdb_breakpoint_override && ((bp_type == BKPT_SOFT) || (bp_type == BKPT_HARD)))
1415 bp_type = gdb_breakpoint_override_type;
1416
1417 if (*separator != ',') {
1418 LOG_ERROR("incomplete breakpoint/watchpoint packet received, dropping connection");
1419 return ERROR_SERVER_REMOTE_CLOSED;
1420 }
1421
1422 address = strtoul(separator + 1, &separator, 16);
1423
1424 if (*separator != ',') {
1425 LOG_ERROR("incomplete breakpoint/watchpoint packet received, dropping connection");
1426 return ERROR_SERVER_REMOTE_CLOSED;
1427 }
1428
1429 size = strtoul(separator + 1, &separator, 16);
1430
1431 switch (type) {
1432 case 0:
1433 case 1:
1434 if (packet[0] == 'Z') {
1435 retval = breakpoint_add(target, address, size, bp_type);
1436 if (retval != ERROR_OK) {
1437 retval = gdb_error(connection, retval);
1438 if (retval != ERROR_OK)
1439 return retval;
1440 } else
1441 gdb_put_packet(connection, "OK", 2);
1442 } else {
1443 breakpoint_remove(target, address);
1444 gdb_put_packet(connection, "OK", 2);
1445 }
1446 break;
1447 case 2:
1448 case 3:
1449 case 4:
1450 {
1451 if (packet[0] == 'Z') {
1452 retval = watchpoint_add(target, address, size, wp_type, 0, 0xffffffffu);
1453 if (retval != ERROR_OK) {
1454 retval = gdb_error(connection, retval);
1455 if (retval != ERROR_OK)
1456 return retval;
1457 } else
1458 gdb_put_packet(connection, "OK", 2);
1459 } else {
1460 watchpoint_remove(target, address);
1461 gdb_put_packet(connection, "OK", 2);
1462 }
1463 break;
1464 }
1465 default:
1466 break;
1467 }
1468
1469 return ERROR_OK;
1470 }
1471
1472 /* print out a string and allocate more space as needed,
1473 * mainly used for XML at this point
1474 */
1475 static void xml_printf(int *retval, char **xml, int *pos, int *size,
1476 const char *fmt, ...)
1477 {
1478 if (*retval != ERROR_OK)
1479 return;
1480 int first = 1;
1481
1482 for (;; ) {
1483 if ((*xml == NULL) || (!first)) {
1484 /* start by 0 to exercise all the code paths.
1485 * Need minimum 2 bytes to fit 1 char and 0 terminator. */
1486
1487 *size = *size * 2 + 2;
1488 char *t = *xml;
1489 *xml = realloc(*xml, *size);
1490 if (*xml == NULL) {
1491 if (t)
1492 free(t);
1493 *retval = ERROR_SERVER_REMOTE_CLOSED;
1494 return;
1495 }
1496 }
1497
1498 va_list ap;
1499 int ret;
1500 va_start(ap, fmt);
1501 ret = vsnprintf(*xml + *pos, *size - *pos, fmt, ap);
1502 va_end(ap);
1503 if ((ret > 0) && ((ret + 1) < *size - *pos)) {
1504 *pos += ret;
1505 return;
1506 }
1507 /* there was just enough or not enough space, allocate more. */
1508 first = 0;
1509 }
1510 }
1511
1512 static int decode_xfer_read(char *buf, char **annex, int *ofs, unsigned int *len)
1513 {
1514 char *separator;
1515
1516 /* Extract and NUL-terminate the annex. */
1517 *annex = buf;
1518 while (*buf && *buf != ':')
1519 buf++;
1520 if (*buf == '\0')
1521 return -1;
1522 *buf++ = 0;
1523
1524 /* After the read marker and annex, qXfer looks like a
1525 * traditional 'm' packet. */
1526
1527 *ofs = strtoul(buf, &separator, 16);
1528
1529 if (*separator != ',')
1530 return -1;
1531
1532 *len = strtoul(separator + 1, NULL, 16);
1533
1534 return 0;
1535 }
1536
1537 static int compare_bank(const void *a, const void *b)
1538 {
1539 struct flash_bank *b1, *b2;
1540 b1 = *((struct flash_bank **)a);
1541 b2 = *((struct flash_bank **)b);
1542
1543 if (b1->base == b2->base)
1544 return 0;
1545 else if (b1->base > b2->base)
1546 return 1;
1547 else
1548 return -1;
1549 }
1550
1551 static int gdb_memory_map(struct connection *connection,
1552 char *packet, int packet_size)
1553 {
1554 /* We get away with only specifying flash here. Regions that are not
1555 * specified are treated as if we provided no memory map(if not we
1556 * could detect the holes and mark them as RAM).
1557 * Normally we only execute this code once, but no big deal if we
1558 * have to regenerate it a couple of times.
1559 */
1560
1561 struct target *target = get_target_from_connection(connection);
1562 struct flash_bank *p;
1563 char *xml = NULL;
1564 int size = 0;
1565 int pos = 0;
1566 int retval = ERROR_OK;
1567 struct flash_bank **banks;
1568 int offset;
1569 int length;
1570 char *separator;
1571 uint32_t ram_start = 0;
1572 int i;
1573 int target_flash_banks = 0;
1574
1575 /* skip command character */
1576 packet += 23;
1577
1578 offset = strtoul(packet, &separator, 16);
1579 length = strtoul(separator + 1, &separator, 16);
1580
1581 xml_printf(&retval, &xml, &pos, &size, "<memory-map>\n");
1582
1583 /* Sort banks in ascending order. We need to report non-flash
1584 * memory as ram (or rather read/write) by default for GDB, since
1585 * it has no concept of non-cacheable read/write memory (i/o etc).
1586 *
1587 * FIXME Most non-flash addresses are *NOT* RAM! Don't lie.
1588 * Current versions of GDB assume unlisted addresses are RAM...
1589 */
1590 banks = malloc(sizeof(struct flash_bank *)*flash_get_bank_count());
1591
1592 for (i = 0; i < flash_get_bank_count(); i++) {
1593 retval = get_flash_bank_by_num(i, &p);
1594 if (retval != ERROR_OK) {
1595 free(banks);
1596 gdb_error(connection, retval);
1597 return retval;
1598 }
1599 if (p->target == target)
1600 banks[target_flash_banks++] = p;
1601 }
1602
1603 qsort(banks, target_flash_banks, sizeof(struct flash_bank *),
1604 compare_bank);
1605
1606 for (i = 0; i < target_flash_banks; i++) {
1607 int j;
1608 unsigned sector_size = 0;
1609 uint32_t start;
1610
1611 p = banks[i];
1612 start = p->base;
1613
1614 if (ram_start < p->base)
1615 xml_printf(&retval, &xml, &pos, &size,
1616 "<memory type=\"ram\" start=\"0x%x\" "
1617 "length=\"0x%x\"/>\n",
1618 ram_start, p->base - ram_start);
1619
1620 /* Report adjacent groups of same-size sectors. So for
1621 * example top boot CFI flash will list an initial region
1622 * with several large sectors (maybe 128KB) and several
1623 * smaller ones at the end (maybe 32KB). STR7 will have
1624 * regions with 8KB, 32KB, and 64KB sectors; etc.
1625 */
1626 for (j = 0; j < p->num_sectors; j++) {
1627 unsigned group_len;
1628
1629 /* Maybe start a new group of sectors. */
1630 if (sector_size == 0) {
1631 start = p->base + p->sectors[j].offset;
1632 xml_printf(&retval, &xml, &pos, &size,
1633 "<memory type=\"flash\" "
1634 "start=\"0x%x\" ",
1635 start);
1636 sector_size = p->sectors[j].size;
1637 }
1638
1639 /* Does this finish a group of sectors?
1640 * If not, continue an already-started group.
1641 */
1642 if (j == p->num_sectors - 1)
1643 group_len = (p->base + p->size) - start;
1644 else if (p->sectors[j + 1].size != sector_size)
1645 group_len = p->base + p->sectors[j + 1].offset
1646 - start;
1647 else
1648 continue;
1649
1650 xml_printf(&retval, &xml, &pos, &size,
1651 "length=\"0x%x\">\n"
1652 "<property name=\"blocksize\">"
1653 "0x%x</property>\n"
1654 "</memory>\n",
1655 group_len,
1656 sector_size);
1657 sector_size = 0;
1658 }
1659
1660 ram_start = p->base + p->size;
1661 }
1662
1663 if (ram_start != 0)
1664 xml_printf(&retval, &xml, &pos, &size,
1665 "<memory type=\"ram\" start=\"0x%x\" "
1666 "length=\"0x%x\"/>\n",
1667 ram_start, 0-ram_start);
1668 /* ELSE a flash chip could be at the very end of the 32 bit address
1669 * space, in which case ram_start will be precisely 0
1670 */
1671
1672 free(banks);
1673 banks = NULL;
1674
1675 xml_printf(&retval, &xml, &pos, &size, "</memory-map>\n");
1676
1677 if (retval != ERROR_OK) {
1678 gdb_error(connection, retval);
1679 return retval;
1680 }
1681
1682 if (offset + length > pos)
1683 length = pos - offset;
1684
1685 char *t = malloc(length + 1);
1686 t[0] = 'l';
1687 memcpy(t + 1, xml + offset, length);
1688 gdb_put_packet(connection, t, length + 1);
1689
1690 free(t);
1691 free(xml);
1692 return ERROR_OK;
1693 }
1694
1695 static int gdb_query_packet(struct connection *connection,
1696 char *packet, int packet_size)
1697 {
1698 struct command_context *cmd_ctx = connection->cmd_ctx;
1699 struct gdb_connection *gdb_connection = connection->priv;
1700 struct target *target = get_target_from_connection(connection);
1701
1702 if (strstr(packet, "qRcmd,")) {
1703 if (packet_size > 6) {
1704 char *cmd;
1705 int i;
1706 cmd = malloc((packet_size - 6)/2 + 1);
1707 for (i = 0; i < (packet_size - 6)/2; i++) {
1708 uint32_t tmp;
1709 sscanf(packet + 6 + 2*i, "%2" SCNx32, &tmp);
1710 cmd[i] = tmp;
1711 }
1712 cmd[(packet_size - 6)/2] = 0x0;
1713
1714 /* We want to print all debug output to GDB connection */
1715 log_add_callback(gdb_log_callback, connection);
1716 target_call_timer_callbacks_now();
1717 /* some commands need to know the GDB connection, make note of current
1718 * GDB connection. */
1719 current_gdb_connection = gdb_connection;
1720 command_run_line(cmd_ctx, cmd);
1721 current_gdb_connection = NULL;
1722 target_call_timer_callbacks_now();
1723 log_remove_callback(gdb_log_callback, connection);
1724 free(cmd);
1725 }
1726 gdb_put_packet(connection, "OK", 2);
1727 return ERROR_OK;
1728 } else if (strstr(packet, "qCRC:")) {
1729 if (packet_size > 5) {
1730 int retval;
1731 char gdb_reply[10];
1732 char *separator;
1733 uint32_t checksum;
1734 uint32_t addr = 0;
1735 uint32_t len = 0;
1736
1737 /* skip command character */
1738 packet += 5;
1739
1740 addr = strtoul(packet, &separator, 16);
1741
1742 if (*separator != ',') {
1743 LOG_ERROR(
1744 "incomplete read memory packet received, dropping connection");
1745 return ERROR_SERVER_REMOTE_CLOSED;
1746 }
1747
1748 len = strtoul(separator + 1, NULL, 16);
1749
1750 retval = target_checksum_memory(target, addr, len, &checksum);
1751
1752 if (retval == ERROR_OK) {
1753 snprintf(gdb_reply, 10, "C%8.8" PRIx32 "", checksum);
1754 gdb_put_packet(connection, gdb_reply, 9);
1755 } else {
1756 retval = gdb_error(connection, retval);
1757 if (retval != ERROR_OK)
1758 return retval;
1759 }
1760
1761 return ERROR_OK;
1762 }
1763 } else if (strstr(packet, "qSupported")) {
1764 /* we currently support packet size and qXfer:memory-map:read (if enabled)
1765 * disable qXfer:features:read for the moment */
1766 int retval = ERROR_OK;
1767 char *buffer = NULL;
1768 int pos = 0;
1769 int size = 0;
1770
1771 xml_printf(&retval,
1772 &buffer,
1773 &pos,
1774 &size,
1775 "PacketSize=%x;qXfer:memory-map:read%c;qXfer:features:read-;QStartNoAckMode+",
1776 (GDB_BUFFER_SIZE - 1),
1777 ((gdb_use_memory_map == 1) && (flash_get_bank_count() > 0)) ? '+' : '-');
1778
1779 if (retval != ERROR_OK) {
1780 gdb_send_error(connection, 01);
1781 return ERROR_OK;
1782 }
1783
1784 gdb_put_packet(connection, buffer, strlen(buffer));
1785 free(buffer);
1786
1787 return ERROR_OK;
1788 } else if (strstr(packet, "qXfer:memory-map:read::")
1789 && (flash_get_bank_count() > 0))
1790 return gdb_memory_map(connection, packet, packet_size);
1791 else if (strstr(packet, "qXfer:features:read:")) {
1792 char *xml = NULL;
1793 int size = 0;
1794 int pos = 0;
1795 int retval = ERROR_OK;
1796
1797 int offset;
1798 unsigned int length;
1799 char *annex;
1800
1801 /* skip command character */
1802 packet += 20;
1803
1804 if (decode_xfer_read(packet, &annex, &offset, &length) < 0) {
1805 gdb_send_error(connection, 01);
1806 return ERROR_OK;
1807 }
1808
1809 if (strcmp(annex, "target.xml") != 0) {
1810 gdb_send_error(connection, 01);
1811 return ERROR_OK;
1812 }
1813
1814 xml_printf(&retval,
1815 &xml,
1816 &pos,
1817 &size, \
1818 "l < target version=\"1.0\">\n < architecture > arm</architecture>\n</target>\n");
1819
1820 if (retval != ERROR_OK) {
1821 gdb_error(connection, retval);
1822 return retval;
1823 }
1824
1825 gdb_put_packet(connection, xml, strlen(xml));
1826
1827 free(xml);
1828 return ERROR_OK;
1829 } else if (strstr(packet, "QStartNoAckMode")) {
1830 gdb_connection->noack_mode = 1;
1831 gdb_put_packet(connection, "OK", 2);
1832 return ERROR_OK;
1833 }
1834
1835 gdb_put_packet(connection, "", 0);
1836 return ERROR_OK;
1837 }
1838
1839 static int gdb_v_packet(struct connection *connection,
1840 char *packet, int packet_size)
1841 {
1842 struct gdb_connection *gdb_connection = connection->priv;
1843 struct gdb_service *gdb_service = connection->service->priv;
1844 int result;
1845
1846 /* if flash programming disabled - send a empty reply */
1847
1848 if (gdb_flash_program == 0) {
1849 gdb_put_packet(connection, "", 0);
1850 return ERROR_OK;
1851 }
1852
1853 if (strstr(packet, "vFlashErase:")) {
1854 unsigned long addr;
1855 unsigned long length;
1856
1857 char *parse = packet + 12;
1858 if (*parse == '\0') {
1859 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1860 return ERROR_SERVER_REMOTE_CLOSED;
1861 }
1862
1863 addr = strtoul(parse, &parse, 16);
1864
1865 if (*(parse++) != ',' || *parse == '\0') {
1866 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1867 return ERROR_SERVER_REMOTE_CLOSED;
1868 }
1869
1870 length = strtoul(parse, &parse, 16);
1871
1872 if (*parse != '\0') {
1873 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1874 return ERROR_SERVER_REMOTE_CLOSED;
1875 }
1876
1877 /* assume all sectors need erasing - stops any problems
1878 * when flash_write is called multiple times */
1879 flash_set_dirty();
1880
1881 /* perform any target specific operations before the erase */
1882 target_call_event_callbacks(gdb_service->target,
1883 TARGET_EVENT_GDB_FLASH_ERASE_START);
1884
1885 /* vFlashErase:addr,length messages require region start and
1886 * end to be "block" aligned ... if padding is ever needed,
1887 * GDB will have become dangerously confused.
1888 */
1889 result = flash_erase_address_range(gdb_service->target,
1890 false, addr, length);
1891
1892 /* perform any target specific operations after the erase */
1893 target_call_event_callbacks(gdb_service->target,
1894 TARGET_EVENT_GDB_FLASH_ERASE_END);
1895
1896 /* perform erase */
1897 if (result != ERROR_OK) {
1898 /* GDB doesn't evaluate the actual error number returned,
1899 * treat a failed erase as an I/O error
1900 */
1901 gdb_send_error(connection, EIO);
1902 LOG_ERROR("flash_erase returned %i", result);
1903 } else
1904 gdb_put_packet(connection, "OK", 2);
1905
1906 return ERROR_OK;
1907 }
1908
1909 if (strstr(packet, "vFlashWrite:")) {
1910 int retval;
1911 unsigned long addr;
1912 unsigned long length;
1913 char *parse = packet + 12;
1914
1915 if (*parse == '\0') {
1916 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1917 return ERROR_SERVER_REMOTE_CLOSED;
1918 }
1919 addr = strtoul(parse, &parse, 16);
1920 if (*(parse++) != ':') {
1921 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1922 return ERROR_SERVER_REMOTE_CLOSED;
1923 }
1924 length = packet_size - (parse - packet);
1925
1926 /* create a new image if there isn't already one */
1927 if (gdb_connection->vflash_image == NULL) {
1928 gdb_connection->vflash_image = malloc(sizeof(struct image));
1929 image_open(gdb_connection->vflash_image, "", "build");
1930 }
1931
1932 /* create new section with content from packet buffer */
1933 retval = image_add_section(gdb_connection->vflash_image,
1934 addr, length, 0x0, (uint8_t *)parse);
1935 if (retval != ERROR_OK)
1936 return retval;
1937
1938 gdb_put_packet(connection, "OK", 2);
1939
1940 return ERROR_OK;
1941 }
1942
1943 if (!strcmp(packet, "vFlashDone")) {
1944 uint32_t written;
1945
1946 /* process the flashing buffer. No need to erase as GDB
1947 * always issues a vFlashErase first. */
1948 target_call_event_callbacks(gdb_service->target,
1949 TARGET_EVENT_GDB_FLASH_WRITE_START);
1950 result =
1951 flash_write(gdb_service->target, gdb_connection->vflash_image, &written, 0);
1952 target_call_event_callbacks(gdb_service->target, TARGET_EVENT_GDB_FLASH_WRITE_END);
1953 if (result != ERROR_OK) {
1954 if (result == ERROR_FLASH_DST_OUT_OF_BANK)
1955 gdb_put_packet(connection, "E.memtype", 9);
1956 else
1957 gdb_send_error(connection, EIO);
1958 } else {
1959 LOG_DEBUG("wrote %u bytes from vFlash image to flash", (unsigned)written);
1960 gdb_put_packet(connection, "OK", 2);
1961 }
1962
1963 image_close(gdb_connection->vflash_image);
1964 free(gdb_connection->vflash_image);
1965 gdb_connection->vflash_image = NULL;
1966
1967 return ERROR_OK;
1968 }
1969
1970 gdb_put_packet(connection, "", 0);
1971 return ERROR_OK;
1972 }
1973
1974 static int gdb_detach(struct connection *connection)
1975 {
1976 struct gdb_service *gdb_service = connection->service->priv;
1977
1978 target_call_event_callbacks(gdb_service->target,
1979 TARGET_EVENT_GDB_DETACH);
1980
1981 return gdb_put_packet(connection, "OK", 2);
1982 }
1983
1984 static void gdb_log_callback(void *priv, const char *file, unsigned line,
1985 const char *function, const char *string)
1986 {
1987 struct connection *connection = priv;
1988 struct gdb_connection *gdb_con = connection->priv;
1989
1990 if (gdb_con->busy) {
1991 /* do not reply this using the O packet */
1992 return;
1993 }
1994
1995 gdb_output_con(connection, string);
1996 }
1997
1998 static void gdb_sig_halted(struct connection *connection)
1999 {
2000 char sig_reply[4];
2001 snprintf(sig_reply, 4, "T%2.2x", 2);
2002 gdb_put_packet(connection, sig_reply, 3);
2003
2004 }
2005
2006 static int gdb_input_inner(struct connection *connection)
2007 {
2008 /* Do not allocate this on the stack */
2009 static char gdb_packet_buffer[GDB_BUFFER_SIZE];
2010
2011 struct gdb_service *gdb_service = connection->service->priv;
2012 struct target *target = gdb_service->target;
2013 char *packet = gdb_packet_buffer;
2014 int packet_size;
2015 int retval;
2016 struct gdb_connection *gdb_con = connection->priv;
2017 static int extended_protocol;
2018
2019 /* drain input buffer. If one of the packets fail, then an error
2020 * packet is replied, if applicable.
2021 *
2022 * This loop will terminate and the error code is returned.
2023 *
2024 * The calling fn will check if this error is something that
2025 * can be recovered from, or if the connection must be closed.
2026 *
2027 * If the error is recoverable, this fn is called again to
2028 * drain the rest of the buffer.
2029 */
2030 do {
2031 packet_size = GDB_BUFFER_SIZE-1;
2032 retval = gdb_get_packet(connection, packet, &packet_size);
2033 if (retval != ERROR_OK)
2034 return retval;
2035
2036 /* terminate with zero */
2037 packet[packet_size] = 0;
2038
2039 if (LOG_LEVEL_IS(LOG_LVL_DEBUG)) {
2040 if (packet[0] == 'X') {
2041 /* binary packets spew junk into the debug log stream */
2042 char buf[50];
2043 int x;
2044 for (x = 0; (x < 49) && (packet[x] != ':'); x++)
2045 buf[x] = packet[x];
2046 buf[x] = 0;
2047 LOG_DEBUG("received packet: '%s:<binary-data>'", buf);
2048 } else
2049 LOG_DEBUG("received packet: '%s'", packet);
2050 }
2051
2052 if (packet_size > 0) {
2053 retval = ERROR_OK;
2054 switch (packet[0]) {
2055 case 'T': /* Is thread alive? */
2056 gdb_thread_packet(connection, packet, packet_size);
2057 break;
2058 case 'H': /* Set current thread ( 'c' for step and continue, 'g' for
2059 * all other operations ) */
2060 gdb_thread_packet(connection, packet, packet_size);
2061 break;
2062 case 'q':
2063 case 'Q':
2064 retval = gdb_thread_packet(connection, packet, packet_size);
2065 if (retval == GDB_THREAD_PACKET_NOT_CONSUMED)
2066 retval = gdb_query_packet(connection, packet, packet_size);
2067 break;
2068 case 'g':
2069 retval = gdb_get_registers_packet(connection, packet, packet_size);
2070 break;
2071 case 'G':
2072 retval = gdb_set_registers_packet(connection, packet, packet_size);
2073 break;
2074 case 'p':
2075 retval = gdb_get_register_packet(connection, packet, packet_size);
2076 break;
2077 case 'P':
2078 retval = gdb_set_register_packet(connection, packet, packet_size);
2079 break;
2080 case 'm':
2081 retval = gdb_read_memory_packet(connection, packet, packet_size);
2082 break;
2083 case 'M':
2084 retval = gdb_write_memory_packet(connection, packet, packet_size);
2085 break;
2086 case 'z':
2087 case 'Z':
2088 retval = gdb_breakpoint_watchpoint_packet(connection, packet, packet_size);
2089 break;
2090 case '?':
2091 gdb_last_signal_packet(connection, packet, packet_size);
2092 break;
2093 case 'c':
2094 case 's':
2095 {
2096 gdb_thread_packet(connection, packet, packet_size);
2097 log_add_callback(gdb_log_callback, connection);
2098
2099 if (gdb_con->mem_write_error) {
2100 LOG_ERROR("Memory write failure!");
2101
2102 /* now that we have reported the memory write error,
2103 *we can clear the condition */
2104 gdb_con->mem_write_error = false;
2105 }
2106
2107 bool nostep = false;
2108 bool already_running = false;
2109 if (target->state == TARGET_RUNNING) {
2110 LOG_WARNING("WARNING! The target is already running. "
2111 "All changes GDB did to registers will be discarded! "
2112 "Waiting for target to halt.");
2113 already_running = true;
2114 } else if (target->state != TARGET_HALTED) {
2115 LOG_WARNING("The target is not in the halted nor running stated, " \
2116 "stepi/continue ignored.");
2117 nostep = true;
2118 } else if ((packet[0] == 's') && gdb_con->sync) {
2119 /* Hmm..... when you issue a continue in GDB, then a "stepi" is
2120 * sent by GDB first to OpenOCD, thus defeating the check to
2121 * make only the single stepping have the sync feature...
2122 */
2123 nostep = true;
2124 LOG_WARNING("stepi ignored. GDB will now fetch the register state " \
2125 "from the target.");
2126 }
2127 gdb_con->sync = false;
2128
2129 if (!already_running && nostep) {
2130 /* Either the target isn't in the halted state, then we can't
2131 * step/continue. This might be early setup, etc.
2132 *
2133 * Or we want to allow GDB to pick up a fresh set of
2134 * register values without modifying the target state.
2135 *
2136 */
2137 gdb_sig_halted(connection);
2138
2139 /* stop forwarding log packets! */
2140 log_remove_callback(gdb_log_callback, connection);
2141 } else {
2142 /* We're running/stepping, in which case we can
2143 * forward log output until the target is halted
2144 */
2145 gdb_con->frontend_state = TARGET_RUNNING;
2146 target_call_event_callbacks(target, TARGET_EVENT_GDB_START);
2147
2148 if (!already_running) {
2149 /* Here we don't want packet processing to stop even if this fails,
2150 * so we use a local variable instead of retval. */
2151 retval = gdb_step_continue_packet(connection, packet, packet_size);
2152 if (retval != ERROR_OK) {
2153 /* we'll never receive a halted
2154 *condition... issue a false one..
2155 **/
2156 gdb_frontend_halted(target, connection);
2157 }
2158 }
2159 }
2160 }
2161 break;
2162 case 'v':
2163 retval = gdb_v_packet(connection, packet, packet_size);
2164 break;
2165 case 'D':
2166 retval = gdb_detach(connection);
2167 extended_protocol = 0;
2168 break;
2169 case 'X':
2170 retval = gdb_write_memory_binary_packet(connection, packet, packet_size);
2171 if (retval != ERROR_OK)
2172 return retval;
2173 break;
2174 case 'k':
2175 if (extended_protocol != 0)
2176 break;
2177 gdb_put_packet(connection, "OK", 2);
2178 return ERROR_SERVER_REMOTE_CLOSED;
2179 case '!':
2180 /* handle extended remote protocol */
2181 extended_protocol = 1;
2182 gdb_put_packet(connection, "OK", 2);
2183 break;
2184 case 'R':
2185 /* handle extended restart packet */
2186 breakpoint_clear_target(gdb_service->target);
2187 watchpoint_clear_target(gdb_service->target);
2188 command_run_linef(connection->cmd_ctx,
2189 "ocd_gdb_restart %s",
2190 target_name(target));
2191 /* info rtos parts */
2192 gdb_thread_packet(connection, packet, packet_size);
2193 gdb_put_packet(connection, "OK", 2);
2194 break;
2195
2196 case 'j':
2197 /* packet supported only by smp target i.e cortex_a.c*/
2198 /* handle smp packet replying coreid played to gbd */
2199 gdb_read_smp_packet(connection, packet, packet_size);
2200 break;
2201
2202 case 'J':
2203 /* packet supported only by smp target i.e cortex_a.c */
2204 /* handle smp packet setting coreid to be played at next
2205 * resume to gdb */
2206 gdb_write_smp_packet(connection, packet, packet_size);
2207 break;
2208
2209 default:
2210 /* ignore unknown packets */
2211 LOG_DEBUG("ignoring 0x%2.2x packet", packet[0]);
2212 gdb_put_packet(connection, NULL, 0);
2213 break;
2214 }
2215
2216 /* if a packet handler returned an error, exit input loop */
2217 if (retval != ERROR_OK)
2218 return retval;
2219 }
2220
2221 if (gdb_con->ctrl_c) {
2222 if (target->state == TARGET_RUNNING) {
2223 retval = target_halt(target);
2224 if (retval != ERROR_OK)
2225 target_call_event_callbacks(target, TARGET_EVENT_GDB_HALT);
2226 gdb_con->ctrl_c = 0;
2227 } else {
2228 LOG_INFO(
2229 "The target is not running when halt was requested, stopping GDB.");
2230 target_call_event_callbacks(target, TARGET_EVENT_GDB_HALT);
2231 }
2232 }
2233
2234 } while (gdb_con->buf_cnt > 0);
2235
2236 return ERROR_OK;
2237 }
2238
2239 static int gdb_input(struct connection *connection)
2240 {
2241 int retval = gdb_input_inner(connection);
2242 struct gdb_connection *gdb_con = connection->priv;
2243 if (retval == ERROR_SERVER_REMOTE_CLOSED)
2244 return retval;
2245
2246 /* logging does not propagate the error, yet can set the gdb_con->closed flag */
2247 if (gdb_con->closed)
2248 return ERROR_SERVER_REMOTE_CLOSED;
2249
2250 /* we'll recover from any other errors(e.g. temporary timeouts, etc.) */
2251 return ERROR_OK;
2252 }
2253
2254 static int gdb_target_start(struct target *target, const char *port)
2255 {
2256 struct gdb_service *gdb_service;
2257 int ret;
2258 gdb_service = malloc(sizeof(struct gdb_service));
2259
2260 if (NULL == gdb_service)
2261 return -ENOMEM;
2262
2263 gdb_service->target = target;
2264 gdb_service->core[0] = -1;
2265 gdb_service->core[1] = -1;
2266 target->gdb_service = gdb_service;
2267
2268 ret = add_service("gdb",
2269 port, 1, &gdb_new_connection, &gdb_input,
2270 &gdb_connection_closed, gdb_service);
2271 /* initialialize all targets gdb service with the same pointer */
2272 {
2273 struct target_list *head;
2274 struct target *curr;
2275 head = target->head;
2276 while (head != (struct target_list *)NULL) {
2277 curr = head->target;
2278 if (curr != target)
2279 curr->gdb_service = gdb_service;
2280 head = head->next;
2281 }
2282 }
2283 return ret;
2284 }
2285
2286 static int gdb_target_add_one(struct target *target)
2287 {
2288 /* one gdb instance per smp list */
2289 if ((target->smp) && (target->gdb_service))
2290 return ERROR_OK;
2291 int retval = gdb_target_start(target, gdb_port_next);
2292 if (retval == ERROR_OK) {
2293 long portnumber;
2294 /* If we can parse the port number
2295 * then we increment the port number for the next target.
2296 */
2297 char *end;
2298 portnumber = strtol(gdb_port_next, &end, 0);
2299 if (!*end) {
2300 if (parse_long(gdb_port_next, &portnumber) == ERROR_OK) {
2301 free((void *)gdb_port_next);
2302 gdb_port_next = alloc_printf("%d", portnumber+1);
2303 }
2304 }
2305 }
2306 return retval;
2307 }
2308
2309 int gdb_target_add_all(struct target *target)
2310 {
2311 if (NULL == target) {
2312 LOG_WARNING("gdb services need one or more targets defined");
2313 return ERROR_OK;
2314 }
2315
2316 while (NULL != target) {
2317 int retval = gdb_target_add_one(target);
2318 if (ERROR_OK != retval)
2319 return retval;
2320
2321 target = target->next;
2322 }
2323
2324 return ERROR_OK;
2325 }
2326
2327 COMMAND_HANDLER(handle_gdb_sync_command)
2328 {
2329 if (CMD_ARGC != 0)
2330 return ERROR_COMMAND_SYNTAX_ERROR;
2331
2332 if (current_gdb_connection == NULL) {
2333 command_print(CMD_CTX,
2334 "gdb_sync command can only be run from within gdb using \"monitor gdb_sync\"");
2335 return ERROR_FAIL;
2336 }
2337
2338 current_gdb_connection->sync = true;
2339
2340 return ERROR_OK;
2341 }
2342
2343 /* daemon configuration command gdb_port */
2344 COMMAND_HANDLER(handle_gdb_port_command)
2345 {
2346 int retval = CALL_COMMAND_HANDLER(server_pipe_command, &gdb_port);
2347 if (ERROR_OK == retval) {
2348 free((void *)gdb_port_next);
2349 gdb_port_next = strdup(gdb_port);
2350 }
2351 return retval;
2352 }
2353
2354 COMMAND_HANDLER(handle_gdb_memory_map_command)
2355 {
2356 if (CMD_ARGC != 1)
2357 return ERROR_COMMAND_SYNTAX_ERROR;
2358
2359 COMMAND_PARSE_ENABLE(CMD_ARGV[0], gdb_use_memory_map);
2360 return ERROR_OK;
2361 }
2362
2363 COMMAND_HANDLER(handle_gdb_flash_program_command)
2364 {
2365 if (CMD_ARGC != 1)
2366 return ERROR_COMMAND_SYNTAX_ERROR;
2367
2368 COMMAND_PARSE_ENABLE(CMD_ARGV[0], gdb_flash_program);
2369 return ERROR_OK;
2370 }
2371
2372 COMMAND_HANDLER(handle_gdb_report_data_abort_command)
2373 {
2374 if (CMD_ARGC != 1)
2375 return ERROR_COMMAND_SYNTAX_ERROR;
2376
2377 COMMAND_PARSE_ENABLE(CMD_ARGV[0], gdb_report_data_abort);
2378 return ERROR_OK;
2379 }
2380
2381 /* gdb_breakpoint_override */
2382 COMMAND_HANDLER(handle_gdb_breakpoint_override_command)
2383 {
2384 if (CMD_ARGC == 0) {
2385 /* nothing */
2386 } else if (CMD_ARGC == 1) {
2387 gdb_breakpoint_override = 1;
2388 if (strcmp(CMD_ARGV[0], "hard") == 0)
2389 gdb_breakpoint_override_type = BKPT_HARD;
2390 else if (strcmp(CMD_ARGV[0], "soft") == 0)
2391 gdb_breakpoint_override_type = BKPT_SOFT;
2392 else if (strcmp(CMD_ARGV[0], "disable") == 0)
2393 gdb_breakpoint_override = 0;
2394 } else
2395 return ERROR_COMMAND_SYNTAX_ERROR;
2396 if (gdb_breakpoint_override)
2397 LOG_USER("force %s breakpoints",
2398 (gdb_breakpoint_override_type == BKPT_HARD) ? "hard" : "soft");
2399 else
2400 LOG_USER("breakpoint type is not overridden");
2401
2402 return ERROR_OK;
2403 }
2404
2405 static const struct command_registration gdb_command_handlers[] = {
2406 {
2407 .name = "gdb_sync",
2408 .handler = handle_gdb_sync_command,
2409 .mode = COMMAND_ANY,
2410 .help = "next stepi will return immediately allowing "
2411 "GDB to fetch register state without affecting "
2412 "target state",
2413 .usage = ""
2414 },
2415 {
2416 .name = "gdb_port",
2417 .handler = handle_gdb_port_command,
2418 .mode = COMMAND_ANY,
2419 .help = "Normally gdb listens to a TCP/IP port. Each subsequent GDB "
2420 "server listens for the next port number after the "
2421 "base port number specified. "
2422 "No arguments reports GDB port. \"pipe\" means listen to stdin "
2423 "output to stdout, an integer is base port number, \"disable\" disables "
2424 "port. Any other string is are interpreted as named pipe to listen to. "
2425 "Output pipe is the same name as input pipe, but with 'o' appended.",
2426 .usage = "[port_num]",
2427 },
2428 {
2429 .name = "gdb_memory_map",
2430 .handler = handle_gdb_memory_map_command,
2431 .mode = COMMAND_CONFIG,
2432 .help = "enable or disable memory map",
2433 .usage = "('enable'|'disable')"
2434 },
2435 {
2436 .name = "gdb_flash_program",
2437 .handler = handle_gdb_flash_program_command,
2438 .mode = COMMAND_CONFIG,
2439 .help = "enable or disable flash program",
2440 .usage = "('enable'|'disable')"
2441 },
2442 {
2443 .name = "gdb_report_data_abort",
2444 .handler = handle_gdb_report_data_abort_command,
2445 .mode = COMMAND_CONFIG,
2446 .help = "enable or disable reporting data aborts",
2447 .usage = "('enable'|'disable')"
2448 },
2449 {
2450 .name = "gdb_breakpoint_override",
2451 .handler = handle_gdb_breakpoint_override_command,
2452 .mode = COMMAND_ANY,
2453 .help = "Display or specify type of breakpoint "
2454 "to be used by gdb 'break' commands.",
2455 .usage = "('hard'|'soft'|'disable')"
2456 },
2457 COMMAND_REGISTRATION_DONE
2458 };
2459
2460 int gdb_register_commands(struct command_context *cmd_ctx)
2461 {
2462 gdb_port = strdup("3333");
2463 gdb_port_next = strdup("3333");
2464 return register_commands(cmd_ctx, NULL, gdb_command_handlers);
2465 }
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)