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"
40 #include "target_request.h"
41 #include "configuration.h"
49 #define _DEBUG_GDB_IO_
52 static int gdb_breakpoint_override
;
53 static enum breakpoint_type gdb_breakpoint_override_type
;
55 extern int gdb_error(connection_t
*connection
, int retval
);
56 static unsigned short gdb_port
;
57 static const char *DIGITS
= "0123456789abcdef";
59 static void gdb_log_callback(void *priv
, const char *file
, int line
,
60 const char *function
, const char *string
);
70 /* target behaviour on gdb detach */
71 enum gdb_detach_mode detach_mode
= GDB_DETACH_RESUME
;
73 /* set if we are sending a memory map to gdb
74 * via qXfer:memory-map:read packet */
75 /* enabled by default*/
76 int gdb_use_memory_map
= 1;
77 /* enabled by default*/
78 int gdb_flash_program
= 1;
80 /* if set, data aborts cause an error to be reported in memory read packets
81 * see the code in gdb_read_memory_packet() for further explanations */
82 int gdb_report_data_abort
= 0;
84 int gdb_last_signal(target_t
*target
)
86 switch (target
->debug_reason
)
88 case DBG_REASON_DBGRQ
:
89 return 0x2; /* SIGINT */
90 case DBG_REASON_BREAKPOINT
:
91 case DBG_REASON_WATCHPOINT
:
92 case DBG_REASON_WPTANDBKPT
:
93 return 0x05; /* SIGTRAP */
94 case DBG_REASON_SINGLESTEP
:
95 return 0x05; /* SIGTRAP */
96 case DBG_REASON_NOTHALTED
:
97 return 0x0; /* no signal... shouldn't happen */
99 LOG_USER("undefined debug reason %d - target needs reset", target
->debug_reason
);
104 int check_pending(connection_t
*connection
, int timeout_s
, int *got_data
)
106 /* a non-blocking socket will block if there is 0 bytes available on the socket,
107 * but return with as many bytes as are available immediately
111 gdb_connection_t
*gdb_con
= connection
->priv
;
117 if (gdb_con
->buf_cnt
>0)
124 FD_SET(connection
->fd
, &read_fds
);
126 tv
.tv_sec
= timeout_s
;
128 if (select(connection
->fd
+ 1, &read_fds
, NULL
, NULL
, &tv
) == 0)
130 /* This can typically be because a "monitor" command took too long
131 * before printing any progress messages
135 return ERROR_GDB_TIMEOUT
;
141 *got_data
=FD_ISSET(connection
->fd
, &read_fds
)!=0;
145 int gdb_get_char(connection_t
*connection
, int* next_char
)
147 gdb_connection_t
*gdb_con
= connection
->priv
;
150 #ifdef _DEBUG_GDB_IO_
154 if (gdb_con
->buf_cnt
-- > 0)
156 *next_char
= *(gdb_con
->buf_p
++);
157 if (gdb_con
->buf_cnt
> 0)
158 connection
->input_pending
= 1;
160 connection
->input_pending
= 0;
162 #ifdef _DEBUG_GDB_IO_
163 LOG_DEBUG("returned char '%c' (0x%2.2x)", *next_char
, *next_char
);
171 retval
=check_pending(connection
, 1, NULL
);
172 if (retval
!=ERROR_OK
)
174 gdb_con
->buf_cnt
= read_socket(connection
->fd
, gdb_con
->buffer
, GDB_BUFFER_SIZE
);
175 if (gdb_con
->buf_cnt
> 0)
179 if (gdb_con
->buf_cnt
== 0)
182 return ERROR_SERVER_REMOTE_CLOSED
;
186 errno
= WSAGetLastError();
193 case WSAECONNABORTED
:
195 return ERROR_SERVER_REMOTE_CLOSED
;
198 return ERROR_SERVER_REMOTE_CLOSED
;
200 LOG_ERROR("read: %d", errno
);
211 return ERROR_SERVER_REMOTE_CLOSED
;
214 return ERROR_SERVER_REMOTE_CLOSED
;
216 LOG_ERROR("read: %s", strerror(errno
));
218 return ERROR_SERVER_REMOTE_CLOSED
;
223 #ifdef _DEBUG_GDB_IO_
224 debug_buffer
= malloc(gdb_con
->buf_cnt
+ 1);
225 memcpy(debug_buffer
, gdb_con
->buffer
, gdb_con
->buf_cnt
);
226 debug_buffer
[gdb_con
->buf_cnt
] = 0;
227 LOG_DEBUG("received '%s'", debug_buffer
);
231 gdb_con
->buf_p
= gdb_con
->buffer
;
233 *next_char
= *(gdb_con
->buf_p
++);
234 if (gdb_con
->buf_cnt
> 0)
235 connection
->input_pending
= 1;
237 connection
->input_pending
= 0;
238 #ifdef _DEBUG_GDB_IO_
239 LOG_DEBUG("returned char '%c' (0x%2.2x)", *next_char
, *next_char
);
245 int gdb_putback_char(connection_t
*connection
, int last_char
)
247 gdb_connection_t
*gdb_con
= connection
->priv
;
249 if (gdb_con
->buf_p
> gdb_con
->buffer
)
251 *(--gdb_con
->buf_p
) = last_char
;
256 LOG_ERROR("BUG: couldn't put character back");
262 /* The only way we can detect that the socket is closed is the first time
263 * we write to it, we will fail. Subsequent write operations will
264 * succeed. Shudder! */
265 int gdb_write(connection_t
*connection
, void *data
, int len
)
267 gdb_connection_t
*gdb_con
= connection
->priv
;
269 return ERROR_SERVER_REMOTE_CLOSED
;
271 if (write_socket(connection
->fd
, data
, len
) == len
)
276 return ERROR_SERVER_REMOTE_CLOSED
;
279 int gdb_put_packet_inner(connection_t
*connection
, char *buffer
, int len
)
282 unsigned char my_checksum
= 0;
283 #ifdef _DEBUG_GDB_IO_
288 gdb_connection_t
*gdb_con
= connection
->priv
;
290 for (i
= 0; i
< len
; i
++)
291 my_checksum
+= buffer
[i
];
293 #ifdef _DEBUG_GDB_IO_
295 * At this point we should have nothing in the input queue from GDB,
296 * however sometimes '-' is sent even though we've already received
297 * an ACK (+) for everything we've sent off.
302 if ((retval
=check_pending(connection
, 0, &gotdata
))!=ERROR_OK
)
306 if ((retval
= gdb_get_char(connection
, &reply
)) != ERROR_OK
)
308 LOG_WARNING("Discard unexpected char %c", reply
);
314 #ifdef _DEBUG_GDB_IO_
315 debug_buffer
= malloc(len
+ 1);
316 memcpy(debug_buffer
, buffer
, len
);
317 debug_buffer
[len
] = 0;
318 LOG_DEBUG("sending packet '$%s#%2.2x'", debug_buffer
, my_checksum
);
322 char local_buffer
[1024];
323 local_buffer
[0] = '$';
324 if (len
+4 <= sizeof(local_buffer
))
326 /* performance gain on smaller packets by only a single call to gdb_write() */
327 memcpy(local_buffer
+1, buffer
, len
++);
328 local_buffer
[len
++] = '#';
329 local_buffer
[len
++] = DIGITS
[(my_checksum
>> 4) & 0xf];
330 local_buffer
[len
++] = DIGITS
[my_checksum
& 0xf];
331 gdb_write(connection
, local_buffer
, len
);
335 /* larger packets are transmitted directly from caller supplied buffer
336 by several calls to gdb_write() to avoid dynamic allocation */
337 local_buffer
[1] = '#';
338 local_buffer
[2] = DIGITS
[(my_checksum
>> 4) & 0xf];
339 local_buffer
[3] = DIGITS
[my_checksum
& 0xf];
340 gdb_write(connection
, local_buffer
, 1);
341 gdb_write(connection
, buffer
, len
);
342 gdb_write(connection
, local_buffer
+1, 3);
345 if (gdb_con
->noack_mode
)
348 if ((retval
= gdb_get_char(connection
, &reply
)) != ERROR_OK
)
353 else if (reply
== '-')
355 /* Stop sending output packets for now */
356 log_remove_callback(gdb_log_callback
, connection
);
357 LOG_WARNING("negative reply, retrying");
359 else if (reply
== 0x3)
362 if ((retval
= gdb_get_char(connection
, &reply
)) != ERROR_OK
)
366 else if (reply
== '-')
368 /* Stop sending output packets for now */
369 log_remove_callback(gdb_log_callback
, connection
);
370 LOG_WARNING("negative reply, retrying");
374 LOG_ERROR("unknown character 0x%2.2x in reply, dropping connection", reply
);
376 return ERROR_SERVER_REMOTE_CLOSED
;
381 LOG_ERROR("unknown character 0x%2.2x in reply, dropping connection", reply
);
383 return ERROR_SERVER_REMOTE_CLOSED
;
387 return ERROR_SERVER_REMOTE_CLOSED
;
392 int gdb_put_packet(connection_t
*connection
, char *buffer
, int len
)
394 gdb_connection_t
*gdb_con
= connection
->priv
;
396 int retval
= gdb_put_packet_inner(connection
, buffer
, len
);
399 /* we sent some data, reset timer for keep alive messages */
405 static __inline__
int fetch_packet(connection_t
*connection
, int *checksum_ok
, int noack
, int *len
, char *buffer
)
407 unsigned char my_checksum
= 0;
412 gdb_connection_t
*gdb_con
= connection
->priv
;
418 /* The common case is that we have an entire packet with no escape chars.
419 * We need to leave at least 2 bytes in the buffer to have
420 * gdb_get_char() update various bits and bobs correctly.
422 if ((gdb_con
->buf_cnt
> 2) && ((gdb_con
->buf_cnt
+count
) < *len
))
424 /* The compiler will struggle a bit with constant propagation and
425 * aliasing, so we help it by showing that these values do not
426 * change inside the loop
429 char *buf
= gdb_con
->buf_p
;
430 int run
= gdb_con
->buf_cnt
- 2;
437 if (character
== '#')
439 /* Danger! character can be '#' when esc is
440 * used so we need an explicit boolean for done here.
446 if (character
== '}')
448 /* data transmitted in binary mode (X packet)
449 * uses 0x7d as escape character */
450 my_checksum
+= character
& 0xff;
453 my_checksum
+= character
& 0xff;
454 buffer
[count
++] = (character
^ 0x20) & 0xff;
458 my_checksum
+= character
& 0xff;
459 buffer
[count
++] = character
& 0xff;
463 gdb_con
->buf_cnt
-= i
;
469 LOG_ERROR("packet buffer too small");
470 return ERROR_GDB_BUFFER_TOO_SMALL
;
473 if ((retval
= gdb_get_char(connection
, &character
)) != ERROR_OK
)
476 if (character
== '#')
479 if (character
== '}')
481 /* data transmitted in binary mode (X packet)
482 * uses 0x7d as escape character */
483 my_checksum
+= character
& 0xff;
484 if ((retval
= gdb_get_char(connection
, &character
)) != ERROR_OK
)
486 my_checksum
+= character
& 0xff;
487 buffer
[count
++] = (character
^ 0x20) & 0xff;
491 my_checksum
+= character
& 0xff;
492 buffer
[count
++] = character
& 0xff;
498 if ((retval
= gdb_get_char(connection
, &character
)) != ERROR_OK
)
500 checksum
[0] = character
;
501 if ((retval
= gdb_get_char(connection
, &character
)) != ERROR_OK
)
503 checksum
[1] = character
;
508 *checksum_ok
=(my_checksum
== strtoul(checksum
, NULL
, 16));
514 int gdb_get_packet_inner(connection_t
*connection
, char *buffer
, int *len
)
518 gdb_connection_t
*gdb_con
= connection
->priv
;
524 if ((retval
= gdb_get_char(connection
, &character
)) != ERROR_OK
)
527 #ifdef _DEBUG_GDB_IO_
528 LOG_DEBUG("character: '%c'", character
);
536 /* gdb sends a dummy ack '+' at every remote connect - see remote_start_remote (remote.c)
537 * incase anyone tries to debug why they receive this warning every time */
538 LOG_WARNING("acknowledgment received, but no packet pending");
541 LOG_WARNING("negative acknowledgment, but no packet pending");
548 LOG_WARNING("ignoring character 0x%x", character
);
551 } while (character
!= '$');
556 /* explicit code expansion here to get faster inlined code in -O3 by not
557 * calculating checksum
559 if (gdb_con
->noack_mode
)
561 if ((retval
=fetch_packet(connection
, &checksum_ok
, 1, len
, buffer
))!=ERROR_OK
)
565 if ((retval
=fetch_packet(connection
, &checksum_ok
, 0, len
, buffer
))!=ERROR_OK
)
569 if (gdb_con
->noack_mode
)
571 /* checksum is not checked in noack mode */
576 gdb_write(connection
, "+", 1);
581 return ERROR_SERVER_REMOTE_CLOSED
;
586 int gdb_get_packet(connection_t
*connection
, char *buffer
, int *len
)
588 gdb_connection_t
*gdb_con
= connection
->priv
;
590 int retval
= gdb_get_packet_inner(connection
, buffer
, len
);
595 int gdb_output_con(connection_t
*connection
, const char* line
)
600 bin_size
= strlen(line
);
602 hex_buffer
= malloc(bin_size
*2 + 2);
603 if (hex_buffer
== NULL
)
604 return ERROR_GDB_BUFFER_TOO_SMALL
;
607 for (i
=0; i
<bin_size
; i
++)
608 snprintf(hex_buffer
+ 1 + i
*2, 3, "%2.2x", line
[i
]);
609 hex_buffer
[bin_size
*2+1] = 0;
611 gdb_put_packet(connection
, hex_buffer
, bin_size
*2 + 1);
617 int gdb_output(struct command_context_s
*context
, const char* line
)
619 /* this will be dumped to the log and also sent as an O packet if possible */
620 LOG_USER_N("%s", line
);
625 static void gdb_frontend_halted(struct target_s
*target
, connection_t
*connection
)
627 gdb_connection_t
*gdb_connection
= connection
->priv
;
629 /* In the GDB protocol when we are stepping or coninuing execution,
630 * we have a lingering reply. Upon receiving a halted event
631 * when we have that lingering packet, we reply to the original
632 * step or continue packet.
634 * Executing monitor commands can bring the target in and
635 * out of the running state so we'll see lots of TARGET_EVENT_XXX
636 * that are to be ignored.
638 if (gdb_connection
->frontend_state
== TARGET_RUNNING
)
642 /* stop forwarding log packets! */
643 log_remove_callback(gdb_log_callback
, connection
);
645 if (gdb_connection
->ctrl_c
)
648 gdb_connection
->ctrl_c
= 0;
652 signal
= gdb_last_signal(target
);
655 snprintf(sig_reply
, 4, "T%2.2x", signal
);
656 gdb_put_packet(connection
, sig_reply
, 3);
657 gdb_connection
->frontend_state
= TARGET_HALTED
;
661 int gdb_target_callback_event_handler(struct target_s
*target
, enum target_event event
, void *priv
)
663 connection_t
*connection
= priv
;
665 target_handle_event( target
, event
);
668 case TARGET_EVENT_EARLY_HALTED
:
669 gdb_frontend_halted(target
, connection
);
671 case TARGET_EVENT_GDB_FLASH_ERASE_START
:
672 target_handle_event( target
, TARGET_EVENT_OLD_gdb_program_config
);
673 jtag_execute_queue();
683 int gdb_new_connection(connection_t
*connection
)
685 gdb_connection_t
*gdb_connection
= malloc(sizeof(gdb_connection_t
));
686 gdb_service_t
*gdb_service
= connection
->service
->priv
;
690 connection
->priv
= gdb_connection
;
692 /* initialize gdb connection information */
693 gdb_connection
->buf_p
= gdb_connection
->buffer
;
694 gdb_connection
->buf_cnt
= 0;
695 gdb_connection
->ctrl_c
= 0;
696 gdb_connection
->frontend_state
= TARGET_HALTED
;
697 gdb_connection
->vflash_image
= NULL
;
698 gdb_connection
->closed
= 0;
699 gdb_connection
->busy
= 0;
700 gdb_connection
->noack_mode
= 0;
702 /* send ACK to GDB for debug request */
703 gdb_write(connection
, "+", 1);
705 /* output goes through gdb connection */
706 command_set_output_handler(connection
->cmd_ctx
, gdb_output
, connection
);
708 /* we must remove all breakpoints registered to the target as a previous
709 * GDB session could leave dangling breakpoints if e.g. communication
712 breakpoint_clear_target(gdb_service
->target
);
713 watchpoint_clear_target(gdb_service
->target
);
715 /* register callback to be informed about target events */
716 target_register_event_callback(gdb_target_callback_event_handler
, connection
);
718 /* a gdb session just attached, try to put the target in halt mode.
722 * If the halt fails(e.g. target needs a reset, JTAG communication not
723 * working, etc.), then the GDB connect will succeed as
724 * the get_gdb_reg_list() will lie and return a register list with
727 * This allows GDB monitor commands to be run from a GDB init script to
728 * initialize the target
730 * Also, since the halt() is asynchronous target connect will be
731 * instantaneous and thus avoiding annoying timeout problems during
734 target_halt(gdb_service
->target
);
735 /* FIX!!!! could extended-remote work better here?
737 * wait a tiny bit for halted state or we just continue. The
738 * GDB register packet will then contain garbage
740 target_wait_state(gdb_service
->target
, TARGET_HALTED
, 500);
742 /* remove the initial ACK from the incoming buffer */
743 if ((retval
= gdb_get_char(connection
, &initial_ack
)) != ERROR_OK
)
746 /* FIX!!!??? would we actually ever receive a + here???
749 if (initial_ack
!= '+')
750 gdb_putback_char(connection
, initial_ack
);
751 target_call_event_callbacks(gdb_service
->target
, TARGET_EVENT_GDB_ATTACH
);
755 int gdb_connection_closed(connection_t
*connection
)
757 gdb_service_t
*gdb_service
= connection
->service
->priv
;
758 gdb_connection_t
*gdb_connection
= connection
->priv
;
760 /* see if an image built with vFlash commands is left */
761 if (gdb_connection
->vflash_image
)
763 image_close(gdb_connection
->vflash_image
);
764 free(gdb_connection
->vflash_image
);
765 gdb_connection
->vflash_image
= NULL
;
768 /* if this connection registered a debug-message receiver delete it */
769 delete_debug_msg_receiver(connection
->cmd_ctx
, gdb_service
->target
);
771 if (connection
->priv
)
773 free(connection
->priv
);
774 connection
->priv
= NULL
;
778 LOG_ERROR("BUG: connection->priv == NULL");
781 target_unregister_event_callback(gdb_target_callback_event_handler
, connection
);
782 log_remove_callback(gdb_log_callback
, connection
);
784 target_call_event_callbacks(gdb_service
->target
, TARGET_EVENT_GDB_DETACH
);
788 void gdb_send_error(connection_t
*connection
, u8 the_error
)
791 snprintf(err
, 4, "E%2.2X", the_error
);
792 gdb_put_packet(connection
, err
, 3);
795 int gdb_last_signal_packet(connection_t
*connection
, target_t
*target
, char* packet
, int packet_size
)
800 signal
= gdb_last_signal(target
);
802 snprintf(sig_reply
, 4, "S%2.2x", signal
);
803 gdb_put_packet(connection
, sig_reply
, 3);
808 /* Convert register to string of bits. NB! The # of bits in the
809 * register might be non-divisible by 8(a byte), in which
810 * case an entire byte is shown. */
811 void gdb_str_to_target(target_t
*target
, char *tstr
, reg_t
*reg
)
818 buf_len
= CEIL(reg
->size
, 8);
820 for (i
= 0; i
< buf_len
; i
++)
822 tstr
[i
*2] = DIGITS
[(buf
[i
]>>4) & 0xf];
823 tstr
[i
*2+1] = DIGITS
[buf
[i
]&0xf];
827 void gdb_target_to_str(target_t
*target
, char *tstr
, char *str
)
829 int str_len
= strlen(tstr
);
834 LOG_ERROR("BUG: gdb value with uneven number of characters encountered");
838 for (i
= 0; i
< str_len
; i
+=2)
840 str
[str_len
- i
- 1] = tstr
[i
+ 1];
841 str
[str_len
- i
- 2] = tstr
[i
];
845 int gdb_get_registers_packet(connection_t
*connection
, target_t
*target
, char* packet
, int packet_size
)
850 int reg_packet_size
= 0;
855 #ifdef _DEBUG_GDB_IO_
859 if ((retval
= target
->type
->get_gdb_reg_list(target
, ®_list
, ®_list_size
)) != ERROR_OK
)
861 return gdb_error(connection
, retval
);
864 for (i
= 0; i
< reg_list_size
; i
++)
866 reg_packet_size
+= reg_list
[i
]->size
;
869 reg_packet
= malloc(CEIL(reg_packet_size
, 8) * 2);
870 reg_packet_p
= reg_packet
;
872 for (i
= 0; i
< reg_list_size
; i
++)
874 gdb_str_to_target(target
, reg_packet_p
, reg_list
[i
]);
875 reg_packet_p
+= CEIL(reg_list
[i
]->size
, 8) * 2;
878 #ifdef _DEBUG_GDB_IO_
881 reg_packet_p
= strndup(reg_packet
, CEIL(reg_packet_size
, 8) * 2);
882 LOG_DEBUG("reg_packet: %s", reg_packet_p
);
887 gdb_put_packet(connection
, reg_packet
, CEIL(reg_packet_size
, 8) * 2);
895 int gdb_set_registers_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
903 #ifdef _DEBUG_GDB_IO_
907 /* skip command character */
913 LOG_WARNING("GDB set_registers packet with uneven characters received, dropping connection");
914 return ERROR_SERVER_REMOTE_CLOSED
;
917 if ((retval
= target
->type
->get_gdb_reg_list(target
, ®_list
, ®_list_size
)) != ERROR_OK
)
919 return gdb_error(connection
, retval
);
923 for (i
= 0; i
< reg_list_size
; i
++)
927 reg_arch_type_t
*arch_type
;
929 /* convert from GDB-string (target-endian) to hex-string (big-endian) */
930 hex_buf
= malloc(CEIL(reg_list
[i
]->size
, 8) * 2);
931 gdb_target_to_str(target
, packet_p
, hex_buf
);
933 /* convert hex-string to binary buffer */
934 bin_buf
= malloc(CEIL(reg_list
[i
]->size
, 8));
935 str_to_buf(hex_buf
, CEIL(reg_list
[i
]->size
, 8) * 2, bin_buf
, reg_list
[i
]->size
, 16);
937 /* get register arch_type, and call set method */
938 arch_type
= register_get_arch_type(reg_list
[i
]->arch_type
);
940 arch_type
->set(reg_list
[i
], bin_buf
);
942 /* advance packet pointer */
943 packet_p
+= (CEIL(reg_list
[i
]->size
, 8) * 2);
949 /* free reg_t *reg_list[] array allocated by get_gdb_reg_list */
952 gdb_put_packet(connection
, "OK", 2);
957 int gdb_get_register_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
960 int reg_num
= strtoul(packet
+ 1, NULL
, 16);
965 #ifdef _DEBUG_GDB_IO_
969 if ((retval
= target
->type
->get_gdb_reg_list(target
, ®_list
, ®_list_size
)) != ERROR_OK
)
971 return gdb_error(connection
, retval
);
974 if (reg_list_size
<= reg_num
)
976 LOG_ERROR("gdb requested a non-existing register");
980 reg_packet
= malloc(CEIL(reg_list
[reg_num
]->size
, 8) * 2);
982 gdb_str_to_target(target
, reg_packet
, reg_list
[reg_num
]);
984 gdb_put_packet(connection
, reg_packet
, CEIL(reg_list
[reg_num
]->size
, 8) * 2);
992 int gdb_set_register_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
997 int reg_num
= strtoul(packet
+ 1, &separator
, 16);
1001 reg_arch_type_t
*arch_type
;
1005 if ((retval
= target
->type
->get_gdb_reg_list(target
, ®_list
, ®_list_size
)) != ERROR_OK
)
1007 return gdb_error(connection
, retval
);
1010 if (reg_list_size
< reg_num
)
1012 LOG_ERROR("gdb requested a non-existing register");
1013 return ERROR_SERVER_REMOTE_CLOSED
;
1016 if (*separator
!= '=')
1018 LOG_ERROR("GDB 'set register packet', but no '=' following the register number");
1019 return ERROR_SERVER_REMOTE_CLOSED
;
1022 /* convert from GDB-string (target-endian) to hex-string (big-endian) */
1023 hex_buf
= malloc(CEIL(reg_list
[reg_num
]->size
, 8) * 2);
1024 gdb_target_to_str(target
, separator
+ 1, hex_buf
);
1026 /* convert hex-string to binary buffer */
1027 bin_buf
= malloc(CEIL(reg_list
[reg_num
]->size
, 8));
1028 str_to_buf(hex_buf
, CEIL(reg_list
[reg_num
]->size
, 8) * 2, bin_buf
, reg_list
[reg_num
]->size
, 16);
1030 /* get register arch_type, and call set method */
1031 arch_type
= register_get_arch_type(reg_list
[reg_num
]->arch_type
);
1032 arch_type
->set(reg_list
[reg_num
], bin_buf
);
1034 gdb_put_packet(connection
, "OK", 2);
1043 int gdb_error(connection_t
*connection
, int retval
)
1047 case ERROR_TARGET_DATA_ABORT
:
1048 gdb_send_error(connection
, EIO
);
1050 case ERROR_TARGET_TRANSLATION_FAULT
:
1051 gdb_send_error(connection
, EFAULT
);
1053 case ERROR_TARGET_UNALIGNED_ACCESS
:
1054 gdb_send_error(connection
, EFAULT
);
1056 case ERROR_TARGET_NOT_HALTED
:
1057 gdb_send_error(connection
, EFAULT
);
1060 /* This could be that the target reset itself. */
1061 LOG_ERROR("unexpected error %i", retval
);
1062 gdb_send_error(connection
, EFAULT
);
1069 /* We don't have to worry about the default 2 second timeout for GDB packets,
1070 * because GDB breaks up large memory reads into smaller reads.
1072 * 8191 bytes by the looks of it. Why 8191 bytes instead of 8192?????
1074 int gdb_read_memory_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1083 int retval
= ERROR_OK
;
1085 /* skip command character */
1088 addr
= strtoul(packet
, &separator
, 16);
1090 if (*separator
!= ',')
1092 LOG_ERROR("incomplete read memory packet received, dropping connection");
1093 return ERROR_SERVER_REMOTE_CLOSED
;
1096 len
= strtoul(separator
+1, NULL
, 16);
1098 buffer
= malloc(len
);
1100 LOG_DEBUG("addr: 0x%8.8x, len: 0x%8.8x", addr
, len
);
1102 retval
= target_read_buffer(target
, addr
, len
, buffer
);
1104 if ((retval
== ERROR_TARGET_DATA_ABORT
) && (!gdb_report_data_abort
))
1106 /* TODO : Here we have to lie and send back all zero's lest stack traces won't work.
1107 * At some point this might be fixed in GDB, in which case this code can be removed.
1109 * OpenOCD developers are acutely aware of this problem, but there is nothing
1110 * gained by involving the user in this problem that hopefully will get resolved
1113 * http://sourceware.org/cgi-bin/gnatsweb.pl?cmd=view%20audit-trail&database=gdb&pr=2395
1115 * For now, the default is to fix up things to make current GDB versions work.
1116 * This can be overwritten using the gdb_report_data_abort <'enable'|'disable'> command.
1118 memset(buffer
, 0, len
);
1122 if (retval
== ERROR_OK
)
1124 hex_buffer
= malloc(len
* 2 + 1);
1127 for (i
= 0; i
< len
; i
++)
1130 hex_buffer
[2 * i
] = DIGITS
[(t
>> 4) & 0xf];
1131 hex_buffer
[2 * i
+ 1] = DIGITS
[t
& 0xf];
1134 gdb_put_packet(connection
, hex_buffer
, len
* 2);
1140 retval
= gdb_error(connection
, retval
);
1148 int gdb_write_memory_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1159 /* skip command character */
1162 addr
= strtoul(packet
, &separator
, 16);
1164 if (*separator
!= ',')
1166 LOG_ERROR("incomplete write memory packet received, dropping connection");
1167 return ERROR_SERVER_REMOTE_CLOSED
;
1170 len
= strtoul(separator
+1, &separator
, 16);
1172 if (*(separator
++) != ':')
1174 LOG_ERROR("incomplete write memory packet received, dropping connection");
1175 return ERROR_SERVER_REMOTE_CLOSED
;
1178 buffer
= malloc(len
);
1180 LOG_DEBUG("addr: 0x%8.8x, len: 0x%8.8x", addr
, len
);
1182 for (i
=0; i
<len
; i
++)
1185 sscanf(separator
+ 2*i
, "%2x", &tmp
);
1189 retval
= target_write_buffer(target
, addr
, len
, buffer
);
1191 if (retval
== ERROR_OK
)
1193 gdb_put_packet(connection
, "OK", 2);
1197 retval
= gdb_error(connection
, retval
);
1205 int gdb_write_memory_binary_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1213 /* skip command character */
1216 addr
= strtoul(packet
, &separator
, 16);
1218 if (*separator
!= ',')
1220 LOG_ERROR("incomplete write memory binary packet received, dropping connection");
1221 return ERROR_SERVER_REMOTE_CLOSED
;
1224 len
= strtoul(separator
+1, &separator
, 16);
1226 if (*(separator
++) != ':')
1228 LOG_ERROR("incomplete write memory binary packet received, dropping connection");
1229 return ERROR_SERVER_REMOTE_CLOSED
;
1235 LOG_DEBUG("addr: 0x%8.8x, len: 0x%8.8x", addr
, len
);
1237 retval
= target_write_buffer(target
, addr
, len
, (u8
*)separator
);
1240 if (retval
== ERROR_OK
)
1242 gdb_put_packet(connection
, "OK", 2);
1246 if ((retval
= gdb_error(connection
, retval
)) != ERROR_OK
)
1253 int gdb_step_continue_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1257 int retval
=ERROR_OK
;
1261 if (packet_size
> 1)
1263 packet
[packet_size
] = 0;
1264 address
= strtoul(packet
+ 1, NULL
, 16);
1271 if (packet
[0] == 'c')
1273 LOG_DEBUG("continue");
1274 target_handle_event( target
, TARGET_EVENT_OLD_pre_resume
);
1275 retval
=target_resume(target
, current
, address
, 0, 0); /* resume at current address, don't handle breakpoints, not debugging */
1277 else if (packet
[0] == 's')
1280 retval
=target
->type
->step(target
, current
, address
, 0); /* step at current or address, don't handle breakpoints */
1285 int gdb_breakpoint_watchpoint_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1288 enum breakpoint_type bp_type
= BKPT_SOFT
/* dummy init to avoid warning */;
1289 enum watchpoint_rw wp_type
;
1297 type
= strtoul(packet
+ 1, &separator
, 16);
1299 if (type
== 0) /* memory breakpoint */
1300 bp_type
= BKPT_SOFT
;
1301 else if (type
== 1) /* hardware breakpoint */
1302 bp_type
= BKPT_HARD
;
1303 else if (type
== 2) /* write watchpoint */
1304 wp_type
= WPT_WRITE
;
1305 else if (type
== 3) /* read watchpoint */
1307 else if (type
== 4) /* access watchpoint */
1308 wp_type
= WPT_ACCESS
;
1310 if (gdb_breakpoint_override
&&((bp_type
==BKPT_SOFT
)||(bp_type
==BKPT_HARD
)))
1312 bp_type
=gdb_breakpoint_override_type
;
1315 if (*separator
!= ',')
1317 LOG_ERROR("incomplete breakpoint/watchpoint packet received, dropping connection");
1318 return ERROR_SERVER_REMOTE_CLOSED
;
1321 address
= strtoul(separator
+1, &separator
, 16);
1323 if (*separator
!= ',')
1325 LOG_ERROR("incomplete breakpoint/watchpoint packet received, dropping connection");
1326 return ERROR_SERVER_REMOTE_CLOSED
;
1329 size
= strtoul(separator
+1, &separator
, 16);
1335 if (packet
[0] == 'Z')
1337 if ((retval
= breakpoint_add(target
, address
, size
, bp_type
)) != ERROR_OK
)
1339 if ((retval
= gdb_error(connection
, retval
)) != ERROR_OK
)
1344 gdb_put_packet(connection
, "OK", 2);
1349 breakpoint_remove(target
, address
);
1350 gdb_put_packet(connection
, "OK", 2);
1357 if (packet
[0] == 'Z')
1359 if ((retval
= watchpoint_add(target
, address
, size
, type
-2, 0, 0xffffffffu
)) != ERROR_OK
)
1361 if ((retval
= gdb_error(connection
, retval
)) != ERROR_OK
)
1366 gdb_put_packet(connection
, "OK", 2);
1371 watchpoint_remove(target
, address
);
1372 gdb_put_packet(connection
, "OK", 2);
1383 /* print out a string and allocate more space as needed, mainly used for XML at this point */
1384 void xml_printf(int *retval
, char **xml
, int *pos
, int *size
, const char *fmt
, ...)
1386 if (*retval
!= ERROR_OK
)
1394 if ((*xml
== NULL
) || (!first
))
1396 /* start by 0 to exercise all the code paths.
1397 * Need minimum 2 bytes to fit 1 char and 0 terminator. */
1399 *size
= *size
* 2 + 2;
1401 *xml
= realloc(*xml
, *size
);
1406 *retval
= ERROR_SERVER_REMOTE_CLOSED
;
1414 ret
= vsnprintf(*xml
+ *pos
, *size
- *pos
, fmt
, ap
);
1416 if ((ret
> 0) && ((ret
+ 1) < *size
- *pos
))
1421 /* there was just enough or not enough space, allocate more. */
1426 static int decode_xfer_read(char *buf
, char **annex
, int *ofs
, unsigned int *len
)
1430 /* Extract and NUL-terminate the annex. */
1432 while (*buf
&& *buf
!= ':')
1438 /* After the read marker and annex, qXfer looks like a
1439 * traditional 'm' packet. */
1441 *ofs
= strtoul(buf
, &separator
, 16);
1443 if (*separator
!= ',')
1446 *len
= strtoul(separator
+1, NULL
, 16);
1451 int gdb_calc_blocksize(flash_bank_t
*bank
)
1454 int block_size
= 0xffffffff;
1456 /* loop through all sectors and return smallest sector size */
1458 for (i
= 0; i
< bank
->num_sectors
; i
++)
1460 if (bank
->sectors
[i
].size
< block_size
)
1461 block_size
= bank
->sectors
[i
].size
;
1467 static int compare_bank (const void * a
, const void * b
)
1469 flash_bank_t
*b1
, *b2
;
1470 b1
=*((flash_bank_t
**)a
);
1471 b2
=*((flash_bank_t
**)b
);
1473 if (b1
->base
==b2
->base
)
1476 } else if (b1
->base
>b2
->base
)
1485 int gdb_query_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1487 command_context_t
*cmd_ctx
= connection
->cmd_ctx
;
1488 gdb_connection_t
*gdb_connection
= connection
->priv
;
1490 if (strstr(packet
, "qRcmd,"))
1492 if (packet_size
> 6)
1496 cmd
= malloc((packet_size
- 6)/2 + 1);
1497 for (i
=0; i
< (packet_size
- 6)/2; i
++)
1500 sscanf(packet
+ 6 + 2*i
, "%2x", &tmp
);
1503 cmd
[(packet_size
- 6)/2] = 0x0;
1505 /* We want to print all debug output to GDB connection */
1506 log_add_callback(gdb_log_callback
, connection
);
1507 target_call_timer_callbacks_now();
1508 command_run_line(cmd_ctx
, cmd
);
1509 target_call_timer_callbacks_now();
1510 log_remove_callback(gdb_log_callback
, connection
);
1513 gdb_put_packet(connection
, "OK", 2);
1516 else if (strstr(packet
, "qCRC:"))
1518 if (packet_size
> 5)
1527 /* skip command character */
1530 addr
= strtoul(packet
, &separator
, 16);
1532 if (*separator
!= ',')
1534 LOG_ERROR("incomplete read memory packet received, dropping connection");
1535 return ERROR_SERVER_REMOTE_CLOSED
;
1538 len
= strtoul(separator
+ 1, NULL
, 16);
1540 retval
= target_checksum_memory(target
, addr
, len
, &checksum
);
1542 if (retval
== ERROR_OK
)
1544 snprintf(gdb_reply
, 10, "C%8.8x", checksum
);
1545 gdb_put_packet(connection
, gdb_reply
, 9);
1549 if ((retval
= gdb_error(connection
, retval
)) != ERROR_OK
)
1556 else if (strstr(packet
, "qSupported"))
1558 /* we currently support packet size and qXfer:memory-map:read (if enabled)
1559 * disable qXfer:features:read for the moment */
1560 int retval
= ERROR_OK
;
1561 char *buffer
= NULL
;
1565 xml_printf(&retval
, &buffer
, &pos
, &size
,
1566 "PacketSize=%x;qXfer:memory-map:read%c;qXfer:features:read-;QStartNoAckMode+",
1567 (GDB_BUFFER_SIZE
- 1), ((gdb_use_memory_map
== 1)&&(flash_get_bank_count()>0)) ? '+' : '-');
1569 if (retval
!= ERROR_OK
)
1571 gdb_send_error(connection
, 01);
1575 gdb_put_packet(connection
, buffer
, strlen(buffer
));
1580 else if (strstr(packet
, "qXfer:memory-map:read::")&&(flash_get_bank_count()>0))
1582 /* We get away with only specifying flash here. Regions that are not
1583 * specified are treated as if we provided no memory map(if not we
1584 * could detect the holes and mark them as RAM).
1585 * Normally we only execute this code once, but no big deal if we
1586 * have to regenerate it a couple of times. */
1592 int retval
= ERROR_OK
;
1599 /* skip command character */
1602 offset
= strtoul(packet
, &separator
, 16);
1603 length
= strtoul(separator
+ 1, &separator
, 16);
1605 xml_printf(&retval
, &xml
, &pos
, &size
, "<memory-map>\n");
1608 sort banks in ascending order, we need to make non-flash memory be ram(or rather
1609 read/write) by default for GDB.
1610 GDB does not have a concept of non-cacheable read/write memory.
1612 flash_bank_t
**banks
=malloc(sizeof(flash_bank_t
*)*flash_get_bank_count());
1615 for (i
=0; i
<flash_get_bank_count(); i
++)
1617 p
= get_flash_bank_by_num(i
);
1621 retval
= ERROR_FAIL
;
1622 gdb_send_error(connection
, retval
);
1628 qsort(banks
, flash_get_bank_count(), sizeof(flash_bank_t
*), compare_bank
);
1631 for (i
=0; i
<flash_get_bank_count(); i
++)
1635 if (ram_start
<p
->base
)
1637 xml_printf(&retval
, &xml
, &pos
, &size
, "<memory type=\"ram\" start=\"0x%x\" length=\"0x%x\"/>\n",
1638 ram_start
, p
->base
-ram_start
);
1641 /* if device has uneven sector sizes, eg. str7, lpc
1642 * we pass the smallest sector size to gdb memory map */
1643 blocksize
= gdb_calc_blocksize(p
);
1645 xml_printf(&retval
, &xml
, &pos
, &size
, "<memory type=\"flash\" start=\"0x%x\" length=\"0x%x\">\n" \
1646 "<property name=\"blocksize\">0x%x</property>\n" \
1648 p
->base
, p
->size
, blocksize
);
1649 ram_start
=p
->base
+p
->size
;
1653 xml_printf(&retval
, &xml
, &pos
, &size
, "<memory type=\"ram\" start=\"0x%x\" length=\"0x%x\"/>\n",
1654 ram_start
, 0-ram_start
);
1657 /* a flash chip could be at the very end of the 32 bit address space, in which case
1658 ram_start will be precisely 0 */
1664 xml_printf(&retval
, &xml
, &pos
, &size
, "</memory-map>\n");
1666 if (retval
!= ERROR_OK
)
1668 gdb_send_error(connection
, retval
);
1672 if (offset
+ length
> pos
)
1674 length
= pos
- offset
;
1677 char *t
= malloc(length
+ 1);
1679 memcpy(t
+ 1, xml
+ offset
, length
);
1680 gdb_put_packet(connection
, t
, length
+ 1);
1686 else if (strstr(packet
, "qXfer:features:read:"))
1691 int retval
= ERROR_OK
;
1694 unsigned int length
;
1697 /* skip command character */
1700 if (decode_xfer_read(packet
, &annex
, &offset
, &length
) < 0)
1702 gdb_send_error(connection
, 01);
1706 if (strcmp(annex
, "target.xml") != 0)
1708 gdb_send_error(connection
, 01);
1712 xml_printf(&retval
, &xml
, &pos
, &size
, \
1713 "l<target version=\"1.0\">\n<architecture>arm</architecture>\n</target>\n");
1715 if (retval
!= ERROR_OK
)
1717 gdb_send_error(connection
, retval
);
1721 gdb_put_packet(connection
, xml
, strlen(xml
));
1726 else if (strstr(packet
, "QStartNoAckMode"))
1728 gdb_connection
->noack_mode
= 1;
1729 gdb_put_packet(connection
, "OK", 2);
1733 gdb_put_packet(connection
, "", 0);
1737 int gdb_v_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1739 gdb_connection_t
*gdb_connection
= connection
->priv
;
1740 gdb_service_t
*gdb_service
= connection
->service
->priv
;
1743 /* if flash programming disabled - send a empty reply */
1745 if (gdb_flash_program
== 0)
1747 gdb_put_packet(connection
, "", 0);
1751 if (strstr(packet
, "vFlashErase:"))
1754 unsigned long length
;
1756 char *parse
= packet
+ 12;
1759 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1760 return ERROR_SERVER_REMOTE_CLOSED
;
1763 addr
= strtoul(parse
, &parse
, 16);
1765 if (*(parse
++) != ',' || *parse
== '\0')
1767 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1768 return ERROR_SERVER_REMOTE_CLOSED
;
1771 length
= strtoul(parse
, &parse
, 16);
1775 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1776 return ERROR_SERVER_REMOTE_CLOSED
;
1779 /* assume all sectors need erasing - stops any problems
1780 * when flash_write is called multiple times */
1783 /* perform any target specific operations before the erase */
1784 target_call_event_callbacks(gdb_service
->target
, TARGET_EVENT_GDB_FLASH_ERASE_START
);
1785 result
= flash_erase_address_range(gdb_service
->target
, addr
, length
);
1786 target_call_event_callbacks(gdb_service
->target
, TARGET_EVENT_GDB_FLASH_ERASE_END
);
1789 if (result
!= ERROR_OK
)
1791 /* GDB doesn't evaluate the actual error number returned,
1792 * treat a failed erase as an I/O error
1794 gdb_send_error(connection
, EIO
);
1795 LOG_ERROR("flash_erase returned %i", result
);
1798 gdb_put_packet(connection
, "OK", 2);
1803 if (strstr(packet
, "vFlashWrite:"))
1806 unsigned long length
;
1807 char *parse
= packet
+ 12;
1811 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1812 return ERROR_SERVER_REMOTE_CLOSED
;
1814 addr
= strtoul(parse
, &parse
, 16);
1815 if (*(parse
++) != ':')
1817 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1818 return ERROR_SERVER_REMOTE_CLOSED
;
1820 length
= packet_size
- (parse
- packet
);
1822 /* create a new image if there isn't already one */
1823 if (gdb_connection
->vflash_image
== NULL
)
1825 gdb_connection
->vflash_image
= malloc(sizeof(image_t
));
1826 image_open(gdb_connection
->vflash_image
, "", "build");
1829 /* create new section with content from packet buffer */
1830 image_add_section(gdb_connection
->vflash_image
, addr
, length
, 0x0, (u8
*)parse
);
1832 gdb_put_packet(connection
, "OK", 2);
1837 if (!strcmp(packet
, "vFlashDone"))
1841 /* process the flashing buffer. No need to erase as GDB
1842 * always issues a vFlashErase first. */
1843 target_call_event_callbacks(gdb_service
->target
, TARGET_EVENT_GDB_FLASH_WRITE_START
);
1844 result
= flash_write(gdb_service
->target
, gdb_connection
->vflash_image
, &written
, 0);
1845 target_call_event_callbacks(gdb_service
->target
, TARGET_EVENT_GDB_FLASH_WRITE_END
);
1846 if ( result
!= ERROR_OK
)
1848 if (result
== ERROR_FLASH_DST_OUT_OF_BANK
)
1849 gdb_put_packet(connection
, "E.memtype", 9);
1851 gdb_send_error(connection
, EIO
);
1855 LOG_DEBUG("wrote %u bytes from vFlash image to flash", written
);
1856 gdb_put_packet(connection
, "OK", 2);
1859 image_close(gdb_connection
->vflash_image
);
1860 free(gdb_connection
->vflash_image
);
1861 gdb_connection
->vflash_image
= NULL
;
1866 gdb_put_packet(connection
, "", 0);
1870 int gdb_detach(connection_t
*connection
, target_t
*target
)
1873 switch( detach_mode
)
1875 case GDB_DETACH_RESUME
:
1876 target_handle_event( target
, TARGET_EVENT_OLD_pre_resume
);
1877 target_resume(target
, 1, 0, 1, 0);
1880 case GDB_DETACH_RESET
:
1881 /* FIX?? make this configurable?? */
1882 target_process_reset(connection
->cmd_ctx
, RESET_HALT
);
1885 case GDB_DETACH_HALT
:
1886 target_halt(target
);
1889 case GDB_DETACH_NOTHING
:
1893 gdb_put_packet(connection
, "OK", 2);
1897 static void gdb_log_callback(void *priv
, const char *file
, int line
,
1898 const char *function
, const char *string
)
1900 connection_t
*connection
= priv
;
1901 gdb_connection_t
*gdb_con
= connection
->priv
;
1905 /* do not reply this using the O packet */
1909 gdb_output_con(connection
, string
);
1912 /* Do not allocate this on the stack */
1913 char gdb_packet_buffer
[GDB_BUFFER_SIZE
];
1915 static void gdb_sig_halted(connection_t
*connection
)
1918 snprintf(sig_reply
, 4, "T%2.2x", 2);
1919 gdb_put_packet(connection
, sig_reply
, 3);
1923 int gdb_input_inner(connection_t
*connection
)
1925 gdb_service_t
*gdb_service
= connection
->service
->priv
;
1926 target_t
*target
= gdb_service
->target
;
1927 char *packet
=gdb_packet_buffer
;
1930 gdb_connection_t
*gdb_con
= connection
->priv
;
1931 static int extended_protocol
= 0;
1933 /* drain input buffer */
1936 packet_size
= GDB_BUFFER_SIZE
-1;
1937 if ((retval
= gdb_get_packet(connection
, packet
, &packet_size
)) != ERROR_OK
)
1942 /* terminate with zero */
1943 packet
[packet_size
] = 0;
1945 LOG_DEBUG("received packet: '%s'", packet
);
1947 if (packet_size
> 0)
1953 /* Hct... -- set thread
1954 * we don't have threads, send empty reply */
1955 gdb_put_packet(connection
, NULL
, 0);
1959 retval
= gdb_query_packet(connection
, target
, packet
, packet_size
);
1962 retval
= gdb_get_registers_packet(connection
, target
, packet
, packet_size
);
1965 retval
= gdb_set_registers_packet(connection
, target
, packet
, packet_size
);
1968 retval
= gdb_get_register_packet(connection
, target
, packet
, packet_size
);
1971 retval
= gdb_set_register_packet(connection
, target
, packet
, packet_size
);
1974 retval
= gdb_read_memory_packet(connection
, target
, packet
, packet_size
);
1977 retval
= gdb_write_memory_packet(connection
, target
, packet
, packet_size
);
1981 retval
= gdb_breakpoint_watchpoint_packet(connection
, target
, packet
, packet_size
);
1984 gdb_last_signal_packet(connection
, target
, packet
, packet_size
);
1989 if (target
->state
!= TARGET_HALTED
)
1991 /* If the target isn't in the halted state, then we can't
1992 * step/continue. This might be early setup, etc.
1994 gdb_sig_halted(connection
);
1997 /* We're running/stepping, in which case we can
1998 * forward log output until the target is halted
2000 gdb_connection_t
*gdb_con
= connection
->priv
;
2001 gdb_con
->frontend_state
= TARGET_RUNNING
;
2002 log_add_callback(gdb_log_callback
, connection
);
2003 int retval
=gdb_step_continue_packet(connection
, target
, packet
, packet_size
);
2004 if (retval
!=ERROR_OK
)
2006 /* we'll never receive a halted condition... issue a false one.. */
2007 gdb_frontend_halted(target
, connection
);
2013 retval
= gdb_v_packet(connection
, target
, packet
, packet_size
);
2016 retval
= gdb_detach(connection
, target
);
2017 extended_protocol
= 0;
2020 if ((retval
= gdb_write_memory_binary_packet(connection
, target
, packet
, packet_size
)) != ERROR_OK
)
2024 if (extended_protocol
!= 0)
2026 gdb_put_packet(connection
, "OK", 2);
2027 return ERROR_SERVER_REMOTE_CLOSED
;
2029 /* handle extended remote protocol */
2030 extended_protocol
= 1;
2031 gdb_put_packet(connection
, "OK", 2);
2034 /* handle extended restart packet */
2035 breakpoint_clear_target(gdb_service
->target
);
2036 watchpoint_clear_target(gdb_service
->target
);
2037 command_run_linef(connection
->cmd_ctx
, "ocd_gdb_restart %d", get_num_by_target(target
));
2040 /* ignore unkown packets */
2041 LOG_DEBUG("ignoring 0x%2.2x packet", packet
[0]);
2042 gdb_put_packet(connection
, NULL
, 0);
2046 /* if a packet handler returned an error, exit input loop */
2047 if (retval
!= ERROR_OK
)
2051 if (gdb_con
->ctrl_c
)
2053 if (target
->state
== TARGET_RUNNING
)
2055 target_halt(target
);
2056 gdb_con
->ctrl_c
= 0;
2060 } while (gdb_con
->buf_cnt
> 0);
2065 int gdb_input(connection_t
*connection
)
2067 int retval
= gdb_input_inner(connection
);
2068 gdb_connection_t
*gdb_con
= connection
->priv
;
2069 if (retval
== ERROR_SERVER_REMOTE_CLOSED
)
2072 /* logging does not propagate the error, yet can set th gdb_con->closed flag */
2073 if (gdb_con
->closed
)
2074 return ERROR_SERVER_REMOTE_CLOSED
;
2076 /* we'll recover from any other errors(e.g. temporary timeouts, etc.) */
2082 gdb_service_t
*gdb_service
;
2083 target_t
*target
= all_targets
;
2087 LOG_WARNING("no gdb ports allocated as no target has been specified");
2093 LOG_WARNING("no gdb port specified, using default port 3333");
2099 char service_name
[8];
2101 snprintf(service_name
, 8, "gdb-%2.2i", target
->target_number
);
2103 gdb_service
= malloc(sizeof(gdb_service_t
));
2104 gdb_service
->target
= target
;
2106 add_service("gdb", CONNECTION_GDB
,
2107 gdb_port
+ target
->target_number
,
2108 1, gdb_new_connection
, gdb_input
,
2109 gdb_connection_closed
,
2112 LOG_DEBUG("gdb service for target %s at port %i",
2114 gdb_port
+ target
->target_number
);
2116 target
= target
->next
;
2122 /* daemon configuration command gdb_port */
2123 int handle_gdb_port_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2128 /* only if the port wasn't overwritten by cmdline */
2130 gdb_port
= strtoul(args
[0], NULL
, 0);
2135 int handle_gdb_detach_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2139 if (strcmp(args
[0], "resume") == 0)
2141 detach_mode
= GDB_DETACH_RESUME
;
2144 else if (strcmp(args
[0], "reset") == 0)
2146 detach_mode
= GDB_DETACH_RESET
;
2149 else if (strcmp(args
[0], "halt") == 0)
2151 detach_mode
= GDB_DETACH_HALT
;
2154 else if (strcmp(args
[0], "nothing") == 0)
2156 detach_mode
= GDB_DETACH_NOTHING
;
2161 LOG_WARNING("invalid gdb_detach configuration directive: %s", args
[0]);
2165 int handle_gdb_memory_map_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2169 if (strcmp(args
[0], "enable") == 0)
2171 gdb_use_memory_map
= 1;
2174 else if (strcmp(args
[0], "disable") == 0)
2176 gdb_use_memory_map
= 0;
2181 LOG_WARNING("invalid gdb_memory_map configuration directive: %s", args
[0]);
2185 int handle_gdb_flash_program_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2189 if (strcmp(args
[0], "enable") == 0)
2191 gdb_flash_program
= 1;
2194 else if (strcmp(args
[0], "disable") == 0)
2196 gdb_flash_program
= 0;
2201 LOG_WARNING("invalid gdb_memory_map configuration directive: %s", args
[0]);
2205 int handle_gdb_report_data_abort_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2209 if (strcmp(args
[0], "enable") == 0)
2211 gdb_report_data_abort
= 1;
2214 else if (strcmp(args
[0], "disable") == 0)
2216 gdb_report_data_abort
= 0;
2221 LOG_WARNING("invalid gdb_report_data_abort configuration directive: %s", args
[0]);
2225 /* daemon configuration command gdb_port */
2226 int handle_gdb_breakpoint_override_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2233 gdb_breakpoint_override
= 1;
2234 if (strcmp(args
[0], "hard")==0)
2236 gdb_breakpoint_override_type
=BKPT_HARD
;
2237 } else if (strcmp(args
[0], "soft")==0)
2239 gdb_breakpoint_override_type
=BKPT_SOFT
;
2240 } else if (strcmp(args
[0], "disable") == 0)
2242 gdb_breakpoint_override
= 0;
2246 return ERROR_COMMAND_SYNTAX_ERROR
;
2248 if (gdb_breakpoint_override
)
2250 LOG_USER("force %s breakpoints", (gdb_breakpoint_override_type
==BKPT_HARD
)?"hard":"soft");
2253 LOG_USER("breakpoint type is not overriden");
2260 int gdb_register_commands(command_context_t
*command_context
)
2262 register_command(command_context
, NULL
, "gdb_port", handle_gdb_port_command
,
2263 COMMAND_CONFIG
, "");
2264 register_command(command_context
, NULL
, "gdb_detach", handle_gdb_detach_command
,
2265 COMMAND_CONFIG
, "");
2266 register_command(command_context
, NULL
, "gdb_memory_map", handle_gdb_memory_map_command
,
2267 COMMAND_CONFIG
, "");
2268 register_command(command_context
, NULL
, "gdb_flash_program", handle_gdb_flash_program_command
,
2269 COMMAND_CONFIG
, "");
2270 register_command(command_context
, NULL
, "gdb_report_data_abort", handle_gdb_report_data_abort_command
,
2271 COMMAND_CONFIG
, "");
2272 register_command(command_context
, NULL
, "gdb_breakpoint_override", handle_gdb_breakpoint_override_command
,
2273 COMMAND_EXEC
, "hard/soft/disabled - force breakpoint type for gdb 'break' commands."
2274 "The raison d'etre for this option is to support GDB GUI's without "
2275 "a hard/soft breakpoint concept where the default OpenOCD behaviour "
2276 "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)