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