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
);
939 if (arch_type
== NULL
)
941 LOG_ERROR("BUG: encountered unregistered arch type");
944 arch_type
->set(reg_list
[i
], bin_buf
);
946 /* advance packet pointer */
947 packet_p
+= (CEIL(reg_list
[i
]->size
, 8) * 2);
953 /* free reg_t *reg_list[] array allocated by get_gdb_reg_list */
956 gdb_put_packet(connection
, "OK", 2);
961 int gdb_get_register_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
964 int reg_num
= strtoul(packet
+ 1, NULL
, 16);
969 #ifdef _DEBUG_GDB_IO_
973 if ((retval
= target
->type
->get_gdb_reg_list(target
, ®_list
, ®_list_size
)) != ERROR_OK
)
975 return gdb_error(connection
, retval
);
978 if (reg_list_size
<= reg_num
)
980 LOG_ERROR("gdb requested a non-existing register");
984 reg_packet
= malloc(CEIL(reg_list
[reg_num
]->size
, 8) * 2);
986 gdb_str_to_target(target
, reg_packet
, reg_list
[reg_num
]);
988 gdb_put_packet(connection
, reg_packet
, CEIL(reg_list
[reg_num
]->size
, 8) * 2);
996 int gdb_set_register_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1001 int reg_num
= strtoul(packet
+ 1, &separator
, 16);
1005 reg_arch_type_t
*arch_type
;
1009 if ((retval
= target
->type
->get_gdb_reg_list(target
, ®_list
, ®_list_size
)) != ERROR_OK
)
1011 return gdb_error(connection
, retval
);
1014 if (reg_list_size
< reg_num
)
1016 LOG_ERROR("gdb requested a non-existing register");
1017 return ERROR_SERVER_REMOTE_CLOSED
;
1020 if (*separator
!= '=')
1022 LOG_ERROR("GDB 'set register packet', but no '=' following the register number");
1023 return ERROR_SERVER_REMOTE_CLOSED
;
1026 /* convert from GDB-string (target-endian) to hex-string (big-endian) */
1027 hex_buf
= malloc(CEIL(reg_list
[reg_num
]->size
, 8) * 2);
1028 gdb_target_to_str(target
, separator
+ 1, hex_buf
);
1030 /* convert hex-string to binary buffer */
1031 bin_buf
= malloc(CEIL(reg_list
[reg_num
]->size
, 8));
1032 str_to_buf(hex_buf
, CEIL(reg_list
[reg_num
]->size
, 8) * 2, bin_buf
, reg_list
[reg_num
]->size
, 16);
1034 /* get register arch_type, and call set method */
1035 arch_type
= register_get_arch_type(reg_list
[reg_num
]->arch_type
);
1036 if (arch_type
== NULL
)
1038 LOG_ERROR("BUG: encountered unregistered arch type");
1041 arch_type
->set(reg_list
[reg_num
], bin_buf
);
1043 gdb_put_packet(connection
, "OK", 2);
1052 int gdb_error(connection_t
*connection
, int retval
)
1056 case ERROR_TARGET_DATA_ABORT
:
1057 gdb_send_error(connection
, EIO
);
1059 case ERROR_TARGET_TRANSLATION_FAULT
:
1060 gdb_send_error(connection
, EFAULT
);
1062 case ERROR_TARGET_UNALIGNED_ACCESS
:
1063 gdb_send_error(connection
, EFAULT
);
1065 case ERROR_TARGET_NOT_HALTED
:
1066 gdb_send_error(connection
, EFAULT
);
1069 /* This could be that the target reset itself. */
1070 LOG_ERROR("unexpected error %i", retval
);
1071 gdb_send_error(connection
, EFAULT
);
1078 /* We don't have to worry about the default 2 second timeout for GDB packets,
1079 * because GDB breaks up large memory reads into smaller reads.
1081 * 8191 bytes by the looks of it. Why 8191 bytes instead of 8192?????
1083 int gdb_read_memory_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1092 int retval
= ERROR_OK
;
1094 /* skip command character */
1097 addr
= strtoul(packet
, &separator
, 16);
1099 if (*separator
!= ',')
1101 LOG_ERROR("incomplete read memory packet received, dropping connection");
1102 return ERROR_SERVER_REMOTE_CLOSED
;
1105 len
= strtoul(separator
+1, NULL
, 16);
1107 buffer
= malloc(len
);
1109 LOG_DEBUG("addr: 0x%8.8x, len: 0x%8.8x", addr
, len
);
1111 retval
= target_read_buffer(target
, addr
, len
, buffer
);
1113 if ((retval
== ERROR_TARGET_DATA_ABORT
) && (!gdb_report_data_abort
))
1115 /* TODO : Here we have to lie and send back all zero's lest stack traces won't work.
1116 * At some point this might be fixed in GDB, in which case this code can be removed.
1118 * OpenOCD developers are acutely aware of this problem, but there is nothing
1119 * gained by involving the user in this problem that hopefully will get resolved
1122 * http://sourceware.org/cgi-bin/gnatsweb.pl?cmd=view%20audit-trail&database=gdb&pr=2395
1124 * For now, the default is to fix up things to make current GDB versions work.
1125 * This can be overwritten using the gdb_report_data_abort <'enable'|'disable'> command.
1127 memset(buffer
, 0, len
);
1131 if (retval
== ERROR_OK
)
1133 hex_buffer
= malloc(len
* 2 + 1);
1136 for (i
= 0; i
< len
; i
++)
1139 hex_buffer
[2 * i
] = DIGITS
[(t
>> 4) & 0xf];
1140 hex_buffer
[2 * i
+ 1] = DIGITS
[t
& 0xf];
1143 gdb_put_packet(connection
, hex_buffer
, len
* 2);
1149 retval
= gdb_error(connection
, retval
);
1157 int gdb_write_memory_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1168 /* skip command character */
1171 addr
= strtoul(packet
, &separator
, 16);
1173 if (*separator
!= ',')
1175 LOG_ERROR("incomplete write memory packet received, dropping connection");
1176 return ERROR_SERVER_REMOTE_CLOSED
;
1179 len
= strtoul(separator
+1, &separator
, 16);
1181 if (*(separator
++) != ':')
1183 LOG_ERROR("incomplete write memory packet received, dropping connection");
1184 return ERROR_SERVER_REMOTE_CLOSED
;
1187 buffer
= malloc(len
);
1189 LOG_DEBUG("addr: 0x%8.8x, len: 0x%8.8x", addr
, len
);
1191 for (i
=0; i
<len
; i
++)
1194 sscanf(separator
+ 2*i
, "%2x", &tmp
);
1198 retval
= target_write_buffer(target
, addr
, len
, buffer
);
1200 if (retval
== ERROR_OK
)
1202 gdb_put_packet(connection
, "OK", 2);
1206 retval
= gdb_error(connection
, retval
);
1214 int gdb_write_memory_binary_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1222 /* skip command character */
1225 addr
= strtoul(packet
, &separator
, 16);
1227 if (*separator
!= ',')
1229 LOG_ERROR("incomplete write memory binary packet received, dropping connection");
1230 return ERROR_SERVER_REMOTE_CLOSED
;
1233 len
= strtoul(separator
+1, &separator
, 16);
1235 if (*(separator
++) != ':')
1237 LOG_ERROR("incomplete write memory binary packet received, dropping connection");
1238 return ERROR_SERVER_REMOTE_CLOSED
;
1244 LOG_DEBUG("addr: 0x%8.8x, len: 0x%8.8x", addr
, len
);
1246 retval
= target_write_buffer(target
, addr
, len
, (u8
*)separator
);
1249 if (retval
== ERROR_OK
)
1251 gdb_put_packet(connection
, "OK", 2);
1255 if ((retval
= gdb_error(connection
, retval
)) != ERROR_OK
)
1262 int gdb_step_continue_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1266 int retval
=ERROR_OK
;
1270 if (packet_size
> 1)
1272 packet
[packet_size
] = 0;
1273 address
= strtoul(packet
+ 1, NULL
, 16);
1280 if (packet
[0] == 'c')
1282 LOG_DEBUG("continue");
1283 target_handle_event( target
, TARGET_EVENT_OLD_pre_resume
);
1284 retval
=target_resume(target
, current
, address
, 0, 0); /* resume at current address, don't handle breakpoints, not debugging */
1286 else if (packet
[0] == 's')
1289 retval
=target
->type
->step(target
, current
, address
, 0); /* step at current or address, don't handle breakpoints */
1294 int gdb_breakpoint_watchpoint_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1297 enum breakpoint_type bp_type
= BKPT_SOFT
/* dummy init to avoid warning */;
1298 enum watchpoint_rw wp_type
;
1306 type
= strtoul(packet
+ 1, &separator
, 16);
1308 if (type
== 0) /* memory breakpoint */
1309 bp_type
= BKPT_SOFT
;
1310 else if (type
== 1) /* hardware breakpoint */
1311 bp_type
= BKPT_HARD
;
1312 else if (type
== 2) /* write watchpoint */
1313 wp_type
= WPT_WRITE
;
1314 else if (type
== 3) /* read watchpoint */
1316 else if (type
== 4) /* access watchpoint */
1317 wp_type
= WPT_ACCESS
;
1319 if (gdb_breakpoint_override
&&((bp_type
==BKPT_SOFT
)||(bp_type
==BKPT_HARD
)))
1321 bp_type
=gdb_breakpoint_override_type
;
1324 if (*separator
!= ',')
1326 LOG_ERROR("incomplete breakpoint/watchpoint packet received, dropping connection");
1327 return ERROR_SERVER_REMOTE_CLOSED
;
1330 address
= strtoul(separator
+1, &separator
, 16);
1332 if (*separator
!= ',')
1334 LOG_ERROR("incomplete breakpoint/watchpoint packet received, dropping connection");
1335 return ERROR_SERVER_REMOTE_CLOSED
;
1338 size
= strtoul(separator
+1, &separator
, 16);
1344 if (packet
[0] == 'Z')
1346 if ((retval
= breakpoint_add(target
, address
, size
, bp_type
)) != ERROR_OK
)
1348 if ((retval
= gdb_error(connection
, retval
)) != ERROR_OK
)
1353 gdb_put_packet(connection
, "OK", 2);
1358 breakpoint_remove(target
, address
);
1359 gdb_put_packet(connection
, "OK", 2);
1366 if (packet
[0] == 'Z')
1368 if ((retval
= watchpoint_add(target
, address
, size
, type
-2, 0, 0xffffffffu
)) != ERROR_OK
)
1370 if ((retval
= gdb_error(connection
, retval
)) != ERROR_OK
)
1375 gdb_put_packet(connection
, "OK", 2);
1380 watchpoint_remove(target
, address
);
1381 gdb_put_packet(connection
, "OK", 2);
1392 /* print out a string and allocate more space as needed, mainly used for XML at this point */
1393 void xml_printf(int *retval
, char **xml
, int *pos
, int *size
, const char *fmt
, ...)
1395 if (*retval
!= ERROR_OK
)
1403 if ((*xml
== NULL
) || (!first
))
1405 /* start by 0 to exercise all the code paths.
1406 * Need minimum 2 bytes to fit 1 char and 0 terminator. */
1408 *size
= *size
* 2 + 2;
1410 *xml
= realloc(*xml
, *size
);
1415 *retval
= ERROR_SERVER_REMOTE_CLOSED
;
1423 ret
= vsnprintf(*xml
+ *pos
, *size
- *pos
, fmt
, ap
);
1425 if ((ret
> 0) && ((ret
+ 1) < *size
- *pos
))
1430 /* there was just enough or not enough space, allocate more. */
1435 static int decode_xfer_read(char *buf
, char **annex
, int *ofs
, unsigned int *len
)
1439 /* Extract and NUL-terminate the annex. */
1441 while (*buf
&& *buf
!= ':')
1447 /* After the read marker and annex, qXfer looks like a
1448 * traditional 'm' packet. */
1450 *ofs
= strtoul(buf
, &separator
, 16);
1452 if (*separator
!= ',')
1455 *len
= strtoul(separator
+1, NULL
, 16);
1460 int gdb_calc_blocksize(flash_bank_t
*bank
)
1463 int block_size
= 0xffffffff;
1465 /* loop through all sectors and return smallest sector size */
1467 for (i
= 0; i
< bank
->num_sectors
; i
++)
1469 if (bank
->sectors
[i
].size
< block_size
)
1470 block_size
= bank
->sectors
[i
].size
;
1476 static int compare_bank (const void * a
, const void * b
)
1478 flash_bank_t
*b1
, *b2
;
1479 b1
=*((flash_bank_t
**)a
);
1480 b2
=*((flash_bank_t
**)b
);
1482 if (b1
->base
==b2
->base
)
1485 } else if (b1
->base
>b2
->base
)
1494 int gdb_query_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1496 command_context_t
*cmd_ctx
= connection
->cmd_ctx
;
1497 gdb_connection_t
*gdb_connection
= connection
->priv
;
1499 if (strstr(packet
, "qRcmd,"))
1501 if (packet_size
> 6)
1505 cmd
= malloc((packet_size
- 6)/2 + 1);
1506 for (i
=0; i
< (packet_size
- 6)/2; i
++)
1509 sscanf(packet
+ 6 + 2*i
, "%2x", &tmp
);
1512 cmd
[(packet_size
- 6)/2] = 0x0;
1514 /* We want to print all debug output to GDB connection */
1515 log_add_callback(gdb_log_callback
, connection
);
1516 target_call_timer_callbacks_now();
1517 command_run_line(cmd_ctx
, cmd
);
1518 target_call_timer_callbacks_now();
1519 log_remove_callback(gdb_log_callback
, connection
);
1522 gdb_put_packet(connection
, "OK", 2);
1525 else if (strstr(packet
, "qCRC:"))
1527 if (packet_size
> 5)
1536 /* skip command character */
1539 addr
= strtoul(packet
, &separator
, 16);
1541 if (*separator
!= ',')
1543 LOG_ERROR("incomplete read memory packet received, dropping connection");
1544 return ERROR_SERVER_REMOTE_CLOSED
;
1547 len
= strtoul(separator
+ 1, NULL
, 16);
1549 retval
= target_checksum_memory(target
, addr
, len
, &checksum
);
1551 if (retval
== ERROR_OK
)
1553 snprintf(gdb_reply
, 10, "C%8.8x", checksum
);
1554 gdb_put_packet(connection
, gdb_reply
, 9);
1558 if ((retval
= gdb_error(connection
, retval
)) != ERROR_OK
)
1565 else if (strstr(packet
, "qSupported"))
1567 /* we currently support packet size and qXfer:memory-map:read (if enabled)
1568 * disable qXfer:features:read for the moment */
1569 int retval
= ERROR_OK
;
1570 char *buffer
= NULL
;
1574 xml_printf(&retval
, &buffer
, &pos
, &size
,
1575 "PacketSize=%x;qXfer:memory-map:read%c;qXfer:features:read-;QStartNoAckMode+",
1576 (GDB_BUFFER_SIZE
- 1), ((gdb_use_memory_map
== 1)&&(flash_get_bank_count()>0)) ? '+' : '-');
1578 if (retval
!= ERROR_OK
)
1580 gdb_send_error(connection
, 01);
1584 gdb_put_packet(connection
, buffer
, strlen(buffer
));
1589 else if (strstr(packet
, "qXfer:memory-map:read::")&&(flash_get_bank_count()>0))
1591 /* We get away with only specifying flash here. Regions that are not
1592 * specified are treated as if we provided no memory map(if not we
1593 * could detect the holes and mark them as RAM).
1594 * Normally we only execute this code once, but no big deal if we
1595 * have to regenerate it a couple of times. */
1601 int retval
= ERROR_OK
;
1608 /* skip command character */
1611 offset
= strtoul(packet
, &separator
, 16);
1612 length
= strtoul(separator
+ 1, &separator
, 16);
1614 xml_printf(&retval
, &xml
, &pos
, &size
, "<memory-map>\n");
1617 sort banks in ascending order, we need to make non-flash memory be ram(or rather
1618 read/write) by default for GDB.
1619 GDB does not have a concept of non-cacheable read/write memory.
1621 flash_bank_t
**banks
=malloc(sizeof(flash_bank_t
*)*flash_get_bank_count());
1624 for (i
=0; i
<flash_get_bank_count(); i
++)
1626 p
= get_flash_bank_by_num(i
);
1630 retval
= ERROR_FAIL
;
1631 gdb_send_error(connection
, retval
);
1637 qsort(banks
, flash_get_bank_count(), sizeof(flash_bank_t
*), compare_bank
);
1640 for (i
=0; i
<flash_get_bank_count(); i
++)
1644 if (ram_start
<p
->base
)
1646 xml_printf(&retval
, &xml
, &pos
, &size
, "<memory type=\"ram\" start=\"0x%x\" length=\"0x%x\"/>\n",
1647 ram_start
, p
->base
-ram_start
);
1650 /* if device has uneven sector sizes, eg. str7, lpc
1651 * we pass the smallest sector size to gdb memory map */
1652 blocksize
= gdb_calc_blocksize(p
);
1654 xml_printf(&retval
, &xml
, &pos
, &size
, "<memory type=\"flash\" start=\"0x%x\" length=\"0x%x\">\n" \
1655 "<property name=\"blocksize\">0x%x</property>\n" \
1657 p
->base
, p
->size
, blocksize
);
1658 ram_start
=p
->base
+p
->size
;
1662 xml_printf(&retval
, &xml
, &pos
, &size
, "<memory type=\"ram\" start=\"0x%x\" length=\"0x%x\"/>\n",
1663 ram_start
, 0-ram_start
);
1666 /* a flash chip could be at the very end of the 32 bit address space, in which case
1667 ram_start will be precisely 0 */
1673 xml_printf(&retval
, &xml
, &pos
, &size
, "</memory-map>\n");
1675 if (retval
!= ERROR_OK
)
1677 gdb_send_error(connection
, retval
);
1681 if (offset
+ length
> pos
)
1683 length
= pos
- offset
;
1686 char *t
= malloc(length
+ 1);
1688 memcpy(t
+ 1, xml
+ offset
, length
);
1689 gdb_put_packet(connection
, t
, length
+ 1);
1695 else if (strstr(packet
, "qXfer:features:read:"))
1700 int retval
= ERROR_OK
;
1703 unsigned int length
;
1706 /* skip command character */
1709 if (decode_xfer_read(packet
, &annex
, &offset
, &length
) < 0)
1711 gdb_send_error(connection
, 01);
1715 if (strcmp(annex
, "target.xml") != 0)
1717 gdb_send_error(connection
, 01);
1721 xml_printf(&retval
, &xml
, &pos
, &size
, \
1722 "l<target version=\"1.0\">\n<architecture>arm</architecture>\n</target>\n");
1724 if (retval
!= ERROR_OK
)
1726 gdb_send_error(connection
, retval
);
1730 gdb_put_packet(connection
, xml
, strlen(xml
));
1735 else if (strstr(packet
, "QStartNoAckMode"))
1737 gdb_connection
->noack_mode
= 1;
1738 gdb_put_packet(connection
, "OK", 2);
1742 gdb_put_packet(connection
, "", 0);
1746 int gdb_v_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1748 gdb_connection_t
*gdb_connection
= connection
->priv
;
1749 gdb_service_t
*gdb_service
= connection
->service
->priv
;
1752 /* if flash programming disabled - send a empty reply */
1754 if (gdb_flash_program
== 0)
1756 gdb_put_packet(connection
, "", 0);
1760 if (strstr(packet
, "vFlashErase:"))
1763 unsigned long length
;
1765 char *parse
= packet
+ 12;
1768 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1769 return ERROR_SERVER_REMOTE_CLOSED
;
1772 addr
= strtoul(parse
, &parse
, 16);
1774 if (*(parse
++) != ',' || *parse
== '\0')
1776 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1777 return ERROR_SERVER_REMOTE_CLOSED
;
1780 length
= strtoul(parse
, &parse
, 16);
1784 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1785 return ERROR_SERVER_REMOTE_CLOSED
;
1788 /* assume all sectors need erasing - stops any problems
1789 * when flash_write is called multiple times */
1792 /* perform any target specific operations before the erase */
1793 target_call_event_callbacks(gdb_service
->target
, TARGET_EVENT_GDB_FLASH_ERASE_START
);
1794 result
= flash_erase_address_range(gdb_service
->target
, addr
, length
);
1795 target_call_event_callbacks(gdb_service
->target
, TARGET_EVENT_GDB_FLASH_ERASE_END
);
1798 if (result
!= ERROR_OK
)
1800 /* GDB doesn't evaluate the actual error number returned,
1801 * treat a failed erase as an I/O error
1803 gdb_send_error(connection
, EIO
);
1804 LOG_ERROR("flash_erase returned %i", result
);
1807 gdb_put_packet(connection
, "OK", 2);
1812 if (strstr(packet
, "vFlashWrite:"))
1815 unsigned long length
;
1816 char *parse
= packet
+ 12;
1820 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1821 return ERROR_SERVER_REMOTE_CLOSED
;
1823 addr
= strtoul(parse
, &parse
, 16);
1824 if (*(parse
++) != ':')
1826 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1827 return ERROR_SERVER_REMOTE_CLOSED
;
1829 length
= packet_size
- (parse
- packet
);
1831 /* create a new image if there isn't already one */
1832 if (gdb_connection
->vflash_image
== NULL
)
1834 gdb_connection
->vflash_image
= malloc(sizeof(image_t
));
1835 image_open(gdb_connection
->vflash_image
, "", "build");
1838 /* create new section with content from packet buffer */
1839 image_add_section(gdb_connection
->vflash_image
, addr
, length
, 0x0, (u8
*)parse
);
1841 gdb_put_packet(connection
, "OK", 2);
1846 if (!strcmp(packet
, "vFlashDone"))
1850 /* process the flashing buffer. No need to erase as GDB
1851 * always issues a vFlashErase first. */
1852 target_call_event_callbacks(gdb_service
->target
, TARGET_EVENT_GDB_FLASH_WRITE_START
);
1853 result
= flash_write(gdb_service
->target
, gdb_connection
->vflash_image
, &written
, 0);
1854 target_call_event_callbacks(gdb_service
->target
, TARGET_EVENT_GDB_FLASH_WRITE_END
);
1855 if ( result
!= ERROR_OK
)
1857 if (result
== ERROR_FLASH_DST_OUT_OF_BANK
)
1858 gdb_put_packet(connection
, "E.memtype", 9);
1860 gdb_send_error(connection
, EIO
);
1864 LOG_DEBUG("wrote %u bytes from vFlash image to flash", written
);
1865 gdb_put_packet(connection
, "OK", 2);
1868 image_close(gdb_connection
->vflash_image
);
1869 free(gdb_connection
->vflash_image
);
1870 gdb_connection
->vflash_image
= NULL
;
1875 gdb_put_packet(connection
, "", 0);
1879 int gdb_detach(connection_t
*connection
, target_t
*target
)
1882 switch( detach_mode
)
1884 case GDB_DETACH_RESUME
:
1885 target_handle_event( target
, TARGET_EVENT_OLD_pre_resume
);
1886 target_resume(target
, 1, 0, 1, 0);
1889 case GDB_DETACH_RESET
:
1890 /* FIX?? make this configurable?? */
1891 target_process_reset(connection
->cmd_ctx
, RESET_HALT
);
1894 case GDB_DETACH_HALT
:
1895 target_halt(target
);
1898 case GDB_DETACH_NOTHING
:
1902 gdb_put_packet(connection
, "OK", 2);
1906 static void gdb_log_callback(void *priv
, const char *file
, int line
,
1907 const char *function
, const char *string
)
1909 connection_t
*connection
= priv
;
1910 gdb_connection_t
*gdb_con
= connection
->priv
;
1914 /* do not reply this using the O packet */
1918 gdb_output_con(connection
, string
);
1921 /* Do not allocate this on the stack */
1922 char gdb_packet_buffer
[GDB_BUFFER_SIZE
];
1924 static void gdb_sig_halted(connection_t
*connection
)
1927 snprintf(sig_reply
, 4, "T%2.2x", 2);
1928 gdb_put_packet(connection
, sig_reply
, 3);
1932 int gdb_input_inner(connection_t
*connection
)
1934 gdb_service_t
*gdb_service
= connection
->service
->priv
;
1935 target_t
*target
= gdb_service
->target
;
1936 char *packet
=gdb_packet_buffer
;
1939 gdb_connection_t
*gdb_con
= connection
->priv
;
1940 static int extended_protocol
= 0;
1942 /* drain input buffer */
1945 packet_size
= GDB_BUFFER_SIZE
-1;
1946 if ((retval
= gdb_get_packet(connection
, packet
, &packet_size
)) != ERROR_OK
)
1951 /* terminate with zero */
1952 packet
[packet_size
] = 0;
1954 LOG_DEBUG("received packet: '%s'", packet
);
1956 if (packet_size
> 0)
1962 /* Hct... -- set thread
1963 * we don't have threads, send empty reply */
1964 gdb_put_packet(connection
, NULL
, 0);
1968 retval
= gdb_query_packet(connection
, target
, packet
, packet_size
);
1971 retval
= gdb_get_registers_packet(connection
, target
, packet
, packet_size
);
1974 retval
= gdb_set_registers_packet(connection
, target
, packet
, packet_size
);
1977 retval
= gdb_get_register_packet(connection
, target
, packet
, packet_size
);
1980 retval
= gdb_set_register_packet(connection
, target
, packet
, packet_size
);
1983 retval
= gdb_read_memory_packet(connection
, target
, packet
, packet_size
);
1986 retval
= gdb_write_memory_packet(connection
, target
, packet
, packet_size
);
1990 retval
= gdb_breakpoint_watchpoint_packet(connection
, target
, packet
, packet_size
);
1993 gdb_last_signal_packet(connection
, target
, packet
, packet_size
);
1998 if (target
->state
!= TARGET_HALTED
)
2000 /* If the target isn't in the halted state, then we can't
2001 * step/continue. This might be early setup, etc.
2003 gdb_sig_halted(connection
);
2006 /* We're running/stepping, in which case we can
2007 * forward log output until the target is halted
2009 gdb_connection_t
*gdb_con
= connection
->priv
;
2010 gdb_con
->frontend_state
= TARGET_RUNNING
;
2011 log_add_callback(gdb_log_callback
, connection
);
2012 int retval
=gdb_step_continue_packet(connection
, target
, packet
, packet_size
);
2013 if (retval
!=ERROR_OK
)
2015 /* we'll never receive a halted condition... issue a false one.. */
2016 gdb_frontend_halted(target
, connection
);
2022 retval
= gdb_v_packet(connection
, target
, packet
, packet_size
);
2025 retval
= gdb_detach(connection
, target
);
2026 extended_protocol
= 0;
2029 if ((retval
= gdb_write_memory_binary_packet(connection
, target
, packet
, packet_size
)) != ERROR_OK
)
2033 if (extended_protocol
!= 0)
2035 gdb_put_packet(connection
, "OK", 2);
2036 return ERROR_SERVER_REMOTE_CLOSED
;
2038 /* handle extended remote protocol */
2039 extended_protocol
= 1;
2040 gdb_put_packet(connection
, "OK", 2);
2043 /* handle extended restart packet */
2044 breakpoint_clear_target(gdb_service
->target
);
2045 watchpoint_clear_target(gdb_service
->target
);
2046 command_run_linef(connection
->cmd_ctx
, "ocd_gdb_restart %d", get_num_by_target(target
));
2049 /* ignore unkown packets */
2050 LOG_DEBUG("ignoring 0x%2.2x packet", packet
[0]);
2051 gdb_put_packet(connection
, NULL
, 0);
2055 /* if a packet handler returned an error, exit input loop */
2056 if (retval
!= ERROR_OK
)
2060 if (gdb_con
->ctrl_c
)
2062 if (target
->state
== TARGET_RUNNING
)
2064 target_halt(target
);
2065 gdb_con
->ctrl_c
= 0;
2069 } while (gdb_con
->buf_cnt
> 0);
2074 int gdb_input(connection_t
*connection
)
2076 int retval
= gdb_input_inner(connection
);
2077 gdb_connection_t
*gdb_con
= connection
->priv
;
2078 if (retval
== ERROR_SERVER_REMOTE_CLOSED
)
2081 /* logging does not propagate the error, yet can set th gdb_con->closed flag */
2082 if (gdb_con
->closed
)
2083 return ERROR_SERVER_REMOTE_CLOSED
;
2085 /* we'll recover from any other errors(e.g. temporary timeouts, etc.) */
2091 gdb_service_t
*gdb_service
;
2092 target_t
*target
= all_targets
;
2096 LOG_WARNING("no gdb ports allocated as no target has been specified");
2102 LOG_WARNING("no gdb port specified, using default port 3333");
2108 char service_name
[8];
2110 snprintf(service_name
, 8, "gdb-%2.2i", target
->target_number
);
2112 gdb_service
= malloc(sizeof(gdb_service_t
));
2113 gdb_service
->target
= target
;
2115 add_service("gdb", CONNECTION_GDB
,
2116 gdb_port
+ target
->target_number
,
2117 1, gdb_new_connection
, gdb_input
,
2118 gdb_connection_closed
,
2121 LOG_DEBUG("gdb service for target %s at port %i",
2123 gdb_port
+ target
->target_number
);
2125 target
= target
->next
;
2131 /* daemon configuration command gdb_port */
2132 int handle_gdb_port_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2137 /* only if the port wasn't overwritten by cmdline */
2139 gdb_port
= strtoul(args
[0], NULL
, 0);
2144 int handle_gdb_detach_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2148 if (strcmp(args
[0], "resume") == 0)
2150 detach_mode
= GDB_DETACH_RESUME
;
2153 else if (strcmp(args
[0], "reset") == 0)
2155 detach_mode
= GDB_DETACH_RESET
;
2158 else if (strcmp(args
[0], "halt") == 0)
2160 detach_mode
= GDB_DETACH_HALT
;
2163 else if (strcmp(args
[0], "nothing") == 0)
2165 detach_mode
= GDB_DETACH_NOTHING
;
2170 LOG_WARNING("invalid gdb_detach configuration directive: %s", args
[0]);
2174 int handle_gdb_memory_map_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2178 if (strcmp(args
[0], "enable") == 0)
2180 gdb_use_memory_map
= 1;
2183 else if (strcmp(args
[0], "disable") == 0)
2185 gdb_use_memory_map
= 0;
2190 LOG_WARNING("invalid gdb_memory_map configuration directive: %s", args
[0]);
2194 int handle_gdb_flash_program_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2198 if (strcmp(args
[0], "enable") == 0)
2200 gdb_flash_program
= 1;
2203 else if (strcmp(args
[0], "disable") == 0)
2205 gdb_flash_program
= 0;
2210 LOG_WARNING("invalid gdb_memory_map configuration directive: %s", args
[0]);
2214 int handle_gdb_report_data_abort_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2218 if (strcmp(args
[0], "enable") == 0)
2220 gdb_report_data_abort
= 1;
2223 else if (strcmp(args
[0], "disable") == 0)
2225 gdb_report_data_abort
= 0;
2230 LOG_WARNING("invalid gdb_report_data_abort configuration directive: %s", args
[0]);
2234 /* daemon configuration command gdb_port */
2235 int handle_gdb_breakpoint_override_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2242 gdb_breakpoint_override
= 1;
2243 if (strcmp(args
[0], "hard")==0)
2245 gdb_breakpoint_override_type
=BKPT_HARD
;
2246 } else if (strcmp(args
[0], "soft")==0)
2248 gdb_breakpoint_override_type
=BKPT_SOFT
;
2249 } else if (strcmp(args
[0], "disable") == 0)
2251 gdb_breakpoint_override
= 0;
2255 return ERROR_COMMAND_SYNTAX_ERROR
;
2257 if (gdb_breakpoint_override
)
2259 LOG_USER("force %s breakpoints", (gdb_breakpoint_override_type
==BKPT_HARD
)?"hard":"soft");
2262 LOG_USER("breakpoint type is not overriden");
2269 int gdb_register_commands(command_context_t
*command_context
)
2271 register_command(command_context
, NULL
, "gdb_port", handle_gdb_port_command
,
2272 COMMAND_CONFIG
, "");
2273 register_command(command_context
, NULL
, "gdb_detach", handle_gdb_detach_command
,
2274 COMMAND_CONFIG
, "");
2275 register_command(command_context
, NULL
, "gdb_memory_map", handle_gdb_memory_map_command
,
2276 COMMAND_CONFIG
, "");
2277 register_command(command_context
, NULL
, "gdb_flash_program", handle_gdb_flash_program_command
,
2278 COMMAND_CONFIG
, "");
2279 register_command(command_context
, NULL
, "gdb_report_data_abort", handle_gdb_report_data_abort_command
,
2280 COMMAND_CONFIG
, "");
2281 register_command(command_context
, NULL
, "gdb_breakpoint_override", handle_gdb_breakpoint_override_command
,
2282 COMMAND_EXEC
, "hard/soft/disabled - force breakpoint type for gdb 'break' commands."
2283 "The raison d'etre for this option is to support GDB GUI's without "
2284 "a hard/soft breakpoint concept where the default OpenOCD behaviour "
2285 "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)