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