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

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)