Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
Centralize error handling for buggy register handling
[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
399 /* we sent some data, reset timer for keep alive messages */
400 kept_alive();
401
402 return retval;
403 }
404
405 static __inline__ int fetch_packet(connection_t *connection, int *checksum_ok, int noack, int *len, char *buffer)
406 {
407 unsigned char my_checksum = 0;
408 char checksum[3];
409 int character;
410 int retval;
411
412 gdb_connection_t *gdb_con = connection->priv;
413 my_checksum = 0;
414 int count = 0;
415 count = 0;
416 for (;;)
417 {
418 /* The common case is that we have an entire packet with no escape chars.
419 * We need to leave at least 2 bytes in the buffer to have
420 * gdb_get_char() update various bits and bobs correctly.
421 */
422 if ((gdb_con->buf_cnt > 2) && ((gdb_con->buf_cnt+count) < *len))
423 {
424 /* The compiler will struggle a bit with constant propagation and
425 * aliasing, so we help it by showing that these values do not
426 * change inside the loop
427 */
428 int i;
429 char *buf = gdb_con->buf_p;
430 int run = gdb_con->buf_cnt - 2;
431 i = 0;
432 int done = 0;
433 while (i < run)
434 {
435 character = *buf++;
436 i++;
437 if (character == '#')
438 {
439 /* Danger! character can be '#' when esc is
440 * used so we need an explicit boolean for done here.
441 */
442 done = 1;
443 break;
444 }
445
446 if (character == '}')
447 {
448 /* data transmitted in binary mode (X packet)
449 * uses 0x7d as escape character */
450 my_checksum += character & 0xff;
451 character = *buf++;
452 i++;
453 my_checksum += character & 0xff;
454 buffer[count++] = (character ^ 0x20) & 0xff;
455 }
456 else
457 {
458 my_checksum += character & 0xff;
459 buffer[count++] = character & 0xff;
460 }
461 }
462 gdb_con->buf_p += i;
463 gdb_con->buf_cnt -= i;
464 if (done)
465 break;
466 }
467 if (count > *len)
468 {
469 LOG_ERROR("packet buffer too small");
470 return ERROR_GDB_BUFFER_TOO_SMALL;
471 }
472
473 if ((retval = gdb_get_char(connection, &character)) != ERROR_OK)
474 return retval;
475
476 if (character == '#')
477 break;
478
479 if (character == '}')
480 {
481 /* data transmitted in binary mode (X packet)
482 * uses 0x7d as escape character */
483 my_checksum += character & 0xff;
484 if ((retval = gdb_get_char(connection, &character)) != ERROR_OK)
485 return retval;
486 my_checksum += character & 0xff;
487 buffer[count++] = (character ^ 0x20) & 0xff;
488 }
489 else
490 {
491 my_checksum += character & 0xff;
492 buffer[count++] = character & 0xff;
493 }
494 }
495
496 *len = count;
497
498 if ((retval = gdb_get_char(connection, &character)) != ERROR_OK)
499 return retval;
500 checksum[0] = character;
501 if ((retval = gdb_get_char(connection, &character)) != ERROR_OK)
502 return retval;
503 checksum[1] = character;
504 checksum[2] = 0;
505
506 if (!noack)
507 {
508 *checksum_ok=(my_checksum == strtoul(checksum, NULL, 16));
509 }
510
511 return ERROR_OK;
512 }
513
514 int gdb_get_packet_inner(connection_t *connection, char *buffer, int *len)
515 {
516 int character;
517 int retval;
518 gdb_connection_t *gdb_con = connection->priv;
519
520 while (1)
521 {
522 do
523 {
524 if ((retval = gdb_get_char(connection, &character)) != ERROR_OK)
525 return retval;
526
527 #ifdef _DEBUG_GDB_IO_
528 LOG_DEBUG("character: '%c'", character);
529 #endif
530
531 switch (character)
532 {
533 case '$':
534 break;
535 case '+':
536 /* gdb sends a dummy ack '+' at every remote connect - see remote_start_remote (remote.c)
537 * incase anyone tries to debug why they receive this warning every time */
538 LOG_WARNING("acknowledgment received, but no packet pending");
539 break;
540 case '-':
541 LOG_WARNING("negative acknowledgment, but no packet pending");
542 break;
543 case 0x3:
544 gdb_con->ctrl_c = 1;
545 *len = 0;
546 return ERROR_OK;
547 default:
548 LOG_WARNING("ignoring character 0x%x", character);
549 break;
550 }
551 } while (character != '$');
552
553
554
555 int checksum_ok;
556 /* explicit code expansion here to get faster inlined code in -O3 by not
557 * calculating checksum
558 */
559 if (gdb_con->noack_mode)
560 {
561 if ((retval=fetch_packet(connection, &checksum_ok, 1, len, buffer))!=ERROR_OK)
562 return retval;
563 } else
564 {
565 if ((retval=fetch_packet(connection, &checksum_ok, 0, len, buffer))!=ERROR_OK)
566 return retval;
567 }
568
569 if (gdb_con->noack_mode)
570 {
571 /* checksum is not checked in noack mode */
572 break;
573 }
574 if (checksum_ok)
575 {
576 gdb_write(connection, "+", 1);
577 break;
578 }
579 }
580 if (gdb_con->closed)
581 return ERROR_SERVER_REMOTE_CLOSED;
582
583 return ERROR_OK;
584 }
585
586 int gdb_get_packet(connection_t *connection, char *buffer, int *len)
587 {
588 gdb_connection_t *gdb_con = connection->priv;
589 gdb_con->busy = 1;
590 int retval = gdb_get_packet_inner(connection, buffer, len);
591 gdb_con->busy = 0;
592 return retval;
593 }
594
595 int gdb_output_con(connection_t *connection, const char* line)
596 {
597 char *hex_buffer;
598 int i, bin_size;
599
600 bin_size = strlen(line);
601
602 hex_buffer = malloc(bin_size*2 + 2);
603 if (hex_buffer == NULL)
604 return ERROR_GDB_BUFFER_TOO_SMALL;
605
606 hex_buffer[0] = 'O';
607 for (i=0; i<bin_size; i++)
608 snprintf(hex_buffer + 1 + i*2, 3, "%2.2x", line[i]);
609 hex_buffer[bin_size*2+1] = 0;
610
611 gdb_put_packet(connection, hex_buffer, bin_size*2 + 1);
612
613 free(hex_buffer);
614 return ERROR_OK;
615 }
616
617 int gdb_output(struct command_context_s *context, const char* line)
618 {
619 /* this will be dumped to the log and also sent as an O packet if possible */
620 LOG_USER_N("%s", line);
621 return ERROR_OK;
622 }
623
624
625 static void gdb_frontend_halted(struct target_s *target, connection_t *connection)
626 {
627 gdb_connection_t *gdb_connection = connection->priv;
628
629 /* In the GDB protocol when we are stepping or coninuing execution,
630 * we have a lingering reply. Upon receiving a halted event
631 * when we have that lingering packet, we reply to the original
632 * step or continue packet.
633 *
634 * Executing monitor commands can bring the target in and
635 * out of the running state so we'll see lots of TARGET_EVENT_XXX
636 * that are to be ignored.
637 */
638 if (gdb_connection->frontend_state == TARGET_RUNNING)
639 {
640 char sig_reply[4];
641 int signal;
642 /* stop forwarding log packets! */
643 log_remove_callback(gdb_log_callback, connection);
644
645 if (gdb_connection->ctrl_c)
646 {
647 signal = 0x2;
648 gdb_connection->ctrl_c = 0;
649 }
650 else
651 {
652 signal = gdb_last_signal(target);
653 }
654
655 snprintf(sig_reply, 4, "T%2.2x", signal);
656 gdb_put_packet(connection, sig_reply, 3);
657 gdb_connection->frontend_state = TARGET_HALTED;
658 }
659 }
660
661 int gdb_target_callback_event_handler(struct target_s *target, enum target_event event, void *priv)
662 {
663 connection_t *connection = priv;
664
665 target_handle_event( target, event );
666 switch (event)
667 {
668 case TARGET_EVENT_EARLY_HALTED:
669 gdb_frontend_halted(target, connection);
670 break;
671 case TARGET_EVENT_GDB_FLASH_ERASE_START:
672 target_handle_event( target, TARGET_EVENT_OLD_gdb_program_config );
673 jtag_execute_queue();
674 break;
675 default:
676 break;
677 }
678
679 return ERROR_OK;
680 }
681
682
683 int gdb_new_connection(connection_t *connection)
684 {
685 gdb_connection_t *gdb_connection = malloc(sizeof(gdb_connection_t));
686 gdb_service_t *gdb_service = connection->service->priv;
687 int retval;
688 int initial_ack;
689
690 connection->priv = gdb_connection;
691
692 /* initialize gdb connection information */
693 gdb_connection->buf_p = gdb_connection->buffer;
694 gdb_connection->buf_cnt = 0;
695 gdb_connection->ctrl_c = 0;
696 gdb_connection->frontend_state = TARGET_HALTED;
697 gdb_connection->vflash_image = NULL;
698 gdb_connection->closed = 0;
699 gdb_connection->busy = 0;
700 gdb_connection->noack_mode = 0;
701
702 /* send ACK to GDB for debug request */
703 gdb_write(connection, "+", 1);
704
705 /* output goes through gdb connection */
706 command_set_output_handler(connection->cmd_ctx, gdb_output, connection);
707
708 /* we must remove all breakpoints registered to the target as a previous
709 * GDB session could leave dangling breakpoints if e.g. communication
710 * timed out.
711 */
712 breakpoint_clear_target(gdb_service->target);
713 watchpoint_clear_target(gdb_service->target);
714
715 /* register callback to be informed about target events */
716 target_register_event_callback(gdb_target_callback_event_handler, connection);
717
718 /* a gdb session just attached, try to put the target in halt mode.
719 *
720 * DANGER!!!!
721 *
722 * If the halt fails(e.g. target needs a reset, JTAG communication not
723 * working, etc.), then the GDB connect will succeed as
724 * the get_gdb_reg_list() will lie and return a register list with
725 * dummy values.
726 *
727 * This allows GDB monitor commands to be run from a GDB init script to
728 * initialize the target
729 *
730 * Also, since the halt() is asynchronous target connect will be
731 * instantaneous and thus avoiding annoying timeout problems during
732 * connect.
733 */
734 target_halt(gdb_service->target);
735 /* FIX!!!! could extended-remote work better here?
736 *
737 * wait a tiny bit for halted state or we just continue. The
738 * GDB register packet will then contain garbage
739 */
740 target_wait_state(gdb_service->target, TARGET_HALTED, 500);
741
742 /* remove the initial ACK from the incoming buffer */
743 if ((retval = gdb_get_char(connection, &initial_ack)) != ERROR_OK)
744 return retval;
745
746 /* FIX!!!??? would we actually ever receive a + here???
747 * Not observed.
748 */
749 if (initial_ack != '+')
750 gdb_putback_char(connection, initial_ack);
751 target_call_event_callbacks(gdb_service->target, TARGET_EVENT_GDB_ATTACH );
752 return ERROR_OK;
753 }
754
755 int gdb_connection_closed(connection_t *connection)
756 {
757 gdb_service_t *gdb_service = connection->service->priv;
758 gdb_connection_t *gdb_connection = connection->priv;
759
760 /* see if an image built with vFlash commands is left */
761 if (gdb_connection->vflash_image)
762 {
763 image_close(gdb_connection->vflash_image);
764 free(gdb_connection->vflash_image);
765 gdb_connection->vflash_image = NULL;
766 }
767
768 /* if this connection registered a debug-message receiver delete it */
769 delete_debug_msg_receiver(connection->cmd_ctx, gdb_service->target);
770
771 if (connection->priv)
772 {
773 free(connection->priv);
774 connection->priv = NULL;
775 }
776 else
777 {
778 LOG_ERROR("BUG: connection->priv == NULL");
779 }
780
781 target_unregister_event_callback(gdb_target_callback_event_handler, connection);
782 log_remove_callback(gdb_log_callback, connection);
783
784 target_call_event_callbacks(gdb_service->target, TARGET_EVENT_GDB_DETACH );
785 return ERROR_OK;
786 }
787
788 void gdb_send_error(connection_t *connection, u8 the_error)
789 {
790 char err[4];
791 snprintf(err, 4, "E%2.2X", the_error );
792 gdb_put_packet(connection, err, 3);
793 }
794
795 int gdb_last_signal_packet(connection_t *connection, target_t *target, char* packet, int packet_size)
796 {
797 char sig_reply[4];
798 int signal;
799
800 signal = gdb_last_signal(target);
801
802 snprintf(sig_reply, 4, "S%2.2x", signal);
803 gdb_put_packet(connection, sig_reply, 3);
804
805 return ERROR_OK;
806 }
807
808 /* Convert register to string of bits. NB! The # of bits in the
809 * register might be non-divisible by 8(a byte), in which
810 * case an entire byte is shown. */
811 void gdb_str_to_target(target_t *target, char *tstr, reg_t *reg)
812 {
813 int i;
814
815 u8 *buf;
816 int buf_len;
817 buf = reg->value;
818 buf_len = CEIL(reg->size, 8);
819
820 for (i = 0; i < buf_len; i++)
821 {
822 tstr[i*2] = DIGITS[(buf[i]>>4) & 0xf];
823 tstr[i*2+1] = DIGITS[buf[i]&0xf];
824 }
825 }
826
827 void gdb_target_to_str(target_t *target, char *tstr, char *str)
828 {
829 int str_len = strlen(tstr);
830 int i;
831
832 if (str_len % 2)
833 {
834 LOG_ERROR("BUG: gdb value with uneven number of characters encountered");
835 exit(-1);
836 }
837
838 for (i = 0; i < str_len; i+=2)
839 {
840 str[str_len - i - 1] = tstr[i + 1];
841 str[str_len - i - 2] = tstr[i];
842 }
843 }
844
845 int gdb_get_registers_packet(connection_t *connection, target_t *target, char* packet, int packet_size)
846 {
847 reg_t **reg_list;
848 int reg_list_size;
849 int retval;
850 int reg_packet_size = 0;
851 char *reg_packet;
852 char *reg_packet_p;
853 int i;
854
855 #ifdef _DEBUG_GDB_IO_
856 LOG_DEBUG("-");
857 #endif
858
859 if ((retval = target->type->get_gdb_reg_list(target, &reg_list, &reg_list_size)) != ERROR_OK)
860 {
861 return gdb_error(connection, retval);
862 }
863
864 for (i = 0; i < reg_list_size; i++)
865 {
866 reg_packet_size += reg_list[i]->size;
867 }
868
869 reg_packet = malloc(CEIL(reg_packet_size, 8) * 2);
870 reg_packet_p = reg_packet;
871
872 for (i = 0; i < reg_list_size; i++)
873 {
874 gdb_str_to_target(target, reg_packet_p, reg_list[i]);
875 reg_packet_p += CEIL(reg_list[i]->size, 8) * 2;
876 }
877
878 #ifdef _DEBUG_GDB_IO_
879 {
880 char *reg_packet_p;
881 reg_packet_p = strndup(reg_packet, CEIL(reg_packet_size, 8) * 2);
882 LOG_DEBUG("reg_packet: %s", reg_packet_p);
883 free(reg_packet_p);
884 }
885 #endif
886
887 gdb_put_packet(connection, reg_packet, CEIL(reg_packet_size, 8) * 2);
888 free(reg_packet);
889
890 free(reg_list);
891
892 return ERROR_OK;
893 }
894
895 int gdb_set_registers_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
896 {
897 int i;
898 reg_t **reg_list;
899 int reg_list_size;
900 int retval;
901 char *packet_p;
902
903 #ifdef _DEBUG_GDB_IO_
904 LOG_DEBUG("-");
905 #endif
906
907 /* skip command character */
908 packet++;
909 packet_size--;
910
911 if (packet_size % 2)
912 {
913 LOG_WARNING("GDB set_registers packet with uneven characters received, dropping connection");
914 return ERROR_SERVER_REMOTE_CLOSED;
915 }
916
917 if ((retval = target->type->get_gdb_reg_list(target, &reg_list, &reg_list_size)) != ERROR_OK)
918 {
919 return gdb_error(connection, retval);
920 }
921
922 packet_p = packet;
923 for (i = 0; i < reg_list_size; i++)
924 {
925 u8 *bin_buf;
926 char *hex_buf;
927 reg_arch_type_t *arch_type;
928
929 /* convert from GDB-string (target-endian) to hex-string (big-endian) */
930 hex_buf = malloc(CEIL(reg_list[i]->size, 8) * 2);
931 gdb_target_to_str(target, packet_p, hex_buf);
932
933 /* convert hex-string to binary buffer */
934 bin_buf = malloc(CEIL(reg_list[i]->size, 8));
935 str_to_buf(hex_buf, CEIL(reg_list[i]->size, 8) * 2, bin_buf, reg_list[i]->size, 16);
936
937 /* get register arch_type, and call set method */
938 arch_type = register_get_arch_type(reg_list[i]->arch_type);
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 arch_type->set(reg_list[reg_num], bin_buf);
1033
1034 gdb_put_packet(connection, "OK", 2);
1035
1036 free(bin_buf);
1037 free(hex_buf);
1038 free(reg_list);
1039
1040 return ERROR_OK;
1041 }
1042
1043 int gdb_error(connection_t *connection, int retval)
1044 {
1045 switch (retval)
1046 {
1047 case ERROR_TARGET_DATA_ABORT:
1048 gdb_send_error(connection, EIO);
1049 break;
1050 case ERROR_TARGET_TRANSLATION_FAULT:
1051 gdb_send_error(connection, EFAULT);
1052 break;
1053 case ERROR_TARGET_UNALIGNED_ACCESS:
1054 gdb_send_error(connection, EFAULT);
1055 break;
1056 case ERROR_TARGET_NOT_HALTED:
1057 gdb_send_error(connection, EFAULT);
1058 break;
1059 default:
1060 /* This could be that the target reset itself. */
1061 LOG_ERROR("unexpected error %i", retval);
1062 gdb_send_error(connection, EFAULT);
1063 break;
1064 }
1065
1066 return ERROR_OK;
1067 }
1068
1069 /* We don't have to worry about the default 2 second timeout for GDB packets,
1070 * because GDB breaks up large memory reads into smaller reads.
1071 *
1072 * 8191 bytes by the looks of it. Why 8191 bytes instead of 8192?????
1073 */
1074 int gdb_read_memory_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
1075 {
1076 char *separator;
1077 u32 addr = 0;
1078 u32 len = 0;
1079
1080 u8 *buffer;
1081 char *hex_buffer;
1082
1083 int retval = ERROR_OK;
1084
1085 /* skip command character */
1086 packet++;
1087
1088 addr = strtoul(packet, &separator, 16);
1089
1090 if (*separator != ',')
1091 {
1092 LOG_ERROR("incomplete read memory packet received, dropping connection");
1093 return ERROR_SERVER_REMOTE_CLOSED;
1094 }
1095
1096 len = strtoul(separator+1, NULL, 16);
1097
1098 buffer = malloc(len);
1099
1100 LOG_DEBUG("addr: 0x%8.8x, len: 0x%8.8x", addr, len);
1101
1102 retval = target_read_buffer(target, addr, len, buffer);
1103
1104 if ((retval == ERROR_TARGET_DATA_ABORT) && (!gdb_report_data_abort))
1105 {
1106 /* TODO : Here we have to lie and send back all zero's lest stack traces won't work.
1107 * At some point this might be fixed in GDB, in which case this code can be removed.
1108 *
1109 * OpenOCD developers are acutely aware of this problem, but there is nothing
1110 * gained by involving the user in this problem that hopefully will get resolved
1111 * eventually
1112 *
1113 * http://sourceware.org/cgi-bin/gnatsweb.pl?cmd=view%20audit-trail&database=gdb&pr=2395
1114 *
1115 * For now, the default is to fix up things to make current GDB versions work.
1116 * This can be overwritten using the gdb_report_data_abort <'enable'|'disable'> command.
1117 */
1118 memset(buffer, 0, len);
1119 retval = ERROR_OK;
1120 }
1121
1122 if (retval == ERROR_OK)
1123 {
1124 hex_buffer = malloc(len * 2 + 1);
1125
1126 int i;
1127 for (i = 0; i < len; i++)
1128 {
1129 u8 t = buffer[i];
1130 hex_buffer[2 * i] = DIGITS[(t >> 4) & 0xf];
1131 hex_buffer[2 * i + 1] = DIGITS[t & 0xf];
1132 }
1133
1134 gdb_put_packet(connection, hex_buffer, len * 2);
1135
1136 free(hex_buffer);
1137 }
1138 else
1139 {
1140 retval = gdb_error(connection, retval);
1141 }
1142
1143 free(buffer);
1144
1145 return retval;
1146 }
1147
1148 int gdb_write_memory_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
1149 {
1150 char *separator;
1151 u32 addr = 0;
1152 u32 len = 0;
1153
1154 u8 *buffer;
1155
1156 int i;
1157 int retval;
1158
1159 /* skip command character */
1160 packet++;
1161
1162 addr = strtoul(packet, &separator, 16);
1163
1164 if (*separator != ',')
1165 {
1166 LOG_ERROR("incomplete write memory packet received, dropping connection");
1167 return ERROR_SERVER_REMOTE_CLOSED;
1168 }
1169
1170 len = strtoul(separator+1, &separator, 16);
1171
1172 if (*(separator++) != ':')
1173 {
1174 LOG_ERROR("incomplete write memory packet received, dropping connection");
1175 return ERROR_SERVER_REMOTE_CLOSED;
1176 }
1177
1178 buffer = malloc(len);
1179
1180 LOG_DEBUG("addr: 0x%8.8x, len: 0x%8.8x", addr, len);
1181
1182 for (i=0; i<len; i++)
1183 {
1184 u32 tmp;
1185 sscanf(separator + 2*i, "%2x", &tmp);
1186 buffer[i] = tmp;
1187 }
1188
1189 retval = target_write_buffer(target, addr, len, buffer);
1190
1191 if (retval == ERROR_OK)
1192 {
1193 gdb_put_packet(connection, "OK", 2);
1194 }
1195 else
1196 {
1197 retval = gdb_error(connection, retval);
1198 }
1199
1200 free(buffer);
1201
1202 return retval;
1203 }
1204
1205 int gdb_write_memory_binary_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
1206 {
1207 char *separator;
1208 u32 addr = 0;
1209 u32 len = 0;
1210
1211 int retval;
1212
1213 /* skip command character */
1214 packet++;
1215
1216 addr = strtoul(packet, &separator, 16);
1217
1218 if (*separator != ',')
1219 {
1220 LOG_ERROR("incomplete write memory binary packet received, dropping connection");
1221 return ERROR_SERVER_REMOTE_CLOSED;
1222 }
1223
1224 len = strtoul(separator+1, &separator, 16);
1225
1226 if (*(separator++) != ':')
1227 {
1228 LOG_ERROR("incomplete write memory binary packet received, dropping connection");
1229 return ERROR_SERVER_REMOTE_CLOSED;
1230 }
1231
1232 retval = ERROR_OK;
1233 if (len)
1234 {
1235 LOG_DEBUG("addr: 0x%8.8x, len: 0x%8.8x", addr, len);
1236
1237 retval = target_write_buffer(target, addr, len, (u8*)separator);
1238 }
1239
1240 if (retval == ERROR_OK)
1241 {
1242 gdb_put_packet(connection, "OK", 2);
1243 }
1244 else
1245 {
1246 if ((retval = gdb_error(connection, retval)) != ERROR_OK)
1247 return retval;
1248 }
1249
1250 return ERROR_OK;
1251 }
1252
1253 int gdb_step_continue_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
1254 {
1255 int current = 0;
1256 u32 address = 0x0;
1257 int retval=ERROR_OK;
1258
1259 LOG_DEBUG("-");
1260
1261 if (packet_size > 1)
1262 {
1263 packet[packet_size] = 0;
1264 address = strtoul(packet + 1, NULL, 16);
1265 }
1266 else
1267 {
1268 current = 1;
1269 }
1270
1271 if (packet[0] == 'c')
1272 {
1273 LOG_DEBUG("continue");
1274 target_handle_event( target, TARGET_EVENT_OLD_pre_resume );
1275 retval=target_resume(target, current, address, 0, 0); /* resume at current address, don't handle breakpoints, not debugging */
1276 }
1277 else if (packet[0] == 's')
1278 {
1279 LOG_DEBUG("step");
1280 retval=target->type->step(target, current, address, 0); /* step at current or address, don't handle breakpoints */
1281 }
1282 return retval;
1283 }
1284
1285 int gdb_breakpoint_watchpoint_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
1286 {
1287 int type;
1288 enum breakpoint_type bp_type = BKPT_SOFT /* dummy init to avoid warning */;
1289 enum watchpoint_rw wp_type;
1290 u32 address;
1291 u32 size;
1292 char *separator;
1293 int retval;
1294
1295 LOG_DEBUG("-");
1296
1297 type = strtoul(packet + 1, &separator, 16);
1298
1299 if (type == 0) /* memory breakpoint */
1300 bp_type = BKPT_SOFT;
1301 else if (type == 1) /* hardware breakpoint */
1302 bp_type = BKPT_HARD;
1303 else if (type == 2) /* write watchpoint */
1304 wp_type = WPT_WRITE;
1305 else if (type == 3) /* read watchpoint */
1306 wp_type = WPT_READ;
1307 else if (type == 4) /* access watchpoint */
1308 wp_type = WPT_ACCESS;
1309
1310 if (gdb_breakpoint_override&&((bp_type==BKPT_SOFT)||(bp_type==BKPT_HARD)))
1311 {
1312 bp_type=gdb_breakpoint_override_type;
1313 }
1314
1315 if (*separator != ',')
1316 {
1317 LOG_ERROR("incomplete breakpoint/watchpoint packet received, dropping connection");
1318 return ERROR_SERVER_REMOTE_CLOSED;
1319 }
1320
1321 address = strtoul(separator+1, &separator, 16);
1322
1323 if (*separator != ',')
1324 {
1325 LOG_ERROR("incomplete breakpoint/watchpoint packet received, dropping connection");
1326 return ERROR_SERVER_REMOTE_CLOSED;
1327 }
1328
1329 size = strtoul(separator+1, &separator, 16);
1330
1331 switch (type)
1332 {
1333 case 0:
1334 case 1:
1335 if (packet[0] == 'Z')
1336 {
1337 if ((retval = breakpoint_add(target, address, size, bp_type)) != ERROR_OK)
1338 {
1339 if ((retval = gdb_error(connection, retval)) != ERROR_OK)
1340 return retval;
1341 }
1342 else
1343 {
1344 gdb_put_packet(connection, "OK", 2);
1345 }
1346 }
1347 else
1348 {
1349 breakpoint_remove(target, address);
1350 gdb_put_packet(connection, "OK", 2);
1351 }
1352 break;
1353 case 2:
1354 case 3:
1355 case 4:
1356 {
1357 if (packet[0] == 'Z')
1358 {
1359 if ((retval = watchpoint_add(target, address, size, type-2, 0, 0xffffffffu)) != ERROR_OK)
1360 {
1361 if ((retval = gdb_error(connection, retval)) != ERROR_OK)
1362 return retval;
1363 }
1364 else
1365 {
1366 gdb_put_packet(connection, "OK", 2);
1367 }
1368 }
1369 else
1370 {
1371 watchpoint_remove(target, address);
1372 gdb_put_packet(connection, "OK", 2);
1373 }
1374 break;
1375 }
1376 default:
1377 break;
1378 }
1379
1380 return ERROR_OK;
1381 }
1382
1383 /* print out a string and allocate more space as needed, mainly used for XML at this point */
1384 void xml_printf(int *retval, char **xml, int *pos, int *size, const char *fmt, ...)
1385 {
1386 if (*retval != ERROR_OK)
1387 {
1388 return;
1389 }
1390 int first = 1;
1391
1392 for (;;)
1393 {
1394 if ((*xml == NULL) || (!first))
1395 {
1396 /* start by 0 to exercise all the code paths.
1397 * Need minimum 2 bytes to fit 1 char and 0 terminator. */
1398
1399 *size = *size * 2 + 2;
1400 char *t = *xml;
1401 *xml = realloc(*xml, *size);
1402 if (*xml == NULL)
1403 {
1404 if (t)
1405 free(t);
1406 *retval = ERROR_SERVER_REMOTE_CLOSED;
1407 return;
1408 }
1409 }
1410
1411 va_list ap;
1412 int ret;
1413 va_start(ap, fmt);
1414 ret = vsnprintf(*xml + *pos, *size - *pos, fmt, ap);
1415 va_end(ap);
1416 if ((ret > 0) && ((ret + 1) < *size - *pos))
1417 {
1418 *pos += ret;
1419 return;
1420 }
1421 /* there was just enough or not enough space, allocate more. */
1422 first = 0;
1423 }
1424 }
1425
1426 static int decode_xfer_read(char *buf, char **annex, int *ofs, unsigned int *len)
1427 {
1428 char *separator;
1429
1430 /* Extract and NUL-terminate the annex. */
1431 *annex = buf;
1432 while (*buf && *buf != ':')
1433 buf++;
1434 if (*buf == '\0')
1435 return -1;
1436 *buf++ = 0;
1437
1438 /* After the read marker and annex, qXfer looks like a
1439 * traditional 'm' packet. */
1440
1441 *ofs = strtoul(buf, &separator, 16);
1442
1443 if (*separator != ',')
1444 return -1;
1445
1446 *len = strtoul(separator+1, NULL, 16);
1447
1448 return 0;
1449 }
1450
1451 int gdb_calc_blocksize(flash_bank_t *bank)
1452 {
1453 int i;
1454 int block_size = 0xffffffff;
1455
1456 /* loop through all sectors and return smallest sector size */
1457
1458 for (i = 0; i < bank->num_sectors; i++)
1459 {
1460 if (bank->sectors[i].size < block_size)
1461 block_size = bank->sectors[i].size;
1462 }
1463
1464 return block_size;
1465 }
1466
1467 static int compare_bank (const void * a, const void * b)
1468 {
1469 flash_bank_t *b1, *b2;
1470 b1=*((flash_bank_t **)a);
1471 b2=*((flash_bank_t **)b);
1472
1473 if (b1->base==b2->base)
1474 {
1475 return 0;
1476 } else if (b1->base>b2->base)
1477 {
1478 return 1;
1479 } else
1480 {
1481 return -1;
1482 }
1483 }
1484
1485 int gdb_query_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
1486 {
1487 command_context_t *cmd_ctx = connection->cmd_ctx;
1488 gdb_connection_t *gdb_connection = connection->priv;
1489
1490 if (strstr(packet, "qRcmd,"))
1491 {
1492 if (packet_size > 6)
1493 {
1494 char *cmd;
1495 int i;
1496 cmd = malloc((packet_size - 6)/2 + 1);
1497 for (i=0; i < (packet_size - 6)/2; i++)
1498 {
1499 u32 tmp;
1500 sscanf(packet + 6 + 2*i, "%2x", &tmp);
1501 cmd[i] = tmp;
1502 }
1503 cmd[(packet_size - 6)/2] = 0x0;
1504
1505 /* We want to print all debug output to GDB connection */
1506 log_add_callback(gdb_log_callback, connection);
1507 target_call_timer_callbacks_now();
1508 command_run_line(cmd_ctx, cmd);
1509 target_call_timer_callbacks_now();
1510 log_remove_callback(gdb_log_callback, connection);
1511 free(cmd);
1512 }
1513 gdb_put_packet(connection, "OK", 2);
1514 return ERROR_OK;
1515 }
1516 else if (strstr(packet, "qCRC:"))
1517 {
1518 if (packet_size > 5)
1519 {
1520 int retval;
1521 char gdb_reply[10];
1522 char *separator;
1523 u32 checksum;
1524 u32 addr = 0;
1525 u32 len = 0;
1526
1527 /* skip command character */
1528 packet += 5;
1529
1530 addr = strtoul(packet, &separator, 16);
1531
1532 if (*separator != ',')
1533 {
1534 LOG_ERROR("incomplete read memory packet received, dropping connection");
1535 return ERROR_SERVER_REMOTE_CLOSED;
1536 }
1537
1538 len = strtoul(separator + 1, NULL, 16);
1539
1540 retval = target_checksum_memory(target, addr, len, &checksum);
1541
1542 if (retval == ERROR_OK)
1543 {
1544 snprintf(gdb_reply, 10, "C%8.8x", checksum);
1545 gdb_put_packet(connection, gdb_reply, 9);
1546 }
1547 else
1548 {
1549 if ((retval = gdb_error(connection, retval)) != ERROR_OK)
1550 return retval;
1551 }
1552
1553 return ERROR_OK;
1554 }
1555 }
1556 else if (strstr(packet, "qSupported"))
1557 {
1558 /* we currently support packet size and qXfer:memory-map:read (if enabled)
1559 * disable qXfer:features:read for the moment */
1560 int retval = ERROR_OK;
1561 char *buffer = NULL;
1562 int pos = 0;
1563 int size = 0;
1564
1565 xml_printf(&retval, &buffer, &pos, &size,
1566 "PacketSize=%x;qXfer:memory-map:read%c;qXfer:features:read-;QStartNoAckMode+",
1567 (GDB_BUFFER_SIZE - 1), ((gdb_use_memory_map == 1)&&(flash_get_bank_count()>0)) ? '+' : '-');
1568
1569 if (retval != ERROR_OK)
1570 {
1571 gdb_send_error(connection, 01);
1572 return ERROR_OK;
1573 }
1574
1575 gdb_put_packet(connection, buffer, strlen(buffer));
1576 free(buffer);
1577
1578 return ERROR_OK;
1579 }
1580 else if (strstr(packet, "qXfer:memory-map:read::")&&(flash_get_bank_count()>0))
1581 {
1582 /* We get away with only specifying flash here. Regions that are not
1583 * specified are treated as if we provided no memory map(if not we
1584 * could detect the holes and mark them as RAM).
1585 * Normally we only execute this code once, but no big deal if we
1586 * have to regenerate it a couple of times. */
1587
1588 flash_bank_t *p;
1589 char *xml = NULL;
1590 int size = 0;
1591 int pos = 0;
1592 int retval = ERROR_OK;
1593
1594 int offset;
1595 int length;
1596 char *separator;
1597 int blocksize;
1598
1599 /* skip command character */
1600 packet += 23;
1601
1602 offset = strtoul(packet, &separator, 16);
1603 length = strtoul(separator + 1, &separator, 16);
1604
1605 xml_printf(&retval, &xml, &pos, &size, "<memory-map>\n");
1606
1607 /*
1608 sort banks in ascending order, we need to make non-flash memory be ram(or rather
1609 read/write) by default for GDB.
1610 GDB does not have a concept of non-cacheable read/write memory.
1611 */
1612 flash_bank_t **banks=malloc(sizeof(flash_bank_t *)*flash_get_bank_count());
1613 int i;
1614
1615 for (i=0; i<flash_get_bank_count(); i++)
1616 {
1617 p = get_flash_bank_by_num(i);
1618 if (p == NULL)
1619 {
1620 free(banks);
1621 retval = ERROR_FAIL;
1622 gdb_send_error(connection, retval);
1623 return retval;
1624 }
1625 banks[i]=p;
1626 }
1627
1628 qsort(banks, flash_get_bank_count(), sizeof(flash_bank_t *), compare_bank);
1629
1630 u32 ram_start=0;
1631 for (i=0; i<flash_get_bank_count(); i++)
1632 {
1633 p = banks[i];
1634
1635 if (ram_start<p->base)
1636 {
1637 xml_printf(&retval, &xml, &pos, &size, "<memory type=\"ram\" start=\"0x%x\" length=\"0x%x\"/>\n",
1638 ram_start, p->base-ram_start);
1639 }
1640
1641 /* if device has uneven sector sizes, eg. str7, lpc
1642 * we pass the smallest sector size to gdb memory map */
1643 blocksize = gdb_calc_blocksize(p);
1644
1645 xml_printf(&retval, &xml, &pos, &size, "<memory type=\"flash\" start=\"0x%x\" length=\"0x%x\">\n" \
1646 "<property name=\"blocksize\">0x%x</property>\n" \
1647 "</memory>\n", \
1648 p->base, p->size, blocksize);
1649 ram_start=p->base+p->size;
1650 }
1651 if (ram_start!=0)
1652 {
1653 xml_printf(&retval, &xml, &pos, &size, "<memory type=\"ram\" start=\"0x%x\" length=\"0x%x\"/>\n",
1654 ram_start, 0-ram_start);
1655 } else
1656 {
1657 /* a flash chip could be at the very end of the 32 bit address space, in which case
1658 ram_start will be precisely 0 */
1659 }
1660
1661 free(banks);
1662 banks = NULL;
1663
1664 xml_printf(&retval, &xml, &pos, &size, "</memory-map>\n");
1665
1666 if (retval != ERROR_OK)
1667 {
1668 gdb_send_error(connection, retval);
1669 return retval;
1670 }
1671
1672 if (offset + length > pos)
1673 {
1674 length = pos - offset;
1675 }
1676
1677 char *t = malloc(length + 1);
1678 t[0] = 'l';
1679 memcpy(t + 1, xml + offset, length);
1680 gdb_put_packet(connection, t, length + 1);
1681
1682 free(t);
1683 free(xml);
1684 return ERROR_OK;
1685 }
1686 else if (strstr(packet, "qXfer:features:read:"))
1687 {
1688 char *xml = NULL;
1689 int size = 0;
1690 int pos = 0;
1691 int retval = ERROR_OK;
1692
1693 int offset;
1694 unsigned int length;
1695 char *annex;
1696
1697 /* skip command character */
1698 packet += 20;
1699
1700 if (decode_xfer_read(packet, &annex, &offset, &length) < 0)
1701 {
1702 gdb_send_error(connection, 01);
1703 return ERROR_OK;
1704 }
1705
1706 if (strcmp(annex, "target.xml") != 0)
1707 {
1708 gdb_send_error(connection, 01);
1709 return ERROR_OK;
1710 }
1711
1712 xml_printf(&retval, &xml, &pos, &size, \
1713 "l<target version=\"1.0\">\n<architecture>arm</architecture>\n</target>\n");
1714
1715 if (retval != ERROR_OK)
1716 {
1717 gdb_send_error(connection, retval);
1718 return retval;
1719 }
1720
1721 gdb_put_packet(connection, xml, strlen(xml));
1722
1723 free(xml);
1724 return ERROR_OK;
1725 }
1726 else if (strstr(packet, "QStartNoAckMode"))
1727 {
1728 gdb_connection->noack_mode = 1;
1729 gdb_put_packet(connection, "OK", 2);
1730 return ERROR_OK;
1731 }
1732
1733 gdb_put_packet(connection, "", 0);
1734 return ERROR_OK;
1735 }
1736
1737 int gdb_v_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
1738 {
1739 gdb_connection_t *gdb_connection = connection->priv;
1740 gdb_service_t *gdb_service = connection->service->priv;
1741 int result;
1742
1743 /* if flash programming disabled - send a empty reply */
1744
1745 if (gdb_flash_program == 0)
1746 {
1747 gdb_put_packet(connection, "", 0);
1748 return ERROR_OK;
1749 }
1750
1751 if (strstr(packet, "vFlashErase:"))
1752 {
1753 unsigned long addr;
1754 unsigned long length;
1755
1756 char *parse = packet + 12;
1757 if (*parse == '\0')
1758 {
1759 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1760 return ERROR_SERVER_REMOTE_CLOSED;
1761 }
1762
1763 addr = strtoul(parse, &parse, 16);
1764
1765 if (*(parse++) != ',' || *parse == '\0')
1766 {
1767 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1768 return ERROR_SERVER_REMOTE_CLOSED;
1769 }
1770
1771 length = strtoul(parse, &parse, 16);
1772
1773 if (*parse != '\0')
1774 {
1775 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1776 return ERROR_SERVER_REMOTE_CLOSED;
1777 }
1778
1779 /* assume all sectors need erasing - stops any problems
1780 * when flash_write is called multiple times */
1781 flash_set_dirty();
1782
1783 /* perform any target specific operations before the erase */
1784 target_call_event_callbacks(gdb_service->target, TARGET_EVENT_GDB_FLASH_ERASE_START);
1785 result = flash_erase_address_range(gdb_service->target, addr, length );
1786 target_call_event_callbacks(gdb_service->target, TARGET_EVENT_GDB_FLASH_ERASE_END);
1787
1788 /* perform erase */
1789 if (result != ERROR_OK)
1790 {
1791 /* GDB doesn't evaluate the actual error number returned,
1792 * treat a failed erase as an I/O error
1793 */
1794 gdb_send_error(connection, EIO);
1795 LOG_ERROR("flash_erase returned %i", result);
1796 }
1797 else
1798 gdb_put_packet(connection, "OK", 2);
1799
1800 return ERROR_OK;
1801 }
1802
1803 if (strstr(packet, "vFlashWrite:"))
1804 {
1805 unsigned long addr;
1806 unsigned long length;
1807 char *parse = packet + 12;
1808
1809 if (*parse == '\0')
1810 {
1811 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1812 return ERROR_SERVER_REMOTE_CLOSED;
1813 }
1814 addr = strtoul(parse, &parse, 16);
1815 if (*(parse++) != ':')
1816 {
1817 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1818 return ERROR_SERVER_REMOTE_CLOSED;
1819 }
1820 length = packet_size - (parse - packet);
1821
1822 /* create a new image if there isn't already one */
1823 if (gdb_connection->vflash_image == NULL)
1824 {
1825 gdb_connection->vflash_image = malloc(sizeof(image_t));
1826 image_open(gdb_connection->vflash_image, "", "build");
1827 }
1828
1829 /* create new section with content from packet buffer */
1830 image_add_section(gdb_connection->vflash_image, addr, length, 0x0, (u8*)parse);
1831
1832 gdb_put_packet(connection, "OK", 2);
1833
1834 return ERROR_OK;
1835 }
1836
1837 if (!strcmp(packet, "vFlashDone"))
1838 {
1839 u32 written;
1840
1841 /* process the flashing buffer. No need to erase as GDB
1842 * always issues a vFlashErase first. */
1843 target_call_event_callbacks(gdb_service->target, TARGET_EVENT_GDB_FLASH_WRITE_START);
1844 result = flash_write(gdb_service->target, gdb_connection->vflash_image, &written, 0);
1845 target_call_event_callbacks(gdb_service->target, TARGET_EVENT_GDB_FLASH_WRITE_END);
1846 if ( result != ERROR_OK)
1847 {
1848 if (result == ERROR_FLASH_DST_OUT_OF_BANK)
1849 gdb_put_packet(connection, "E.memtype", 9);
1850 else
1851 gdb_send_error(connection, EIO);
1852 }
1853 else
1854 {
1855 LOG_DEBUG("wrote %u bytes from vFlash image to flash", written);
1856 gdb_put_packet(connection, "OK", 2);
1857 }
1858
1859 image_close(gdb_connection->vflash_image);
1860 free(gdb_connection->vflash_image);
1861 gdb_connection->vflash_image = NULL;
1862
1863 return ERROR_OK;
1864 }
1865
1866 gdb_put_packet(connection, "", 0);
1867 return ERROR_OK;
1868 }
1869
1870 int gdb_detach(connection_t *connection, target_t *target)
1871 {
1872
1873 switch( detach_mode )
1874 {
1875 case GDB_DETACH_RESUME:
1876 target_handle_event( target, TARGET_EVENT_OLD_pre_resume );
1877 target_resume(target, 1, 0, 1, 0);
1878 break;
1879
1880 case GDB_DETACH_RESET:
1881 /* FIX?? make this configurable?? */
1882 target_process_reset(connection->cmd_ctx, RESET_HALT);
1883 break;
1884
1885 case GDB_DETACH_HALT:
1886 target_halt(target);
1887 break;
1888
1889 case GDB_DETACH_NOTHING:
1890 break;
1891 }
1892
1893 gdb_put_packet(connection, "OK", 2);
1894 return ERROR_OK;
1895 }
1896
1897 static void gdb_log_callback(void *priv, const char *file, int line,
1898 const char *function, const char *string)
1899 {
1900 connection_t *connection = priv;
1901 gdb_connection_t *gdb_con = connection->priv;
1902
1903 if (gdb_con->busy)
1904 {
1905 /* do not reply this using the O packet */
1906 return;
1907 }
1908
1909 gdb_output_con(connection, string);
1910 }
1911
1912 /* Do not allocate this on the stack */
1913 char gdb_packet_buffer[GDB_BUFFER_SIZE];
1914
1915 static void gdb_sig_halted(connection_t *connection)
1916 {
1917 char sig_reply[4];
1918 snprintf(sig_reply, 4, "T%2.2x", 2);
1919 gdb_put_packet(connection, sig_reply, 3);
1920
1921 }
1922
1923 int gdb_input_inner(connection_t *connection)
1924 {
1925 gdb_service_t *gdb_service = connection->service->priv;
1926 target_t *target = gdb_service->target;
1927 char *packet=gdb_packet_buffer;
1928 int packet_size;
1929 int retval;
1930 gdb_connection_t *gdb_con = connection->priv;
1931 static int extended_protocol = 0;
1932
1933 /* drain input buffer */
1934 do
1935 {
1936 packet_size = GDB_BUFFER_SIZE-1;
1937 if ((retval = gdb_get_packet(connection, packet, &packet_size)) != ERROR_OK)
1938 {
1939 return retval;
1940 }
1941
1942 /* terminate with zero */
1943 packet[packet_size] = 0;
1944
1945 LOG_DEBUG("received packet: '%s'", packet);
1946
1947 if (packet_size > 0)
1948 {
1949 retval = ERROR_OK;
1950 switch (packet[0])
1951 {
1952 case 'H':
1953 /* Hct... -- set thread
1954 * we don't have threads, send empty reply */
1955 gdb_put_packet(connection, NULL, 0);
1956 break;
1957 case 'q':
1958 case 'Q':
1959 retval = gdb_query_packet(connection, target, packet, packet_size);
1960 break;
1961 case 'g':
1962 retval = gdb_get_registers_packet(connection, target, packet, packet_size);
1963 break;
1964 case 'G':
1965 retval = gdb_set_registers_packet(connection, target, packet, packet_size);
1966 break;
1967 case 'p':
1968 retval = gdb_get_register_packet(connection, target, packet, packet_size);
1969 break;
1970 case 'P':
1971 retval = gdb_set_register_packet(connection, target, packet, packet_size);
1972 break;
1973 case 'm':
1974 retval = gdb_read_memory_packet(connection, target, packet, packet_size);
1975 break;
1976 case 'M':
1977 retval = gdb_write_memory_packet(connection, target, packet, packet_size);
1978 break;
1979 case 'z':
1980 case 'Z':
1981 retval = gdb_breakpoint_watchpoint_packet(connection, target, packet, packet_size);
1982 break;
1983 case '?':
1984 gdb_last_signal_packet(connection, target, packet, packet_size);
1985 break;
1986 case 'c':
1987 case 's':
1988 {
1989 if (target->state != TARGET_HALTED)
1990 {
1991 /* If the target isn't in the halted state, then we can't
1992 * step/continue. This might be early setup, etc.
1993 */
1994 gdb_sig_halted(connection);
1995 } else
1996 {
1997 /* We're running/stepping, in which case we can
1998 * forward log output until the target is halted
1999 */
2000 gdb_connection_t *gdb_con = connection->priv;
2001 gdb_con->frontend_state = TARGET_RUNNING;
2002 log_add_callback(gdb_log_callback, connection);
2003 int retval=gdb_step_continue_packet(connection, target, packet, packet_size);
2004 if (retval!=ERROR_OK)
2005 {
2006 /* we'll never receive a halted condition... issue a false one.. */
2007 gdb_frontend_halted(target, connection);
2008 }
2009 }
2010 }
2011 break;
2012 case 'v':
2013 retval = gdb_v_packet(connection, target, packet, packet_size);
2014 break;
2015 case 'D':
2016 retval = gdb_detach(connection, target);
2017 extended_protocol = 0;
2018 break;
2019 case 'X':
2020 if ((retval = gdb_write_memory_binary_packet(connection, target, packet, packet_size)) != ERROR_OK)
2021 return retval;
2022 break;
2023 case 'k':
2024 if (extended_protocol != 0)
2025 break;
2026 gdb_put_packet(connection, "OK", 2);
2027 return ERROR_SERVER_REMOTE_CLOSED;
2028 case '!':
2029 /* handle extended remote protocol */
2030 extended_protocol = 1;
2031 gdb_put_packet(connection, "OK", 2);
2032 break;
2033 case 'R':
2034 /* handle extended restart packet */
2035 breakpoint_clear_target(gdb_service->target);
2036 watchpoint_clear_target(gdb_service->target);
2037 command_run_linef(connection->cmd_ctx, "ocd_gdb_restart %d", get_num_by_target(target));
2038 break;
2039 default:
2040 /* ignore unkown packets */
2041 LOG_DEBUG("ignoring 0x%2.2x packet", packet[0]);
2042 gdb_put_packet(connection, NULL, 0);
2043 break;
2044 }
2045
2046 /* if a packet handler returned an error, exit input loop */
2047 if (retval != ERROR_OK)
2048 return retval;
2049 }
2050
2051 if (gdb_con->ctrl_c)
2052 {
2053 if (target->state == TARGET_RUNNING)
2054 {
2055 target_halt(target);
2056 gdb_con->ctrl_c = 0;
2057 }
2058 }
2059
2060 } while (gdb_con->buf_cnt > 0);
2061
2062 return ERROR_OK;
2063 }
2064
2065 int gdb_input(connection_t *connection)
2066 {
2067 int retval = gdb_input_inner(connection);
2068 gdb_connection_t *gdb_con = connection->priv;
2069 if (retval == ERROR_SERVER_REMOTE_CLOSED)
2070 return retval;
2071
2072 /* logging does not propagate the error, yet can set th gdb_con->closed flag */
2073 if (gdb_con->closed)
2074 return ERROR_SERVER_REMOTE_CLOSED;
2075
2076 /* we'll recover from any other errors(e.g. temporary timeouts, etc.) */
2077 return ERROR_OK;
2078 }
2079
2080 int gdb_init(void)
2081 {
2082 gdb_service_t *gdb_service;
2083 target_t *target = all_targets;
2084
2085 if (!target)
2086 {
2087 LOG_WARNING("no gdb ports allocated as no target has been specified");
2088 return ERROR_OK;
2089 }
2090
2091 if (gdb_port == 0)
2092 {
2093 LOG_WARNING("no gdb port specified, using default port 3333");
2094 gdb_port = 3333;
2095 }
2096
2097 while (target)
2098 {
2099 char service_name[8];
2100
2101 snprintf(service_name, 8, "gdb-%2.2i", target->target_number);
2102
2103 gdb_service = malloc(sizeof(gdb_service_t));
2104 gdb_service->target = target;
2105
2106 add_service("gdb", CONNECTION_GDB,
2107 gdb_port + target->target_number,
2108 1, gdb_new_connection, gdb_input,
2109 gdb_connection_closed,
2110 gdb_service);
2111
2112 LOG_DEBUG("gdb service for target %s at port %i",
2113 target->type->name,
2114 gdb_port + target->target_number);
2115
2116 target = target->next;
2117 }
2118
2119 return ERROR_OK;
2120 }
2121
2122 /* daemon configuration command gdb_port */
2123 int handle_gdb_port_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2124 {
2125 if (argc == 0)
2126 return ERROR_OK;
2127
2128 /* only if the port wasn't overwritten by cmdline */
2129 if (gdb_port == 0)
2130 gdb_port = strtoul(args[0], NULL, 0);
2131
2132 return ERROR_OK;
2133 }
2134
2135 int handle_gdb_detach_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2136 {
2137 if (argc == 1)
2138 {
2139 if (strcmp(args[0], "resume") == 0)
2140 {
2141 detach_mode = GDB_DETACH_RESUME;
2142 return ERROR_OK;
2143 }
2144 else if (strcmp(args[0], "reset") == 0)
2145 {
2146 detach_mode = GDB_DETACH_RESET;
2147 return ERROR_OK;
2148 }
2149 else if (strcmp(args[0], "halt") == 0)
2150 {
2151 detach_mode = GDB_DETACH_HALT;
2152 return ERROR_OK;
2153 }
2154 else if (strcmp(args[0], "nothing") == 0)
2155 {
2156 detach_mode = GDB_DETACH_NOTHING;
2157 return ERROR_OK;
2158 }
2159 }
2160
2161 LOG_WARNING("invalid gdb_detach configuration directive: %s", args[0]);
2162 return ERROR_OK;
2163 }
2164
2165 int handle_gdb_memory_map_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2166 {
2167 if (argc == 1)
2168 {
2169 if (strcmp(args[0], "enable") == 0)
2170 {
2171 gdb_use_memory_map = 1;
2172 return ERROR_OK;
2173 }
2174 else if (strcmp(args[0], "disable") == 0)
2175 {
2176 gdb_use_memory_map = 0;
2177 return ERROR_OK;
2178 }
2179 }
2180
2181 LOG_WARNING("invalid gdb_memory_map configuration directive: %s", args[0]);
2182 return ERROR_OK;
2183 }
2184
2185 int handle_gdb_flash_program_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2186 {
2187 if (argc == 1)
2188 {
2189 if (strcmp(args[0], "enable") == 0)
2190 {
2191 gdb_flash_program = 1;
2192 return ERROR_OK;
2193 }
2194 else if (strcmp(args[0], "disable") == 0)
2195 {
2196 gdb_flash_program = 0;
2197 return ERROR_OK;
2198 }
2199 }
2200
2201 LOG_WARNING("invalid gdb_memory_map configuration directive: %s", args[0]);
2202 return ERROR_OK;
2203 }
2204
2205 int handle_gdb_report_data_abort_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2206 {
2207 if (argc == 1)
2208 {
2209 if (strcmp(args[0], "enable") == 0)
2210 {
2211 gdb_report_data_abort = 1;
2212 return ERROR_OK;
2213 }
2214 else if (strcmp(args[0], "disable") == 0)
2215 {
2216 gdb_report_data_abort = 0;
2217 return ERROR_OK;
2218 }
2219 }
2220
2221 LOG_WARNING("invalid gdb_report_data_abort configuration directive: %s", args[0]);
2222 return ERROR_OK;
2223 }
2224
2225 /* daemon configuration command gdb_port */
2226 int handle_gdb_breakpoint_override_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2227 {
2228 if (argc == 0)
2229 {
2230
2231 } else if (argc==1)
2232 {
2233 gdb_breakpoint_override = 1;
2234 if (strcmp(args[0], "hard")==0)
2235 {
2236 gdb_breakpoint_override_type=BKPT_HARD;
2237 } else if (strcmp(args[0], "soft")==0)
2238 {
2239 gdb_breakpoint_override_type=BKPT_SOFT;
2240 } else if (strcmp(args[0], "disable") == 0)
2241 {
2242 gdb_breakpoint_override = 0;
2243 }
2244 } else
2245 {
2246 return ERROR_COMMAND_SYNTAX_ERROR;
2247 }
2248 if (gdb_breakpoint_override)
2249 {
2250 LOG_USER("force %s breakpoints", (gdb_breakpoint_override_type==BKPT_HARD)?"hard":"soft");
2251 } else
2252 {
2253 LOG_USER("breakpoint type is not overriden");
2254 }
2255
2256 return ERROR_OK;
2257 }
2258
2259
2260 int gdb_register_commands(command_context_t *command_context)
2261 {
2262 register_command(command_context, NULL, "gdb_port", handle_gdb_port_command,
2263 COMMAND_CONFIG, "");
2264 register_command(command_context, NULL, "gdb_detach", handle_gdb_detach_command,
2265 COMMAND_CONFIG, "");
2266 register_command(command_context, NULL, "gdb_memory_map", handle_gdb_memory_map_command,
2267 COMMAND_CONFIG, "");
2268 register_command(command_context, NULL, "gdb_flash_program", handle_gdb_flash_program_command,
2269 COMMAND_CONFIG, "");
2270 register_command(command_context, NULL, "gdb_report_data_abort", handle_gdb_report_data_abort_command,
2271 COMMAND_CONFIG, "");
2272 register_command(command_context, NULL, "gdb_breakpoint_override", handle_gdb_breakpoint_override_command,
2273 COMMAND_EXEC, "hard/soft/disabled - force breakpoint type for gdb 'break' commands."
2274 "The raison d'etre for this option is to support GDB GUI's without "
2275 "a hard/soft breakpoint concept where the default OpenOCD behaviour "
2276 "is not sufficient");
2277 return ERROR_OK;
2278 }
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)