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
;
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
;
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
;
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
, u8 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
, u8
*bin
)
921 LOG_ERROR("BUG: gdb value with uneven number of characters encountered");
926 for (i
= 0; i
< str_len
; i
+=2)
928 u8 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.8x, len: 0x%8.8x", 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
++)
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.8x, len: 0x%8.8x", addr
, len
);
1271 for (i
=0; i
<len
; i
++)
1274 sscanf(separator
+ 2*i
, "%2x", &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.8x, len: 0x%8.8x", addr
, len
);
1326 retval
= target_write_buffer(target
, addr
, len
, (u8
*)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
)
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 retval
=target
->type
->step(target
, current
, address
, 0); /* step at current or address, don't handle breakpoints */
1374 int gdb_breakpoint_watchpoint_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1377 enum breakpoint_type bp_type
= BKPT_SOFT
/* dummy init to avoid warning */;
1378 enum watchpoint_rw wp_type
;
1386 type
= strtoul(packet
+ 1, &separator
, 16);
1388 if (type
== 0) /* memory breakpoint */
1389 bp_type
= BKPT_SOFT
;
1390 else if (type
== 1) /* hardware breakpoint */
1391 bp_type
= BKPT_HARD
;
1392 else if (type
== 2) /* write watchpoint */
1393 wp_type
= WPT_WRITE
;
1394 else if (type
== 3) /* read watchpoint */
1396 else if (type
== 4) /* access watchpoint */
1397 wp_type
= WPT_ACCESS
;
1399 if (gdb_breakpoint_override
&&((bp_type
==BKPT_SOFT
)||(bp_type
==BKPT_HARD
)))
1401 bp_type
=gdb_breakpoint_override_type
;
1404 if (*separator
!= ',')
1406 LOG_ERROR("incomplete breakpoint/watchpoint packet received, dropping connection");
1407 return ERROR_SERVER_REMOTE_CLOSED
;
1410 address
= strtoul(separator
+1, &separator
, 16);
1412 if (*separator
!= ',')
1414 LOG_ERROR("incomplete breakpoint/watchpoint packet received, dropping connection");
1415 return ERROR_SERVER_REMOTE_CLOSED
;
1418 size
= strtoul(separator
+1, &separator
, 16);
1424 if (packet
[0] == 'Z')
1426 if ((retval
= breakpoint_add(target
, address
, size
, bp_type
)) != ERROR_OK
)
1428 if ((retval
= gdb_error(connection
, retval
)) != ERROR_OK
)
1433 gdb_put_packet(connection
, "OK", 2);
1438 breakpoint_remove(target
, address
);
1439 gdb_put_packet(connection
, "OK", 2);
1446 if (packet
[0] == 'Z')
1448 if ((retval
= watchpoint_add(target
, address
, size
, type
-2, 0, 0xffffffffu
)) != ERROR_OK
)
1450 if ((retval
= gdb_error(connection
, retval
)) != ERROR_OK
)
1455 gdb_put_packet(connection
, "OK", 2);
1460 watchpoint_remove(target
, address
);
1461 gdb_put_packet(connection
, "OK", 2);
1472 /* print out a string and allocate more space as needed, mainly used for XML at this point */
1473 void xml_printf(int *retval
, char **xml
, int *pos
, int *size
, const char *fmt
, ...)
1475 if (*retval
!= ERROR_OK
)
1483 if ((*xml
== NULL
) || (!first
))
1485 /* start by 0 to exercise all the code paths.
1486 * Need minimum 2 bytes to fit 1 char and 0 terminator. */
1488 *size
= *size
* 2 + 2;
1490 *xml
= realloc(*xml
, *size
);
1495 *retval
= ERROR_SERVER_REMOTE_CLOSED
;
1503 ret
= vsnprintf(*xml
+ *pos
, *size
- *pos
, fmt
, ap
);
1505 if ((ret
> 0) && ((ret
+ 1) < *size
- *pos
))
1510 /* there was just enough or not enough space, allocate more. */
1515 static int decode_xfer_read(char *buf
, char **annex
, int *ofs
, unsigned int *len
)
1519 /* Extract and NUL-terminate the annex. */
1521 while (*buf
&& *buf
!= ':')
1527 /* After the read marker and annex, qXfer looks like a
1528 * traditional 'm' packet. */
1530 *ofs
= strtoul(buf
, &separator
, 16);
1532 if (*separator
!= ',')
1535 *len
= strtoul(separator
+1, NULL
, 16);
1540 int gdb_calc_blocksize(flash_bank_t
*bank
)
1543 u32 block_size
= 0xffffffff;
1545 /* loop through all sectors and return smallest sector size */
1547 for (i
= 0; i
< (u32
)bank
->num_sectors
; i
++)
1549 if (bank
->sectors
[i
].size
< block_size
)
1550 block_size
= bank
->sectors
[i
].size
;
1556 static int compare_bank (const void * a
, const void * b
)
1558 flash_bank_t
*b1
, *b2
;
1559 b1
=*((flash_bank_t
**)a
);
1560 b2
=*((flash_bank_t
**)b
);
1562 if (b1
->base
==b2
->base
)
1565 } else if (b1
->base
>b2
->base
)
1574 int gdb_query_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1576 command_context_t
*cmd_ctx
= connection
->cmd_ctx
;
1577 gdb_connection_t
*gdb_connection
= connection
->priv
;
1579 if (strstr(packet
, "qRcmd,"))
1581 if (packet_size
> 6)
1585 cmd
= malloc((packet_size
- 6)/2 + 1);
1586 for (i
=0; i
< (packet_size
- 6)/2; i
++)
1589 sscanf(packet
+ 6 + 2*i
, "%2x", &tmp
);
1592 cmd
[(packet_size
- 6)/2] = 0x0;
1594 /* We want to print all debug output to GDB connection */
1595 log_add_callback(gdb_log_callback
, connection
);
1596 target_call_timer_callbacks_now();
1597 command_run_line(cmd_ctx
, cmd
);
1598 target_call_timer_callbacks_now();
1599 log_remove_callback(gdb_log_callback
, connection
);
1602 gdb_put_packet(connection
, "OK", 2);
1605 else if (strstr(packet
, "qCRC:"))
1607 if (packet_size
> 5)
1616 /* skip command character */
1619 addr
= strtoul(packet
, &separator
, 16);
1621 if (*separator
!= ',')
1623 LOG_ERROR("incomplete read memory packet received, dropping connection");
1624 return ERROR_SERVER_REMOTE_CLOSED
;
1627 len
= strtoul(separator
+ 1, NULL
, 16);
1629 retval
= target_checksum_memory(target
, addr
, len
, &checksum
);
1631 if (retval
== ERROR_OK
)
1633 snprintf(gdb_reply
, 10, "C%8.8x", checksum
);
1634 gdb_put_packet(connection
, gdb_reply
, 9);
1638 if ((retval
= gdb_error(connection
, retval
)) != ERROR_OK
)
1645 else if (strstr(packet
, "qSupported"))
1647 /* we currently support packet size and qXfer:memory-map:read (if enabled)
1648 * disable qXfer:features:read for the moment */
1649 int retval
= ERROR_OK
;
1650 char *buffer
= NULL
;
1654 xml_printf(&retval
, &buffer
, &pos
, &size
,
1655 "PacketSize=%x;qXfer:memory-map:read%c;qXfer:features:read-;QStartNoAckMode+",
1656 (GDB_BUFFER_SIZE
- 1), ((gdb_use_memory_map
== 1)&&(flash_get_bank_count()>0)) ? '+' : '-');
1658 if (retval
!= ERROR_OK
)
1660 gdb_send_error(connection
, 01);
1664 gdb_put_packet(connection
, buffer
, strlen(buffer
));
1669 else if (strstr(packet
, "qXfer:memory-map:read::")&&(flash_get_bank_count()>0))
1671 /* We get away with only specifying flash here. Regions that are not
1672 * specified are treated as if we provided no memory map(if not we
1673 * could detect the holes and mark them as RAM).
1674 * Normally we only execute this code once, but no big deal if we
1675 * have to regenerate it a couple of times. */
1681 int retval
= ERROR_OK
;
1688 /* skip command character */
1691 offset
= strtoul(packet
, &separator
, 16);
1692 length
= strtoul(separator
+ 1, &separator
, 16);
1694 xml_printf(&retval
, &xml
, &pos
, &size
, "<memory-map>\n");
1697 sort banks in ascending order, we need to make non-flash memory be ram(or rather
1698 read/write) by default for GDB.
1699 GDB does not have a concept of non-cacheable read/write memory.
1701 flash_bank_t
**banks
=malloc(sizeof(flash_bank_t
*)*flash_get_bank_count());
1704 for (i
=0; i
<flash_get_bank_count(); i
++)
1706 p
= get_flash_bank_by_num(i
);
1710 retval
= ERROR_FAIL
;
1711 gdb_send_error(connection
, retval
);
1717 qsort(banks
, flash_get_bank_count(), sizeof(flash_bank_t
*), compare_bank
);
1720 for (i
=0; i
<flash_get_bank_count(); i
++)
1724 if (ram_start
<p
->base
)
1726 xml_printf(&retval
, &xml
, &pos
, &size
, "<memory type=\"ram\" start=\"0x%x\" length=\"0x%x\"/>\n",
1727 ram_start
, p
->base
-ram_start
);
1730 /* if device has uneven sector sizes, eg. str7, lpc
1731 * we pass the smallest sector size to gdb memory map */
1732 blocksize
= gdb_calc_blocksize(p
);
1734 xml_printf(&retval
, &xml
, &pos
, &size
, "<memory type=\"flash\" start=\"0x%x\" length=\"0x%x\">\n" \
1735 "<property name=\"blocksize\">0x%x</property>\n" \
1737 p
->base
, p
->size
, blocksize
);
1738 ram_start
=p
->base
+p
->size
;
1742 xml_printf(&retval
, &xml
, &pos
, &size
, "<memory type=\"ram\" start=\"0x%x\" length=\"0x%x\"/>\n",
1743 ram_start
, 0-ram_start
);
1746 /* a flash chip could be at the very end of the 32 bit address space, in which case
1747 ram_start will be precisely 0 */
1753 xml_printf(&retval
, &xml
, &pos
, &size
, "</memory-map>\n");
1755 if (retval
!= ERROR_OK
)
1757 gdb_send_error(connection
, retval
);
1761 if (offset
+ length
> pos
)
1763 length
= pos
- offset
;
1766 char *t
= malloc(length
+ 1);
1768 memcpy(t
+ 1, xml
+ offset
, length
);
1769 gdb_put_packet(connection
, t
, length
+ 1);
1775 else if (strstr(packet
, "qXfer:features:read:"))
1780 int retval
= ERROR_OK
;
1783 unsigned int length
;
1786 /* skip command character */
1789 if (decode_xfer_read(packet
, &annex
, &offset
, &length
) < 0)
1791 gdb_send_error(connection
, 01);
1795 if (strcmp(annex
, "target.xml") != 0)
1797 gdb_send_error(connection
, 01);
1801 xml_printf(&retval
, &xml
, &pos
, &size
, \
1802 "l<target version=\"1.0\">\n<architecture>arm</architecture>\n</target>\n");
1804 if (retval
!= ERROR_OK
)
1806 gdb_send_error(connection
, retval
);
1810 gdb_put_packet(connection
, xml
, strlen(xml
));
1815 else if (strstr(packet
, "QStartNoAckMode"))
1817 gdb_connection
->noack_mode
= 1;
1818 gdb_put_packet(connection
, "OK", 2);
1822 gdb_put_packet(connection
, "", 0);
1826 int gdb_v_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1828 gdb_connection_t
*gdb_connection
= connection
->priv
;
1829 gdb_service_t
*gdb_service
= connection
->service
->priv
;
1832 /* if flash programming disabled - send a empty reply */
1834 if (gdb_flash_program
== 0)
1836 gdb_put_packet(connection
, "", 0);
1840 if (strstr(packet
, "vFlashErase:"))
1843 unsigned long length
;
1845 char *parse
= packet
+ 12;
1848 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1849 return ERROR_SERVER_REMOTE_CLOSED
;
1852 addr
= strtoul(parse
, &parse
, 16);
1854 if (*(parse
++) != ',' || *parse
== '\0')
1856 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1857 return ERROR_SERVER_REMOTE_CLOSED
;
1860 length
= strtoul(parse
, &parse
, 16);
1864 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1865 return ERROR_SERVER_REMOTE_CLOSED
;
1868 /* assume all sectors need erasing - stops any problems
1869 * when flash_write is called multiple times */
1872 /* perform any target specific operations before the erase */
1873 target_call_event_callbacks(gdb_service
->target
, TARGET_EVENT_GDB_FLASH_ERASE_START
);
1874 result
= flash_erase_address_range(gdb_service
->target
, addr
, length
);
1875 target_call_event_callbacks(gdb_service
->target
, TARGET_EVENT_GDB_FLASH_ERASE_END
);
1878 if (result
!= ERROR_OK
)
1880 /* GDB doesn't evaluate the actual error number returned,
1881 * treat a failed erase as an I/O error
1883 gdb_send_error(connection
, EIO
);
1884 LOG_ERROR("flash_erase returned %i", result
);
1887 gdb_put_packet(connection
, "OK", 2);
1892 if (strstr(packet
, "vFlashWrite:"))
1896 unsigned long length
;
1897 char *parse
= packet
+ 12;
1901 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1902 return ERROR_SERVER_REMOTE_CLOSED
;
1904 addr
= strtoul(parse
, &parse
, 16);
1905 if (*(parse
++) != ':')
1907 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1908 return ERROR_SERVER_REMOTE_CLOSED
;
1910 length
= packet_size
- (parse
- packet
);
1912 /* create a new image if there isn't already one */
1913 if (gdb_connection
->vflash_image
== NULL
)
1915 gdb_connection
->vflash_image
= malloc(sizeof(image_t
));
1916 image_open(gdb_connection
->vflash_image
, "", "build");
1919 /* create new section with content from packet buffer */
1920 if((retval
= image_add_section(gdb_connection
->vflash_image
, addr
, length
, 0x0, (u8
*)parse
)) != ERROR_OK
)
1925 gdb_put_packet(connection
, "OK", 2);
1930 if (!strcmp(packet
, "vFlashDone"))
1934 /* process the flashing buffer. No need to erase as GDB
1935 * always issues a vFlashErase first. */
1936 target_call_event_callbacks(gdb_service
->target
, TARGET_EVENT_GDB_FLASH_WRITE_START
);
1937 result
= flash_write(gdb_service
->target
, gdb_connection
->vflash_image
, &written
, 0);
1938 target_call_event_callbacks(gdb_service
->target
, TARGET_EVENT_GDB_FLASH_WRITE_END
);
1939 if ( result
!= ERROR_OK
)
1941 if (result
== ERROR_FLASH_DST_OUT_OF_BANK
)
1942 gdb_put_packet(connection
, "E.memtype", 9);
1944 gdb_send_error(connection
, EIO
);
1948 LOG_DEBUG("wrote %u bytes from vFlash image to flash", written
);
1949 gdb_put_packet(connection
, "OK", 2);
1952 image_close(gdb_connection
->vflash_image
);
1953 free(gdb_connection
->vflash_image
);
1954 gdb_connection
->vflash_image
= NULL
;
1959 gdb_put_packet(connection
, "", 0);
1963 int gdb_detach(connection_t
*connection
, target_t
*target
)
1966 switch( detach_mode
)
1968 case GDB_DETACH_RESUME
:
1969 target_handle_event( target
, TARGET_EVENT_OLD_pre_resume
);
1970 target_resume(target
, 1, 0, 1, 0);
1973 case GDB_DETACH_RESET
:
1974 /* FIX?? make this configurable?? */
1975 target_process_reset(connection
->cmd_ctx
, RESET_HALT
);
1978 case GDB_DETACH_HALT
:
1979 target_halt(target
);
1982 case GDB_DETACH_NOTHING
:
1986 gdb_put_packet(connection
, "OK", 2);
1990 static void gdb_log_callback(void *priv
, const char *file
, int line
,
1991 const char *function
, const char *string
)
1993 connection_t
*connection
= priv
;
1994 gdb_connection_t
*gdb_con
= connection
->priv
;
1998 /* do not reply this using the O packet */
2002 gdb_output_con(connection
, string
);
2005 /* Do not allocate this on the stack */
2006 char gdb_packet_buffer
[GDB_BUFFER_SIZE
];
2008 static void gdb_sig_halted(connection_t
*connection
)
2011 snprintf(sig_reply
, 4, "T%2.2x", 2);
2012 gdb_put_packet(connection
, sig_reply
, 3);
2016 int gdb_input_inner(connection_t
*connection
)
2018 gdb_service_t
*gdb_service
= connection
->service
->priv
;
2019 target_t
*target
= gdb_service
->target
;
2020 char *packet
=gdb_packet_buffer
;
2023 gdb_connection_t
*gdb_con
= connection
->priv
;
2024 static int extended_protocol
= 0;
2026 /* drain input buffer */
2029 packet_size
= GDB_BUFFER_SIZE
-1;
2030 if ((retval
= gdb_get_packet(connection
, packet
, &packet_size
)) != ERROR_OK
)
2035 /* terminate with zero */
2036 packet
[packet_size
] = 0;
2038 if( LOG_LEVEL_IS( LOG_LVL_DEBUG
) ){
2039 if( packet
[0] == 'X' ){
2040 // binary packets spew junk into the debug log stream
2043 for( x
= 0 ; (x
< 49) && (packet
[x
] != ':') ; x
++ ){
2047 LOG_DEBUG("received packet: '%s:<binary-data>'", buf
);
2049 LOG_DEBUG("received packet: '%s'", packet
);
2053 if (packet_size
> 0)
2059 /* Hct... -- set thread
2060 * we don't have threads, send empty reply */
2061 gdb_put_packet(connection
, NULL
, 0);
2065 retval
= gdb_query_packet(connection
, target
, packet
, packet_size
);
2068 retval
= gdb_get_registers_packet(connection
, target
, packet
, packet_size
);
2071 retval
= gdb_set_registers_packet(connection
, target
, packet
, packet_size
);
2074 retval
= gdb_get_register_packet(connection
, target
, packet
, packet_size
);
2077 retval
= gdb_set_register_packet(connection
, target
, packet
, packet_size
);
2080 retval
= gdb_read_memory_packet(connection
, target
, packet
, packet_size
);
2083 retval
= gdb_write_memory_packet(connection
, target
, packet
, packet_size
);
2087 retval
= gdb_breakpoint_watchpoint_packet(connection
, target
, packet
, packet_size
);
2090 gdb_last_signal_packet(connection
, target
, packet
, packet_size
);
2095 if (target
->state
!= TARGET_HALTED
)
2097 /* If the target isn't in the halted state, then we can't
2098 * step/continue. This might be early setup, etc.
2100 gdb_sig_halted(connection
);
2103 /* We're running/stepping, in which case we can
2104 * forward log output until the target is halted
2106 gdb_connection_t
*gdb_con
= connection
->priv
;
2107 gdb_con
->frontend_state
= TARGET_RUNNING
;
2108 log_add_callback(gdb_log_callback
, connection
);
2109 target_call_event_callbacks(target
, TARGET_EVENT_GDB_START
);
2110 int retval
=gdb_step_continue_packet(connection
, target
, packet
, packet_size
);
2111 if (retval
!=ERROR_OK
)
2113 /* we'll never receive a halted condition... issue a false one.. */
2114 gdb_frontend_halted(target
, connection
);
2120 retval
= gdb_v_packet(connection
, target
, packet
, packet_size
);
2123 retval
= gdb_detach(connection
, target
);
2124 extended_protocol
= 0;
2127 if ((retval
= gdb_write_memory_binary_packet(connection
, target
, packet
, packet_size
)) != ERROR_OK
)
2131 if (extended_protocol
!= 0)
2133 gdb_put_packet(connection
, "OK", 2);
2134 return ERROR_SERVER_REMOTE_CLOSED
;
2136 /* handle extended remote protocol */
2137 extended_protocol
= 1;
2138 gdb_put_packet(connection
, "OK", 2);
2141 /* handle extended restart packet */
2142 breakpoint_clear_target(gdb_service
->target
);
2143 watchpoint_clear_target(gdb_service
->target
);
2144 command_run_linef(connection
->cmd_ctx
, "ocd_gdb_restart %d", get_num_by_target(target
));
2147 /* ignore unkown packets */
2148 LOG_DEBUG("ignoring 0x%2.2x packet", packet
[0]);
2149 gdb_put_packet(connection
, NULL
, 0);
2153 /* if a packet handler returned an error, exit input loop */
2154 if (retval
!= ERROR_OK
)
2158 if (gdb_con
->ctrl_c
)
2160 if (target
->state
== TARGET_RUNNING
)
2162 target_halt(target
);
2163 gdb_con
->ctrl_c
= 0;
2167 } while (gdb_con
->buf_cnt
> 0);
2172 int gdb_input(connection_t
*connection
)
2174 int retval
= gdb_input_inner(connection
);
2175 gdb_connection_t
*gdb_con
= connection
->priv
;
2176 if (retval
== ERROR_SERVER_REMOTE_CLOSED
)
2179 /* logging does not propagate the error, yet can set the gdb_con->closed flag */
2180 if (gdb_con
->closed
)
2181 return ERROR_SERVER_REMOTE_CLOSED
;
2183 /* we'll recover from any other errors(e.g. temporary timeouts, etc.) */
2189 gdb_service_t
*gdb_service
;
2190 target_t
*target
= all_targets
;
2194 LOG_WARNING("no gdb ports allocated as no target has been specified");
2198 if (gdb_port
== 0 && server_use_pipes
== 0)
2200 LOG_DEBUG("no gdb port specified, using default port 3333");
2204 if (server_use_pipes
)
2206 /* only a single gdb connection when using a pipe */
2208 gdb_service
= malloc(sizeof(gdb_service_t
));
2209 gdb_service
->target
= target
;
2211 add_service("gdb", CONNECTION_PIPE
, 0, 1, gdb_new_connection
, gdb_input
, gdb_connection_closed
, gdb_service
);
2213 LOG_DEBUG("gdb service for target %s using pipes", target
->type
->name
);
2219 gdb_service
= malloc(sizeof(gdb_service_t
));
2220 gdb_service
->target
= target
;
2222 add_service("gdb", CONNECTION_TCP
, gdb_port
+ target
->target_number
, 1, gdb_new_connection
, gdb_input
, gdb_connection_closed
, gdb_service
);
2224 LOG_DEBUG("gdb service for target %s at port %i", target
->type
->name
, gdb_port
+ target
->target_number
);
2225 target
= target
->next
;
2232 /* daemon configuration command gdb_port */
2233 int handle_gdb_port_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2237 command_print(cmd_ctx
, "%d", gdb_port
);
2241 /* only if the port wasn't overwritten by cmdline */
2243 gdb_port
= strtoul(args
[0], NULL
, 0);
2248 int handle_gdb_detach_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2252 if (strcmp(args
[0], "resume") == 0)
2254 detach_mode
= GDB_DETACH_RESUME
;
2257 else if (strcmp(args
[0], "reset") == 0)
2259 detach_mode
= GDB_DETACH_RESET
;
2262 else if (strcmp(args
[0], "halt") == 0)
2264 detach_mode
= GDB_DETACH_HALT
;
2267 else if (strcmp(args
[0], "nothing") == 0)
2269 detach_mode
= GDB_DETACH_NOTHING
;
2273 LOG_WARNING("invalid gdb_detach configuration directive: %s", args
[0]);
2276 return ERROR_COMMAND_SYNTAX_ERROR
;
2279 int handle_gdb_memory_map_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2283 if (strcmp(args
[0], "enable") == 0)
2285 gdb_use_memory_map
= 1;
2288 else if (strcmp(args
[0], "disable") == 0)
2290 gdb_use_memory_map
= 0;
2294 LOG_WARNING("invalid gdb_memory_map configuration directive %s", args
[0]);
2297 return ERROR_COMMAND_SYNTAX_ERROR
;
2300 int handle_gdb_flash_program_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2304 if (strcmp(args
[0], "enable") == 0)
2306 gdb_flash_program
= 1;
2309 else if (strcmp(args
[0], "disable") == 0)
2311 gdb_flash_program
= 0;
2315 LOG_WARNING("invalid gdb_flash_program configuration directive: %s", args
[0]);
2318 return ERROR_COMMAND_SYNTAX_ERROR
;
2321 int handle_gdb_report_data_abort_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2325 if (strcmp(args
[0], "enable") == 0)
2327 gdb_report_data_abort
= 1;
2330 else if (strcmp(args
[0], "disable") == 0)
2332 gdb_report_data_abort
= 0;
2336 LOG_WARNING("invalid gdb_report_data_abort configuration directive: %s", args
[0]);
2339 return ERROR_COMMAND_SYNTAX_ERROR
;
2342 /* gdb_breakpoint_override */
2343 int handle_gdb_breakpoint_override_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2350 gdb_breakpoint_override
= 1;
2351 if (strcmp(args
[0], "hard")==0)
2353 gdb_breakpoint_override_type
=BKPT_HARD
;
2354 } else if (strcmp(args
[0], "soft")==0)
2356 gdb_breakpoint_override_type
=BKPT_SOFT
;
2357 } else if (strcmp(args
[0], "disable") == 0)
2359 gdb_breakpoint_override
= 0;
2363 return ERROR_COMMAND_SYNTAX_ERROR
;
2365 if (gdb_breakpoint_override
)
2367 LOG_USER("force %s breakpoints", (gdb_breakpoint_override_type
==BKPT_HARD
)?"hard":"soft");
2370 LOG_USER("breakpoint type is not overriden");
2376 int gdb_register_commands(command_context_t
*command_context
)
2378 register_command(command_context
, NULL
, "gdb_port", handle_gdb_port_command
,
2379 COMMAND_ANY
, "daemon configuration command gdb_port");
2380 register_command(command_context
, NULL
, "gdb_detach", handle_gdb_detach_command
,
2381 COMMAND_CONFIG
, "resume/reset/halt/nothing - "
2382 "specify behavior when GDB detaches from the target");
2383 register_command(command_context
, NULL
, "gdb_memory_map", handle_gdb_memory_map_command
,
2384 COMMAND_CONFIG
, "enable or disable memory map");
2385 register_command(command_context
, NULL
, "gdb_flash_program", handle_gdb_flash_program_command
,
2386 COMMAND_CONFIG
, "enable or disable flash program");
2387 register_command(command_context
, NULL
, "gdb_report_data_abort", handle_gdb_report_data_abort_command
,
2388 COMMAND_CONFIG
, "enable or disable reporting data aborts");
2389 register_command(command_context
, NULL
, "gdb_breakpoint_override", handle_gdb_breakpoint_override_command
,
2390 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)