1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * Copyright (C) 2007,2008 Øyvind Harboe *
6 * oyvind.harboe@zylin.com *
8 * Copyright (C) 2008 by Spencer Oliver *
9 * spen@spen-soft.co.uk *
11 * This program is free software; you can redistribute it and/or modify *
12 * it under the terms of the GNU General Public License as published by *
13 * the Free Software Foundation; either version 2 of the License, or *
14 * (at your option) any later version. *
16 * This program is distributed in the hope that it will be useful, *
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
19 * GNU General Public License for more details. *
21 * You should have received a copy of the GNU General Public License *
22 * along with this program; if not, write to the *
23 * Free Software Foundation, Inc., *
24 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
25 ***************************************************************************/
30 #include "replacements.h"
32 #include "gdb_server.h"
36 #include "binarybuffer.h"
38 #include "breakpoints.h"
41 #include "target_request.h"
42 #include "configuration.h"
50 #define _DEBUG_GDB_IO_
53 static int gdb_breakpoint_override
;
54 static enum breakpoint_type gdb_breakpoint_override_type
;
56 extern int gdb_error(connection_t
*connection
, int retval
);
57 static unsigned short gdb_port
;
58 static const char *DIGITS
= "0123456789abcdef";
60 static void gdb_log_callback(void *priv
, const char *file
, int line
,
61 const char *function
, const char *string
);
71 /* target behaviour on gdb detach */
72 enum gdb_detach_mode detach_mode
= GDB_DETACH_RESUME
;
74 /* set if we are sending a memory map to gdb
75 * via qXfer:memory-map:read packet */
76 /* enabled by default*/
77 int gdb_use_memory_map
= 1;
78 /* enabled by default*/
79 int gdb_flash_program
= 1;
81 /* if set, data aborts cause an error to be reported in memory read packets
82 * see the code in gdb_read_memory_packet() for further explanations */
83 int gdb_report_data_abort
= 0;
85 int gdb_last_signal(target_t
*target
)
87 switch (target
->debug_reason
)
89 case DBG_REASON_DBGRQ
:
90 return 0x2; /* SIGINT */
91 case DBG_REASON_BREAKPOINT
:
92 case DBG_REASON_WATCHPOINT
:
93 case DBG_REASON_WPTANDBKPT
:
94 return 0x05; /* SIGTRAP */
95 case DBG_REASON_SINGLESTEP
:
96 return 0x05; /* SIGTRAP */
97 case DBG_REASON_NOTHALTED
:
98 return 0x0; /* no signal... shouldn't happen */
100 LOG_USER("undefined debug reason %d - target needs reset", target
->debug_reason
);
105 int check_pending(connection_t
*connection
, int timeout_s
, int *got_data
)
107 /* a non-blocking socket will block if there is 0 bytes available on the socket,
108 * but return with as many bytes as are available immediately
112 gdb_connection_t
*gdb_con
= connection
->priv
;
118 if (gdb_con
->buf_cnt
>0)
125 FD_SET(connection
->fd
, &read_fds
);
127 tv
.tv_sec
= timeout_s
;
129 if (select(connection
->fd
+ 1, &read_fds
, NULL
, NULL
, &tv
) == 0)
131 /* This can typically be because a "monitor" command took too long
132 * before printing any progress messages
136 return ERROR_GDB_TIMEOUT
;
142 *got_data
=FD_ISSET(connection
->fd
, &read_fds
)!=0;
146 int gdb_get_char(connection_t
*connection
, int* next_char
)
148 gdb_connection_t
*gdb_con
= connection
->priv
;
151 #ifdef _DEBUG_GDB_IO_
155 if (gdb_con
->buf_cnt
-- > 0)
157 *next_char
= *(gdb_con
->buf_p
++);
158 if (gdb_con
->buf_cnt
> 0)
159 connection
->input_pending
= 1;
161 connection
->input_pending
= 0;
163 #ifdef _DEBUG_GDB_IO_
164 LOG_DEBUG("returned char '%c' (0x%2.2x)", *next_char
, *next_char
);
172 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
);
176 if (gdb_con
->buf_cnt
> 0)
180 if (gdb_con
->buf_cnt
== 0)
183 return ERROR_SERVER_REMOTE_CLOSED
;
187 errno
= WSAGetLastError();
194 case WSAECONNABORTED
:
196 return ERROR_SERVER_REMOTE_CLOSED
;
199 return ERROR_SERVER_REMOTE_CLOSED
;
201 LOG_ERROR("read: %d", errno
);
212 return ERROR_SERVER_REMOTE_CLOSED
;
215 return ERROR_SERVER_REMOTE_CLOSED
;
217 LOG_ERROR("read: %s", strerror(errno
));
219 return ERROR_SERVER_REMOTE_CLOSED
;
224 #ifdef _DEBUG_GDB_IO_
225 debug_buffer
= malloc(gdb_con
->buf_cnt
+ 1);
226 memcpy(debug_buffer
, gdb_con
->buffer
, gdb_con
->buf_cnt
);
227 debug_buffer
[gdb_con
->buf_cnt
] = 0;
228 LOG_DEBUG("received '%s'", debug_buffer
);
232 gdb_con
->buf_p
= gdb_con
->buffer
;
234 *next_char
= *(gdb_con
->buf_p
++);
235 if (gdb_con
->buf_cnt
> 0)
236 connection
->input_pending
= 1;
238 connection
->input_pending
= 0;
239 #ifdef _DEBUG_GDB_IO_
240 LOG_DEBUG("returned char '%c' (0x%2.2x)", *next_char
, *next_char
);
246 int gdb_putback_char(connection_t
*connection
, int last_char
)
248 gdb_connection_t
*gdb_con
= connection
->priv
;
250 if (gdb_con
->buf_p
> gdb_con
->buffer
)
252 *(--gdb_con
->buf_p
) = last_char
;
257 LOG_ERROR("BUG: couldn't put character back");
263 /* The only way we can detect that the socket is closed is the first time
264 * we write to it, we will fail. Subsequent write operations will
265 * succeed. Shudder! */
266 int gdb_write(connection_t
*connection
, void *data
, int len
)
268 gdb_connection_t
*gdb_con
= connection
->priv
;
270 return ERROR_SERVER_REMOTE_CLOSED
;
272 if (write_socket(connection
->fd
, data
, len
) == len
)
277 return ERROR_SERVER_REMOTE_CLOSED
;
280 int gdb_put_packet_inner(connection_t
*connection
, char *buffer
, int len
)
283 unsigned char my_checksum
= 0;
284 #ifdef _DEBUG_GDB_IO_
289 gdb_connection_t
*gdb_con
= connection
->priv
;
291 for (i
= 0; i
< len
; i
++)
292 my_checksum
+= buffer
[i
];
294 #ifdef _DEBUG_GDB_IO_
296 * At this point we should have nothing in the input queue from GDB,
297 * however sometimes '-' is sent even though we've already received
298 * an ACK (+) for everything we've sent off.
303 if ((retval
=check_pending(connection
, 0, &gotdata
))!=ERROR_OK
)
307 if ((retval
= gdb_get_char(connection
, &reply
)) != ERROR_OK
)
310 // fix a problem with some IAR tools
311 gdb_putback_char( connection
, reply
);
312 LOG_DEBUG("Unexpected start of new packet");
316 LOG_WARNING("Discard unexpected char %c", reply
);
322 #ifdef _DEBUG_GDB_IO_
323 debug_buffer
= malloc(len
+ 1);
324 memcpy(debug_buffer
, buffer
, len
);
325 debug_buffer
[len
] = 0;
326 LOG_DEBUG("sending packet '$%s#%2.2x'", debug_buffer
, my_checksum
);
330 char local_buffer
[1024];
331 local_buffer
[0] = '$';
332 if (len
+4 <= sizeof(local_buffer
))
334 /* performance gain on smaller packets by only a single call to gdb_write() */
335 memcpy(local_buffer
+1, buffer
, len
++);
336 local_buffer
[len
++] = '#';
337 local_buffer
[len
++] = DIGITS
[(my_checksum
>> 4) & 0xf];
338 local_buffer
[len
++] = DIGITS
[my_checksum
& 0xf];
339 if((retval
= gdb_write(connection
, local_buffer
, len
)) != ERROR_OK
)
346 /* larger packets are transmitted directly from caller supplied buffer
347 by several calls to gdb_write() to avoid dynamic allocation */
348 local_buffer
[1] = '#';
349 local_buffer
[2] = DIGITS
[(my_checksum
>> 4) & 0xf];
350 local_buffer
[3] = DIGITS
[my_checksum
& 0xf];
351 if((retval
= gdb_write(connection
, local_buffer
, 1)) != ERROR_OK
)
355 if((retval
= gdb_write(connection
, buffer
, len
)) != ERROR_OK
)
359 if((retval
= gdb_write(connection
, local_buffer
+1, 3)) != ERROR_OK
)
365 if (gdb_con
->noack_mode
)
368 if ((retval
= gdb_get_char(connection
, &reply
)) != ERROR_OK
)
373 else if (reply
== '-')
375 /* Stop sending output packets for now */
376 log_remove_callback(gdb_log_callback
, connection
);
377 LOG_WARNING("negative reply, retrying");
379 else if (reply
== 0x3)
382 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
== '$' ){
393 LOG_ERROR("GDB missing ack(1) - assumed good");
394 gdb_putback_char( connection
, reply
);
398 LOG_ERROR("unknown character(1) 0x%2.2x in reply, dropping connection", reply
);
400 return ERROR_SERVER_REMOTE_CLOSED
;
403 else if( reply
== '$' ){
404 LOG_ERROR("GDB missing ack(2) - assumed good");
405 gdb_putback_char( connection
, reply
);
410 LOG_ERROR("unknown character(2) 0x%2.2x in reply, dropping connection", reply
);
412 return ERROR_SERVER_REMOTE_CLOSED
;
416 return ERROR_SERVER_REMOTE_CLOSED
;
421 int gdb_put_packet(connection_t
*connection
, char *buffer
, int len
)
423 gdb_connection_t
*gdb_con
= connection
->priv
;
425 int retval
= gdb_put_packet_inner(connection
, buffer
, len
);
428 /* we sent some data, reset timer for keep alive messages */
434 static __inline__
int fetch_packet(connection_t
*connection
, int *checksum_ok
, int noack
, int *len
, char *buffer
)
436 unsigned char my_checksum
= 0;
441 gdb_connection_t
*gdb_con
= connection
->priv
;
447 /* The common case is that we have an entire packet with no escape chars.
448 * We need to leave at least 2 bytes in the buffer to have
449 * gdb_get_char() update various bits and bobs correctly.
451 if ((gdb_con
->buf_cnt
> 2) && ((gdb_con
->buf_cnt
+count
) < *len
))
453 /* The compiler will struggle a bit with constant propagation and
454 * aliasing, so we help it by showing that these values do not
455 * change inside the loop
458 char *buf
= gdb_con
->buf_p
;
459 int run
= gdb_con
->buf_cnt
- 2;
466 if (character
== '#')
468 /* Danger! character can be '#' when esc is
469 * used so we need an explicit boolean for done here.
475 if (character
== '}')
477 /* data transmitted in binary mode (X packet)
478 * uses 0x7d as escape character */
479 my_checksum
+= character
& 0xff;
482 my_checksum
+= character
& 0xff;
483 buffer
[count
++] = (character
^ 0x20) & 0xff;
487 my_checksum
+= character
& 0xff;
488 buffer
[count
++] = character
& 0xff;
492 gdb_con
->buf_cnt
-= i
;
498 LOG_ERROR("packet buffer too small");
499 return ERROR_GDB_BUFFER_TOO_SMALL
;
502 if ((retval
= gdb_get_char(connection
, &character
)) != ERROR_OK
)
505 if (character
== '#')
508 if (character
== '}')
510 /* data transmitted in binary mode (X packet)
511 * uses 0x7d as escape character */
512 my_checksum
+= character
& 0xff;
513 if ((retval
= gdb_get_char(connection
, &character
)) != ERROR_OK
)
515 my_checksum
+= character
& 0xff;
516 buffer
[count
++] = (character
^ 0x20) & 0xff;
520 my_checksum
+= character
& 0xff;
521 buffer
[count
++] = character
& 0xff;
527 if ((retval
= gdb_get_char(connection
, &character
)) != ERROR_OK
)
529 checksum
[0] = character
;
530 if ((retval
= gdb_get_char(connection
, &character
)) != ERROR_OK
)
532 checksum
[1] = character
;
537 *checksum_ok
=(my_checksum
== strtoul(checksum
, NULL
, 16));
543 int gdb_get_packet_inner(connection_t
*connection
, char *buffer
, int *len
)
547 gdb_connection_t
*gdb_con
= connection
->priv
;
553 if ((retval
= gdb_get_char(connection
, &character
)) != ERROR_OK
)
556 #ifdef _DEBUG_GDB_IO_
557 LOG_DEBUG("character: '%c'", character
);
565 /* gdb sends a dummy ack '+' at every remote connect - see remote_start_remote (remote.c)
566 * incase anyone tries to debug why they receive this warning every time */
567 LOG_WARNING("acknowledgment received, but no packet pending");
570 LOG_WARNING("negative acknowledgment, but no packet pending");
577 LOG_WARNING("ignoring character 0x%x", character
);
580 } while (character
!= '$');
585 /* explicit code expansion here to get faster inlined code in -O3 by not
586 * calculating checksum
588 if (gdb_con
->noack_mode
)
590 if ((retval
=fetch_packet(connection
, &checksum_ok
, 1, len
, buffer
))!=ERROR_OK
)
594 if ((retval
=fetch_packet(connection
, &checksum_ok
, 0, len
, buffer
))!=ERROR_OK
)
598 if (gdb_con
->noack_mode
)
600 /* checksum is not checked in noack mode */
605 if ((retval
= gdb_write(connection
, "+", 1)) != ERROR_OK
)
613 return ERROR_SERVER_REMOTE_CLOSED
;
618 int gdb_get_packet(connection_t
*connection
, char *buffer
, int *len
)
620 gdb_connection_t
*gdb_con
= connection
->priv
;
622 int retval
= gdb_get_packet_inner(connection
, buffer
, len
);
627 int gdb_output_con(connection_t
*connection
, const char* line
)
632 bin_size
= strlen(line
);
634 hex_buffer
= malloc(bin_size
*2 + 2);
635 if (hex_buffer
== NULL
)
636 return ERROR_GDB_BUFFER_TOO_SMALL
;
639 for (i
=0; i
<bin_size
; i
++)
640 snprintf(hex_buffer
+ 1 + i
*2, 3, "%2.2x", line
[i
]);
641 hex_buffer
[bin_size
*2+1] = 0;
643 int retval
= gdb_put_packet(connection
, hex_buffer
, bin_size
*2 + 1);
649 int gdb_output(struct command_context_s
*context
, const char* line
)
651 /* this will be dumped to the log and also sent as an O packet if possible */
652 LOG_USER_N("%s", line
);
657 static void gdb_frontend_halted(struct target_s
*target
, connection_t
*connection
)
659 gdb_connection_t
*gdb_connection
= connection
->priv
;
661 /* In the GDB protocol when we are stepping or coninuing execution,
662 * we have a lingering reply. Upon receiving a halted event
663 * when we have that lingering packet, we reply to the original
664 * step or continue packet.
666 * Executing monitor commands can bring the target in and
667 * out of the running state so we'll see lots of TARGET_EVENT_XXX
668 * that are to be ignored.
670 if (gdb_connection
->frontend_state
== TARGET_RUNNING
)
674 /* stop forwarding log packets! */
675 log_remove_callback(gdb_log_callback
, connection
);
677 if (gdb_connection
->ctrl_c
)
680 gdb_connection
->ctrl_c
= 0;
684 signal
= gdb_last_signal(target
);
687 snprintf(sig_reply
, 4, "T%2.2x", signal
);
688 gdb_put_packet(connection
, sig_reply
, 3);
689 gdb_connection
->frontend_state
= TARGET_HALTED
;
693 int gdb_target_callback_event_handler(struct target_s
*target
, enum target_event event
, void *priv
)
696 connection_t
*connection
= priv
;
698 target_handle_event( target
, event
);
701 case TARGET_EVENT_EARLY_HALTED
:
702 gdb_frontend_halted(target
, connection
);
704 case TARGET_EVENT_GDB_FLASH_ERASE_START
:
705 target_handle_event( target
, TARGET_EVENT_OLD_gdb_program_config
);
706 if((retval
= jtag_execute_queue()) != ERROR_OK
)
719 int gdb_new_connection(connection_t
*connection
)
721 gdb_connection_t
*gdb_connection
= malloc(sizeof(gdb_connection_t
));
722 gdb_service_t
*gdb_service
= connection
->service
->priv
;
726 connection
->priv
= gdb_connection
;
728 /* initialize gdb connection information */
729 gdb_connection
->buf_p
= gdb_connection
->buffer
;
730 gdb_connection
->buf_cnt
= 0;
731 gdb_connection
->ctrl_c
= 0;
732 gdb_connection
->frontend_state
= TARGET_HALTED
;
733 gdb_connection
->vflash_image
= NULL
;
734 gdb_connection
->closed
= 0;
735 gdb_connection
->busy
= 0;
736 gdb_connection
->noack_mode
= 0;
738 /* send ACK to GDB for debug request */
739 gdb_write(connection
, "+", 1);
741 /* output goes through gdb connection */
742 command_set_output_handler(connection
->cmd_ctx
, gdb_output
, connection
);
744 /* we must remove all breakpoints registered to the target as a previous
745 * GDB session could leave dangling breakpoints if e.g. communication
748 breakpoint_clear_target(gdb_service
->target
);
749 watchpoint_clear_target(gdb_service
->target
);
751 /* register callback to be informed about target events */
752 target_register_event_callback(gdb_target_callback_event_handler
, connection
);
754 /* a gdb session just attached, try to put the target in halt mode.
758 * If the halt fails(e.g. target needs a reset, JTAG communication not
759 * working, etc.), then the GDB connect will succeed as
760 * the get_gdb_reg_list() will lie and return a register list with
763 * This allows GDB monitor commands to be run from a GDB init script to
764 * initialize the target
766 * Also, since the halt() is asynchronous target connect will be
767 * instantaneous and thus avoiding annoying timeout problems during
770 target_halt(gdb_service
->target
);
771 /* FIX!!!! could extended-remote work better here?
773 * wait a tiny bit for halted state or we just continue. The
774 * GDB register packet will then contain garbage
776 target_wait_state(gdb_service
->target
, TARGET_HALTED
, 500);
778 /* remove the initial ACK from the incoming buffer */
779 if ((retval
= gdb_get_char(connection
, &initial_ack
)) != ERROR_OK
)
782 /* FIX!!!??? would we actually ever receive a + here???
785 if (initial_ack
!= '+')
786 gdb_putback_char(connection
, initial_ack
);
787 target_call_event_callbacks(gdb_service
->target
, TARGET_EVENT_GDB_ATTACH
);
791 int gdb_connection_closed(connection_t
*connection
)
793 gdb_service_t
*gdb_service
= connection
->service
->priv
;
794 gdb_connection_t
*gdb_connection
= connection
->priv
;
796 /* see if an image built with vFlash commands is left */
797 if (gdb_connection
->vflash_image
)
799 image_close(gdb_connection
->vflash_image
);
800 free(gdb_connection
->vflash_image
);
801 gdb_connection
->vflash_image
= NULL
;
804 /* if this connection registered a debug-message receiver delete it */
805 delete_debug_msg_receiver(connection
->cmd_ctx
, gdb_service
->target
);
807 if (connection
->priv
)
809 free(connection
->priv
);
810 connection
->priv
= NULL
;
814 LOG_ERROR("BUG: connection->priv == NULL");
817 target_unregister_event_callback(gdb_target_callback_event_handler
, connection
);
818 log_remove_callback(gdb_log_callback
, connection
);
820 target_call_event_callbacks(gdb_service
->target
, TARGET_EVENT_GDB_DETACH
);
825 void gdb_send_error(connection_t
*connection
, u8 the_error
)
828 snprintf(err
, 4, "E%2.2X", the_error
);
829 gdb_put_packet(connection
, err
, 3);
832 int gdb_last_signal_packet(connection_t
*connection
, target_t
*target
, char* packet
, int packet_size
)
837 signal
= gdb_last_signal(target
);
839 snprintf(sig_reply
, 4, "S%2.2x", signal
);
840 gdb_put_packet(connection
, sig_reply
, 3);
845 /* Convert register to string of bits. NB! The # of bits in the
846 * register might be non-divisible by 8(a byte), in which
847 * case an entire byte is shown. */
848 void gdb_str_to_target(target_t
*target
, char *tstr
, reg_t
*reg
)
855 buf_len
= CEIL(reg
->size
, 8);
857 for (i
= 0; i
< buf_len
; i
++)
859 tstr
[i
*2] = DIGITS
[(buf
[i
]>>4) & 0xf];
860 tstr
[i
*2+1] = DIGITS
[buf
[i
]&0xf];
864 void gdb_target_to_str(target_t
*target
, char *tstr
, char *str
)
866 int str_len
= strlen(tstr
);
871 LOG_ERROR("BUG: gdb value with uneven number of characters encountered");
875 for (i
= 0; i
< str_len
; i
+=2)
877 str
[str_len
- i
- 1] = tstr
[i
+ 1];
878 str
[str_len
- i
- 2] = tstr
[i
];
882 int gdb_get_registers_packet(connection_t
*connection
, target_t
*target
, char* packet
, int packet_size
)
887 int reg_packet_size
= 0;
892 #ifdef _DEBUG_GDB_IO_
896 if ((retval
= target
->type
->get_gdb_reg_list(target
, ®_list
, ®_list_size
)) != ERROR_OK
)
898 return gdb_error(connection
, retval
);
901 for (i
= 0; i
< reg_list_size
; i
++)
903 reg_packet_size
+= reg_list
[i
]->size
;
906 reg_packet
= malloc(CEIL(reg_packet_size
, 8) * 2);
907 reg_packet_p
= reg_packet
;
909 for (i
= 0; i
< reg_list_size
; i
++)
911 gdb_str_to_target(target
, reg_packet_p
, reg_list
[i
]);
912 reg_packet_p
+= CEIL(reg_list
[i
]->size
, 8) * 2;
915 #ifdef _DEBUG_GDB_IO_
918 reg_packet_p
= strndup(reg_packet
, CEIL(reg_packet_size
, 8) * 2);
919 LOG_DEBUG("reg_packet: %s", reg_packet_p
);
924 gdb_put_packet(connection
, reg_packet
, CEIL(reg_packet_size
, 8) * 2);
932 int gdb_set_registers_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
940 #ifdef _DEBUG_GDB_IO_
944 /* skip command character */
950 LOG_WARNING("GDB set_registers packet with uneven characters received, dropping connection");
951 return ERROR_SERVER_REMOTE_CLOSED
;
954 if ((retval
= target
->type
->get_gdb_reg_list(target
, ®_list
, ®_list_size
)) != ERROR_OK
)
956 return gdb_error(connection
, retval
);
960 for (i
= 0; i
< reg_list_size
; i
++)
964 reg_arch_type_t
*arch_type
;
966 /* convert from GDB-string (target-endian) to hex-string (big-endian) */
967 hex_buf
= malloc(CEIL(reg_list
[i
]->size
, 8) * 2);
968 gdb_target_to_str(target
, packet_p
, hex_buf
);
970 /* convert hex-string to binary buffer */
971 bin_buf
= malloc(CEIL(reg_list
[i
]->size
, 8));
972 str_to_buf(hex_buf
, CEIL(reg_list
[i
]->size
, 8) * 2, bin_buf
, reg_list
[i
]->size
, 16);
974 /* get register arch_type, and call set method */
975 arch_type
= register_get_arch_type(reg_list
[i
]->arch_type
);
977 arch_type
->set(reg_list
[i
], bin_buf
);
979 /* advance packet pointer */
980 packet_p
+= (CEIL(reg_list
[i
]->size
, 8) * 2);
986 /* free reg_t *reg_list[] array allocated by get_gdb_reg_list */
989 gdb_put_packet(connection
, "OK", 2);
994 int gdb_get_register_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
997 int reg_num
= strtoul(packet
+ 1, NULL
, 16);
1002 #ifdef _DEBUG_GDB_IO_
1006 if ((retval
= target
->type
->get_gdb_reg_list(target
, ®_list
, ®_list_size
)) != ERROR_OK
)
1008 return gdb_error(connection
, retval
);
1011 if (reg_list_size
<= reg_num
)
1013 LOG_ERROR("gdb requested a non-existing register");
1017 reg_packet
= malloc(CEIL(reg_list
[reg_num
]->size
, 8) * 2);
1019 gdb_str_to_target(target
, reg_packet
, reg_list
[reg_num
]);
1021 gdb_put_packet(connection
, reg_packet
, CEIL(reg_list
[reg_num
]->size
, 8) * 2);
1029 int gdb_set_register_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1034 int reg_num
= strtoul(packet
+ 1, &separator
, 16);
1038 reg_arch_type_t
*arch_type
;
1042 if ((retval
= target
->type
->get_gdb_reg_list(target
, ®_list
, ®_list_size
)) != ERROR_OK
)
1044 return gdb_error(connection
, retval
);
1047 if (reg_list_size
< reg_num
)
1049 LOG_ERROR("gdb requested a non-existing register");
1050 return ERROR_SERVER_REMOTE_CLOSED
;
1053 if (*separator
!= '=')
1055 LOG_ERROR("GDB 'set register packet', but no '=' following the register number");
1056 return ERROR_SERVER_REMOTE_CLOSED
;
1059 /* convert from GDB-string (target-endian) to hex-string (big-endian) */
1060 hex_buf
= malloc(CEIL(reg_list
[reg_num
]->size
, 8) * 2);
1061 gdb_target_to_str(target
, separator
+ 1, hex_buf
);
1063 /* convert hex-string to binary buffer */
1064 bin_buf
= malloc(CEIL(reg_list
[reg_num
]->size
, 8));
1065 str_to_buf(hex_buf
, CEIL(reg_list
[reg_num
]->size
, 8) * 2, bin_buf
, reg_list
[reg_num
]->size
, 16);
1067 /* get register arch_type, and call set method */
1068 arch_type
= register_get_arch_type(reg_list
[reg_num
]->arch_type
);
1069 arch_type
->set(reg_list
[reg_num
], bin_buf
);
1071 gdb_put_packet(connection
, "OK", 2);
1080 int gdb_error(connection_t
*connection
, int retval
)
1084 case ERROR_TARGET_DATA_ABORT
:
1085 gdb_send_error(connection
, EIO
);
1087 case ERROR_TARGET_TRANSLATION_FAULT
:
1088 gdb_send_error(connection
, EFAULT
);
1090 case ERROR_TARGET_UNALIGNED_ACCESS
:
1091 gdb_send_error(connection
, EFAULT
);
1093 case ERROR_TARGET_NOT_HALTED
:
1094 gdb_send_error(connection
, EFAULT
);
1097 /* This could be that the target reset itself. */
1098 LOG_ERROR("unexpected error %i", retval
);
1099 gdb_send_error(connection
, EFAULT
);
1106 /* We don't have to worry about the default 2 second timeout for GDB packets,
1107 * because GDB breaks up large memory reads into smaller reads.
1109 * 8191 bytes by the looks of it. Why 8191 bytes instead of 8192?????
1111 int gdb_read_memory_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1120 int retval
= ERROR_OK
;
1122 /* skip command character */
1125 addr
= strtoul(packet
, &separator
, 16);
1127 if (*separator
!= ',')
1129 LOG_ERROR("incomplete read memory packet received, dropping connection");
1130 return ERROR_SERVER_REMOTE_CLOSED
;
1133 len
= strtoul(separator
+1, NULL
, 16);
1135 buffer
= malloc(len
);
1137 LOG_DEBUG("addr: 0x%8.8x, len: 0x%8.8x", addr
, len
);
1139 retval
= target_read_buffer(target
, addr
, len
, buffer
);
1141 if ((retval
== ERROR_TARGET_DATA_ABORT
) && (!gdb_report_data_abort
))
1143 /* TODO : Here we have to lie and send back all zero's lest stack traces won't work.
1144 * At some point this might be fixed in GDB, in which case this code can be removed.
1146 * OpenOCD developers are acutely aware of this problem, but there is nothing
1147 * gained by involving the user in this problem that hopefully will get resolved
1150 * http://sourceware.org/cgi-bin/gnatsweb.pl?cmd=view%20audit-trail&database=gdb&pr=2395
1152 * For now, the default is to fix up things to make current GDB versions work.
1153 * This can be overwritten using the gdb_report_data_abort <'enable'|'disable'> command.
1155 memset(buffer
, 0, len
);
1159 if (retval
== ERROR_OK
)
1161 hex_buffer
= malloc(len
* 2 + 1);
1164 for (i
= 0; i
< len
; i
++)
1167 hex_buffer
[2 * i
] = DIGITS
[(t
>> 4) & 0xf];
1168 hex_buffer
[2 * i
+ 1] = DIGITS
[t
& 0xf];
1171 gdb_put_packet(connection
, hex_buffer
, len
* 2);
1177 retval
= gdb_error(connection
, retval
);
1185 int gdb_write_memory_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1196 /* skip command character */
1199 addr
= strtoul(packet
, &separator
, 16);
1201 if (*separator
!= ',')
1203 LOG_ERROR("incomplete write memory packet received, dropping connection");
1204 return ERROR_SERVER_REMOTE_CLOSED
;
1207 len
= strtoul(separator
+1, &separator
, 16);
1209 if (*(separator
++) != ':')
1211 LOG_ERROR("incomplete write memory packet received, dropping connection");
1212 return ERROR_SERVER_REMOTE_CLOSED
;
1215 buffer
= malloc(len
);
1217 LOG_DEBUG("addr: 0x%8.8x, len: 0x%8.8x", addr
, len
);
1219 for (i
=0; i
<len
; i
++)
1222 sscanf(separator
+ 2*i
, "%2x", &tmp
);
1226 retval
= target_write_buffer(target
, addr
, len
, buffer
);
1228 if (retval
== ERROR_OK
)
1230 gdb_put_packet(connection
, "OK", 2);
1234 retval
= gdb_error(connection
, retval
);
1242 int gdb_write_memory_binary_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1250 /* skip command character */
1253 addr
= strtoul(packet
, &separator
, 16);
1255 if (*separator
!= ',')
1257 LOG_ERROR("incomplete write memory binary packet received, dropping connection");
1258 return ERROR_SERVER_REMOTE_CLOSED
;
1261 len
= strtoul(separator
+1, &separator
, 16);
1263 if (*(separator
++) != ':')
1265 LOG_ERROR("incomplete write memory binary packet received, dropping connection");
1266 return ERROR_SERVER_REMOTE_CLOSED
;
1272 LOG_DEBUG("addr: 0x%8.8x, len: 0x%8.8x", addr
, len
);
1274 retval
= target_write_buffer(target
, addr
, len
, (u8
*)separator
);
1277 if (retval
== ERROR_OK
)
1279 gdb_put_packet(connection
, "OK", 2);
1283 if ((retval
= gdb_error(connection
, retval
)) != ERROR_OK
)
1290 int gdb_step_continue_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1294 int retval
=ERROR_OK
;
1298 if (packet_size
> 1)
1300 packet
[packet_size
] = 0;
1301 address
= strtoul(packet
+ 1, NULL
, 16);
1308 if (packet
[0] == 'c')
1310 LOG_DEBUG("continue");
1311 target_handle_event( target
, TARGET_EVENT_OLD_pre_resume
);
1312 retval
=target_resume(target
, current
, address
, 0, 0); /* resume at current address, don't handle breakpoints, not debugging */
1314 else if (packet
[0] == 's')
1317 retval
=target
->type
->step(target
, current
, address
, 0); /* step at current or address, don't handle breakpoints */
1322 int gdb_breakpoint_watchpoint_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1325 enum breakpoint_type bp_type
= BKPT_SOFT
/* dummy init to avoid warning */;
1326 enum watchpoint_rw wp_type
;
1334 type
= strtoul(packet
+ 1, &separator
, 16);
1336 if (type
== 0) /* memory breakpoint */
1337 bp_type
= BKPT_SOFT
;
1338 else if (type
== 1) /* hardware breakpoint */
1339 bp_type
= BKPT_HARD
;
1340 else if (type
== 2) /* write watchpoint */
1341 wp_type
= WPT_WRITE
;
1342 else if (type
== 3) /* read watchpoint */
1344 else if (type
== 4) /* access watchpoint */
1345 wp_type
= WPT_ACCESS
;
1347 if (gdb_breakpoint_override
&&((bp_type
==BKPT_SOFT
)||(bp_type
==BKPT_HARD
)))
1349 bp_type
=gdb_breakpoint_override_type
;
1352 if (*separator
!= ',')
1354 LOG_ERROR("incomplete breakpoint/watchpoint packet received, dropping connection");
1355 return ERROR_SERVER_REMOTE_CLOSED
;
1358 address
= strtoul(separator
+1, &separator
, 16);
1360 if (*separator
!= ',')
1362 LOG_ERROR("incomplete breakpoint/watchpoint packet received, dropping connection");
1363 return ERROR_SERVER_REMOTE_CLOSED
;
1366 size
= strtoul(separator
+1, &separator
, 16);
1372 if (packet
[0] == 'Z')
1374 if ((retval
= breakpoint_add(target
, address
, size
, bp_type
)) != ERROR_OK
)
1376 if ((retval
= gdb_error(connection
, retval
)) != ERROR_OK
)
1381 gdb_put_packet(connection
, "OK", 2);
1386 breakpoint_remove(target
, address
);
1387 gdb_put_packet(connection
, "OK", 2);
1394 if (packet
[0] == 'Z')
1396 if ((retval
= watchpoint_add(target
, address
, size
, type
-2, 0, 0xffffffffu
)) != ERROR_OK
)
1398 if ((retval
= gdb_error(connection
, retval
)) != ERROR_OK
)
1403 gdb_put_packet(connection
, "OK", 2);
1408 watchpoint_remove(target
, address
);
1409 gdb_put_packet(connection
, "OK", 2);
1420 /* print out a string and allocate more space as needed, mainly used for XML at this point */
1421 void xml_printf(int *retval
, char **xml
, int *pos
, int *size
, const char *fmt
, ...)
1423 if (*retval
!= ERROR_OK
)
1431 if ((*xml
== NULL
) || (!first
))
1433 /* start by 0 to exercise all the code paths.
1434 * Need minimum 2 bytes to fit 1 char and 0 terminator. */
1436 *size
= *size
* 2 + 2;
1438 *xml
= realloc(*xml
, *size
);
1443 *retval
= ERROR_SERVER_REMOTE_CLOSED
;
1451 ret
= vsnprintf(*xml
+ *pos
, *size
- *pos
, fmt
, ap
);
1453 if ((ret
> 0) && ((ret
+ 1) < *size
- *pos
))
1458 /* there was just enough or not enough space, allocate more. */
1463 static int decode_xfer_read(char *buf
, char **annex
, int *ofs
, unsigned int *len
)
1467 /* Extract and NUL-terminate the annex. */
1469 while (*buf
&& *buf
!= ':')
1475 /* After the read marker and annex, qXfer looks like a
1476 * traditional 'm' packet. */
1478 *ofs
= strtoul(buf
, &separator
, 16);
1480 if (*separator
!= ',')
1483 *len
= strtoul(separator
+1, NULL
, 16);
1488 int gdb_calc_blocksize(flash_bank_t
*bank
)
1491 int block_size
= 0xffffffff;
1493 /* loop through all sectors and return smallest sector size */
1495 for (i
= 0; i
< bank
->num_sectors
; i
++)
1497 if (bank
->sectors
[i
].size
< block_size
)
1498 block_size
= bank
->sectors
[i
].size
;
1504 static int compare_bank (const void * a
, const void * b
)
1506 flash_bank_t
*b1
, *b2
;
1507 b1
=*((flash_bank_t
**)a
);
1508 b2
=*((flash_bank_t
**)b
);
1510 if (b1
->base
==b2
->base
)
1513 } else if (b1
->base
>b2
->base
)
1522 int gdb_query_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1524 command_context_t
*cmd_ctx
= connection
->cmd_ctx
;
1525 gdb_connection_t
*gdb_connection
= connection
->priv
;
1527 if (strstr(packet
, "qRcmd,"))
1529 if (packet_size
> 6)
1533 cmd
= malloc((packet_size
- 6)/2 + 1);
1534 for (i
=0; i
< (packet_size
- 6)/2; i
++)
1537 sscanf(packet
+ 6 + 2*i
, "%2x", &tmp
);
1540 cmd
[(packet_size
- 6)/2] = 0x0;
1542 /* We want to print all debug output to GDB connection */
1543 log_add_callback(gdb_log_callback
, connection
);
1544 target_call_timer_callbacks_now();
1545 command_run_line(cmd_ctx
, cmd
);
1546 target_call_timer_callbacks_now();
1547 log_remove_callback(gdb_log_callback
, connection
);
1550 gdb_put_packet(connection
, "OK", 2);
1553 else if (strstr(packet
, "qCRC:"))
1555 if (packet_size
> 5)
1564 /* skip command character */
1567 addr
= strtoul(packet
, &separator
, 16);
1569 if (*separator
!= ',')
1571 LOG_ERROR("incomplete read memory packet received, dropping connection");
1572 return ERROR_SERVER_REMOTE_CLOSED
;
1575 len
= strtoul(separator
+ 1, NULL
, 16);
1577 retval
= target_checksum_memory(target
, addr
, len
, &checksum
);
1579 if (retval
== ERROR_OK
)
1581 snprintf(gdb_reply
, 10, "C%8.8x", checksum
);
1582 gdb_put_packet(connection
, gdb_reply
, 9);
1586 if ((retval
= gdb_error(connection
, retval
)) != ERROR_OK
)
1593 else if (strstr(packet
, "qSupported"))
1595 /* we currently support packet size and qXfer:memory-map:read (if enabled)
1596 * disable qXfer:features:read for the moment */
1597 int retval
= ERROR_OK
;
1598 char *buffer
= NULL
;
1602 xml_printf(&retval
, &buffer
, &pos
, &size
,
1603 "PacketSize=%x;qXfer:memory-map:read%c;qXfer:features:read-;QStartNoAckMode+",
1604 (GDB_BUFFER_SIZE
- 1), ((gdb_use_memory_map
== 1)&&(flash_get_bank_count()>0)) ? '+' : '-');
1606 if (retval
!= ERROR_OK
)
1608 gdb_send_error(connection
, 01);
1612 gdb_put_packet(connection
, buffer
, strlen(buffer
));
1617 else if (strstr(packet
, "qXfer:memory-map:read::")&&(flash_get_bank_count()>0))
1619 /* We get away with only specifying flash here. Regions that are not
1620 * specified are treated as if we provided no memory map(if not we
1621 * could detect the holes and mark them as RAM).
1622 * Normally we only execute this code once, but no big deal if we
1623 * have to regenerate it a couple of times. */
1629 int retval
= ERROR_OK
;
1636 /* skip command character */
1639 offset
= strtoul(packet
, &separator
, 16);
1640 length
= strtoul(separator
+ 1, &separator
, 16);
1642 xml_printf(&retval
, &xml
, &pos
, &size
, "<memory-map>\n");
1645 sort banks in ascending order, we need to make non-flash memory be ram(or rather
1646 read/write) by default for GDB.
1647 GDB does not have a concept of non-cacheable read/write memory.
1649 flash_bank_t
**banks
=malloc(sizeof(flash_bank_t
*)*flash_get_bank_count());
1652 for (i
=0; i
<flash_get_bank_count(); i
++)
1654 p
= get_flash_bank_by_num(i
);
1658 retval
= ERROR_FAIL
;
1659 gdb_send_error(connection
, retval
);
1665 qsort(banks
, flash_get_bank_count(), sizeof(flash_bank_t
*), compare_bank
);
1668 for (i
=0; i
<flash_get_bank_count(); i
++)
1672 if (ram_start
<p
->base
)
1674 xml_printf(&retval
, &xml
, &pos
, &size
, "<memory type=\"ram\" start=\"0x%x\" length=\"0x%x\"/>\n",
1675 ram_start
, p
->base
-ram_start
);
1678 /* if device has uneven sector sizes, eg. str7, lpc
1679 * we pass the smallest sector size to gdb memory map */
1680 blocksize
= gdb_calc_blocksize(p
);
1682 xml_printf(&retval
, &xml
, &pos
, &size
, "<memory type=\"flash\" start=\"0x%x\" length=\"0x%x\">\n" \
1683 "<property name=\"blocksize\">0x%x</property>\n" \
1685 p
->base
, p
->size
, blocksize
);
1686 ram_start
=p
->base
+p
->size
;
1690 xml_printf(&retval
, &xml
, &pos
, &size
, "<memory type=\"ram\" start=\"0x%x\" length=\"0x%x\"/>\n",
1691 ram_start
, 0-ram_start
);
1694 /* a flash chip could be at the very end of the 32 bit address space, in which case
1695 ram_start will be precisely 0 */
1701 xml_printf(&retval
, &xml
, &pos
, &size
, "</memory-map>\n");
1703 if (retval
!= ERROR_OK
)
1705 gdb_send_error(connection
, retval
);
1709 if (offset
+ length
> pos
)
1711 length
= pos
- offset
;
1714 char *t
= malloc(length
+ 1);
1716 memcpy(t
+ 1, xml
+ offset
, length
);
1717 gdb_put_packet(connection
, t
, length
+ 1);
1723 else if (strstr(packet
, "qXfer:features:read:"))
1728 int retval
= ERROR_OK
;
1731 unsigned int length
;
1734 /* skip command character */
1737 if (decode_xfer_read(packet
, &annex
, &offset
, &length
) < 0)
1739 gdb_send_error(connection
, 01);
1743 if (strcmp(annex
, "target.xml") != 0)
1745 gdb_send_error(connection
, 01);
1749 xml_printf(&retval
, &xml
, &pos
, &size
, \
1750 "l<target version=\"1.0\">\n<architecture>arm</architecture>\n</target>\n");
1752 if (retval
!= ERROR_OK
)
1754 gdb_send_error(connection
, retval
);
1758 gdb_put_packet(connection
, xml
, strlen(xml
));
1763 else if (strstr(packet
, "QStartNoAckMode"))
1765 gdb_connection
->noack_mode
= 1;
1766 gdb_put_packet(connection
, "OK", 2);
1770 gdb_put_packet(connection
, "", 0);
1774 int gdb_v_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1776 gdb_connection_t
*gdb_connection
= connection
->priv
;
1777 gdb_service_t
*gdb_service
= connection
->service
->priv
;
1780 /* if flash programming disabled - send a empty reply */
1782 if (gdb_flash_program
== 0)
1784 gdb_put_packet(connection
, "", 0);
1788 if (strstr(packet
, "vFlashErase:"))
1791 unsigned long length
;
1793 char *parse
= packet
+ 12;
1796 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1797 return ERROR_SERVER_REMOTE_CLOSED
;
1800 addr
= strtoul(parse
, &parse
, 16);
1802 if (*(parse
++) != ',' || *parse
== '\0')
1804 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1805 return ERROR_SERVER_REMOTE_CLOSED
;
1808 length
= strtoul(parse
, &parse
, 16);
1812 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1813 return ERROR_SERVER_REMOTE_CLOSED
;
1816 /* assume all sectors need erasing - stops any problems
1817 * when flash_write is called multiple times */
1820 /* perform any target specific operations before the erase */
1821 target_call_event_callbacks(gdb_service
->target
, TARGET_EVENT_GDB_FLASH_ERASE_START
);
1822 result
= flash_erase_address_range(gdb_service
->target
, addr
, length
);
1823 target_call_event_callbacks(gdb_service
->target
, TARGET_EVENT_GDB_FLASH_ERASE_END
);
1826 if (result
!= ERROR_OK
)
1828 /* GDB doesn't evaluate the actual error number returned,
1829 * treat a failed erase as an I/O error
1831 gdb_send_error(connection
, EIO
);
1832 LOG_ERROR("flash_erase returned %i", result
);
1835 gdb_put_packet(connection
, "OK", 2);
1840 if (strstr(packet
, "vFlashWrite:"))
1844 unsigned long length
;
1845 char *parse
= packet
+ 12;
1849 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1850 return ERROR_SERVER_REMOTE_CLOSED
;
1852 addr
= strtoul(parse
, &parse
, 16);
1853 if (*(parse
++) != ':')
1855 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1856 return ERROR_SERVER_REMOTE_CLOSED
;
1858 length
= packet_size
- (parse
- packet
);
1860 /* create a new image if there isn't already one */
1861 if (gdb_connection
->vflash_image
== NULL
)
1863 gdb_connection
->vflash_image
= malloc(sizeof(image_t
));
1864 image_open(gdb_connection
->vflash_image
, "", "build");
1867 /* create new section with content from packet buffer */
1868 if((retval
= image_add_section(gdb_connection
->vflash_image
, addr
, length
, 0x0, (u8
*)parse
)) != ERROR_OK
)
1873 gdb_put_packet(connection
, "OK", 2);
1878 if (!strcmp(packet
, "vFlashDone"))
1882 /* process the flashing buffer. No need to erase as GDB
1883 * always issues a vFlashErase first. */
1884 target_call_event_callbacks(gdb_service
->target
, TARGET_EVENT_GDB_FLASH_WRITE_START
);
1885 result
= flash_write(gdb_service
->target
, gdb_connection
->vflash_image
, &written
, 0);
1886 target_call_event_callbacks(gdb_service
->target
, TARGET_EVENT_GDB_FLASH_WRITE_END
);
1887 if ( result
!= ERROR_OK
)
1889 if (result
== ERROR_FLASH_DST_OUT_OF_BANK
)
1890 gdb_put_packet(connection
, "E.memtype", 9);
1892 gdb_send_error(connection
, EIO
);
1896 LOG_DEBUG("wrote %u bytes from vFlash image to flash", written
);
1897 gdb_put_packet(connection
, "OK", 2);
1900 image_close(gdb_connection
->vflash_image
);
1901 free(gdb_connection
->vflash_image
);
1902 gdb_connection
->vflash_image
= NULL
;
1907 gdb_put_packet(connection
, "", 0);
1911 int gdb_detach(connection_t
*connection
, target_t
*target
)
1914 switch( detach_mode
)
1916 case GDB_DETACH_RESUME
:
1917 target_handle_event( target
, TARGET_EVENT_OLD_pre_resume
);
1918 target_resume(target
, 1, 0, 1, 0);
1921 case GDB_DETACH_RESET
:
1922 /* FIX?? make this configurable?? */
1923 target_process_reset(connection
->cmd_ctx
, RESET_HALT
);
1926 case GDB_DETACH_HALT
:
1927 target_halt(target
);
1930 case GDB_DETACH_NOTHING
:
1934 gdb_put_packet(connection
, "OK", 2);
1938 static void gdb_log_callback(void *priv
, const char *file
, int line
,
1939 const char *function
, const char *string
)
1941 connection_t
*connection
= priv
;
1942 gdb_connection_t
*gdb_con
= connection
->priv
;
1946 /* do not reply this using the O packet */
1950 gdb_output_con(connection
, string
);
1953 /* Do not allocate this on the stack */
1954 char gdb_packet_buffer
[GDB_BUFFER_SIZE
];
1956 static void gdb_sig_halted(connection_t
*connection
)
1959 snprintf(sig_reply
, 4, "T%2.2x", 2);
1960 gdb_put_packet(connection
, sig_reply
, 3);
1964 int gdb_input_inner(connection_t
*connection
)
1966 gdb_service_t
*gdb_service
= connection
->service
->priv
;
1967 target_t
*target
= gdb_service
->target
;
1968 char *packet
=gdb_packet_buffer
;
1971 gdb_connection_t
*gdb_con
= connection
->priv
;
1972 static int extended_protocol
= 0;
1974 /* drain input buffer */
1977 packet_size
= GDB_BUFFER_SIZE
-1;
1978 if ((retval
= gdb_get_packet(connection
, packet
, &packet_size
)) != ERROR_OK
)
1983 /* terminate with zero */
1984 packet
[packet_size
] = 0;
1986 if( LOG_LEVEL_IS( LOG_LVL_DEBUG
) ){
1987 if( packet
[0] == 'X' ){
1988 // binary packets spew junk into the debug log stream
1991 for( x
= 0 ; (x
< 49) && (packet
[x
] != ':') ; x
++ ){
1995 LOG_DEBUG("received packet: '%s:<binary-data>'", buf
);
1997 LOG_DEBUG("received packet: '%s'", packet
);
2001 if (packet_size
> 0)
2007 /* Hct... -- set thread
2008 * we don't have threads, send empty reply */
2009 gdb_put_packet(connection
, NULL
, 0);
2013 retval
= gdb_query_packet(connection
, target
, packet
, packet_size
);
2016 retval
= gdb_get_registers_packet(connection
, target
, packet
, packet_size
);
2019 retval
= gdb_set_registers_packet(connection
, target
, packet
, packet_size
);
2022 retval
= gdb_get_register_packet(connection
, target
, packet
, packet_size
);
2025 retval
= gdb_set_register_packet(connection
, target
, packet
, packet_size
);
2028 retval
= gdb_read_memory_packet(connection
, target
, packet
, packet_size
);
2031 retval
= gdb_write_memory_packet(connection
, target
, packet
, packet_size
);
2035 retval
= gdb_breakpoint_watchpoint_packet(connection
, target
, packet
, packet_size
);
2038 gdb_last_signal_packet(connection
, target
, packet
, packet_size
);
2043 if (target
->state
!= TARGET_HALTED
)
2045 /* If the target isn't in the halted state, then we can't
2046 * step/continue. This might be early setup, etc.
2048 gdb_sig_halted(connection
);
2051 /* We're running/stepping, in which case we can
2052 * forward log output until the target is halted
2054 gdb_connection_t
*gdb_con
= connection
->priv
;
2055 gdb_con
->frontend_state
= TARGET_RUNNING
;
2056 log_add_callback(gdb_log_callback
, connection
);
2057 int retval
=gdb_step_continue_packet(connection
, target
, packet
, packet_size
);
2058 if (retval
!=ERROR_OK
)
2060 /* we'll never receive a halted condition... issue a false one.. */
2061 gdb_frontend_halted(target
, connection
);
2067 retval
= gdb_v_packet(connection
, target
, packet
, packet_size
);
2070 retval
= gdb_detach(connection
, target
);
2071 extended_protocol
= 0;
2074 if ((retval
= gdb_write_memory_binary_packet(connection
, target
, packet
, packet_size
)) != ERROR_OK
)
2078 if (extended_protocol
!= 0)
2080 gdb_put_packet(connection
, "OK", 2);
2081 return ERROR_SERVER_REMOTE_CLOSED
;
2083 /* handle extended remote protocol */
2084 extended_protocol
= 1;
2085 gdb_put_packet(connection
, "OK", 2);
2088 /* handle extended restart packet */
2089 breakpoint_clear_target(gdb_service
->target
);
2090 watchpoint_clear_target(gdb_service
->target
);
2091 command_run_linef(connection
->cmd_ctx
, "ocd_gdb_restart %d", get_num_by_target(target
));
2094 /* ignore unkown packets */
2095 LOG_DEBUG("ignoring 0x%2.2x packet", packet
[0]);
2096 gdb_put_packet(connection
, NULL
, 0);
2100 /* if a packet handler returned an error, exit input loop */
2101 if (retval
!= ERROR_OK
)
2105 if (gdb_con
->ctrl_c
)
2107 if (target
->state
== TARGET_RUNNING
)
2109 target_halt(target
);
2110 gdb_con
->ctrl_c
= 0;
2114 } while (gdb_con
->buf_cnt
> 0);
2119 int gdb_input(connection_t
*connection
)
2121 int retval
= gdb_input_inner(connection
);
2122 gdb_connection_t
*gdb_con
= connection
->priv
;
2123 if (retval
== ERROR_SERVER_REMOTE_CLOSED
)
2126 /* logging does not propagate the error, yet can set th gdb_con->closed flag */
2127 if (gdb_con
->closed
)
2128 return ERROR_SERVER_REMOTE_CLOSED
;
2130 /* we'll recover from any other errors(e.g. temporary timeouts, etc.) */
2136 gdb_service_t
*gdb_service
;
2137 target_t
*target
= all_targets
;
2141 LOG_WARNING("no gdb ports allocated as no target has been specified");
2147 LOG_WARNING("no gdb port specified, using default port 3333");
2153 char service_name
[8];
2155 snprintf(service_name
, 8, "gdb-%2.2i", target
->target_number
);
2157 gdb_service
= malloc(sizeof(gdb_service_t
));
2158 gdb_service
->target
= target
;
2160 add_service("gdb", CONNECTION_GDB
,
2161 gdb_port
+ target
->target_number
,
2162 1, gdb_new_connection
, gdb_input
,
2163 gdb_connection_closed
,
2166 LOG_DEBUG("gdb service for target %s at port %i",
2168 gdb_port
+ target
->target_number
);
2170 target
= target
->next
;
2176 /* daemon configuration command gdb_port */
2177 int handle_gdb_port_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2181 command_print(cmd_ctx
, "gdb_port: %ld", gdb_port
);
2185 /* only if the port wasn't overwritten by cmdline */
2187 gdb_port
= strtoul(args
[0], NULL
, 0);
2192 int handle_gdb_detach_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2196 if (strcmp(args
[0], "resume") == 0)
2198 detach_mode
= GDB_DETACH_RESUME
;
2201 else if (strcmp(args
[0], "reset") == 0)
2203 detach_mode
= GDB_DETACH_RESET
;
2206 else if (strcmp(args
[0], "halt") == 0)
2208 detach_mode
= GDB_DETACH_HALT
;
2211 else if (strcmp(args
[0], "nothing") == 0)
2213 detach_mode
= GDB_DETACH_NOTHING
;
2217 LOG_WARNING("invalid gdb_detach configuration directive: %s", args
[0]);
2220 return ERROR_COMMAND_SYNTAX_ERROR
;
2223 int handle_gdb_memory_map_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2227 if (strcmp(args
[0], "enable") == 0)
2229 gdb_use_memory_map
= 1;
2232 else if (strcmp(args
[0], "disable") == 0)
2234 gdb_use_memory_map
= 0;
2238 LOG_WARNING("invalid gdb_memory_map configuration directive %s", args
[0]);
2241 return ERROR_COMMAND_SYNTAX_ERROR
;
2244 int handle_gdb_flash_program_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2248 if (strcmp(args
[0], "enable") == 0)
2250 gdb_flash_program
= 1;
2253 else if (strcmp(args
[0], "disable") == 0)
2255 gdb_flash_program
= 0;
2259 LOG_WARNING("invalid gdb_flash_program configuration directive: %s", args
[0]);
2262 return ERROR_COMMAND_SYNTAX_ERROR
;
2265 int handle_gdb_report_data_abort_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2269 if (strcmp(args
[0], "enable") == 0)
2271 gdb_report_data_abort
= 1;
2274 else if (strcmp(args
[0], "disable") == 0)
2276 gdb_report_data_abort
= 0;
2280 LOG_WARNING("invalid gdb_report_data_abort configuration directive: %s", args
[0]);
2283 return ERROR_COMMAND_SYNTAX_ERROR
;
2286 /* gdb_breakpoint_override */
2287 int handle_gdb_breakpoint_override_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2294 gdb_breakpoint_override
= 1;
2295 if (strcmp(args
[0], "hard")==0)
2297 gdb_breakpoint_override_type
=BKPT_HARD
;
2298 } else if (strcmp(args
[0], "soft")==0)
2300 gdb_breakpoint_override_type
=BKPT_SOFT
;
2301 } else if (strcmp(args
[0], "disable") == 0)
2303 gdb_breakpoint_override
= 0;
2307 return ERROR_COMMAND_SYNTAX_ERROR
;
2309 if (gdb_breakpoint_override
)
2311 LOG_USER("force %s breakpoints", (gdb_breakpoint_override_type
==BKPT_HARD
)?"hard":"soft");
2314 LOG_USER("breakpoint type is not overriden");
2321 int gdb_register_commands(command_context_t
*command_context
)
2323 register_command(command_context
, NULL
, "gdb_port", handle_gdb_port_command
,
2324 COMMAND_CONFIG
, "daemon configuration command gdb_port");
2325 register_command(command_context
, NULL
, "gdb_detach", handle_gdb_detach_command
,
2326 COMMAND_CONFIG
, "");
2327 register_command(command_context
, NULL
, "gdb_memory_map", handle_gdb_memory_map_command
,
2328 COMMAND_CONFIG
, "enable or disable memory map");
2329 register_command(command_context
, NULL
, "gdb_flash_program", handle_gdb_flash_program_command
,
2330 COMMAND_CONFIG
, "enable or disable flash program");
2331 register_command(command_context
, NULL
, "gdb_report_data_abort", handle_gdb_report_data_abort_command
,
2332 COMMAND_CONFIG
, "enable or disable report data");
2333 register_command(command_context
, NULL
, "gdb_breakpoint_override", handle_gdb_breakpoint_override_command
,
2334 COMMAND_EXEC
, "hard/soft/disabled - force breakpoint type for gdb 'break' commands."
2335 "The raison d'etre for this option is to support GDB GUI's without "
2336 "a hard/soft breakpoint concept where the default OpenOCD behaviour "
2337 "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)