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