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