1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * Copyright (C) 2007,2008 Øyvind Harboe *
6 * oyvind.harboe@zylin.com *
8 * Copyright (C) 2008 by Spencer Oliver *
9 * spen@spen-soft.co.uk *
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. *
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. *
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 ***************************************************************************/
30 #include "gdb_server.h"
31 #include "target_request.h"
40 #define _DEBUG_GDB_IO_
43 static int gdb_breakpoint_override
;
44 static enum breakpoint_type gdb_breakpoint_override_type
;
46 extern int gdb_error(connection_t
*connection
, int retval
);
47 static unsigned short gdb_port
= 3333;
48 static const char *DIGITS
= "0123456789abcdef";
50 static void gdb_log_callback(void *priv
, const char *file
, int line
,
51 const char *function
, const char *string
);
61 /* target behaviour on gdb detach */
62 enum gdb_detach_mode detach_mode
= GDB_DETACH_RESUME
;
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
;
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;
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;
79 int gdb_last_signal(target_t
*target
)
81 switch (target
->debug_reason
)
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 */
94 LOG_USER("undefined debug reason %d - target needs reset", target
->debug_reason
);
99 int check_pending(connection_t
*connection
, int timeout_s
, int *got_data
)
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
106 gdb_connection_t
*gdb_con
= connection
->priv
;
108 if (got_data
== NULL
)
112 if (gdb_con
->buf_cnt
>0)
119 FD_SET(connection
->fd
, &read_fds
);
121 tv
.tv_sec
= timeout_s
;
123 if (socket_select(connection
->fd
+ 1, &read_fds
, NULL
, NULL
, &tv
) == 0)
125 /* This can typically be because a "monitor" command took too long
126 * before printing any progress messages
130 return ERROR_GDB_TIMEOUT
;
136 *got_data
= FD_ISSET(connection
->fd
, &read_fds
) != 0;
140 int gdb_get_char(connection_t
*connection
, int* next_char
)
142 gdb_connection_t
*gdb_con
= connection
->priv
;
143 int retval
= ERROR_OK
;
145 #ifdef _DEBUG_GDB_IO_
149 if (gdb_con
->buf_cnt
-- > 0)
151 *next_char
= *(gdb_con
->buf_p
++);
152 if (gdb_con
->buf_cnt
> 0)
153 connection
->input_pending
= 1;
155 connection
->input_pending
= 0;
157 #ifdef _DEBUG_GDB_IO_
158 LOG_DEBUG("returned char '%c' (0x%2.2x)", *next_char
, *next_char
);
166 if (connection
->service
->type
== CONNECTION_PIPE
)
168 gdb_con
->buf_cnt
= read(connection
->fd
, gdb_con
->buffer
, GDB_BUFFER_SIZE
);
172 retval
= check_pending(connection
, 1, NULL
);
173 if (retval
!= ERROR_OK
)
175 gdb_con
->buf_cnt
= read_socket(connection
->fd
, gdb_con
->buffer
, GDB_BUFFER_SIZE
);
178 if (gdb_con
->buf_cnt
> 0)
182 if (gdb_con
->buf_cnt
== 0)
185 return ERROR_SERVER_REMOTE_CLOSED
;
189 errno
= WSAGetLastError();
196 case WSAECONNABORTED
:
198 return ERROR_SERVER_REMOTE_CLOSED
;
201 return ERROR_SERVER_REMOTE_CLOSED
;
203 LOG_ERROR("read: %d", errno
);
214 return ERROR_SERVER_REMOTE_CLOSED
;
217 return ERROR_SERVER_REMOTE_CLOSED
;
219 LOG_ERROR("read: %s", strerror(errno
));
221 return ERROR_SERVER_REMOTE_CLOSED
;
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
);
234 gdb_con
->buf_p
= gdb_con
->buffer
;
236 *next_char
= *(gdb_con
->buf_p
++);
237 if (gdb_con
->buf_cnt
> 0)
238 connection
->input_pending
= 1;
240 connection
->input_pending
= 0;
241 #ifdef _DEBUG_GDB_IO_
242 LOG_DEBUG("returned char '%c' (0x%2.2x)", *next_char
, *next_char
);
248 int gdb_putback_char(connection_t
*connection
, int last_char
)
250 gdb_connection_t
*gdb_con
= connection
->priv
;
252 if (gdb_con
->buf_p
> gdb_con
->buffer
)
254 *(--gdb_con
->buf_p
) = last_char
;
259 LOG_ERROR("BUG: couldn't put character back");
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
)
270 gdb_connection_t
*gdb_con
= connection
->priv
;
272 return ERROR_SERVER_REMOTE_CLOSED
;
274 if (connection
->service
->type
== CONNECTION_PIPE
)
276 /* write to stdout */
277 if (write(STDOUT_FILENO
, data
, len
) == len
)
284 if (write_socket(connection
->fd
, data
, len
) == len
)
290 return ERROR_SERVER_REMOTE_CLOSED
;
293 int gdb_put_packet_inner(connection_t
*connection
, char *buffer
, int len
)
296 unsigned char my_checksum
= 0;
297 #ifdef _DEBUG_GDB_IO_
302 gdb_connection_t
*gdb_con
= connection
->priv
;
304 for (i
= 0; i
< len
; i
++)
305 my_checksum
+= buffer
[i
];
307 #ifdef _DEBUG_GDB_IO_
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.
316 if ((retval
= check_pending(connection
, 0, &gotdata
)) != ERROR_OK
)
320 if ((retval
= gdb_get_char(connection
, &reply
)) != ERROR_OK
)
323 /* fix a problem with some IAR tools */
324 gdb_putback_char( connection
, reply
);
325 LOG_DEBUG("Unexpected start of new packet");
329 LOG_WARNING("Discard unexpected char %c", reply
);
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
);
343 char local_buffer
[1024];
344 local_buffer
[0] = '$';
345 if ((size_t)len
+ 4 <= sizeof(local_buffer
))
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
)
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
)
368 if ((retval
= gdb_write(connection
, buffer
, len
)) != ERROR_OK
)
372 if ((retval
= gdb_write(connection
, local_buffer
+1, 3)) != ERROR_OK
)
378 if (gdb_con
->noack_mode
)
381 if ((retval
= gdb_get_char(connection
, &reply
)) != ERROR_OK
)
386 else if (reply
== '-')
388 /* Stop sending output packets for now */
389 log_remove_callback(gdb_log_callback
, connection
);
390 LOG_WARNING("negative reply, retrying");
392 else if (reply
== 0x3)
395 if ((retval
= gdb_get_char(connection
, &reply
)) != ERROR_OK
)
399 else if (reply
== '-')
401 /* Stop sending output packets for now */
402 log_remove_callback(gdb_log_callback
, connection
);
403 LOG_WARNING("negative reply, retrying");
405 else if ( reply
== '$' ){
406 LOG_ERROR("GDB missing ack(1) - assumed good");
407 gdb_putback_char( connection
, reply
);
411 LOG_ERROR("unknown character(1) 0x%2.2x in reply, dropping connection", reply
);
413 return ERROR_SERVER_REMOTE_CLOSED
;
416 else if ( reply
== '$' ){
417 LOG_ERROR("GDB missing ack(2) - assumed good");
418 gdb_putback_char( connection
, reply
);
423 LOG_ERROR("unknown character(2) 0x%2.2x in reply, dropping connection", reply
);
425 return ERROR_SERVER_REMOTE_CLOSED
;
429 return ERROR_SERVER_REMOTE_CLOSED
;
434 int gdb_put_packet(connection_t
*connection
, char *buffer
, int len
)
436 gdb_connection_t
*gdb_con
= connection
->priv
;
438 int retval
= gdb_put_packet_inner(connection
, buffer
, len
);
441 /* we sent some data, reset timer for keep alive messages */
447 static __inline__
int fetch_packet(connection_t
*connection
, int *checksum_ok
, int noack
, int *len
, char *buffer
)
449 unsigned char my_checksum
= 0;
454 gdb_connection_t
*gdb_con
= connection
->priv
;
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.
464 if ((gdb_con
->buf_cnt
> 2) && ((gdb_con
->buf_cnt
+count
) < *len
))
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
471 char *buf
= gdb_con
->buf_p
;
472 int run
= gdb_con
->buf_cnt
- 2;
479 if (character
== '#')
481 /* Danger! character can be '#' when esc is
482 * used so we need an explicit boolean for done here.
488 if (character
== '}')
490 /* data transmitted in binary mode (X packet)
491 * uses 0x7d as escape character */
492 my_checksum
+= character
& 0xff;
495 my_checksum
+= character
& 0xff;
496 buffer
[count
++] = (character
^ 0x20) & 0xff;
500 my_checksum
+= character
& 0xff;
501 buffer
[count
++] = character
& 0xff;
505 gdb_con
->buf_cnt
-= i
;
511 LOG_ERROR("packet buffer too small");
512 return ERROR_GDB_BUFFER_TOO_SMALL
;
515 if ((retval
= gdb_get_char(connection
, &character
)) != ERROR_OK
)
518 if (character
== '#')
521 if (character
== '}')
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
)
528 my_checksum
+= character
& 0xff;
529 buffer
[count
++] = (character
^ 0x20) & 0xff;
533 my_checksum
+= character
& 0xff;
534 buffer
[count
++] = character
& 0xff;
540 if ((retval
= gdb_get_char(connection
, &character
)) != ERROR_OK
)
542 checksum
[0] = character
;
543 if ((retval
= gdb_get_char(connection
, &character
)) != ERROR_OK
)
545 checksum
[1] = character
;
550 *checksum_ok
= (my_checksum
== strtoul(checksum
, NULL
, 16));
556 int gdb_get_packet_inner(connection_t
*connection
, char *buffer
, int *len
)
560 gdb_connection_t
*gdb_con
= connection
->priv
;
566 if ((retval
= gdb_get_char(connection
, &character
)) != ERROR_OK
)
569 #ifdef _DEBUG_GDB_IO_
570 LOG_DEBUG("character: '%c'", character
);
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");
583 LOG_WARNING("negative acknowledgment, but no packet pending");
590 LOG_WARNING("ignoring character 0x%x", character
);
593 } while (character
!= '$');
598 /* explicit code expansion here to get faster inlined code in -O3 by not
599 * calculating checksum
601 if (gdb_con
->noack_mode
)
603 if ((retval
= fetch_packet(connection
, &checksum_ok
, 1, len
, buffer
)) != ERROR_OK
)
607 if ((retval
= fetch_packet(connection
, &checksum_ok
, 0, len
, buffer
)) != ERROR_OK
)
611 if (gdb_con
->noack_mode
)
613 /* checksum is not checked in noack mode */
618 if ((retval
= gdb_write(connection
, "+", 1)) != ERROR_OK
)
626 return ERROR_SERVER_REMOTE_CLOSED
;
631 int gdb_get_packet(connection_t
*connection
, char *buffer
, int *len
)
633 gdb_connection_t
*gdb_con
= connection
->priv
;
635 int retval
= gdb_get_packet_inner(connection
, buffer
, len
);
640 int gdb_output_con(connection_t
*connection
, const char* line
)
645 bin_size
= strlen(line
);
647 hex_buffer
= malloc(bin_size
*2 + 2);
648 if (hex_buffer
== NULL
)
649 return ERROR_GDB_BUFFER_TOO_SMALL
;
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;
656 int retval
= gdb_put_packet(connection
, hex_buffer
, bin_size
*2 + 1);
662 int gdb_output(struct command_context_s
*context
, const char* line
)
664 /* this will be dumped to the log and also sent as an O packet if possible */
665 LOG_USER_N("%s", line
);
670 static void gdb_frontend_halted(struct target_s
*target
, connection_t
*connection
)
672 gdb_connection_t
*gdb_connection
= connection
->priv
;
674 /* In the GDB protocol when we are stepping or coninuing 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.
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.
683 if (gdb_connection
->frontend_state
== TARGET_RUNNING
)
688 /* stop forwarding log packets! */
689 log_remove_callback(gdb_log_callback
, connection
);
691 if (gdb_connection
->ctrl_c
)
694 gdb_connection
->ctrl_c
= 0;
698 signal
= gdb_last_signal(target
);
701 snprintf(sig_reply
, 4, "T%2.2x", signal
);
702 gdb_put_packet(connection
, sig_reply
, 3);
703 gdb_connection
->frontend_state
= TARGET_HALTED
;
707 int gdb_target_callback_event_handler(struct target_s
*target
, enum target_event event
, void *priv
)
710 connection_t
*connection
= priv
;
712 target_handle_event( target
, event
);
715 case TARGET_EVENT_EARLY_HALTED
:
716 gdb_frontend_halted(target
, connection
);
718 case TARGET_EVENT_HALTED
:
719 target_call_event_callbacks(target
, TARGET_EVENT_GDB_END
);
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
)
735 int gdb_new_connection(connection_t
*connection
)
737 gdb_connection_t
*gdb_connection
= malloc(sizeof(gdb_connection_t
));
738 gdb_service_t
*gdb_service
= connection
->service
->priv
;
742 connection
->priv
= gdb_connection
;
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;
754 /* send ACK to GDB for debug request */
755 gdb_write(connection
, "+", 1);
757 /* output goes through gdb connection */
758 command_set_output_handler(connection
->cmd_ctx
, gdb_output
, connection
);
760 /* we must remove all breakpoints registered to the target as a previous
761 * GDB session could leave dangling breakpoints if e.g. communication
764 breakpoint_clear_target(gdb_service
->target
);
765 watchpoint_clear_target(gdb_service
->target
);
767 /* register callback to be informed about target events */
768 target_register_event_callback(gdb_target_callback_event_handler
, connection
);
770 /* a gdb session just attached, try to put the target in halt mode.
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
779 * This allows GDB monitor commands to be run from a GDB init script to
780 * initialize the target
782 * Also, since the halt() is asynchronous target connect will be
783 * instantaneous and thus avoiding annoying timeout problems during
786 target_halt(gdb_service
->target
);
787 /* FIX!!!! could extended-remote work better here?
789 * wait a tiny bit for halted state or we just continue. The
790 * GDB register packet will then contain garbage
792 target_wait_state(gdb_service
->target
, TARGET_HALTED
, 500);
794 /* remove the initial ACK from the incoming buffer */
795 if ((retval
= gdb_get_char(connection
, &initial_ack
)) != ERROR_OK
)
798 /* FIX!!!??? would we actually ever receive a + here???
801 if (initial_ack
!= '+')
802 gdb_putback_char(connection
, initial_ack
);
803 target_call_event_callbacks(gdb_service
->target
, TARGET_EVENT_GDB_ATTACH
);
805 gdb_actual_connections
++;
810 int gdb_connection_closed(connection_t
*connection
)
812 gdb_service_t
*gdb_service
= connection
->service
->priv
;
813 gdb_connection_t
*gdb_connection
= connection
->priv
;
815 gdb_actual_connections
--;
817 /* see if an image built with vFlash commands is left */
818 if (gdb_connection
->vflash_image
)
820 image_close(gdb_connection
->vflash_image
);
821 free(gdb_connection
->vflash_image
);
822 gdb_connection
->vflash_image
= NULL
;
825 /* if this connection registered a debug-message receiver delete it */
826 delete_debug_msg_receiver(connection
->cmd_ctx
, gdb_service
->target
);
828 if (connection
->priv
)
830 free(connection
->priv
);
831 connection
->priv
= NULL
;
835 LOG_ERROR("BUG: connection->priv == NULL");
838 target_unregister_event_callback(gdb_target_callback_event_handler
, connection
);
839 target_call_event_callbacks(gdb_service
->target
, TARGET_EVENT_GDB_END
);
840 log_remove_callback(gdb_log_callback
, connection
);
842 target_call_event_callbacks(gdb_service
->target
, TARGET_EVENT_GDB_DETACH
);
847 void gdb_send_error(connection_t
*connection
, uint8_t the_error
)
850 snprintf(err
, 4, "E%2.2X", the_error
);
851 gdb_put_packet(connection
, err
, 3);
854 int gdb_last_signal_packet(connection_t
*connection
, target_t
*target
, char* packet
, int packet_size
)
859 signal
= gdb_last_signal(target
);
861 snprintf(sig_reply
, 4, "S%2.2x", signal
);
862 gdb_put_packet(connection
, sig_reply
, 3);
867 static int gdb_reg_pos(target_t
*target
, int pos
, int len
)
869 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
872 return len
- 1 - pos
;
875 /* Convert register to string of bytes. NB! The # of bits in the
876 * register might be non-divisible by 8(a byte), in which
877 * case an entire byte is shown.
879 * NB! the format on the wire is the target endianess
881 * The format of reg->value is little endian
884 void gdb_str_to_target(target_t
*target
, char *tstr
, reg_t
*reg
)
891 buf_len
= CEIL(reg
->size
, 8);
893 for (i
= 0; i
< buf_len
; i
++)
895 int j
= gdb_reg_pos(target
, i
, buf_len
);
896 tstr
[i
*2] = DIGITS
[(buf
[j
]>>4) & 0xf];
897 tstr
[i
*2+1] = DIGITS
[buf
[j
]&0xf];
901 static int hextoint(char c
)
912 LOG_ERROR("BUG: invalid register value %08x", c
);
916 /* copy over in register buffer */
917 void gdb_target_to_reg(target_t
*target
, char *tstr
, int str_len
, uint8_t *bin
)
921 LOG_ERROR("BUG: gdb value with uneven number of characters encountered");
926 for (i
= 0; i
< str_len
; i
+= 2)
928 uint8_t t
= hextoint(tstr
[i
]) << 4;
929 t
|= hextoint(tstr
[i
+1]);
931 int j
= gdb_reg_pos(target
, i
/2, str_len
/2);
936 int gdb_get_registers_packet(connection_t
*connection
, target_t
*target
, char* packet
, int packet_size
)
941 int reg_packet_size
= 0;
946 #ifdef _DEBUG_GDB_IO_
950 if ((retval
= target_get_gdb_reg_list(target
, ®_list
, ®_list_size
)) != ERROR_OK
)
952 return gdb_error(connection
, retval
);
955 for (i
= 0; i
< reg_list_size
; i
++)
957 reg_packet_size
+= reg_list
[i
]->size
;
960 reg_packet
= malloc(CEIL(reg_packet_size
, 8) * 2);
961 reg_packet_p
= reg_packet
;
963 for (i
= 0; i
< reg_list_size
; i
++)
965 gdb_str_to_target(target
, reg_packet_p
, reg_list
[i
]);
966 reg_packet_p
+= CEIL(reg_list
[i
]->size
, 8) * 2;
969 #ifdef _DEBUG_GDB_IO_
972 reg_packet_p
= strndup(reg_packet
, CEIL(reg_packet_size
, 8) * 2);
973 LOG_DEBUG("reg_packet: %s", reg_packet_p
);
978 gdb_put_packet(connection
, reg_packet
, CEIL(reg_packet_size
, 8) * 2);
986 int gdb_set_registers_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
994 #ifdef _DEBUG_GDB_IO_
998 /* skip command character */
1002 if (packet_size
% 2)
1004 LOG_WARNING("GDB set_registers packet with uneven characters received, dropping connection");
1005 return ERROR_SERVER_REMOTE_CLOSED
;
1008 if ((retval
= target_get_gdb_reg_list(target
, ®_list
, ®_list_size
)) != ERROR_OK
)
1010 return gdb_error(connection
, retval
);
1014 for (i
= 0; i
< reg_list_size
; i
++)
1017 int chars
= (CEIL(reg_list
[i
]->size
, 8) * 2);
1019 if (packet_p
+ chars
> packet
+ packet_size
)
1021 LOG_ERROR("BUG: register packet is too small for registers");
1024 reg_arch_type_t
*arch_type
;
1025 bin_buf
= malloc(CEIL(reg_list
[i
]->size
, 8));
1026 gdb_target_to_reg(target
, packet_p
, chars
, bin_buf
);
1028 /* get register arch_type, and call set method */
1029 arch_type
= register_get_arch_type(reg_list
[i
]->arch_type
);
1031 arch_type
->set(reg_list
[i
], bin_buf
);
1033 /* advance packet pointer */
1040 /* free reg_t *reg_list[] array allocated by get_gdb_reg_list */
1043 gdb_put_packet(connection
, "OK", 2);
1048 int gdb_get_register_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1051 int reg_num
= strtoul(packet
+ 1, NULL
, 16);
1056 #ifdef _DEBUG_GDB_IO_
1060 if ((retval
= target_get_gdb_reg_list(target
, ®_list
, ®_list_size
)) != ERROR_OK
)
1062 return gdb_error(connection
, retval
);
1065 if (reg_list_size
<= reg_num
)
1067 LOG_ERROR("gdb requested a non-existing register");
1071 reg_packet
= malloc(CEIL(reg_list
[reg_num
]->size
, 8) * 2);
1073 gdb_str_to_target(target
, reg_packet
, reg_list
[reg_num
]);
1075 gdb_put_packet(connection
, reg_packet
, CEIL(reg_list
[reg_num
]->size
, 8) * 2);
1083 int gdb_set_register_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1087 int reg_num
= strtoul(packet
+ 1, &separator
, 16);
1091 reg_arch_type_t
*arch_type
;
1095 if ((retval
= target_get_gdb_reg_list(target
, ®_list
, ®_list_size
)) != ERROR_OK
)
1097 return gdb_error(connection
, retval
);
1100 if (reg_list_size
< reg_num
)
1102 LOG_ERROR("gdb requested a non-existing register");
1103 return ERROR_SERVER_REMOTE_CLOSED
;
1106 if (*separator
!= '=')
1108 LOG_ERROR("GDB 'set register packet', but no '=' following the register number");
1109 return ERROR_SERVER_REMOTE_CLOSED
;
1112 /* convert from GDB-string (target-endian) to hex-string (big-endian) */
1113 bin_buf
= malloc(CEIL(reg_list
[reg_num
]->size
, 8));
1114 int chars
= (CEIL(reg_list
[reg_num
]->size
, 8) * 2);
1116 /* fix!!! add some sanity checks on packet size here */
1118 gdb_target_to_reg(target
, separator
+ 1, chars
, bin_buf
);
1120 /* get register arch_type, and call set method */
1121 arch_type
= register_get_arch_type(reg_list
[reg_num
]->arch_type
);
1122 arch_type
->set(reg_list
[reg_num
], bin_buf
);
1124 gdb_put_packet(connection
, "OK", 2);
1132 int gdb_error(connection_t
*connection
, int retval
)
1136 case ERROR_TARGET_DATA_ABORT
:
1137 gdb_send_error(connection
, EIO
);
1139 case ERROR_TARGET_TRANSLATION_FAULT
:
1140 gdb_send_error(connection
, EFAULT
);
1142 case ERROR_TARGET_UNALIGNED_ACCESS
:
1143 gdb_send_error(connection
, EFAULT
);
1145 case ERROR_TARGET_NOT_HALTED
:
1146 gdb_send_error(connection
, EFAULT
);
1149 /* This could be that the target reset itself. */
1150 LOG_ERROR("unexpected error %i", retval
);
1151 gdb_send_error(connection
, EFAULT
);
1158 /* We don't have to worry about the default 2 second timeout for GDB packets,
1159 * because GDB breaks up large memory reads into smaller reads.
1161 * 8191 bytes by the looks of it. Why 8191 bytes instead of 8192?????
1163 int gdb_read_memory_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1172 int retval
= ERROR_OK
;
1174 /* skip command character */
1177 addr
= strtoul(packet
, &separator
, 16);
1179 if (*separator
!= ',')
1181 LOG_ERROR("incomplete read memory packet received, dropping connection");
1182 return ERROR_SERVER_REMOTE_CLOSED
;
1185 len
= strtoul(separator
+1, NULL
, 16);
1187 buffer
= malloc(len
);
1189 LOG_DEBUG("addr: 0x%8.8" PRIx32
", len: 0x%8.8" PRIx32
"", addr
, len
);
1191 retval
= target_read_buffer(target
, addr
, len
, buffer
);
1193 if ((retval
!= ERROR_OK
)&&!gdb_report_data_abort
)
1195 /* TODO : Here we have to lie and send back all zero's lest stack traces won't work.
1196 * At some point this might be fixed in GDB, in which case this code can be removed.
1198 * OpenOCD developers are acutely aware of this problem, but there is nothing
1199 * gained by involving the user in this problem that hopefully will get resolved
1202 * http://sourceware.org/cgi-bin/gnatsweb.pl?cmd = view%20audit-trail&database = gdb&pr = 2395
1204 * For now, the default is to fix up things to make current GDB versions work.
1205 * This can be overwritten using the gdb_report_data_abort <'enable'|'disable'> command.
1207 memset(buffer
, 0, len
);
1211 if (retval
== ERROR_OK
)
1213 hex_buffer
= malloc(len
* 2 + 1);
1216 for (i
= 0; i
< len
; i
++)
1218 uint8_t t
= buffer
[i
];
1219 hex_buffer
[2 * i
] = DIGITS
[(t
>> 4) & 0xf];
1220 hex_buffer
[2 * i
+ 1] = DIGITS
[t
& 0xf];
1223 gdb_put_packet(connection
, hex_buffer
, len
* 2);
1229 retval
= gdb_error(connection
, retval
);
1237 int gdb_write_memory_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1248 /* skip command character */
1251 addr
= strtoul(packet
, &separator
, 16);
1253 if (*separator
!= ',')
1255 LOG_ERROR("incomplete write memory packet received, dropping connection");
1256 return ERROR_SERVER_REMOTE_CLOSED
;
1259 len
= strtoul(separator
+1, &separator
, 16);
1261 if (*(separator
++) != ':')
1263 LOG_ERROR("incomplete write memory packet received, dropping connection");
1264 return ERROR_SERVER_REMOTE_CLOSED
;
1267 buffer
= malloc(len
);
1269 LOG_DEBUG("addr: 0x%8.8" PRIx32
", len: 0x%8.8" PRIx32
"", addr
, len
);
1271 for (i
= 0; i
<len
; i
++)
1274 sscanf(separator
+ 2*i
, "%2" SCNx32
, &tmp
);
1278 retval
= target_write_buffer(target
, addr
, len
, buffer
);
1280 if (retval
== ERROR_OK
)
1282 gdb_put_packet(connection
, "OK", 2);
1286 retval
= gdb_error(connection
, retval
);
1294 int gdb_write_memory_binary_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1302 /* skip command character */
1305 addr
= strtoul(packet
, &separator
, 16);
1307 if (*separator
!= ',')
1309 LOG_ERROR("incomplete write memory binary packet received, dropping connection");
1310 return ERROR_SERVER_REMOTE_CLOSED
;
1313 len
= strtoul(separator
+1, &separator
, 16);
1315 if (*(separator
++) != ':')
1317 LOG_ERROR("incomplete write memory binary packet received, dropping connection");
1318 return ERROR_SERVER_REMOTE_CLOSED
;
1324 LOG_DEBUG("addr: 0x%8.8" PRIx32
", len: 0x%8.8" PRIx32
"", addr
, len
);
1326 retval
= target_write_buffer(target
, addr
, len
, (uint8_t*)separator
);
1329 if (retval
== ERROR_OK
)
1331 gdb_put_packet(connection
, "OK", 2);
1335 if ((retval
= gdb_error(connection
, retval
)) != ERROR_OK
)
1342 int gdb_step_continue_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1345 uint32_t address
= 0x0;
1346 int retval
= ERROR_OK
;
1350 if (packet_size
> 1)
1352 packet
[packet_size
] = 0;
1353 address
= strtoul(packet
+ 1, NULL
, 16);
1360 if (packet
[0] == 'c')
1362 LOG_DEBUG("continue");
1363 target_handle_event( target
, TARGET_EVENT_OLD_pre_resume
);
1364 retval
= target_resume(target
, current
, address
, 0, 0); /* resume at current address, don't handle breakpoints, not debugging */
1366 else if (packet
[0] == 's')
1369 /* step at current or address, don't handle breakpoints */
1370 retval
= target_step(target
, current
, address
, 0);
1375 int gdb_breakpoint_watchpoint_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1378 enum breakpoint_type bp_type
= BKPT_SOFT
/* dummy init to avoid warning */;
1379 enum watchpoint_rw wp_type
;
1387 type
= strtoul(packet
+ 1, &separator
, 16);
1389 if (type
== 0) /* memory breakpoint */
1390 bp_type
= BKPT_SOFT
;
1391 else if (type
== 1) /* hardware breakpoint */
1392 bp_type
= BKPT_HARD
;
1393 else if (type
== 2) /* write watchpoint */
1394 wp_type
= WPT_WRITE
;
1395 else if (type
== 3) /* read watchpoint */
1397 else if (type
== 4) /* access watchpoint */
1398 wp_type
= WPT_ACCESS
;
1400 if (gdb_breakpoint_override
&& ((bp_type
== BKPT_SOFT
)||(bp_type
== BKPT_HARD
)))
1402 bp_type
= gdb_breakpoint_override_type
;
1405 if (*separator
!= ',')
1407 LOG_ERROR("incomplete breakpoint/watchpoint packet received, dropping connection");
1408 return ERROR_SERVER_REMOTE_CLOSED
;
1411 address
= strtoul(separator
+1, &separator
, 16);
1413 if (*separator
!= ',')
1415 LOG_ERROR("incomplete breakpoint/watchpoint packet received, dropping connection");
1416 return ERROR_SERVER_REMOTE_CLOSED
;
1419 size
= strtoul(separator
+1, &separator
, 16);
1425 if (packet
[0] == 'Z')
1427 if ((retval
= breakpoint_add(target
, address
, size
, bp_type
)) != ERROR_OK
)
1429 if ((retval
= gdb_error(connection
, retval
)) != ERROR_OK
)
1434 gdb_put_packet(connection
, "OK", 2);
1439 breakpoint_remove(target
, address
);
1440 gdb_put_packet(connection
, "OK", 2);
1447 if (packet
[0] == 'Z')
1449 if ((retval
= watchpoint_add(target
, address
, size
, type
-2, 0, 0xffffffffu
)) != ERROR_OK
)
1451 if ((retval
= gdb_error(connection
, retval
)) != ERROR_OK
)
1456 gdb_put_packet(connection
, "OK", 2);
1461 watchpoint_remove(target
, address
);
1462 gdb_put_packet(connection
, "OK", 2);
1473 /* print out a string and allocate more space as needed, mainly used for XML at this point */
1474 void xml_printf(int *retval
, char **xml
, int *pos
, int *size
, const char *fmt
, ...)
1476 if (*retval
!= ERROR_OK
)
1484 if ((*xml
== NULL
) || (!first
))
1486 /* start by 0 to exercise all the code paths.
1487 * Need minimum 2 bytes to fit 1 char and 0 terminator. */
1489 *size
= *size
* 2 + 2;
1491 *xml
= realloc(*xml
, *size
);
1496 *retval
= ERROR_SERVER_REMOTE_CLOSED
;
1504 ret
= vsnprintf(*xml
+ *pos
, *size
- *pos
, fmt
, ap
);
1506 if ((ret
> 0) && ((ret
+ 1) < *size
- *pos
))
1511 /* there was just enough or not enough space, allocate more. */
1516 static int decode_xfer_read(char *buf
, char **annex
, int *ofs
, unsigned int *len
)
1520 /* Extract and NUL-terminate the annex. */
1522 while (*buf
&& *buf
!= ':')
1528 /* After the read marker and annex, qXfer looks like a
1529 * traditional 'm' packet. */
1531 *ofs
= strtoul(buf
, &separator
, 16);
1533 if (*separator
!= ',')
1536 *len
= strtoul(separator
+1, NULL
, 16);
1541 int gdb_calc_blocksize(flash_bank_t
*bank
)
1544 uint32_t block_size
= 0xffffffff;
1546 /* loop through all sectors and return smallest sector size */
1548 for (i
= 0; i
< (uint32_t)bank
->num_sectors
; i
++)
1550 if (bank
->sectors
[i
].size
< block_size
)
1551 block_size
= bank
->sectors
[i
].size
;
1557 static int compare_bank (const void * a
, const void * b
)
1559 flash_bank_t
*b1
, *b2
;
1560 b1
=*((flash_bank_t
**)a
);
1561 b2
=*((flash_bank_t
**)b
);
1563 if (b1
->base
== b2
->base
)
1566 } else if (b1
->base
>b2
->base
)
1575 int gdb_query_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1577 command_context_t
*cmd_ctx
= connection
->cmd_ctx
;
1578 gdb_connection_t
*gdb_connection
= connection
->priv
;
1580 if (strstr(packet
, "qRcmd,"))
1582 if (packet_size
> 6)
1586 cmd
= malloc((packet_size
- 6)/2 + 1);
1587 for (i
= 0; i
< (packet_size
- 6)/2; i
++)
1590 sscanf(packet
+ 6 + 2*i
, "%2" SCNx32
, &tmp
);
1593 cmd
[(packet_size
- 6)/2] = 0x0;
1595 /* We want to print all debug output to GDB connection */
1596 log_add_callback(gdb_log_callback
, connection
);
1597 target_call_timer_callbacks_now();
1598 command_run_line(cmd_ctx
, cmd
);
1599 target_call_timer_callbacks_now();
1600 log_remove_callback(gdb_log_callback
, connection
);
1603 gdb_put_packet(connection
, "OK", 2);
1606 else if (strstr(packet
, "qCRC:"))
1608 if (packet_size
> 5)
1617 /* skip command character */
1620 addr
= strtoul(packet
, &separator
, 16);
1622 if (*separator
!= ',')
1624 LOG_ERROR("incomplete read memory packet received, dropping connection");
1625 return ERROR_SERVER_REMOTE_CLOSED
;
1628 len
= strtoul(separator
+ 1, NULL
, 16);
1630 retval
= target_checksum_memory(target
, addr
, len
, &checksum
);
1632 if (retval
== ERROR_OK
)
1634 snprintf(gdb_reply
, 10, "C%8.8" PRIx32
"", checksum
);
1635 gdb_put_packet(connection
, gdb_reply
, 9);
1639 if ((retval
= gdb_error(connection
, retval
)) != ERROR_OK
)
1646 else if (strstr(packet
, "qSupported"))
1648 /* we currently support packet size and qXfer:memory-map:read (if enabled)
1649 * disable qXfer:features:read for the moment */
1650 int retval
= ERROR_OK
;
1651 char *buffer
= NULL
;
1655 xml_printf(&retval
, &buffer
, &pos
, &size
,
1656 "PacketSize=%x;qXfer:memory-map:read%c;qXfer:features:read-;QStartNoAckMode+",
1657 (GDB_BUFFER_SIZE
- 1), ((gdb_use_memory_map
== 1) && (flash_get_bank_count()>0)) ? '+' : '-');
1659 if (retval
!= ERROR_OK
)
1661 gdb_send_error(connection
, 01);
1665 gdb_put_packet(connection
, buffer
, strlen(buffer
));
1670 else if (strstr(packet
, "qXfer:memory-map:read::") && (flash_get_bank_count()>0))
1672 /* We get away with only specifying flash here. Regions that are not
1673 * specified are treated as if we provided no memory map(if not we
1674 * could detect the holes and mark them as RAM).
1675 * Normally we only execute this code once, but no big deal if we
1676 * have to regenerate it a couple of times. */
1682 int retval
= ERROR_OK
;
1689 /* skip command character */
1692 offset
= strtoul(packet
, &separator
, 16);
1693 length
= strtoul(separator
+ 1, &separator
, 16);
1695 xml_printf(&retval
, &xml
, &pos
, &size
, "<memory-map>\n");
1698 sort banks in ascending order, we need to make non-flash memory be ram(or rather
1699 read/write) by default for GDB.
1700 GDB does not have a concept of non-cacheable read/write memory.
1702 flash_bank_t
**banks
= malloc(sizeof(flash_bank_t
*)*flash_get_bank_count());
1705 for (i
= 0; i
<flash_get_bank_count(); i
++)
1707 p
= get_flash_bank_by_num(i
);
1711 retval
= ERROR_FAIL
;
1712 gdb_send_error(connection
, retval
);
1718 qsort(banks
, flash_get_bank_count(), sizeof(flash_bank_t
*), compare_bank
);
1720 uint32_t ram_start
= 0;
1721 for (i
= 0; i
<flash_get_bank_count(); i
++)
1725 if (ram_start
<p
->base
)
1727 xml_printf(&retval
, &xml
, &pos
, &size
, "<memory type=\"ram\" start=\"0x%x\" length=\"0x%x\"/>\n",
1728 ram_start
, p
->base
-ram_start
);
1731 /* if device has uneven sector sizes, eg. str7, lpc
1732 * we pass the smallest sector size to gdb memory map */
1733 blocksize
= gdb_calc_blocksize(p
);
1735 xml_printf(&retval
, &xml
, &pos
, &size
, "<memory type=\"flash\" start=\"0x%x\" length=\"0x%x\">\n" \
1736 "<property name=\"blocksize\">0x%x</property>\n" \
1738 p
->base
, p
->size
, blocksize
);
1739 ram_start
= p
->base
+p
->size
;
1743 xml_printf(&retval
, &xml
, &pos
, &size
, "<memory type=\"ram\" start=\"0x%x\" length=\"0x%x\"/>\n",
1744 ram_start
, 0-ram_start
);
1747 /* a flash chip could be at the very end of the 32 bit address space, in which case
1748 ram_start will be precisely 0 */
1754 xml_printf(&retval
, &xml
, &pos
, &size
, "</memory-map>\n");
1756 if (retval
!= ERROR_OK
)
1758 gdb_send_error(connection
, retval
);
1762 if (offset
+ length
> pos
)
1764 length
= pos
- offset
;
1767 char *t
= malloc(length
+ 1);
1769 memcpy(t
+ 1, xml
+ offset
, length
);
1770 gdb_put_packet(connection
, t
, length
+ 1);
1776 else if (strstr(packet
, "qXfer:features:read:"))
1781 int retval
= ERROR_OK
;
1784 unsigned int length
;
1787 /* skip command character */
1790 if (decode_xfer_read(packet
, &annex
, &offset
, &length
) < 0)
1792 gdb_send_error(connection
, 01);
1796 if (strcmp(annex
, "target.xml") != 0)
1798 gdb_send_error(connection
, 01);
1802 xml_printf(&retval
, &xml
, &pos
, &size
, \
1803 "l<target version=\"1.0\">\n<architecture>arm</architecture>\n</target>\n");
1805 if (retval
!= ERROR_OK
)
1807 gdb_send_error(connection
, retval
);
1811 gdb_put_packet(connection
, xml
, strlen(xml
));
1816 else if (strstr(packet
, "QStartNoAckMode"))
1818 gdb_connection
->noack_mode
= 1;
1819 gdb_put_packet(connection
, "OK", 2);
1823 gdb_put_packet(connection
, "", 0);
1827 int gdb_v_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1829 gdb_connection_t
*gdb_connection
= connection
->priv
;
1830 gdb_service_t
*gdb_service
= connection
->service
->priv
;
1833 /* if flash programming disabled - send a empty reply */
1835 if (gdb_flash_program
== 0)
1837 gdb_put_packet(connection
, "", 0);
1841 if (strstr(packet
, "vFlashErase:"))
1844 unsigned long length
;
1846 char *parse
= packet
+ 12;
1849 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1850 return ERROR_SERVER_REMOTE_CLOSED
;
1853 addr
= strtoul(parse
, &parse
, 16);
1855 if (*(parse
++) != ',' || *parse
== '\0')
1857 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1858 return ERROR_SERVER_REMOTE_CLOSED
;
1861 length
= strtoul(parse
, &parse
, 16);
1865 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1866 return ERROR_SERVER_REMOTE_CLOSED
;
1869 /* assume all sectors need erasing - stops any problems
1870 * when flash_write is called multiple times */
1873 /* perform any target specific operations before the erase */
1874 target_call_event_callbacks(gdb_service
->target
, TARGET_EVENT_GDB_FLASH_ERASE_START
);
1875 result
= flash_erase_address_range(gdb_service
->target
, addr
, length
);
1876 target_call_event_callbacks(gdb_service
->target
, TARGET_EVENT_GDB_FLASH_ERASE_END
);
1879 if (result
!= ERROR_OK
)
1881 /* GDB doesn't evaluate the actual error number returned,
1882 * treat a failed erase as an I/O error
1884 gdb_send_error(connection
, EIO
);
1885 LOG_ERROR("flash_erase returned %i", result
);
1888 gdb_put_packet(connection
, "OK", 2);
1893 if (strstr(packet
, "vFlashWrite:"))
1897 unsigned long length
;
1898 char *parse
= packet
+ 12;
1902 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1903 return ERROR_SERVER_REMOTE_CLOSED
;
1905 addr
= strtoul(parse
, &parse
, 16);
1906 if (*(parse
++) != ':')
1908 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1909 return ERROR_SERVER_REMOTE_CLOSED
;
1911 length
= packet_size
- (parse
- packet
);
1913 /* create a new image if there isn't already one */
1914 if (gdb_connection
->vflash_image
== NULL
)
1916 gdb_connection
->vflash_image
= malloc(sizeof(image_t
));
1917 image_open(gdb_connection
->vflash_image
, "", "build");
1920 /* create new section with content from packet buffer */
1921 if ((retval
= image_add_section(gdb_connection
->vflash_image
, addr
, length
, 0x0, (uint8_t*)parse
)) != ERROR_OK
)
1926 gdb_put_packet(connection
, "OK", 2);
1931 if (!strcmp(packet
, "vFlashDone"))
1935 /* process the flashing buffer. No need to erase as GDB
1936 * always issues a vFlashErase first. */
1937 target_call_event_callbacks(gdb_service
->target
, TARGET_EVENT_GDB_FLASH_WRITE_START
);
1938 result
= flash_write(gdb_service
->target
, gdb_connection
->vflash_image
, &written
, 0);
1939 target_call_event_callbacks(gdb_service
->target
, TARGET_EVENT_GDB_FLASH_WRITE_END
);
1940 if ( result
!= ERROR_OK
)
1942 if (result
== ERROR_FLASH_DST_OUT_OF_BANK
)
1943 gdb_put_packet(connection
, "E.memtype", 9);
1945 gdb_send_error(connection
, EIO
);
1949 LOG_DEBUG("wrote %u bytes from vFlash image to flash", (unsigned)written
);
1950 gdb_put_packet(connection
, "OK", 2);
1953 image_close(gdb_connection
->vflash_image
);
1954 free(gdb_connection
->vflash_image
);
1955 gdb_connection
->vflash_image
= NULL
;
1960 gdb_put_packet(connection
, "", 0);
1964 int gdb_detach(connection_t
*connection
, target_t
*target
)
1967 switch ( detach_mode
)
1969 case GDB_DETACH_RESUME
:
1970 target_handle_event( target
, TARGET_EVENT_OLD_pre_resume
);
1971 target_resume(target
, 1, 0, 1, 0);
1974 case GDB_DETACH_RESET
:
1975 /* FIX?? make this configurable?? */
1976 target_process_reset(connection
->cmd_ctx
, RESET_HALT
);
1979 case GDB_DETACH_HALT
:
1980 target_halt(target
);
1983 case GDB_DETACH_NOTHING
:
1987 gdb_put_packet(connection
, "OK", 2);
1991 static void gdb_log_callback(void *priv
, const char *file
, int line
,
1992 const char *function
, const char *string
)
1994 connection_t
*connection
= priv
;
1995 gdb_connection_t
*gdb_con
= connection
->priv
;
1999 /* do not reply this using the O packet */
2003 gdb_output_con(connection
, string
);
2006 /* Do not allocate this on the stack */
2007 char gdb_packet_buffer
[GDB_BUFFER_SIZE
];
2009 static void gdb_sig_halted(connection_t
*connection
)
2012 snprintf(sig_reply
, 4, "T%2.2x", 2);
2013 gdb_put_packet(connection
, sig_reply
, 3);
2017 int gdb_input_inner(connection_t
*connection
)
2019 gdb_service_t
*gdb_service
= connection
->service
->priv
;
2020 target_t
*target
= gdb_service
->target
;
2021 char *packet
= gdb_packet_buffer
;
2024 gdb_connection_t
*gdb_con
= connection
->priv
;
2025 static int extended_protocol
= 0;
2027 /* drain input buffer */
2030 packet_size
= GDB_BUFFER_SIZE
-1;
2031 if ((retval
= gdb_get_packet(connection
, packet
, &packet_size
)) != ERROR_OK
)
2036 /* terminate with zero */
2037 packet
[packet_size
] = 0;
2039 if ( LOG_LEVEL_IS( LOG_LVL_DEBUG
) ){
2040 if ( packet
[0] == 'X' ){
2041 // binary packets spew junk into the debug log stream
2044 for ( x
= 0 ; (x
< 49) && (packet
[x
] != ':') ; x
++ ){
2048 LOG_DEBUG("received packet: '%s:<binary-data>'", buf
);
2050 LOG_DEBUG("received packet: '%s'", packet
);
2054 if (packet_size
> 0)
2060 /* Hct... -- set thread
2061 * we don't have threads, send empty reply */
2062 gdb_put_packet(connection
, NULL
, 0);
2066 retval
= gdb_query_packet(connection
, target
, packet
, packet_size
);
2069 retval
= gdb_get_registers_packet(connection
, target
, packet
, packet_size
);
2072 retval
= gdb_set_registers_packet(connection
, target
, packet
, packet_size
);
2075 retval
= gdb_get_register_packet(connection
, target
, packet
, packet_size
);
2078 retval
= gdb_set_register_packet(connection
, target
, packet
, packet_size
);
2081 retval
= gdb_read_memory_packet(connection
, target
, packet
, packet_size
);
2084 retval
= gdb_write_memory_packet(connection
, target
, packet
, packet_size
);
2088 retval
= gdb_breakpoint_watchpoint_packet(connection
, target
, packet
, packet_size
);
2091 gdb_last_signal_packet(connection
, target
, packet
, packet_size
);
2096 if (target
->state
!= TARGET_HALTED
)
2098 /* If the target isn't in the halted state, then we can't
2099 * step/continue. This might be early setup, etc.
2101 gdb_sig_halted(connection
);
2104 /* We're running/stepping, in which case we can
2105 * forward log output until the target is halted
2107 gdb_connection_t
*gdb_con
= connection
->priv
;
2108 gdb_con
->frontend_state
= TARGET_RUNNING
;
2109 log_add_callback(gdb_log_callback
, connection
);
2110 target_call_event_callbacks(target
, TARGET_EVENT_GDB_START
);
2111 int retval
= gdb_step_continue_packet(connection
, target
, packet
, packet_size
);
2112 if (retval
!= ERROR_OK
)
2114 /* we'll never receive a halted condition... issue a false one.. */
2115 gdb_frontend_halted(target
, connection
);
2121 retval
= gdb_v_packet(connection
, target
, packet
, packet_size
);
2124 retval
= gdb_detach(connection
, target
);
2125 extended_protocol
= 0;
2128 if ((retval
= gdb_write_memory_binary_packet(connection
, target
, packet
, packet_size
)) != ERROR_OK
)
2132 if (extended_protocol
!= 0)
2134 gdb_put_packet(connection
, "OK", 2);
2135 return ERROR_SERVER_REMOTE_CLOSED
;
2137 /* handle extended remote protocol */
2138 extended_protocol
= 1;
2139 gdb_put_packet(connection
, "OK", 2);
2142 /* handle extended restart packet */
2143 breakpoint_clear_target(gdb_service
->target
);
2144 watchpoint_clear_target(gdb_service
->target
);
2145 command_run_linef(connection
->cmd_ctx
, "ocd_gdb_restart %d", get_num_by_target(target
));
2148 /* ignore unkown packets */
2149 LOG_DEBUG("ignoring 0x%2.2x packet", packet
[0]);
2150 gdb_put_packet(connection
, NULL
, 0);
2154 /* if a packet handler returned an error, exit input loop */
2155 if (retval
!= ERROR_OK
)
2159 if (gdb_con
->ctrl_c
)
2161 if (target
->state
== TARGET_RUNNING
)
2163 target_halt(target
);
2164 gdb_con
->ctrl_c
= 0;
2168 } while (gdb_con
->buf_cnt
> 0);
2173 int gdb_input(connection_t
*connection
)
2175 int retval
= gdb_input_inner(connection
);
2176 gdb_connection_t
*gdb_con
= connection
->priv
;
2177 if (retval
== ERROR_SERVER_REMOTE_CLOSED
)
2180 /* logging does not propagate the error, yet can set the gdb_con->closed flag */
2181 if (gdb_con
->closed
)
2182 return ERROR_SERVER_REMOTE_CLOSED
;
2184 /* we'll recover from any other errors(e.g. temporary timeouts, etc.) */
2190 gdb_service_t
*gdb_service
;
2191 target_t
*target
= all_targets
;
2195 LOG_WARNING("no gdb ports allocated as no target has been specified");
2199 if (gdb_port
== 0 && server_use_pipes
== 0)
2201 LOG_INFO("gdb port disabled");
2205 if (server_use_pipes
)
2207 /* only a single gdb connection when using a pipe */
2209 gdb_service
= malloc(sizeof(gdb_service_t
));
2210 gdb_service
->target
= target
;
2212 add_service("gdb", CONNECTION_PIPE
, 0, 1, gdb_new_connection
, gdb_input
, gdb_connection_closed
, gdb_service
);
2214 LOG_DEBUG("gdb service for target %s using pipes",
2215 target_get_name(target
));
2221 gdb_service
= malloc(sizeof(gdb_service_t
));
2222 gdb_service
->target
= target
;
2224 add_service("gdb", CONNECTION_TCP
, gdb_port
+ target
->target_number
, 1, gdb_new_connection
, gdb_input
, gdb_connection_closed
, gdb_service
);
2226 LOG_DEBUG("gdb service for target %s at port %i",
2227 target_get_name(target
),
2228 gdb_port
+ target
->target_number
);
2229 target
= target
->next
;
2236 /* daemon configuration command gdb_port */
2237 int handle_gdb_port_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2241 command_print(cmd_ctx
, "%d", gdb_port
);
2245 /* only if the port wasn't overwritten by cmdline */
2247 gdb_port
= strtoul(args
[0], NULL
, 0);
2252 int handle_gdb_detach_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2256 if (strcmp(args
[0], "resume") == 0)
2258 detach_mode
= GDB_DETACH_RESUME
;
2261 else if (strcmp(args
[0], "reset") == 0)
2263 detach_mode
= GDB_DETACH_RESET
;
2266 else if (strcmp(args
[0], "halt") == 0)
2268 detach_mode
= GDB_DETACH_HALT
;
2271 else if (strcmp(args
[0], "nothing") == 0)
2273 detach_mode
= GDB_DETACH_NOTHING
;
2277 LOG_WARNING("invalid gdb_detach configuration directive: %s", args
[0]);
2280 return ERROR_COMMAND_SYNTAX_ERROR
;
2283 int handle_gdb_memory_map_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2287 if (strcmp(args
[0], "enable") == 0)
2289 gdb_use_memory_map
= 1;
2292 else if (strcmp(args
[0], "disable") == 0)
2294 gdb_use_memory_map
= 0;
2298 LOG_WARNING("invalid gdb_memory_map configuration directive %s", args
[0]);
2301 return ERROR_COMMAND_SYNTAX_ERROR
;
2304 int handle_gdb_flash_program_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2308 if (strcmp(args
[0], "enable") == 0)
2310 gdb_flash_program
= 1;
2313 else if (strcmp(args
[0], "disable") == 0)
2315 gdb_flash_program
= 0;
2319 LOG_WARNING("invalid gdb_flash_program configuration directive: %s", args
[0]);
2322 return ERROR_COMMAND_SYNTAX_ERROR
;
2325 int handle_gdb_report_data_abort_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2329 if (strcmp(args
[0], "enable") == 0)
2331 gdb_report_data_abort
= 1;
2334 else if (strcmp(args
[0], "disable") == 0)
2336 gdb_report_data_abort
= 0;
2340 LOG_WARNING("invalid gdb_report_data_abort configuration directive: %s", args
[0]);
2343 return ERROR_COMMAND_SYNTAX_ERROR
;
2346 /* gdb_breakpoint_override */
2347 int handle_gdb_breakpoint_override_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2352 } else if (argc
== 1)
2354 gdb_breakpoint_override
= 1;
2355 if (strcmp(args
[0], "hard") == 0)
2357 gdb_breakpoint_override_type
= BKPT_HARD
;
2358 } else if (strcmp(args
[0], "soft") == 0)
2360 gdb_breakpoint_override_type
= BKPT_SOFT
;
2361 } else if (strcmp(args
[0], "disable") == 0)
2363 gdb_breakpoint_override
= 0;
2367 return ERROR_COMMAND_SYNTAX_ERROR
;
2369 if (gdb_breakpoint_override
)
2371 LOG_USER("force %s breakpoints", (gdb_breakpoint_override_type
== BKPT_HARD
)?"hard":"soft");
2374 LOG_USER("breakpoint type is not overriden");
2380 int gdb_register_commands(command_context_t
*command_context
)
2382 register_command(command_context
, NULL
, "gdb_port", handle_gdb_port_command
,
2383 COMMAND_ANY
, "daemon configuration command gdb_port");
2384 register_command(command_context
, NULL
, "gdb_detach", handle_gdb_detach_command
,
2385 COMMAND_CONFIG
, "resume/reset/halt/nothing - "
2386 "specify behavior when GDB detaches from the target");
2387 register_command(command_context
, NULL
, "gdb_memory_map", handle_gdb_memory_map_command
,
2388 COMMAND_CONFIG
, "enable or disable memory map");
2389 register_command(command_context
, NULL
, "gdb_flash_program", handle_gdb_flash_program_command
,
2390 COMMAND_CONFIG
, "enable or disable flash program");
2391 register_command(command_context
, NULL
, "gdb_report_data_abort", handle_gdb_report_data_abort_command
,
2392 COMMAND_CONFIG
, "enable or disable reporting data aborts");
2393 register_command(command_context
, NULL
, "gdb_breakpoint_override", handle_gdb_breakpoint_override_command
,
2394 COMMAND_EXEC
, "hard/soft/disable - force breakpoint type for gdb 'break' commands.");
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)