1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * Copyright (C) 2007,2008 Øyvind Harboe *
6 * oyvind.harboe@zylin.com *
8 * Copyright (C) 2008 by Spencer Oliver *
9 * spen@spen-soft.co.uk *
11 * This program is free software; you can redistribute it and/or modify *
12 * it under the terms of the GNU General Public License as published by *
13 * the Free Software Foundation; either version 2 of the License, or *
14 * (at your option) any later version. *
16 * This program is distributed in the hope that it will be useful, *
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
19 * GNU General Public License for more details. *
21 * You should have received a copy of the GNU General Public License *
22 * along with this program; if not, write to the *
23 * Free Software Foundation, Inc., *
24 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
25 ***************************************************************************/
30 #include "gdb_server.h"
31 #include "target_request.h"
40 #define _DEBUG_GDB_IO_
43 static int gdb_breakpoint_override
;
44 static enum breakpoint_type gdb_breakpoint_override_type
;
46 extern int gdb_error(connection_t
*connection
, int retval
);
47 static unsigned short gdb_port
= 3333;
48 static const char *DIGITS
= "0123456789abcdef";
50 static void gdb_log_callback(void *priv
, const char *file
, int line
,
51 const char *function
, const char *string
);
61 /* target behaviour on gdb detach */
62 enum gdb_detach_mode detach_mode
= GDB_DETACH_RESUME
;
64 /* number of gdb connections, mainly to supress gdb related debugging spam
65 * in helper/log.c when no gdb connections are actually active */
66 int gdb_actual_connections
;
68 /* set if we are sending a memory map to gdb
69 * via qXfer:memory-map:read packet */
70 /* enabled by default*/
71 int gdb_use_memory_map
= 1;
72 /* enabled by default*/
73 int gdb_flash_program
= 1;
75 /* if set, data aborts cause an error to be reported in memory read packets
76 * see the code in gdb_read_memory_packet() for further explanations */
77 int gdb_report_data_abort
= 0;
79 int gdb_last_signal(target_t
*target
)
81 switch (target
->debug_reason
)
83 case DBG_REASON_DBGRQ
:
84 return 0x2; /* SIGINT */
85 case DBG_REASON_BREAKPOINT
:
86 case DBG_REASON_WATCHPOINT
:
87 case DBG_REASON_WPTANDBKPT
:
88 return 0x05; /* SIGTRAP */
89 case DBG_REASON_SINGLESTEP
:
90 return 0x05; /* SIGTRAP */
91 case DBG_REASON_NOTHALTED
:
92 return 0x0; /* no signal... shouldn't happen */
94 LOG_USER("undefined debug reason %d - target needs reset", target
->debug_reason
);
99 int check_pending(connection_t
*connection
, int timeout_s
, int *got_data
)
101 /* a non-blocking socket will block if there is 0 bytes available on the socket,
102 * but return with as many bytes as are available immediately
106 gdb_connection_t
*gdb_con
= connection
->priv
;
108 if (got_data
== NULL
)
112 if (gdb_con
->buf_cnt
> 0)
119 FD_SET(connection
->fd
, &read_fds
);
121 tv
.tv_sec
= timeout_s
;
123 if (socket_select(connection
->fd
+ 1, &read_fds
, NULL
, NULL
, &tv
) == 0)
125 /* This can typically be because a "monitor" command took too long
126 * before printing any progress messages
130 return ERROR_GDB_TIMEOUT
;
136 *got_data
= FD_ISSET(connection
->fd
, &read_fds
) != 0;
140 int gdb_get_char(connection_t
*connection
, int* next_char
)
142 gdb_connection_t
*gdb_con
= connection
->priv
;
143 int retval
= ERROR_OK
;
145 #ifdef _DEBUG_GDB_IO_
149 if (gdb_con
->buf_cnt
-- > 0)
151 *next_char
= *(gdb_con
->buf_p
++);
152 if (gdb_con
->buf_cnt
> 0)
153 connection
->input_pending
= 1;
155 connection
->input_pending
= 0;
157 #ifdef _DEBUG_GDB_IO_
158 LOG_DEBUG("returned char '%c' (0x%2.2x)", *next_char
, *next_char
);
166 if (connection
->service
->type
== CONNECTION_PIPE
)
168 gdb_con
->buf_cnt
= read(connection
->fd
, gdb_con
->buffer
, GDB_BUFFER_SIZE
);
172 retval
= check_pending(connection
, 1, NULL
);
173 if (retval
!= ERROR_OK
)
175 gdb_con
->buf_cnt
= read_socket(connection
->fd
, gdb_con
->buffer
, GDB_BUFFER_SIZE
);
178 if (gdb_con
->buf_cnt
> 0)
182 if (gdb_con
->buf_cnt
== 0)
185 return ERROR_SERVER_REMOTE_CLOSED
;
189 errno
= WSAGetLastError();
196 case WSAECONNABORTED
:
198 return ERROR_SERVER_REMOTE_CLOSED
;
201 return ERROR_SERVER_REMOTE_CLOSED
;
203 LOG_ERROR("read: %d", errno
);
214 return ERROR_SERVER_REMOTE_CLOSED
;
217 return ERROR_SERVER_REMOTE_CLOSED
;
219 LOG_ERROR("read: %s", strerror(errno
));
221 return ERROR_SERVER_REMOTE_CLOSED
;
226 #ifdef _DEBUG_GDB_IO_
227 debug_buffer
= malloc(gdb_con
->buf_cnt
+ 1);
228 memcpy(debug_buffer
, gdb_con
->buffer
, gdb_con
->buf_cnt
);
229 debug_buffer
[gdb_con
->buf_cnt
] = 0;
230 LOG_DEBUG("received '%s'", debug_buffer
);
234 gdb_con
->buf_p
= gdb_con
->buffer
;
236 *next_char
= *(gdb_con
->buf_p
++);
237 if (gdb_con
->buf_cnt
> 0)
238 connection
->input_pending
= 1;
240 connection
->input_pending
= 0;
241 #ifdef _DEBUG_GDB_IO_
242 LOG_DEBUG("returned char '%c' (0x%2.2x)", *next_char
, *next_char
);
248 int gdb_putback_char(connection_t
*connection
, int last_char
)
250 gdb_connection_t
*gdb_con
= connection
->priv
;
252 if (gdb_con
->buf_p
> gdb_con
->buffer
)
254 *(--gdb_con
->buf_p
) = last_char
;
259 LOG_ERROR("BUG: couldn't put character back");
265 /* The only way we can detect that the socket is closed is the first time
266 * we write to it, we will fail. Subsequent write operations will
267 * succeed. Shudder! */
268 int gdb_write(connection_t
*connection
, void *data
, int len
)
270 gdb_connection_t
*gdb_con
= connection
->priv
;
272 return ERROR_SERVER_REMOTE_CLOSED
;
274 if (connection
->service
->type
== CONNECTION_PIPE
)
276 /* write to stdout */
277 if (write(STDOUT_FILENO
, data
, len
) == len
)
284 if (write_socket(connection
->fd
, data
, len
) == len
)
290 return ERROR_SERVER_REMOTE_CLOSED
;
293 int gdb_put_packet_inner(connection_t
*connection
, char *buffer
, int len
)
296 unsigned char my_checksum
= 0;
297 #ifdef _DEBUG_GDB_IO_
302 gdb_connection_t
*gdb_con
= connection
->priv
;
304 for (i
= 0; i
< len
; i
++)
305 my_checksum
+= buffer
[i
];
307 #ifdef _DEBUG_GDB_IO_
309 * At this point we should have nothing in the input queue from GDB,
310 * however sometimes '-' is sent even though we've already received
311 * an ACK (+) for everything we've sent off.
316 if ((retval
= check_pending(connection
, 0, &gotdata
)) != ERROR_OK
)
320 if ((retval
= gdb_get_char(connection
, &reply
)) != ERROR_OK
)
323 /* fix a problem with some IAR tools */
324 gdb_putback_char(connection
, reply
);
325 LOG_DEBUG("Unexpected start of new packet");
329 LOG_WARNING("Discard unexpected char %c", reply
);
335 #ifdef _DEBUG_GDB_IO_
336 debug_buffer
= malloc(len
+ 1);
337 memcpy(debug_buffer
, buffer
, len
);
338 debug_buffer
[len
] = 0;
339 LOG_DEBUG("sending packet '$%s#%2.2x'", debug_buffer
, my_checksum
);
343 char local_buffer
[1024];
344 local_buffer
[0] = '$';
345 if ((size_t)len
+ 4 <= sizeof(local_buffer
))
347 /* performance gain on smaller packets by only a single call to gdb_write() */
348 memcpy(local_buffer
+ 1, buffer
, len
++);
349 local_buffer
[len
++] = '#';
350 local_buffer
[len
++] = DIGITS
[(my_checksum
>> 4) & 0xf];
351 local_buffer
[len
++] = DIGITS
[my_checksum
& 0xf];
352 if ((retval
= gdb_write(connection
, local_buffer
, len
)) != ERROR_OK
)
359 /* larger packets are transmitted directly from caller supplied buffer
360 by several calls to gdb_write() to avoid dynamic allocation */
361 local_buffer
[1] = '#';
362 local_buffer
[2] = DIGITS
[(my_checksum
>> 4) & 0xf];
363 local_buffer
[3] = DIGITS
[my_checksum
& 0xf];
364 if ((retval
= gdb_write(connection
, local_buffer
, 1)) != ERROR_OK
)
368 if ((retval
= gdb_write(connection
, buffer
, len
)) != ERROR_OK
)
372 if ((retval
= gdb_write(connection
, local_buffer
+ 1, 3)) != ERROR_OK
)
378 if (gdb_con
->noack_mode
)
381 if ((retval
= gdb_get_char(connection
, &reply
)) != ERROR_OK
)
386 else if (reply
== '-')
388 /* Stop sending output packets for now */
389 log_remove_callback(gdb_log_callback
, connection
);
390 LOG_WARNING("negative reply, retrying");
392 else if (reply
== 0x3)
395 if ((retval
= gdb_get_char(connection
, &reply
)) != ERROR_OK
)
399 else if (reply
== '-')
401 /* Stop sending output packets for now */
402 log_remove_callback(gdb_log_callback
, connection
);
403 LOG_WARNING("negative reply, retrying");
405 else if (reply
== '$') {
406 LOG_ERROR("GDB missing ack(1) - assumed good");
407 gdb_putback_char(connection
, reply
);
411 LOG_ERROR("unknown character(1) 0x%2.2x in reply, dropping connection", reply
);
413 return ERROR_SERVER_REMOTE_CLOSED
;
416 else if (reply
== '$') {
417 LOG_ERROR("GDB missing ack(2) - assumed good");
418 gdb_putback_char(connection
, reply
);
423 LOG_ERROR("unknown character(2) 0x%2.2x in reply, dropping connection", reply
);
425 return ERROR_SERVER_REMOTE_CLOSED
;
429 return ERROR_SERVER_REMOTE_CLOSED
;
434 int gdb_put_packet(connection_t
*connection
, char *buffer
, int len
)
436 gdb_connection_t
*gdb_con
= connection
->priv
;
438 int retval
= gdb_put_packet_inner(connection
, buffer
, len
);
441 /* we sent some data, reset timer for keep alive messages */
447 static __inline__
int fetch_packet(connection_t
*connection
, int *checksum_ok
, int noack
, int *len
, char *buffer
)
449 unsigned char my_checksum
= 0;
454 gdb_connection_t
*gdb_con
= connection
->priv
;
460 /* The common case is that we have an entire packet with no escape chars.
461 * We need to leave at least 2 bytes in the buffer to have
462 * gdb_get_char() update various bits and bobs correctly.
464 if ((gdb_con
->buf_cnt
> 2) && ((gdb_con
->buf_cnt
+ count
) < *len
))
466 /* The compiler will struggle a bit with constant propagation and
467 * aliasing, so we help it by showing that these values do not
468 * change inside the loop
471 char *buf
= gdb_con
->buf_p
;
472 int run
= gdb_con
->buf_cnt
- 2;
479 if (character
== '#')
481 /* Danger! character can be '#' when esc is
482 * used so we need an explicit boolean for done here.
488 if (character
== '}')
490 /* data transmitted in binary mode (X packet)
491 * uses 0x7d as escape character */
492 my_checksum
+= character
& 0xff;
495 my_checksum
+= character
& 0xff;
496 buffer
[count
++] = (character
^ 0x20) & 0xff;
500 my_checksum
+= character
& 0xff;
501 buffer
[count
++] = character
& 0xff;
505 gdb_con
->buf_cnt
-= i
;
511 LOG_ERROR("packet buffer too small");
512 return ERROR_GDB_BUFFER_TOO_SMALL
;
515 if ((retval
= gdb_get_char(connection
, &character
)) != ERROR_OK
)
518 if (character
== '#')
521 if (character
== '}')
523 /* data transmitted in binary mode (X packet)
524 * uses 0x7d as escape character */
525 my_checksum
+= character
& 0xff;
526 if ((retval
= gdb_get_char(connection
, &character
)) != ERROR_OK
)
528 my_checksum
+= character
& 0xff;
529 buffer
[count
++] = (character
^ 0x20) & 0xff;
533 my_checksum
+= character
& 0xff;
534 buffer
[count
++] = character
& 0xff;
540 if ((retval
= gdb_get_char(connection
, &character
)) != ERROR_OK
)
542 checksum
[0] = character
;
543 if ((retval
= gdb_get_char(connection
, &character
)) != ERROR_OK
)
545 checksum
[1] = character
;
550 *checksum_ok
= (my_checksum
== strtoul(checksum
, NULL
, 16));
556 int gdb_get_packet_inner(connection_t
*connection
, char *buffer
, int *len
)
560 gdb_connection_t
*gdb_con
= connection
->priv
;
566 if ((retval
= gdb_get_char(connection
, &character
)) != ERROR_OK
)
569 #ifdef _DEBUG_GDB_IO_
570 LOG_DEBUG("character: '%c'", character
);
578 /* gdb sends a dummy ack '+' at every remote connect - see remote_start_remote (remote.c)
579 * incase anyone tries to debug why they receive this warning every time */
580 LOG_WARNING("acknowledgment received, but no packet pending");
583 LOG_WARNING("negative acknowledgment, but no packet pending");
590 LOG_WARNING("ignoring character 0x%x", character
);
593 } while (character
!= '$');
598 /* explicit code expansion here to get faster inlined code in -O3 by not
599 * calculating checksum
601 if (gdb_con
->noack_mode
)
603 if ((retval
= fetch_packet(connection
, &checksum_ok
, 1, len
, buffer
)) != ERROR_OK
)
607 if ((retval
= fetch_packet(connection
, &checksum_ok
, 0, len
, buffer
)) != ERROR_OK
)
611 if (gdb_con
->noack_mode
)
613 /* checksum is not checked in noack mode */
618 if ((retval
= gdb_write(connection
, "+", 1)) != ERROR_OK
)
626 return ERROR_SERVER_REMOTE_CLOSED
;
631 int gdb_get_packet(connection_t
*connection
, char *buffer
, int *len
)
633 gdb_connection_t
*gdb_con
= connection
->priv
;
635 int retval
= gdb_get_packet_inner(connection
, buffer
, len
);
640 int gdb_output_con(connection_t
*connection
, const char* line
)
645 bin_size
= strlen(line
);
647 hex_buffer
= malloc(bin_size
*2 + 2);
648 if (hex_buffer
== NULL
)
649 return ERROR_GDB_BUFFER_TOO_SMALL
;
652 for (i
= 0; i
< bin_size
; i
++)
653 snprintf(hex_buffer
+ 1 + i
*2, 3, "%2.2x", line
[i
]);
654 hex_buffer
[bin_size
*2 + 1] = 0;
656 int retval
= gdb_put_packet(connection
, hex_buffer
, bin_size
*2 + 1);
662 int gdb_output(struct command_context_s
*context
, const char* line
)
664 /* this will be dumped to the log and also sent as an O packet if possible */
665 LOG_USER_N("%s", line
);
670 static void gdb_frontend_halted(struct target_s
*target
, connection_t
*connection
)
672 gdb_connection_t
*gdb_connection
= connection
->priv
;
674 /* In the GDB protocol when we are stepping or continuing execution,
675 * we have a lingering reply. Upon receiving a halted event
676 * when we have that lingering packet, we reply to the original
677 * step or continue packet.
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
++;
806 LOG_DEBUG("New GDB Connection: %d, Target %s, state: %s",
807 gdb_actual_connections
,
808 gdb_service
->target
->cmd_name
,
809 target_state_name(gdb_service
->target
));
814 int gdb_connection_closed(connection_t
*connection
)
816 gdb_service_t
*gdb_service
= connection
->service
->priv
;
817 gdb_connection_t
*gdb_connection
= connection
->priv
;
819 /* we're done forwarding messages. Tear down callback before
820 * cleaning up connection.
822 log_remove_callback(gdb_log_callback
, connection
);
824 gdb_actual_connections
--;
825 LOG_DEBUG("GDB Close, Target: %s, state: %s, gdb_actual_connections=%d",
826 gdb_service
->target
->cmd_name
,
827 target_state_name(gdb_service
->target
),
828 gdb_actual_connections
);
830 /* see if an image built with vFlash commands is left */
831 if (gdb_connection
->vflash_image
)
833 image_close(gdb_connection
->vflash_image
);
834 free(gdb_connection
->vflash_image
);
835 gdb_connection
->vflash_image
= NULL
;
838 /* if this connection registered a debug-message receiver delete it */
839 delete_debug_msg_receiver(connection
->cmd_ctx
, gdb_service
->target
);
841 if (connection
->priv
)
843 free(connection
->priv
);
844 connection
->priv
= NULL
;
848 LOG_ERROR("BUG: connection->priv == NULL");
852 target_unregister_event_callback(gdb_target_callback_event_handler
, connection
);
854 target_call_event_callbacks(gdb_service
->target
, TARGET_EVENT_GDB_END
);
856 target_call_event_callbacks(gdb_service
->target
, TARGET_EVENT_GDB_DETACH
);
861 void gdb_send_error(connection_t
*connection
, uint8_t the_error
)
864 snprintf(err
, 4, "E%2.2X", the_error
);
865 gdb_put_packet(connection
, err
, 3);
868 int gdb_last_signal_packet(connection_t
*connection
, target_t
*target
, char* packet
, int packet_size
)
873 signal
= gdb_last_signal(target
);
875 snprintf(sig_reply
, 4, "S%2.2x", signal
);
876 gdb_put_packet(connection
, sig_reply
, 3);
881 static int gdb_reg_pos(target_t
*target
, int pos
, int len
)
883 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
886 return len
- 1 - pos
;
889 /* Convert register to string of bytes. NB! The # of bits in the
890 * register might be non-divisible by 8(a byte), in which
891 * case an entire byte is shown.
893 * NB! the format on the wire is the target endianess
895 * The format of reg->value is little endian
898 void gdb_str_to_target(target_t
*target
, char *tstr
, reg_t
*reg
)
905 buf_len
= CEIL(reg
->size
, 8);
907 for (i
= 0; i
< buf_len
; i
++)
909 int j
= gdb_reg_pos(target
, i
, buf_len
);
910 tstr
[i
*2] = DIGITS
[(buf
[j
]>>4) & 0xf];
911 tstr
[i
*2 + 1] = DIGITS
[buf
[j
]&0xf];
915 static int hextoint(char c
)
926 LOG_ERROR("BUG: invalid register value %08x", c
);
930 /* copy over in register buffer */
931 void gdb_target_to_reg(target_t
*target
, char *tstr
, int str_len
, uint8_t *bin
)
935 LOG_ERROR("BUG: gdb value with uneven number of characters encountered");
940 for (i
= 0; i
< str_len
; i
+= 2)
942 uint8_t t
= hextoint(tstr
[i
]) << 4;
943 t
|= hextoint(tstr
[i
+ 1]);
945 int j
= gdb_reg_pos(target
, i
/2, str_len
/2);
950 int gdb_get_registers_packet(connection_t
*connection
, target_t
*target
, char* packet
, int packet_size
)
955 int reg_packet_size
= 0;
960 #ifdef _DEBUG_GDB_IO_
964 if ((retval
= target_get_gdb_reg_list(target
, ®_list
, ®_list_size
)) != ERROR_OK
)
966 return gdb_error(connection
, retval
);
969 for (i
= 0; i
< reg_list_size
; i
++)
971 reg_packet_size
+= reg_list
[i
]->size
;
974 reg_packet
= malloc(CEIL(reg_packet_size
, 8) * 2);
975 reg_packet_p
= reg_packet
;
977 for (i
= 0; i
< reg_list_size
; i
++)
979 gdb_str_to_target(target
, reg_packet_p
, reg_list
[i
]);
980 reg_packet_p
+= CEIL(reg_list
[i
]->size
, 8) * 2;
983 #ifdef _DEBUG_GDB_IO_
986 reg_packet_p
= strndup(reg_packet
, CEIL(reg_packet_size
, 8) * 2);
987 LOG_DEBUG("reg_packet: %s", reg_packet_p
);
992 gdb_put_packet(connection
, reg_packet
, CEIL(reg_packet_size
, 8) * 2);
1000 int gdb_set_registers_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1008 #ifdef _DEBUG_GDB_IO_
1012 /* skip command character */
1016 if (packet_size
% 2)
1018 LOG_WARNING("GDB set_registers packet with uneven characters received, dropping connection");
1019 return ERROR_SERVER_REMOTE_CLOSED
;
1022 if ((retval
= target_get_gdb_reg_list(target
, ®_list
, ®_list_size
)) != ERROR_OK
)
1024 return gdb_error(connection
, retval
);
1028 for (i
= 0; i
< reg_list_size
; i
++)
1031 int chars
= (CEIL(reg_list
[i
]->size
, 8) * 2);
1033 if (packet_p
+ chars
> packet
+ packet_size
)
1035 LOG_ERROR("BUG: register packet is too small for registers");
1038 reg_arch_type_t
*arch_type
;
1039 bin_buf
= malloc(CEIL(reg_list
[i
]->size
, 8));
1040 gdb_target_to_reg(target
, packet_p
, chars
, bin_buf
);
1042 /* get register arch_type, and call set method */
1043 arch_type
= register_get_arch_type(reg_list
[i
]->arch_type
);
1045 arch_type
->set(reg_list
[i
], bin_buf
);
1047 /* advance packet pointer */
1054 /* free reg_t *reg_list[] array allocated by get_gdb_reg_list */
1057 gdb_put_packet(connection
, "OK", 2);
1062 int gdb_get_register_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1065 int reg_num
= strtoul(packet
+ 1, NULL
, 16);
1070 #ifdef _DEBUG_GDB_IO_
1074 if ((retval
= target_get_gdb_reg_list(target
, ®_list
, ®_list_size
)) != ERROR_OK
)
1076 return gdb_error(connection
, retval
);
1079 if (reg_list_size
<= reg_num
)
1081 LOG_ERROR("gdb requested a non-existing register");
1085 reg_packet
= malloc(CEIL(reg_list
[reg_num
]->size
, 8) * 2);
1087 gdb_str_to_target(target
, reg_packet
, reg_list
[reg_num
]);
1089 gdb_put_packet(connection
, reg_packet
, CEIL(reg_list
[reg_num
]->size
, 8) * 2);
1097 int gdb_set_register_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1101 int reg_num
= strtoul(packet
+ 1, &separator
, 16);
1105 reg_arch_type_t
*arch_type
;
1109 if ((retval
= target_get_gdb_reg_list(target
, ®_list
, ®_list_size
)) != ERROR_OK
)
1111 return gdb_error(connection
, retval
);
1114 if (reg_list_size
< reg_num
)
1116 LOG_ERROR("gdb requested a non-existing register");
1117 return ERROR_SERVER_REMOTE_CLOSED
;
1120 if (*separator
!= '=')
1122 LOG_ERROR("GDB 'set register packet', but no '=' following the register number");
1123 return ERROR_SERVER_REMOTE_CLOSED
;
1126 /* convert from GDB-string (target-endian) to hex-string (big-endian) */
1127 bin_buf
= malloc(CEIL(reg_list
[reg_num
]->size
, 8));
1128 int chars
= (CEIL(reg_list
[reg_num
]->size
, 8) * 2);
1130 /* fix!!! add some sanity checks on packet size here */
1132 gdb_target_to_reg(target
, separator
+ 1, chars
, bin_buf
);
1134 /* get register arch_type, and call set method */
1135 arch_type
= register_get_arch_type(reg_list
[reg_num
]->arch_type
);
1136 arch_type
->set(reg_list
[reg_num
], bin_buf
);
1138 gdb_put_packet(connection
, "OK", 2);
1146 int gdb_error(connection_t
*connection
, int retval
)
1150 case ERROR_TARGET_DATA_ABORT
:
1151 gdb_send_error(connection
, EIO
);
1153 case ERROR_TARGET_TRANSLATION_FAULT
:
1154 gdb_send_error(connection
, EFAULT
);
1156 case ERROR_TARGET_UNALIGNED_ACCESS
:
1157 gdb_send_error(connection
, EFAULT
);
1159 case ERROR_TARGET_NOT_HALTED
:
1160 gdb_send_error(connection
, EFAULT
);
1163 /* This could be that the target reset itself. */
1164 LOG_ERROR("unexpected error %i", retval
);
1165 gdb_send_error(connection
, EFAULT
);
1172 /* We don't have to worry about the default 2 second timeout for GDB packets,
1173 * because GDB breaks up large memory reads into smaller reads.
1175 * 8191 bytes by the looks of it. Why 8191 bytes instead of 8192?????
1177 int gdb_read_memory_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1186 int retval
= ERROR_OK
;
1188 /* skip command character */
1191 addr
= strtoul(packet
, &separator
, 16);
1193 if (*separator
!= ',')
1195 LOG_ERROR("incomplete read memory packet received, dropping connection");
1196 return ERROR_SERVER_REMOTE_CLOSED
;
1199 len
= strtoul(separator
+ 1, NULL
, 16);
1201 buffer
= malloc(len
);
1203 LOG_DEBUG("addr: 0x%8.8" PRIx32
", len: 0x%8.8" PRIx32
"", addr
, len
);
1205 retval
= target_read_buffer(target
, addr
, len
, buffer
);
1207 if ((retval
!= ERROR_OK
)&&!gdb_report_data_abort
)
1209 /* TODO : Here we have to lie and send back all zero's lest stack traces won't work.
1210 * At some point this might be fixed in GDB, in which case this code can be removed.
1212 * OpenOCD developers are acutely aware of this problem, but there is nothing
1213 * gained by involving the user in this problem that hopefully will get resolved
1216 * http://sourceware.org/cgi-bin/gnatsweb.pl?cmd = view%20audit-trail&database = gdb&pr = 2395
1218 * For now, the default is to fix up things to make current GDB versions work.
1219 * This can be overwritten using the gdb_report_data_abort <'enable'|'disable'> command.
1221 memset(buffer
, 0, len
);
1225 if (retval
== ERROR_OK
)
1227 hex_buffer
= malloc(len
* 2 + 1);
1230 for (i
= 0; i
< len
; i
++)
1232 uint8_t t
= buffer
[i
];
1233 hex_buffer
[2 * i
] = DIGITS
[(t
>> 4) & 0xf];
1234 hex_buffer
[2 * i
+ 1] = DIGITS
[t
& 0xf];
1237 gdb_put_packet(connection
, hex_buffer
, len
* 2);
1243 retval
= gdb_error(connection
, retval
);
1251 int gdb_write_memory_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1262 /* skip command character */
1265 addr
= strtoul(packet
, &separator
, 16);
1267 if (*separator
!= ',')
1269 LOG_ERROR("incomplete write memory packet received, dropping connection");
1270 return ERROR_SERVER_REMOTE_CLOSED
;
1273 len
= strtoul(separator
+ 1, &separator
, 16);
1275 if (*(separator
++) != ':')
1277 LOG_ERROR("incomplete write memory packet received, dropping connection");
1278 return ERROR_SERVER_REMOTE_CLOSED
;
1281 buffer
= malloc(len
);
1283 LOG_DEBUG("addr: 0x%8.8" PRIx32
", len: 0x%8.8" PRIx32
"", addr
, len
);
1285 for (i
= 0; i
< len
; i
++)
1288 sscanf(separator
+ 2*i
, "%2" SCNx32
, &tmp
);
1292 retval
= target_write_buffer(target
, addr
, len
, buffer
);
1294 if (retval
== ERROR_OK
)
1296 gdb_put_packet(connection
, "OK", 2);
1300 retval
= gdb_error(connection
, retval
);
1308 int gdb_write_memory_binary_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1316 /* skip command character */
1319 addr
= strtoul(packet
, &separator
, 16);
1321 if (*separator
!= ',')
1323 LOG_ERROR("incomplete write memory binary packet received, dropping connection");
1324 return ERROR_SERVER_REMOTE_CLOSED
;
1327 len
= strtoul(separator
+ 1, &separator
, 16);
1329 if (*(separator
++) != ':')
1331 LOG_ERROR("incomplete write memory binary packet received, dropping connection");
1332 return ERROR_SERVER_REMOTE_CLOSED
;
1338 LOG_DEBUG("addr: 0x%8.8" PRIx32
", len: 0x%8.8" PRIx32
"", addr
, len
);
1340 retval
= target_write_buffer(target
, addr
, len
, (uint8_t*)separator
);
1343 if (retval
== ERROR_OK
)
1345 gdb_put_packet(connection
, "OK", 2);
1349 if ((retval
= gdb_error(connection
, retval
)) != ERROR_OK
)
1356 int gdb_step_continue_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1359 uint32_t address
= 0x0;
1360 int retval
= ERROR_OK
;
1364 if (packet_size
> 1)
1366 packet
[packet_size
] = 0;
1367 address
= strtoul(packet
+ 1, NULL
, 16);
1374 if (packet
[0] == 'c')
1376 LOG_DEBUG("continue");
1377 target_handle_event(target
, TARGET_EVENT_OLD_pre_resume
);
1378 retval
= target_resume(target
, current
, address
, 0, 0); /* resume at current address, don't handle breakpoints, not debugging */
1380 else if (packet
[0] == 's')
1383 /* step at current or address, don't handle breakpoints */
1384 retval
= target_step(target
, current
, address
, 0);
1389 int gdb_breakpoint_watchpoint_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1392 enum breakpoint_type bp_type
= BKPT_SOFT
/* dummy init to avoid warning */;
1393 enum watchpoint_rw wp_type
;
1401 type
= strtoul(packet
+ 1, &separator
, 16);
1403 if (type
== 0) /* memory breakpoint */
1404 bp_type
= BKPT_SOFT
;
1405 else if (type
== 1) /* hardware breakpoint */
1406 bp_type
= BKPT_HARD
;
1407 else if (type
== 2) /* write watchpoint */
1408 wp_type
= WPT_WRITE
;
1409 else if (type
== 3) /* read watchpoint */
1411 else if (type
== 4) /* access watchpoint */
1412 wp_type
= WPT_ACCESS
;
1414 if (gdb_breakpoint_override
&& ((bp_type
== BKPT_SOFT
)||(bp_type
== BKPT_HARD
)))
1416 bp_type
= gdb_breakpoint_override_type
;
1419 if (*separator
!= ',')
1421 LOG_ERROR("incomplete breakpoint/watchpoint packet received, dropping connection");
1422 return ERROR_SERVER_REMOTE_CLOSED
;
1425 address
= strtoul(separator
+ 1, &separator
, 16);
1427 if (*separator
!= ',')
1429 LOG_ERROR("incomplete breakpoint/watchpoint packet received, dropping connection");
1430 return ERROR_SERVER_REMOTE_CLOSED
;
1433 size
= strtoul(separator
+ 1, &separator
, 16);
1439 if (packet
[0] == 'Z')
1441 if ((retval
= breakpoint_add(target
, address
, size
, bp_type
)) != ERROR_OK
)
1443 if ((retval
= gdb_error(connection
, retval
)) != ERROR_OK
)
1448 gdb_put_packet(connection
, "OK", 2);
1453 breakpoint_remove(target
, address
);
1454 gdb_put_packet(connection
, "OK", 2);
1461 if (packet
[0] == 'Z')
1463 if ((retval
= watchpoint_add(target
, address
, size
, type
-2, 0, 0xffffffffu
)) != ERROR_OK
)
1465 if ((retval
= gdb_error(connection
, retval
)) != ERROR_OK
)
1470 gdb_put_packet(connection
, "OK", 2);
1475 watchpoint_remove(target
, address
);
1476 gdb_put_packet(connection
, "OK", 2);
1487 /* print out a string and allocate more space as needed, mainly used for XML at this point */
1488 void xml_printf(int *retval
, char **xml
, int *pos
, int *size
, const char *fmt
, ...)
1490 if (*retval
!= ERROR_OK
)
1498 if ((*xml
== NULL
) || (!first
))
1500 /* start by 0 to exercise all the code paths.
1501 * Need minimum 2 bytes to fit 1 char and 0 terminator. */
1503 *size
= *size
* 2 + 2;
1505 *xml
= realloc(*xml
, *size
);
1510 *retval
= ERROR_SERVER_REMOTE_CLOSED
;
1518 ret
= vsnprintf(*xml
+ *pos
, *size
- *pos
, fmt
, ap
);
1520 if ((ret
> 0) && ((ret
+ 1) < *size
- *pos
))
1525 /* there was just enough or not enough space, allocate more. */
1530 static int decode_xfer_read(char *buf
, char **annex
, int *ofs
, unsigned int *len
)
1534 /* Extract and NUL-terminate the annex. */
1536 while (*buf
&& *buf
!= ':')
1542 /* After the read marker and annex, qXfer looks like a
1543 * traditional 'm' packet. */
1545 *ofs
= strtoul(buf
, &separator
, 16);
1547 if (*separator
!= ',')
1550 *len
= strtoul(separator
+ 1, NULL
, 16);
1555 int gdb_calc_blocksize(flash_bank_t
*bank
)
1558 uint32_t block_size
= 0xffffffff;
1560 /* loop through all sectors and return smallest sector size */
1562 for (i
= 0; i
< (uint32_t)bank
->num_sectors
; i
++)
1564 if (bank
->sectors
[i
].size
< block_size
)
1565 block_size
= bank
->sectors
[i
].size
;
1571 static int compare_bank (const void * a
, const void * b
)
1573 flash_bank_t
*b1
, *b2
;
1574 b1
=*((flash_bank_t
**)a
);
1575 b2
=*((flash_bank_t
**)b
);
1577 if (b1
->base
== b2
->base
)
1580 } else if (b1
->base
> b2
->base
)
1589 int gdb_query_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1591 command_context_t
*cmd_ctx
= connection
->cmd_ctx
;
1592 gdb_connection_t
*gdb_connection
= connection
->priv
;
1594 if (strstr(packet
, "qRcmd,"))
1596 if (packet_size
> 6)
1600 cmd
= malloc((packet_size
- 6)/2 + 1);
1601 for (i
= 0; i
< (packet_size
- 6)/2; i
++)
1604 sscanf(packet
+ 6 + 2*i
, "%2" SCNx32
, &tmp
);
1607 cmd
[(packet_size
- 6)/2] = 0x0;
1609 /* We want to print all debug output to GDB connection */
1610 log_add_callback(gdb_log_callback
, connection
);
1611 target_call_timer_callbacks_now();
1612 command_run_line(cmd_ctx
, cmd
);
1613 target_call_timer_callbacks_now();
1614 log_remove_callback(gdb_log_callback
, connection
);
1617 gdb_put_packet(connection
, "OK", 2);
1620 else if (strstr(packet
, "qCRC:"))
1622 if (packet_size
> 5)
1631 /* skip command character */
1634 addr
= strtoul(packet
, &separator
, 16);
1636 if (*separator
!= ',')
1638 LOG_ERROR("incomplete read memory packet received, dropping connection");
1639 return ERROR_SERVER_REMOTE_CLOSED
;
1642 len
= strtoul(separator
+ 1, NULL
, 16);
1644 retval
= target_checksum_memory(target
, addr
, len
, &checksum
);
1646 if (retval
== ERROR_OK
)
1648 snprintf(gdb_reply
, 10, "C%8.8" PRIx32
"", checksum
);
1649 gdb_put_packet(connection
, gdb_reply
, 9);
1653 if ((retval
= gdb_error(connection
, retval
)) != ERROR_OK
)
1660 else if (strstr(packet
, "qSupported"))
1662 /* we currently support packet size and qXfer:memory-map:read (if enabled)
1663 * disable qXfer:features:read for the moment */
1664 int retval
= ERROR_OK
;
1665 char *buffer
= NULL
;
1669 xml_printf(&retval
, &buffer
, &pos
, &size
,
1670 "PacketSize=%x;qXfer:memory-map:read%c;qXfer:features:read-;QStartNoAckMode+",
1671 (GDB_BUFFER_SIZE
- 1), ((gdb_use_memory_map
== 1) && (flash_get_bank_count() > 0)) ? '+' : '-');
1673 if (retval
!= ERROR_OK
)
1675 gdb_send_error(connection
, 01);
1679 gdb_put_packet(connection
, buffer
, strlen(buffer
));
1684 else if (strstr(packet
, "qXfer:memory-map:read::") && (flash_get_bank_count() > 0))
1686 /* We get away with only specifying flash here. Regions that are not
1687 * specified are treated as if we provided no memory map(if not we
1688 * could detect the holes and mark them as RAM).
1689 * Normally we only execute this code once, but no big deal if we
1690 * have to regenerate it a couple of times. */
1696 int retval
= ERROR_OK
;
1703 /* skip command character */
1706 offset
= strtoul(packet
, &separator
, 16);
1707 length
= strtoul(separator
+ 1, &separator
, 16);
1709 xml_printf(&retval
, &xml
, &pos
, &size
, "<memory-map>\n");
1712 sort banks in ascending order, we need to make non-flash memory be ram(or rather
1713 read/write) by default for GDB.
1714 GDB does not have a concept of non-cacheable read/write memory.
1716 flash_bank_t
**banks
= malloc(sizeof(flash_bank_t
*)*flash_get_bank_count());
1719 for (i
= 0; i
< flash_get_bank_count(); i
++)
1721 p
= get_flash_bank_by_num(i
);
1725 retval
= ERROR_FAIL
;
1726 gdb_send_error(connection
, retval
);
1732 qsort(banks
, flash_get_bank_count(), sizeof(flash_bank_t
*), compare_bank
);
1734 uint32_t ram_start
= 0;
1735 for (i
= 0; i
< flash_get_bank_count(); i
++)
1739 if (ram_start
< p
->base
)
1741 xml_printf(&retval
, &xml
, &pos
, &size
, "<memory type=\"ram\" start=\"0x%x\" length=\"0x%x\"/>\n",
1742 ram_start
, p
->base
-ram_start
);
1745 /* if device has uneven sector sizes, eg. str7, lpc
1746 * we pass the smallest sector size to gdb memory map */
1747 blocksize
= gdb_calc_blocksize(p
);
1749 xml_printf(&retval
, &xml
, &pos
, &size
, "<memory type=\"flash\" start=\"0x%x\" length=\"0x%x\">\n" \
1750 "<property name=\"blocksize\">0x%x</property>\n" \
1752 p
->base
, p
->size
, blocksize
);
1753 ram_start
= p
->base
+ p
->size
;
1757 xml_printf(&retval
, &xml
, &pos
, &size
, "<memory type=\"ram\" start=\"0x%x\" length=\"0x%x\"/>\n",
1758 ram_start
, 0-ram_start
);
1761 /* a flash chip could be at the very end of the 32 bit address space, in which case
1762 ram_start will be precisely 0 */
1768 xml_printf(&retval
, &xml
, &pos
, &size
, "</memory-map>\n");
1770 if (retval
!= ERROR_OK
)
1772 gdb_send_error(connection
, retval
);
1776 if (offset
+ length
> pos
)
1778 length
= pos
- offset
;
1781 char *t
= malloc(length
+ 1);
1783 memcpy(t
+ 1, xml
+ offset
, length
);
1784 gdb_put_packet(connection
, t
, length
+ 1);
1790 else if (strstr(packet
, "qXfer:features:read:"))
1795 int retval
= ERROR_OK
;
1798 unsigned int length
;
1801 /* skip command character */
1804 if (decode_xfer_read(packet
, &annex
, &offset
, &length
) < 0)
1806 gdb_send_error(connection
, 01);
1810 if (strcmp(annex
, "target.xml") != 0)
1812 gdb_send_error(connection
, 01);
1816 xml_printf(&retval
, &xml
, &pos
, &size
, \
1817 "l < target version=\"1.0\">\n < architecture > arm</architecture>\n</target>\n");
1819 if (retval
!= ERROR_OK
)
1821 gdb_send_error(connection
, retval
);
1825 gdb_put_packet(connection
, xml
, strlen(xml
));
1830 else if (strstr(packet
, "QStartNoAckMode"))
1832 gdb_connection
->noack_mode
= 1;
1833 gdb_put_packet(connection
, "OK", 2);
1837 gdb_put_packet(connection
, "", 0);
1841 int gdb_v_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1843 gdb_connection_t
*gdb_connection
= connection
->priv
;
1844 gdb_service_t
*gdb_service
= connection
->service
->priv
;
1847 /* if flash programming disabled - send a empty reply */
1849 if (gdb_flash_program
== 0)
1851 gdb_put_packet(connection
, "", 0);
1855 if (strstr(packet
, "vFlashErase:"))
1858 unsigned long length
;
1860 char *parse
= packet
+ 12;
1863 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1864 return ERROR_SERVER_REMOTE_CLOSED
;
1867 addr
= strtoul(parse
, &parse
, 16);
1869 if (*(parse
++) != ',' || *parse
== '\0')
1871 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1872 return ERROR_SERVER_REMOTE_CLOSED
;
1875 length
= strtoul(parse
, &parse
, 16);
1879 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1880 return ERROR_SERVER_REMOTE_CLOSED
;
1883 /* assume all sectors need erasing - stops any problems
1884 * when flash_write is called multiple times */
1887 /* perform any target specific operations before the erase */
1888 target_call_event_callbacks(gdb_service
->target
, TARGET_EVENT_GDB_FLASH_ERASE_START
);
1889 result
= flash_erase_address_range(gdb_service
->target
, addr
, length
);
1890 target_call_event_callbacks(gdb_service
->target
, TARGET_EVENT_GDB_FLASH_ERASE_END
);
1893 if (result
!= ERROR_OK
)
1895 /* GDB doesn't evaluate the actual error number returned,
1896 * treat a failed erase as an I/O error
1898 gdb_send_error(connection
, EIO
);
1899 LOG_ERROR("flash_erase returned %i", result
);
1902 gdb_put_packet(connection
, "OK", 2);
1907 if (strstr(packet
, "vFlashWrite:"))
1911 unsigned long length
;
1912 char *parse
= packet
+ 12;
1916 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1917 return ERROR_SERVER_REMOTE_CLOSED
;
1919 addr
= strtoul(parse
, &parse
, 16);
1920 if (*(parse
++) != ':')
1922 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1923 return ERROR_SERVER_REMOTE_CLOSED
;
1925 length
= packet_size
- (parse
- packet
);
1927 /* create a new image if there isn't already one */
1928 if (gdb_connection
->vflash_image
== NULL
)
1930 gdb_connection
->vflash_image
= malloc(sizeof(image_t
));
1931 image_open(gdb_connection
->vflash_image
, "", "build");
1934 /* create new section with content from packet buffer */
1935 if ((retval
= image_add_section(gdb_connection
->vflash_image
, addr
, length
, 0x0, (uint8_t*)parse
)) != ERROR_OK
)
1940 gdb_put_packet(connection
, "OK", 2);
1945 if (!strcmp(packet
, "vFlashDone"))
1949 /* process the flashing buffer. No need to erase as GDB
1950 * always issues a vFlashErase first. */
1951 target_call_event_callbacks(gdb_service
->target
, TARGET_EVENT_GDB_FLASH_WRITE_START
);
1952 result
= flash_write(gdb_service
->target
, gdb_connection
->vflash_image
, &written
, 0);
1953 target_call_event_callbacks(gdb_service
->target
, TARGET_EVENT_GDB_FLASH_WRITE_END
);
1954 if (result
!= ERROR_OK
)
1956 if (result
== ERROR_FLASH_DST_OUT_OF_BANK
)
1957 gdb_put_packet(connection
, "E.memtype", 9);
1959 gdb_send_error(connection
, EIO
);
1963 LOG_DEBUG("wrote %u bytes from vFlash image to flash", (unsigned)written
);
1964 gdb_put_packet(connection
, "OK", 2);
1967 image_close(gdb_connection
->vflash_image
);
1968 free(gdb_connection
->vflash_image
);
1969 gdb_connection
->vflash_image
= NULL
;
1974 gdb_put_packet(connection
, "", 0);
1978 int gdb_detach(connection_t
*connection
, target_t
*target
)
1981 switch (detach_mode
)
1983 case GDB_DETACH_RESUME
:
1984 target_handle_event(target
, TARGET_EVENT_OLD_pre_resume
);
1985 target_resume(target
, 1, 0, 1, 0);
1988 case GDB_DETACH_RESET
:
1989 /* FIX?? make this configurable?? */
1990 target_process_reset(connection
->cmd_ctx
, RESET_HALT
);
1993 case GDB_DETACH_HALT
:
1994 target_halt(target
);
1997 case GDB_DETACH_NOTHING
:
2001 gdb_put_packet(connection
, "OK", 2);
2005 static void gdb_log_callback(void *priv
, const char *file
, int line
,
2006 const char *function
, const char *string
)
2008 connection_t
*connection
= priv
;
2009 gdb_connection_t
*gdb_con
= connection
->priv
;
2013 /* do not reply this using the O packet */
2017 gdb_output_con(connection
, string
);
2020 /* Do not allocate this on the stack */
2021 char gdb_packet_buffer
[GDB_BUFFER_SIZE
];
2023 static void gdb_sig_halted(connection_t
*connection
)
2026 snprintf(sig_reply
, 4, "T%2.2x", 2);
2027 gdb_put_packet(connection
, sig_reply
, 3);
2031 int gdb_input_inner(connection_t
*connection
)
2033 gdb_service_t
*gdb_service
= connection
->service
->priv
;
2034 target_t
*target
= gdb_service
->target
;
2035 char *packet
= gdb_packet_buffer
;
2038 gdb_connection_t
*gdb_con
= connection
->priv
;
2039 static int extended_protocol
= 0;
2041 /* drain input buffer */
2044 packet_size
= GDB_BUFFER_SIZE
-1;
2045 if ((retval
= gdb_get_packet(connection
, packet
, &packet_size
)) != ERROR_OK
)
2050 /* terminate with zero */
2051 packet
[packet_size
] = 0;
2053 if (LOG_LEVEL_IS(LOG_LVL_DEBUG
)) {
2054 if (packet
[0] == 'X') {
2055 // binary packets spew junk into the debug log stream
2058 for (x
= 0 ; (x
< 49) && (packet
[x
] != ':') ; x
++) {
2062 LOG_DEBUG("received packet: '%s:<binary-data>'", buf
);
2064 LOG_DEBUG("received packet: '%s'", packet
);
2068 if (packet_size
> 0)
2074 /* Hct... -- set thread
2075 * we don't have threads, send empty reply */
2076 gdb_put_packet(connection
, NULL
, 0);
2080 retval
= gdb_query_packet(connection
, target
, packet
, packet_size
);
2083 retval
= gdb_get_registers_packet(connection
, target
, packet
, packet_size
);
2086 retval
= gdb_set_registers_packet(connection
, target
, packet
, packet_size
);
2089 retval
= gdb_get_register_packet(connection
, target
, packet
, packet_size
);
2092 retval
= gdb_set_register_packet(connection
, target
, packet
, packet_size
);
2095 retval
= gdb_read_memory_packet(connection
, target
, packet
, packet_size
);
2098 retval
= gdb_write_memory_packet(connection
, target
, packet
, packet_size
);
2102 retval
= gdb_breakpoint_watchpoint_packet(connection
, target
, packet
, packet_size
);
2105 gdb_last_signal_packet(connection
, target
, packet
, packet_size
);
2110 if (target
->state
!= TARGET_HALTED
)
2112 /* If the target isn't in the halted state, then we can't
2113 * step/continue. This might be early setup, etc.
2115 gdb_sig_halted(connection
);
2118 /* We're running/stepping, in which case we can
2119 * forward log output until the target is halted
2121 gdb_connection_t
*gdb_con
= connection
->priv
;
2122 gdb_con
->frontend_state
= TARGET_RUNNING
;
2123 log_add_callback(gdb_log_callback
, connection
);
2124 target_call_event_callbacks(target
, TARGET_EVENT_GDB_START
);
2125 int retval
= gdb_step_continue_packet(connection
, target
, packet
, packet_size
);
2126 if (retval
!= ERROR_OK
)
2128 /* we'll never receive a halted condition... issue a false one.. */
2129 gdb_frontend_halted(target
, connection
);
2135 retval
= gdb_v_packet(connection
, target
, packet
, packet_size
);
2138 retval
= gdb_detach(connection
, target
);
2139 extended_protocol
= 0;
2142 if ((retval
= gdb_write_memory_binary_packet(connection
, target
, packet
, packet_size
)) != ERROR_OK
)
2146 if (extended_protocol
!= 0)
2148 gdb_put_packet(connection
, "OK", 2);
2149 return ERROR_SERVER_REMOTE_CLOSED
;
2151 /* handle extended remote protocol */
2152 extended_protocol
= 1;
2153 gdb_put_packet(connection
, "OK", 2);
2156 /* handle extended restart packet */
2157 breakpoint_clear_target(gdb_service
->target
);
2158 watchpoint_clear_target(gdb_service
->target
);
2159 command_run_linef(connection
->cmd_ctx
,
2160 "ocd_gdb_restart %s",
2164 /* ignore unkown packets */
2165 LOG_DEBUG("ignoring 0x%2.2x packet", packet
[0]);
2166 gdb_put_packet(connection
, NULL
, 0);
2170 /* if a packet handler returned an error, exit input loop */
2171 if (retval
!= ERROR_OK
)
2175 if (gdb_con
->ctrl_c
)
2177 if (target
->state
== TARGET_RUNNING
)
2179 target_halt(target
);
2180 gdb_con
->ctrl_c
= 0;
2184 } while (gdb_con
->buf_cnt
> 0);
2189 int gdb_input(connection_t
*connection
)
2191 int retval
= gdb_input_inner(connection
);
2192 gdb_connection_t
*gdb_con
= connection
->priv
;
2193 if (retval
== ERROR_SERVER_REMOTE_CLOSED
)
2196 /* logging does not propagate the error, yet can set the gdb_con->closed flag */
2197 if (gdb_con
->closed
)
2198 return ERROR_SERVER_REMOTE_CLOSED
;
2200 /* we'll recover from any other errors(e.g. temporary timeouts, etc.) */
2206 gdb_service_t
*gdb_service
;
2207 target_t
*target
= all_targets
;
2211 LOG_WARNING("no gdb ports allocated as no target has been specified");
2215 if (gdb_port
== 0 && server_use_pipes
== 0)
2217 LOG_INFO("gdb port disabled");
2221 if (server_use_pipes
)
2223 /* only a single gdb connection when using a pipe */
2225 gdb_service
= malloc(sizeof(gdb_service_t
));
2226 gdb_service
->target
= target
;
2228 add_service("gdb", CONNECTION_PIPE
, 0, 1, gdb_new_connection
, gdb_input
, gdb_connection_closed
, gdb_service
);
2230 LOG_DEBUG("gdb service for target %s using pipes",
2231 target_get_name(target
));
2235 unsigned short port
= gdb_port
;
2239 gdb_service
= malloc(sizeof(gdb_service_t
));
2240 gdb_service
->target
= target
;
2242 add_service("gdb", CONNECTION_TCP
,
2244 gdb_new_connection
, gdb_input
,
2245 gdb_connection_closed
, gdb_service
);
2247 LOG_DEBUG("gdb service for target %s at TCP port %i",
2248 target_get_name(target
),
2250 target
= target
->next
;
2258 /* daemon configuration command gdb_port */
2259 int handle_gdb_port_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2263 command_print(cmd_ctx
, "%d", gdb_port
);
2267 gdb_port
= strtoul(args
[0], NULL
, 0);
2272 int handle_gdb_detach_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2276 if (strcmp(args
[0], "resume") == 0)
2278 detach_mode
= GDB_DETACH_RESUME
;
2281 else if (strcmp(args
[0], "reset") == 0)
2283 detach_mode
= GDB_DETACH_RESET
;
2286 else if (strcmp(args
[0], "halt") == 0)
2288 detach_mode
= GDB_DETACH_HALT
;
2291 else if (strcmp(args
[0], "nothing") == 0)
2293 detach_mode
= GDB_DETACH_NOTHING
;
2297 LOG_WARNING("invalid gdb_detach configuration directive: %s", args
[0]);
2300 return ERROR_COMMAND_SYNTAX_ERROR
;
2303 int handle_gdb_memory_map_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2307 if (strcmp(args
[0], "enable") == 0)
2309 gdb_use_memory_map
= 1;
2312 else if (strcmp(args
[0], "disable") == 0)
2314 gdb_use_memory_map
= 0;
2318 LOG_WARNING("invalid gdb_memory_map configuration directive %s", args
[0]);
2321 return ERROR_COMMAND_SYNTAX_ERROR
;
2324 int handle_gdb_flash_program_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2328 if (strcmp(args
[0], "enable") == 0)
2330 gdb_flash_program
= 1;
2333 else if (strcmp(args
[0], "disable") == 0)
2335 gdb_flash_program
= 0;
2339 LOG_WARNING("invalid gdb_flash_program configuration directive: %s", args
[0]);
2342 return ERROR_COMMAND_SYNTAX_ERROR
;
2345 int handle_gdb_report_data_abort_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2349 if (strcmp(args
[0], "enable") == 0)
2351 gdb_report_data_abort
= 1;
2354 else if (strcmp(args
[0], "disable") == 0)
2356 gdb_report_data_abort
= 0;
2360 LOG_WARNING("invalid gdb_report_data_abort configuration directive: %s", args
[0]);
2363 return ERROR_COMMAND_SYNTAX_ERROR
;
2366 /* gdb_breakpoint_override */
2367 int handle_gdb_breakpoint_override_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2372 } else if (argc
== 1)
2374 gdb_breakpoint_override
= 1;
2375 if (strcmp(args
[0], "hard") == 0)
2377 gdb_breakpoint_override_type
= BKPT_HARD
;
2378 } else if (strcmp(args
[0], "soft") == 0)
2380 gdb_breakpoint_override_type
= BKPT_SOFT
;
2381 } else if (strcmp(args
[0], "disable") == 0)
2383 gdb_breakpoint_override
= 0;
2387 return ERROR_COMMAND_SYNTAX_ERROR
;
2389 if (gdb_breakpoint_override
)
2391 LOG_USER("force %s breakpoints", (gdb_breakpoint_override_type
== BKPT_HARD
)?"hard":"soft");
2394 LOG_USER("breakpoint type is not overriden");
2400 int gdb_register_commands(command_context_t
*command_context
)
2402 register_command(command_context
, NULL
, "gdb_port", handle_gdb_port_command
,
2403 COMMAND_ANY
, "daemon configuration command gdb_port");
2404 register_command(command_context
, NULL
, "gdb_detach", handle_gdb_detach_command
,
2405 COMMAND_CONFIG
, "resume/reset/halt/nothing - "
2406 "specify behavior when GDB detaches from the target");
2407 register_command(command_context
, NULL
, "gdb_memory_map", handle_gdb_memory_map_command
,
2408 COMMAND_CONFIG
, "enable or disable memory map");
2409 register_command(command_context
, NULL
, "gdb_flash_program", handle_gdb_flash_program_command
,
2410 COMMAND_CONFIG
, "enable or disable flash program");
2411 register_command(command_context
, NULL
, "gdb_report_data_abort", handle_gdb_report_data_abort_command
,
2412 COMMAND_CONFIG
, "enable or disable reporting data aborts");
2413 register_command(command_context
, NULL
, "gdb_breakpoint_override", handle_gdb_breakpoint_override_command
,
2414 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)