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 "replacements.h"
32 #include "gdb_server.h"
36 #include "binarybuffer.h"
38 #include "breakpoints.h"
41 #include "target_request.h"
42 #include "configuration.h"
50 #define _DEBUG_GDB_IO_
53 static int gdb_breakpoint_override
;
54 static enum breakpoint_type gdb_breakpoint_override_type
;
56 extern int gdb_error(connection_t
*connection
, int retval
);
57 static unsigned short gdb_port
;
58 static const char *DIGITS
= "0123456789abcdef";
60 static void gdb_log_callback(void *priv
, const char *file
, int line
,
61 const char *function
, const char *string
);
71 /* target behaviour on gdb detach */
72 enum gdb_detach_mode detach_mode
= GDB_DETACH_RESUME
;
74 /* set if we are sending a memory map to gdb
75 * via qXfer:memory-map:read packet */
76 /* enabled by default*/
77 int gdb_use_memory_map
= 1;
78 /* enabled by default*/
79 int gdb_flash_program
= 1;
81 /* if set, data aborts cause an error to be reported in memory read packets
82 * see the code in gdb_read_memory_packet() for further explanations */
83 int gdb_report_data_abort
= 0;
85 int gdb_last_signal(target_t
*target
)
87 switch (target
->debug_reason
)
89 case DBG_REASON_DBGRQ
:
90 return 0x2; /* SIGINT */
91 case DBG_REASON_BREAKPOINT
:
92 case DBG_REASON_WATCHPOINT
:
93 case DBG_REASON_WPTANDBKPT
:
94 return 0x05; /* SIGTRAP */
95 case DBG_REASON_SINGLESTEP
:
96 return 0x05; /* SIGTRAP */
97 case DBG_REASON_NOTHALTED
:
98 return 0x0; /* no signal... shouldn't happen */
100 LOG_USER("undefined debug reason %d - target needs reset", target
->debug_reason
);
105 int check_pending(connection_t
*connection
, int timeout_s
, int *got_data
)
107 /* a non-blocking socket will block if there is 0 bytes available on the socket,
108 * but return with as many bytes as are available immediately
112 gdb_connection_t
*gdb_con
= connection
->priv
;
118 if (gdb_con
->buf_cnt
>0)
125 FD_SET(connection
->fd
, &read_fds
);
127 tv
.tv_sec
= timeout_s
;
129 if (socket_select(connection
->fd
+ 1, &read_fds
, NULL
, NULL
, &tv
) == 0)
131 /* This can typically be because a "monitor" command took too long
132 * before printing any progress messages
136 return ERROR_GDB_TIMEOUT
;
142 *got_data
=FD_ISSET(connection
->fd
, &read_fds
)!=0;
146 int gdb_get_char(connection_t
*connection
, int* next_char
)
148 gdb_connection_t
*gdb_con
= connection
->priv
;
151 #ifdef _DEBUG_GDB_IO_
155 if (gdb_con
->buf_cnt
-- > 0)
157 *next_char
= *(gdb_con
->buf_p
++);
158 if (gdb_con
->buf_cnt
> 0)
159 connection
->input_pending
= 1;
161 connection
->input_pending
= 0;
163 #ifdef _DEBUG_GDB_IO_
164 LOG_DEBUG("returned char '%c' (0x%2.2x)", *next_char
, *next_char
);
172 if (connection
->service
->type
== CONNECTION_PIPE
)
174 gdb_con
->buf_cnt
= read(connection
->fd
, gdb_con
->buffer
, GDB_BUFFER_SIZE
);
178 retval
= check_pending(connection
, 1, NULL
);
179 if (retval
!= ERROR_OK
)
181 gdb_con
->buf_cnt
= read_socket(connection
->fd
, gdb_con
->buffer
, GDB_BUFFER_SIZE
);
184 if (gdb_con
->buf_cnt
> 0)
188 if (gdb_con
->buf_cnt
== 0)
191 return ERROR_SERVER_REMOTE_CLOSED
;
195 errno
= WSAGetLastError();
202 case WSAECONNABORTED
:
204 return ERROR_SERVER_REMOTE_CLOSED
;
207 return ERROR_SERVER_REMOTE_CLOSED
;
209 LOG_ERROR("read: %d", errno
);
220 return ERROR_SERVER_REMOTE_CLOSED
;
223 return ERROR_SERVER_REMOTE_CLOSED
;
225 LOG_ERROR("read: %s", strerror(errno
));
227 return ERROR_SERVER_REMOTE_CLOSED
;
232 #ifdef _DEBUG_GDB_IO_
233 debug_buffer
= malloc(gdb_con
->buf_cnt
+ 1);
234 memcpy(debug_buffer
, gdb_con
->buffer
, gdb_con
->buf_cnt
);
235 debug_buffer
[gdb_con
->buf_cnt
] = 0;
236 LOG_DEBUG("received '%s'", debug_buffer
);
240 gdb_con
->buf_p
= gdb_con
->buffer
;
242 *next_char
= *(gdb_con
->buf_p
++);
243 if (gdb_con
->buf_cnt
> 0)
244 connection
->input_pending
= 1;
246 connection
->input_pending
= 0;
247 #ifdef _DEBUG_GDB_IO_
248 LOG_DEBUG("returned char '%c' (0x%2.2x)", *next_char
, *next_char
);
254 int gdb_putback_char(connection_t
*connection
, int last_char
)
256 gdb_connection_t
*gdb_con
= connection
->priv
;
258 if (gdb_con
->buf_p
> gdb_con
->buffer
)
260 *(--gdb_con
->buf_p
) = last_char
;
265 LOG_ERROR("BUG: couldn't put character back");
271 /* The only way we can detect that the socket is closed is the first time
272 * we write to it, we will fail. Subsequent write operations will
273 * succeed. Shudder! */
274 int gdb_write(connection_t
*connection
, void *data
, int len
)
276 gdb_connection_t
*gdb_con
= connection
->priv
;
278 return ERROR_SERVER_REMOTE_CLOSED
;
280 if (connection
->service
->type
== CONNECTION_PIPE
)
282 /* write to stdout */
283 if (write(STDOUT_FILENO
, data
, len
) == len
)
290 if (write_socket(connection
->fd
, data
, len
) == len
)
296 return ERROR_SERVER_REMOTE_CLOSED
;
299 int gdb_put_packet_inner(connection_t
*connection
, char *buffer
, int len
)
302 unsigned char my_checksum
= 0;
303 #ifdef _DEBUG_GDB_IO_
308 gdb_connection_t
*gdb_con
= connection
->priv
;
310 for (i
= 0; i
< len
; i
++)
311 my_checksum
+= buffer
[i
];
313 #ifdef _DEBUG_GDB_IO_
315 * At this point we should have nothing in the input queue from GDB,
316 * however sometimes '-' is sent even though we've already received
317 * an ACK (+) for everything we've sent off.
322 if ((retval
=check_pending(connection
, 0, &gotdata
))!=ERROR_OK
)
326 if ((retval
= gdb_get_char(connection
, &reply
)) != ERROR_OK
)
329 /* fix a problem with some IAR tools */
330 gdb_putback_char( connection
, reply
);
331 LOG_DEBUG("Unexpected start of new packet");
335 LOG_WARNING("Discard unexpected char %c", reply
);
341 #ifdef _DEBUG_GDB_IO_
342 debug_buffer
= malloc(len
+ 1);
343 memcpy(debug_buffer
, buffer
, len
);
344 debug_buffer
[len
] = 0;
345 LOG_DEBUG("sending packet '$%s#%2.2x'", debug_buffer
, my_checksum
);
349 char local_buffer
[1024];
350 local_buffer
[0] = '$';
351 if ((size_t)len
+ 4 <= sizeof(local_buffer
))
353 /* performance gain on smaller packets by only a single call to gdb_write() */
354 memcpy(local_buffer
+1, buffer
, len
++);
355 local_buffer
[len
++] = '#';
356 local_buffer
[len
++] = DIGITS
[(my_checksum
>> 4) & 0xf];
357 local_buffer
[len
++] = DIGITS
[my_checksum
& 0xf];
358 if((retval
= gdb_write(connection
, local_buffer
, len
)) != ERROR_OK
)
365 /* larger packets are transmitted directly from caller supplied buffer
366 by several calls to gdb_write() to avoid dynamic allocation */
367 local_buffer
[1] = '#';
368 local_buffer
[2] = DIGITS
[(my_checksum
>> 4) & 0xf];
369 local_buffer
[3] = DIGITS
[my_checksum
& 0xf];
370 if((retval
= gdb_write(connection
, local_buffer
, 1)) != ERROR_OK
)
374 if((retval
= gdb_write(connection
, buffer
, len
)) != ERROR_OK
)
378 if((retval
= gdb_write(connection
, local_buffer
+1, 3)) != ERROR_OK
)
384 if (gdb_con
->noack_mode
)
387 if ((retval
= gdb_get_char(connection
, &reply
)) != ERROR_OK
)
392 else if (reply
== '-')
394 /* Stop sending output packets for now */
395 log_remove_callback(gdb_log_callback
, connection
);
396 LOG_WARNING("negative reply, retrying");
398 else if (reply
== 0x3)
401 if ((retval
= gdb_get_char(connection
, &reply
)) != ERROR_OK
)
405 else if (reply
== '-')
407 /* Stop sending output packets for now */
408 log_remove_callback(gdb_log_callback
, connection
);
409 LOG_WARNING("negative reply, retrying");
411 else if( reply
== '$' ){
412 LOG_ERROR("GDB missing ack(1) - assumed good");
413 gdb_putback_char( connection
, reply
);
417 LOG_ERROR("unknown character(1) 0x%2.2x in reply, dropping connection", reply
);
419 return ERROR_SERVER_REMOTE_CLOSED
;
422 else if( reply
== '$' ){
423 LOG_ERROR("GDB missing ack(2) - assumed good");
424 gdb_putback_char( connection
, reply
);
429 LOG_ERROR("unknown character(2) 0x%2.2x in reply, dropping connection", reply
);
431 return ERROR_SERVER_REMOTE_CLOSED
;
435 return ERROR_SERVER_REMOTE_CLOSED
;
440 int gdb_put_packet(connection_t
*connection
, char *buffer
, int len
)
442 gdb_connection_t
*gdb_con
= connection
->priv
;
444 int retval
= gdb_put_packet_inner(connection
, buffer
, len
);
447 /* we sent some data, reset timer for keep alive messages */
453 static __inline__
int fetch_packet(connection_t
*connection
, int *checksum_ok
, int noack
, int *len
, char *buffer
)
455 unsigned char my_checksum
= 0;
460 gdb_connection_t
*gdb_con
= connection
->priv
;
466 /* The common case is that we have an entire packet with no escape chars.
467 * We need to leave at least 2 bytes in the buffer to have
468 * gdb_get_char() update various bits and bobs correctly.
470 if ((gdb_con
->buf_cnt
> 2) && ((gdb_con
->buf_cnt
+count
) < *len
))
472 /* The compiler will struggle a bit with constant propagation and
473 * aliasing, so we help it by showing that these values do not
474 * change inside the loop
477 char *buf
= gdb_con
->buf_p
;
478 int run
= gdb_con
->buf_cnt
- 2;
485 if (character
== '#')
487 /* Danger! character can be '#' when esc is
488 * used so we need an explicit boolean for done here.
494 if (character
== '}')
496 /* data transmitted in binary mode (X packet)
497 * uses 0x7d as escape character */
498 my_checksum
+= character
& 0xff;
501 my_checksum
+= character
& 0xff;
502 buffer
[count
++] = (character
^ 0x20) & 0xff;
506 my_checksum
+= character
& 0xff;
507 buffer
[count
++] = character
& 0xff;
511 gdb_con
->buf_cnt
-= i
;
517 LOG_ERROR("packet buffer too small");
518 return ERROR_GDB_BUFFER_TOO_SMALL
;
521 if ((retval
= gdb_get_char(connection
, &character
)) != ERROR_OK
)
524 if (character
== '#')
527 if (character
== '}')
529 /* data transmitted in binary mode (X packet)
530 * uses 0x7d as escape character */
531 my_checksum
+= character
& 0xff;
532 if ((retval
= gdb_get_char(connection
, &character
)) != ERROR_OK
)
534 my_checksum
+= character
& 0xff;
535 buffer
[count
++] = (character
^ 0x20) & 0xff;
539 my_checksum
+= character
& 0xff;
540 buffer
[count
++] = character
& 0xff;
546 if ((retval
= gdb_get_char(connection
, &character
)) != ERROR_OK
)
548 checksum
[0] = character
;
549 if ((retval
= gdb_get_char(connection
, &character
)) != ERROR_OK
)
551 checksum
[1] = character
;
556 *checksum_ok
=(my_checksum
== strtoul(checksum
, NULL
, 16));
562 int gdb_get_packet_inner(connection_t
*connection
, char *buffer
, int *len
)
566 gdb_connection_t
*gdb_con
= connection
->priv
;
572 if ((retval
= gdb_get_char(connection
, &character
)) != ERROR_OK
)
575 #ifdef _DEBUG_GDB_IO_
576 LOG_DEBUG("character: '%c'", character
);
584 /* gdb sends a dummy ack '+' at every remote connect - see remote_start_remote (remote.c)
585 * incase anyone tries to debug why they receive this warning every time */
586 LOG_WARNING("acknowledgment received, but no packet pending");
589 LOG_WARNING("negative acknowledgment, but no packet pending");
596 LOG_WARNING("ignoring character 0x%x", character
);
599 } while (character
!= '$');
604 /* explicit code expansion here to get faster inlined code in -O3 by not
605 * calculating checksum
607 if (gdb_con
->noack_mode
)
609 if ((retval
=fetch_packet(connection
, &checksum_ok
, 1, len
, buffer
))!=ERROR_OK
)
613 if ((retval
=fetch_packet(connection
, &checksum_ok
, 0, len
, buffer
))!=ERROR_OK
)
617 if (gdb_con
->noack_mode
)
619 /* checksum is not checked in noack mode */
624 if ((retval
= gdb_write(connection
, "+", 1)) != ERROR_OK
)
632 return ERROR_SERVER_REMOTE_CLOSED
;
637 int gdb_get_packet(connection_t
*connection
, char *buffer
, int *len
)
639 gdb_connection_t
*gdb_con
= connection
->priv
;
641 int retval
= gdb_get_packet_inner(connection
, buffer
, len
);
646 int gdb_output_con(connection_t
*connection
, const char* line
)
651 bin_size
= strlen(line
);
653 hex_buffer
= malloc(bin_size
*2 + 2);
654 if (hex_buffer
== NULL
)
655 return ERROR_GDB_BUFFER_TOO_SMALL
;
658 for (i
=0; i
<bin_size
; i
++)
659 snprintf(hex_buffer
+ 1 + i
*2, 3, "%2.2x", line
[i
]);
660 hex_buffer
[bin_size
*2+1] = 0;
662 int retval
= gdb_put_packet(connection
, hex_buffer
, bin_size
*2 + 1);
668 int gdb_output(struct command_context_s
*context
, const char* line
)
670 /* this will be dumped to the log and also sent as an O packet if possible */
671 LOG_USER_N("%s", line
);
676 static void gdb_frontend_halted(struct target_s
*target
, connection_t
*connection
)
678 gdb_connection_t
*gdb_connection
= connection
->priv
;
680 /* In the GDB protocol when we are stepping or coninuing execution,
681 * we have a lingering reply. Upon receiving a halted event
682 * when we have that lingering packet, we reply to the original
683 * step or continue packet.
685 * Executing monitor commands can bring the target in and
686 * out of the running state so we'll see lots of TARGET_EVENT_XXX
687 * that are to be ignored.
689 if (gdb_connection
->frontend_state
== TARGET_RUNNING
)
694 /* stop forwarding log packets! */
695 log_remove_callback(gdb_log_callback
, connection
);
697 if (gdb_connection
->ctrl_c
)
700 gdb_connection
->ctrl_c
= 0;
704 signal
= gdb_last_signal(target
);
707 snprintf(sig_reply
, 4, "T%2.2x", signal
);
708 gdb_put_packet(connection
, sig_reply
, 3);
709 gdb_connection
->frontend_state
= TARGET_HALTED
;
713 int gdb_target_callback_event_handler(struct target_s
*target
, enum target_event event
, void *priv
)
716 connection_t
*connection
= priv
;
718 target_handle_event( target
, event
);
721 case TARGET_EVENT_EARLY_HALTED
:
722 gdb_frontend_halted(target
, connection
);
724 case TARGET_EVENT_HALTED
:
725 target_call_event_callbacks(target
, TARGET_EVENT_GDB_END
);
727 case TARGET_EVENT_GDB_FLASH_ERASE_START
:
728 target_handle_event( target
, TARGET_EVENT_OLD_gdb_program_config
);
729 if((retval
= jtag_execute_queue()) != ERROR_OK
)
741 int gdb_new_connection(connection_t
*connection
)
743 gdb_connection_t
*gdb_connection
= malloc(sizeof(gdb_connection_t
));
744 gdb_service_t
*gdb_service
= connection
->service
->priv
;
748 connection
->priv
= gdb_connection
;
750 /* initialize gdb connection information */
751 gdb_connection
->buf_p
= gdb_connection
->buffer
;
752 gdb_connection
->buf_cnt
= 0;
753 gdb_connection
->ctrl_c
= 0;
754 gdb_connection
->frontend_state
= TARGET_HALTED
;
755 gdb_connection
->vflash_image
= NULL
;
756 gdb_connection
->closed
= 0;
757 gdb_connection
->busy
= 0;
758 gdb_connection
->noack_mode
= 0;
760 /* send ACK to GDB for debug request */
761 gdb_write(connection
, "+", 1);
763 /* output goes through gdb connection */
764 command_set_output_handler(connection
->cmd_ctx
, gdb_output
, connection
);
766 /* we must remove all breakpoints registered to the target as a previous
767 * GDB session could leave dangling breakpoints if e.g. communication
770 breakpoint_clear_target(gdb_service
->target
);
771 watchpoint_clear_target(gdb_service
->target
);
773 /* register callback to be informed about target events */
774 target_register_event_callback(gdb_target_callback_event_handler
, connection
);
776 /* a gdb session just attached, try to put the target in halt mode.
780 * If the halt fails(e.g. target needs a reset, JTAG communication not
781 * working, etc.), then the GDB connect will succeed as
782 * the get_gdb_reg_list() will lie and return a register list with
785 * This allows GDB monitor commands to be run from a GDB init script to
786 * initialize the target
788 * Also, since the halt() is asynchronous target connect will be
789 * instantaneous and thus avoiding annoying timeout problems during
792 target_halt(gdb_service
->target
);
793 /* FIX!!!! could extended-remote work better here?
795 * wait a tiny bit for halted state or we just continue. The
796 * GDB register packet will then contain garbage
798 target_wait_state(gdb_service
->target
, TARGET_HALTED
, 500);
800 /* remove the initial ACK from the incoming buffer */
801 if ((retval
= gdb_get_char(connection
, &initial_ack
)) != ERROR_OK
)
804 /* FIX!!!??? would we actually ever receive a + here???
807 if (initial_ack
!= '+')
808 gdb_putback_char(connection
, initial_ack
);
809 target_call_event_callbacks(gdb_service
->target
, TARGET_EVENT_GDB_ATTACH
);
813 int gdb_connection_closed(connection_t
*connection
)
815 gdb_service_t
*gdb_service
= connection
->service
->priv
;
816 gdb_connection_t
*gdb_connection
= connection
->priv
;
818 /* see if an image built with vFlash commands is left */
819 if (gdb_connection
->vflash_image
)
821 image_close(gdb_connection
->vflash_image
);
822 free(gdb_connection
->vflash_image
);
823 gdb_connection
->vflash_image
= NULL
;
826 /* if this connection registered a debug-message receiver delete it */
827 delete_debug_msg_receiver(connection
->cmd_ctx
, gdb_service
->target
);
829 if (connection
->priv
)
831 free(connection
->priv
);
832 connection
->priv
= NULL
;
836 LOG_ERROR("BUG: connection->priv == NULL");
839 target_unregister_event_callback(gdb_target_callback_event_handler
, connection
);
840 target_call_event_callbacks(gdb_service
->target
, TARGET_EVENT_GDB_END
);
841 log_remove_callback(gdb_log_callback
, connection
);
843 target_call_event_callbacks(gdb_service
->target
, TARGET_EVENT_GDB_DETACH
);
848 void gdb_send_error(connection_t
*connection
, u8 the_error
)
851 snprintf(err
, 4, "E%2.2X", the_error
);
852 gdb_put_packet(connection
, err
, 3);
855 int gdb_last_signal_packet(connection_t
*connection
, target_t
*target
, char* packet
, int packet_size
)
860 signal
= gdb_last_signal(target
);
862 snprintf(sig_reply
, 4, "S%2.2x", signal
);
863 gdb_put_packet(connection
, sig_reply
, 3);
868 static int gdb_reg_pos(target_t
*target
, int pos
, int len
)
870 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
873 return len
- 1 - pos
;
876 /* Convert register to string of bytes. NB! The # of bits in the
877 * register might be non-divisible by 8(a byte), in which
878 * case an entire byte is shown.
880 * NB! the format on the wire is the target endianess
882 * The format of reg->value is little endian
885 void gdb_str_to_target(target_t
*target
, char *tstr
, reg_t
*reg
)
892 buf_len
= CEIL(reg
->size
, 8);
894 for (i
= 0; i
< buf_len
; i
++)
896 int j
= gdb_reg_pos(target
, i
, buf_len
);
897 tstr
[i
*2] = DIGITS
[(buf
[j
]>>4) & 0xf];
898 tstr
[i
*2+1] = DIGITS
[buf
[j
]&0xf];
902 static int hextoint(char c
)
913 LOG_ERROR("BUG: invalid register value %08x", c
);
917 /* copy over in register buffer */
918 void gdb_target_to_reg(target_t
*target
, char *tstr
, int str_len
, u8
*bin
)
922 LOG_ERROR("BUG: gdb value with uneven number of characters encountered");
927 for (i
= 0; i
< str_len
; i
+=2)
929 u8 t
= hextoint(tstr
[i
])<<4;
930 t
|= hextoint(tstr
[i
+1]);
932 int j
= gdb_reg_pos(target
, i
/2, str_len
/2);
937 int gdb_get_registers_packet(connection_t
*connection
, target_t
*target
, char* packet
, int packet_size
)
942 int reg_packet_size
= 0;
947 #ifdef _DEBUG_GDB_IO_
951 if ((retval
= target
->type
->get_gdb_reg_list(target
, ®_list
, ®_list_size
)) != ERROR_OK
)
953 return gdb_error(connection
, retval
);
956 for (i
= 0; i
< reg_list_size
; i
++)
958 reg_packet_size
+= reg_list
[i
]->size
;
961 reg_packet
= malloc(CEIL(reg_packet_size
, 8) * 2);
962 reg_packet_p
= reg_packet
;
964 for (i
= 0; i
< reg_list_size
; i
++)
966 gdb_str_to_target(target
, reg_packet_p
, reg_list
[i
]);
967 reg_packet_p
+= CEIL(reg_list
[i
]->size
, 8) * 2;
970 #ifdef _DEBUG_GDB_IO_
973 reg_packet_p
= strndup(reg_packet
, CEIL(reg_packet_size
, 8) * 2);
974 LOG_DEBUG("reg_packet: %s", reg_packet_p
);
979 gdb_put_packet(connection
, reg_packet
, CEIL(reg_packet_size
, 8) * 2);
987 int gdb_set_registers_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
995 #ifdef _DEBUG_GDB_IO_
999 /* skip command character */
1003 if (packet_size
% 2)
1005 LOG_WARNING("GDB set_registers packet with uneven characters received, dropping connection");
1006 return ERROR_SERVER_REMOTE_CLOSED
;
1009 if ((retval
= target
->type
->get_gdb_reg_list(target
, ®_list
, ®_list_size
)) != ERROR_OK
)
1011 return gdb_error(connection
, retval
);
1015 for (i
= 0; i
< reg_list_size
; i
++)
1018 int chars
= (CEIL(reg_list
[i
]->size
, 8) * 2);
1020 if (packet_p
+ chars
> packet
+ packet_size
)
1022 LOG_ERROR("BUG: register packet is too small for registers");
1025 reg_arch_type_t
*arch_type
;
1026 bin_buf
= malloc(CEIL(reg_list
[i
]->size
, 8));
1027 gdb_target_to_reg(target
, packet_p
, chars
, bin_buf
);
1029 /* get register arch_type, and call set method */
1030 arch_type
= register_get_arch_type(reg_list
[i
]->arch_type
);
1032 arch_type
->set(reg_list
[i
], bin_buf
);
1034 /* advance packet pointer */
1041 /* free reg_t *reg_list[] array allocated by get_gdb_reg_list */
1044 gdb_put_packet(connection
, "OK", 2);
1049 int gdb_get_register_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1052 int reg_num
= strtoul(packet
+ 1, NULL
, 16);
1057 #ifdef _DEBUG_GDB_IO_
1061 if ((retval
= target
->type
->get_gdb_reg_list(target
, ®_list
, ®_list_size
)) != ERROR_OK
)
1063 return gdb_error(connection
, retval
);
1066 if (reg_list_size
<= reg_num
)
1068 LOG_ERROR("gdb requested a non-existing register");
1072 reg_packet
= malloc(CEIL(reg_list
[reg_num
]->size
, 8) * 2);
1074 gdb_str_to_target(target
, reg_packet
, reg_list
[reg_num
]);
1076 gdb_put_packet(connection
, reg_packet
, CEIL(reg_list
[reg_num
]->size
, 8) * 2);
1084 int gdb_set_register_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1088 int reg_num
= strtoul(packet
+ 1, &separator
, 16);
1092 reg_arch_type_t
*arch_type
;
1096 if ((retval
= target
->type
->get_gdb_reg_list(target
, ®_list
, ®_list_size
)) != ERROR_OK
)
1098 return gdb_error(connection
, retval
);
1101 if (reg_list_size
< reg_num
)
1103 LOG_ERROR("gdb requested a non-existing register");
1104 return ERROR_SERVER_REMOTE_CLOSED
;
1107 if (*separator
!= '=')
1109 LOG_ERROR("GDB 'set register packet', but no '=' following the register number");
1110 return ERROR_SERVER_REMOTE_CLOSED
;
1113 /* convert from GDB-string (target-endian) to hex-string (big-endian) */
1114 bin_buf
= malloc(CEIL(reg_list
[reg_num
]->size
, 8));
1115 int chars
= (CEIL(reg_list
[reg_num
]->size
, 8) * 2);
1117 /* fix!!! add some sanity checks on packet size here */
1119 gdb_target_to_reg(target
, separator
+ 1, chars
, bin_buf
);
1121 /* get register arch_type, and call set method */
1122 arch_type
= register_get_arch_type(reg_list
[reg_num
]->arch_type
);
1123 arch_type
->set(reg_list
[reg_num
], bin_buf
);
1125 gdb_put_packet(connection
, "OK", 2);
1133 int gdb_error(connection_t
*connection
, int retval
)
1137 case ERROR_TARGET_DATA_ABORT
:
1138 gdb_send_error(connection
, EIO
);
1140 case ERROR_TARGET_TRANSLATION_FAULT
:
1141 gdb_send_error(connection
, EFAULT
);
1143 case ERROR_TARGET_UNALIGNED_ACCESS
:
1144 gdb_send_error(connection
, EFAULT
);
1146 case ERROR_TARGET_NOT_HALTED
:
1147 gdb_send_error(connection
, EFAULT
);
1150 /* This could be that the target reset itself. */
1151 LOG_ERROR("unexpected error %i", retval
);
1152 gdb_send_error(connection
, EFAULT
);
1159 /* We don't have to worry about the default 2 second timeout for GDB packets,
1160 * because GDB breaks up large memory reads into smaller reads.
1162 * 8191 bytes by the looks of it. Why 8191 bytes instead of 8192?????
1164 int gdb_read_memory_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1173 int retval
= ERROR_OK
;
1175 /* skip command character */
1178 addr
= strtoul(packet
, &separator
, 16);
1180 if (*separator
!= ',')
1182 LOG_ERROR("incomplete read memory packet received, dropping connection");
1183 return ERROR_SERVER_REMOTE_CLOSED
;
1186 len
= strtoul(separator
+1, NULL
, 16);
1188 buffer
= malloc(len
);
1190 LOG_DEBUG("addr: 0x%8.8x, len: 0x%8.8x", addr
, len
);
1192 retval
= target_read_buffer(target
, addr
, len
, buffer
);
1194 if ((retval
!=ERROR_OK
)&&!gdb_report_data_abort
)
1196 /* TODO : Here we have to lie and send back all zero's lest stack traces won't work.
1197 * At some point this might be fixed in GDB, in which case this code can be removed.
1199 * OpenOCD developers are acutely aware of this problem, but there is nothing
1200 * gained by involving the user in this problem that hopefully will get resolved
1203 * http://sourceware.org/cgi-bin/gnatsweb.pl?cmd=view%20audit-trail&database=gdb&pr=2395
1205 * For now, the default is to fix up things to make current GDB versions work.
1206 * This can be overwritten using the gdb_report_data_abort <'enable'|'disable'> command.
1208 memset(buffer
, 0, len
);
1212 if (retval
== ERROR_OK
)
1214 hex_buffer
= malloc(len
* 2 + 1);
1217 for (i
= 0; i
< len
; i
++)
1220 hex_buffer
[2 * i
] = DIGITS
[(t
>> 4) & 0xf];
1221 hex_buffer
[2 * i
+ 1] = DIGITS
[t
& 0xf];
1224 gdb_put_packet(connection
, hex_buffer
, len
* 2);
1230 retval
= gdb_error(connection
, retval
);
1238 int gdb_write_memory_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1249 /* skip command character */
1252 addr
= strtoul(packet
, &separator
, 16);
1254 if (*separator
!= ',')
1256 LOG_ERROR("incomplete write memory packet received, dropping connection");
1257 return ERROR_SERVER_REMOTE_CLOSED
;
1260 len
= strtoul(separator
+1, &separator
, 16);
1262 if (*(separator
++) != ':')
1264 LOG_ERROR("incomplete write memory packet received, dropping connection");
1265 return ERROR_SERVER_REMOTE_CLOSED
;
1268 buffer
= malloc(len
);
1270 LOG_DEBUG("addr: 0x%8.8x, len: 0x%8.8x", addr
, len
);
1272 for (i
=0; i
<len
; i
++)
1275 sscanf(separator
+ 2*i
, "%2x", &tmp
);
1279 retval
= target_write_buffer(target
, addr
, len
, buffer
);
1281 if (retval
== ERROR_OK
)
1283 gdb_put_packet(connection
, "OK", 2);
1287 retval
= gdb_error(connection
, retval
);
1295 int gdb_write_memory_binary_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1303 /* skip command character */
1306 addr
= strtoul(packet
, &separator
, 16);
1308 if (*separator
!= ',')
1310 LOG_ERROR("incomplete write memory binary packet received, dropping connection");
1311 return ERROR_SERVER_REMOTE_CLOSED
;
1314 len
= strtoul(separator
+1, &separator
, 16);
1316 if (*(separator
++) != ':')
1318 LOG_ERROR("incomplete write memory binary packet received, dropping connection");
1319 return ERROR_SERVER_REMOTE_CLOSED
;
1325 LOG_DEBUG("addr: 0x%8.8x, len: 0x%8.8x", addr
, len
);
1327 retval
= target_write_buffer(target
, addr
, len
, (u8
*)separator
);
1330 if (retval
== ERROR_OK
)
1332 gdb_put_packet(connection
, "OK", 2);
1336 if ((retval
= gdb_error(connection
, retval
)) != ERROR_OK
)
1343 int gdb_step_continue_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1347 int retval
=ERROR_OK
;
1351 if (packet_size
> 1)
1353 packet
[packet_size
] = 0;
1354 address
= strtoul(packet
+ 1, NULL
, 16);
1361 if (packet
[0] == 'c')
1363 LOG_DEBUG("continue");
1364 target_handle_event( target
, TARGET_EVENT_OLD_pre_resume
);
1365 retval
=target_resume(target
, current
, address
, 0, 0); /* resume at current address, don't handle breakpoints, not debugging */
1367 else if (packet
[0] == 's')
1370 retval
=target
->type
->step(target
, current
, address
, 0); /* step at current or address, don't handle breakpoints */
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 u32 block_size
= 0xffffffff;
1546 /* loop through all sectors and return smallest sector size */
1548 for (i
= 0; i
< (u32
)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
, "%2x", &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.8x", 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
);
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, (u8
*)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", 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_WARNING("no gdb port specified, using default port 3333");
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", target
->type
->name
);
2220 gdb_service
= malloc(sizeof(gdb_service_t
));
2221 gdb_service
->target
= target
;
2223 add_service("gdb", CONNECTION_TCP
, gdb_port
+ target
->target_number
, 1, gdb_new_connection
, gdb_input
, gdb_connection_closed
, gdb_service
);
2225 LOG_DEBUG("gdb service for target %s at port %i", target
->type
->name
, gdb_port
+ target
->target_number
);
2226 target
= target
->next
;
2233 /* daemon configuration command gdb_port */
2234 int handle_gdb_port_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2238 command_print(cmd_ctx
, "%d", gdb_port
);
2242 /* only if the port wasn't overwritten by cmdline */
2244 gdb_port
= strtoul(args
[0], NULL
, 0);
2249 int handle_gdb_detach_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2253 if (strcmp(args
[0], "resume") == 0)
2255 detach_mode
= GDB_DETACH_RESUME
;
2258 else if (strcmp(args
[0], "reset") == 0)
2260 detach_mode
= GDB_DETACH_RESET
;
2263 else if (strcmp(args
[0], "halt") == 0)
2265 detach_mode
= GDB_DETACH_HALT
;
2268 else if (strcmp(args
[0], "nothing") == 0)
2270 detach_mode
= GDB_DETACH_NOTHING
;
2274 LOG_WARNING("invalid gdb_detach configuration directive: %s", args
[0]);
2277 return ERROR_COMMAND_SYNTAX_ERROR
;
2280 int handle_gdb_memory_map_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2284 if (strcmp(args
[0], "enable") == 0)
2286 gdb_use_memory_map
= 1;
2289 else if (strcmp(args
[0], "disable") == 0)
2291 gdb_use_memory_map
= 0;
2295 LOG_WARNING("invalid gdb_memory_map configuration directive %s", args
[0]);
2298 return ERROR_COMMAND_SYNTAX_ERROR
;
2301 int handle_gdb_flash_program_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2305 if (strcmp(args
[0], "enable") == 0)
2307 gdb_flash_program
= 1;
2310 else if (strcmp(args
[0], "disable") == 0)
2312 gdb_flash_program
= 0;
2316 LOG_WARNING("invalid gdb_flash_program configuration directive: %s", args
[0]);
2319 return ERROR_COMMAND_SYNTAX_ERROR
;
2322 int handle_gdb_report_data_abort_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2326 if (strcmp(args
[0], "enable") == 0)
2328 gdb_report_data_abort
= 1;
2331 else if (strcmp(args
[0], "disable") == 0)
2333 gdb_report_data_abort
= 0;
2337 LOG_WARNING("invalid gdb_report_data_abort configuration directive: %s", args
[0]);
2340 return ERROR_COMMAND_SYNTAX_ERROR
;
2343 /* gdb_breakpoint_override */
2344 int handle_gdb_breakpoint_override_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2351 gdb_breakpoint_override
= 1;
2352 if (strcmp(args
[0], "hard")==0)
2354 gdb_breakpoint_override_type
=BKPT_HARD
;
2355 } else if (strcmp(args
[0], "soft")==0)
2357 gdb_breakpoint_override_type
=BKPT_SOFT
;
2358 } else if (strcmp(args
[0], "disable") == 0)
2360 gdb_breakpoint_override
= 0;
2364 return ERROR_COMMAND_SYNTAX_ERROR
;
2366 if (gdb_breakpoint_override
)
2368 LOG_USER("force %s breakpoints", (gdb_breakpoint_override_type
==BKPT_HARD
)?"hard":"soft");
2371 LOG_USER("breakpoint type is not overriden");
2377 int gdb_register_commands(command_context_t
*command_context
)
2379 register_command(command_context
, NULL
, "gdb_port", handle_gdb_port_command
,
2380 COMMAND_ANY
, "daemon configuration command gdb_port");
2381 register_command(command_context
, NULL
, "gdb_detach", handle_gdb_detach_command
,
2382 COMMAND_CONFIG
, "");
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 report data");
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."
2391 "The raison d'etre for this option is to support GDB GUI's without "
2392 "a hard/soft breakpoint concept where the default OpenOCD behaviour "
2393 "is not sufficient");
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)