1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19 ***************************************************************************/
24 #include "replacements.h"
26 #include "gdb_server.h"
30 #include "binarybuffer.h"
32 #include "breakpoints.h"
34 #include "target_request.h"
35 #include "configuration.h"
43 #define _DEBUG_GDB_IO_
46 extern int gdb_error(connection_t
*connection
, int retval
);
47 static unsigned short gdb_port
;
48 static const char *DIGITS
= "0123456789abcdef";
50 static void gdb_log_callback(void *priv
, const char *file
, int line
,
51 const char *function
, const char *string
);
61 /* target behaviour on gdb detach */
62 enum gdb_detach_mode detach_mode
= GDB_DETACH_RESUME
;
64 /* set if we are sending a memory map to gdb
65 * via qXfer:memory-map:read packet */
66 /* enabled by default*/
67 int gdb_use_memory_map
= 1;
68 /* enabled by default*/
69 int gdb_flash_program
= 1;
71 /* if set, data aborts cause an error to be reported in memory read packets
72 * see the code in gdb_read_memory_packet() for further explanations */
73 int gdb_report_data_abort
= 0;
75 int gdb_last_signal(target_t
*target
)
77 switch (target
->debug_reason
)
79 case DBG_REASON_DBGRQ
:
80 return 0x2; /* SIGINT */
81 case DBG_REASON_BREAKPOINT
:
82 case DBG_REASON_WATCHPOINT
:
83 case DBG_REASON_WPTANDBKPT
:
84 return 0x05; /* SIGTRAP */
85 case DBG_REASON_SINGLESTEP
:
86 return 0x05; /* SIGTRAP */
87 case DBG_REASON_NOTHALTED
:
88 return 0x0; /* no signal... shouldn't happen */
90 LOG_USER("undefined debug reason %d - target needs reset", target
->debug_reason
);
95 int check_pending(connection_t
*connection
, int timeout_s
, int *got_data
)
97 /* a non-blocking socket will block if there is 0 bytes available on the socket,
98 * but return with as many bytes as are available immediately
102 gdb_connection_t
*gdb_con
= connection
->priv
;
108 if (gdb_con
->buf_cnt
>0)
115 FD_SET(connection
->fd
, &read_fds
);
117 tv
.tv_sec
= timeout_s
;
119 if (select(connection
->fd
+ 1, &read_fds
, NULL
, NULL
, &tv
) == 0)
121 /* This can typically be because a "monitor" command took too long
122 * before printing any progress messages
126 return ERROR_GDB_TIMEOUT
;
132 *got_data
=FD_ISSET(connection
->fd
, &read_fds
)!=0;
136 int gdb_get_char(connection_t
*connection
, int* next_char
)
138 gdb_connection_t
*gdb_con
= connection
->priv
;
141 #ifdef _DEBUG_GDB_IO_
145 if (gdb_con
->buf_cnt
-- > 0)
147 *next_char
= *(gdb_con
->buf_p
++);
148 if (gdb_con
->buf_cnt
> 0)
149 connection
->input_pending
= 1;
151 connection
->input_pending
= 0;
153 #ifdef _DEBUG_GDB_IO_
154 LOG_DEBUG("returned char '%c' (0x%2.2x)", *next_char
, *next_char
);
162 retval
=check_pending(connection
, 1, NULL
);
163 if (retval
!=ERROR_OK
)
165 gdb_con
->buf_cnt
= read_socket(connection
->fd
, gdb_con
->buffer
, GDB_BUFFER_SIZE
);
166 if (gdb_con
->buf_cnt
> 0)
170 if (gdb_con
->buf_cnt
== 0)
173 return ERROR_SERVER_REMOTE_CLOSED
;
177 errno
= WSAGetLastError();
184 case WSAECONNABORTED
:
186 return ERROR_SERVER_REMOTE_CLOSED
;
189 return ERROR_SERVER_REMOTE_CLOSED
;
191 LOG_ERROR("read: %d", errno
);
202 return ERROR_SERVER_REMOTE_CLOSED
;
205 return ERROR_SERVER_REMOTE_CLOSED
;
207 LOG_ERROR("read: %s", strerror(errno
));
209 return ERROR_SERVER_REMOTE_CLOSED
;
214 #ifdef _DEBUG_GDB_IO_
215 debug_buffer
= malloc(gdb_con
->buf_cnt
+ 1);
216 memcpy(debug_buffer
, gdb_con
->buffer
, gdb_con
->buf_cnt
);
217 debug_buffer
[gdb_con
->buf_cnt
] = 0;
218 LOG_DEBUG("received '%s'", debug_buffer
);
222 gdb_con
->buf_p
= gdb_con
->buffer
;
224 *next_char
= *(gdb_con
->buf_p
++);
225 if (gdb_con
->buf_cnt
> 0)
226 connection
->input_pending
= 1;
228 connection
->input_pending
= 0;
229 #ifdef _DEBUG_GDB_IO_
230 LOG_DEBUG("returned char '%c' (0x%2.2x)", *next_char
, *next_char
);
236 int gdb_putback_char(connection_t
*connection
, int last_char
)
238 gdb_connection_t
*gdb_con
= connection
->priv
;
240 if (gdb_con
->buf_p
> gdb_con
->buffer
)
242 *(--gdb_con
->buf_p
) = last_char
;
247 LOG_ERROR("BUG: couldn't put character back");
253 /* The only way we can detect that the socket is closed is the first time
254 * we write to it, we will fail. Subsequent write operations will
255 * succeed. Shudder! */
256 int gdb_write(connection_t
*connection
, void *data
, int len
)
258 gdb_connection_t
*gdb_con
= connection
->priv
;
260 return ERROR_SERVER_REMOTE_CLOSED
;
262 if (write_socket(connection
->fd
, data
, len
) == len
)
267 return ERROR_SERVER_REMOTE_CLOSED
;
270 int gdb_put_packet_inner(connection_t
*connection
, char *buffer
, int len
)
273 unsigned char my_checksum
= 0;
274 #ifdef _DEBUG_GDB_IO_
279 gdb_connection_t
*gdb_con
= connection
->priv
;
281 for (i
= 0; i
< len
; i
++)
282 my_checksum
+= buffer
[i
];
284 #ifdef _DEBUG_GDB_IO_
286 * At this point we should have nothing in the input queue from GDB,
287 * however sometimes '-' is sent even though we've already received
288 * an ACK (+) for everything we've sent off.
293 if ((retval
=check_pending(connection
, 0, &gotdata
))!=ERROR_OK
)
297 if ((retval
= gdb_get_char(connection
, &reply
)) != ERROR_OK
)
299 LOG_WARNING("Discard unexpected char %c", reply
);
305 #ifdef _DEBUG_GDB_IO_
306 debug_buffer
= malloc(len
+ 1);
307 memcpy(debug_buffer
, buffer
, len
);
308 debug_buffer
[len
] = 0;
309 LOG_DEBUG("sending packet '$%s#%2.2x'", debug_buffer
, my_checksum
);
313 char local_buffer
[1024];
314 local_buffer
[0] = '$';
315 if (len
+4 <= sizeof(local_buffer
))
317 /* performance gain on smaller packets by only a single call to gdb_write() */
318 memcpy(local_buffer
+1, buffer
, len
++);
319 local_buffer
[len
++] = '#';
320 local_buffer
[len
++] = DIGITS
[(my_checksum
>> 4) & 0xf];
321 local_buffer
[len
++] = DIGITS
[my_checksum
& 0xf];
322 gdb_write(connection
, local_buffer
, len
);
326 /* larger packets are transmitted directly from caller supplied buffer
327 by several calls to gdb_write() to avoid dynamic allocation */
328 local_buffer
[1] = '#';
329 local_buffer
[2] = DIGITS
[(my_checksum
>> 4) & 0xf];
330 local_buffer
[3] = DIGITS
[my_checksum
& 0xf];
331 gdb_write(connection
, local_buffer
, 1);
332 gdb_write(connection
, buffer
, len
);
333 gdb_write(connection
, local_buffer
+1, 3);
336 if ((retval
= gdb_get_char(connection
, &reply
)) != ERROR_OK
)
341 else if (reply
== '-')
343 /* Stop sending output packets for now */
344 log_remove_callback(gdb_log_callback
, connection
);
345 LOG_WARNING("negative reply, retrying");
347 else if (reply
== 0x3)
350 if ((retval
= gdb_get_char(connection
, &reply
)) != ERROR_OK
)
354 else if (reply
== '-')
356 /* Stop sending output packets for now */
357 log_remove_callback(gdb_log_callback
, connection
);
358 LOG_WARNING("negative reply, retrying");
362 LOG_ERROR("unknown character 0x%2.2x in reply, dropping connection", reply
);
364 return ERROR_SERVER_REMOTE_CLOSED
;
369 LOG_ERROR("unknown character 0x%2.2x in reply, dropping connection", reply
);
371 return ERROR_SERVER_REMOTE_CLOSED
;
375 return ERROR_SERVER_REMOTE_CLOSED
;
380 int gdb_put_packet(connection_t
*connection
, char *buffer
, int len
)
382 gdb_connection_t
*gdb_con
= connection
->priv
;
384 int retval
= gdb_put_packet_inner(connection
, buffer
, len
);
389 int gdb_get_packet_inner(connection_t
*connection
, char *buffer
, int *len
)
395 unsigned char my_checksum
= 0;
396 gdb_connection_t
*gdb_con
= connection
->priv
;
402 if ((retval
= gdb_get_char(connection
, &character
)) != ERROR_OK
)
405 #ifdef _DEBUG_GDB_IO_
406 LOG_DEBUG("character: '%c'", character
);
414 /* gdb sends a dummy ack '+' at every remote connect - see remote_start_remote (remote.c)
415 * incase anyone tries to debug why they receive this warning every time */
416 LOG_WARNING("acknowledgment received, but no packet pending");
419 LOG_WARNING("negative acknowledgment, but no packet pending");
426 LOG_WARNING("ignoring character 0x%x", character
);
429 } while (character
!= '$');
434 gdb_connection_t
*gdb_con
= connection
->priv
;
437 /* The common case is that we have an entire packet with no escape chars.
438 * We need to leave at least 2 bytes in the buffer to have
439 * gdb_get_char() update various bits and bobs correctly.
441 if ((gdb_con
->buf_cnt
> 2) && ((gdb_con
->buf_cnt
+count
) < *len
))
443 /* The compiler will struggle a bit with constant propagation and
444 * aliasing, so we help it by showing that these values do not
445 * change inside the loop
448 char *buf
= gdb_con
->buf_p
;
449 int run
= gdb_con
->buf_cnt
- 2;
456 if (character
== '#')
458 /* Danger! character can be '#' when esc is
459 * used so we need an explicit boolean for done here.
465 if (character
== '}')
467 /* data transmitted in binary mode (X packet)
468 * uses 0x7d as escape character */
469 my_checksum
+= character
& 0xff;
472 my_checksum
+= character
& 0xff;
473 buffer
[count
++] = (character
^ 0x20) & 0xff;
476 my_checksum
+= character
& 0xff;
477 buffer
[count
++] = character
& 0xff;
481 gdb_con
->buf_cnt
-= i
;
487 LOG_ERROR("packet buffer too small");
488 return ERROR_GDB_BUFFER_TOO_SMALL
;
491 if ((retval
= gdb_get_char(connection
, &character
)) != ERROR_OK
)
494 if (character
== '#')
497 if (character
== '}')
499 /* data transmitted in binary mode (X packet)
500 * uses 0x7d as escape character */
501 my_checksum
+= character
& 0xff;
502 if ((retval
= gdb_get_char(connection
, &character
)) != ERROR_OK
)
504 my_checksum
+= character
& 0xff;
505 buffer
[count
++] = (character
^ 0x20) & 0xff;
509 my_checksum
+= character
& 0xff;
510 buffer
[count
++] = character
& 0xff;
516 if ((retval
= gdb_get_char(connection
, &character
)) != ERROR_OK
)
518 checksum
[0] = character
;
519 if ((retval
= gdb_get_char(connection
, &character
)) != ERROR_OK
)
521 checksum
[1] = character
;
524 if (my_checksum
== strtoul(checksum
, NULL
, 16))
526 gdb_write(connection
, "+", 1);
530 LOG_WARNING("checksum error, requesting retransmission");
531 gdb_write(connection
, "-", 1);
534 return ERROR_SERVER_REMOTE_CLOSED
;
539 int gdb_get_packet(connection_t
*connection
, char *buffer
, int *len
)
541 gdb_connection_t
*gdb_con
= connection
->priv
;
543 int retval
= gdb_get_packet_inner(connection
, buffer
, len
);
548 int gdb_output_con(connection_t
*connection
, const char* line
)
553 bin_size
= strlen(line
);
555 hex_buffer
= malloc(bin_size
*2 + 2);
556 if (hex_buffer
== NULL
)
557 return ERROR_GDB_BUFFER_TOO_SMALL
;
560 for (i
=0; i
<bin_size
; i
++)
561 snprintf(hex_buffer
+ 1 + i
*2, 3, "%2.2x", line
[i
]);
562 hex_buffer
[bin_size
*2+1] = 0;
564 gdb_put_packet(connection
, hex_buffer
, bin_size
*2 + 1);
570 int gdb_output(struct command_context_s
*context
, const char* line
)
572 /* this will be dumped to the log and also sent as an O packet if possible */
573 LOG_USER_N("%s", line
);
577 int gdb_program_handler(struct target_s
*target
, enum target_event event
, void *priv
)
579 struct command_context_s
*cmd_ctx
= priv
;
581 target_invoke_script(cmd_ctx
, target
, "gdb_program");
582 jtag_execute_queue();
587 int gdb_target_callback_event_handler(struct target_s
*target
, enum target_event event
, void *priv
)
589 connection_t
*connection
= priv
;
590 gdb_connection_t
*gdb_connection
= connection
->priv
;
596 case TARGET_EVENT_HALTED
:
597 /* In the GDB protocol when we are stepping or coninuing execution,
598 * we have a lingering reply. Upon receiving a halted event
599 * when we have that lingering packet, we reply to the original
600 * step or continue packet.
602 * Executing monitor commands can bring the target in and
603 * out of the running state so we'll see lots of TARGET_EVENT_XXX
604 * that are to be ignored.
606 if (gdb_connection
->frontend_state
== TARGET_RUNNING
)
608 /* stop forwarding log packets! */
609 log_remove_callback(gdb_log_callback
, connection
);
611 if (gdb_connection
->ctrl_c
)
614 gdb_connection
->ctrl_c
= 0;
618 signal
= gdb_last_signal(target
);
621 snprintf(sig_reply
, 4, "T%2.2x", signal
);
622 gdb_put_packet(connection
, sig_reply
, 3);
623 gdb_connection
->frontend_state
= TARGET_HALTED
;
626 case TARGET_EVENT_GDB_PROGRAM
:
627 gdb_program_handler(target
, event
, connection
->cmd_ctx
);
637 int gdb_new_connection(connection_t
*connection
)
639 gdb_connection_t
*gdb_connection
= malloc(sizeof(gdb_connection_t
));
640 gdb_service_t
*gdb_service
= connection
->service
->priv
;
644 connection
->priv
= gdb_connection
;
646 /* initialize gdb connection information */
647 gdb_connection
->buf_p
= gdb_connection
->buffer
;
648 gdb_connection
->buf_cnt
= 0;
649 gdb_connection
->ctrl_c
= 0;
650 gdb_connection
->frontend_state
= TARGET_HALTED
;
651 gdb_connection
->vflash_image
= NULL
;
652 gdb_connection
->closed
= 0;
653 gdb_connection
->busy
= 0;
655 /* send ACK to GDB for debug request */
656 gdb_write(connection
, "+", 1);
658 /* output goes through gdb connection */
659 command_set_output_handler(connection
->cmd_ctx
, gdb_output
, connection
);
661 /* register callback to be informed about target events */
662 target_register_event_callback(gdb_target_callback_event_handler
, connection
);
664 /* a gdb session just attached, try to put the target in halt mode.
668 * If the halt fails(e.g. target needs a reset, JTAG communication not
669 * working, etc.), then the GDB connect will succeed as
670 * the get_gdb_reg_list() will lie and return a register list with
673 * This allows GDB monitor commands to be run from a GDB init script to
674 * initialize the target
676 * Also, since the halt() is asynchronous target connect will be
677 * instantaneous and thus avoiding annoying timeout problems during
680 target_halt(gdb_service
->target
);
682 /* remove the initial ACK from the incoming buffer */
683 if ((retval
= gdb_get_char(connection
, &initial_ack
)) != ERROR_OK
)
686 /* FIX!!!??? would we actually ever receive a + here???
689 if (initial_ack
!= '+')
690 gdb_putback_char(connection
, initial_ack
);
695 int gdb_connection_closed(connection_t
*connection
)
697 gdb_service_t
*gdb_service
= connection
->service
->priv
;
698 gdb_connection_t
*gdb_connection
= connection
->priv
;
700 /* see if an image built with vFlash commands is left */
701 if (gdb_connection
->vflash_image
)
703 image_close(gdb_connection
->vflash_image
);
704 free(gdb_connection
->vflash_image
);
705 gdb_connection
->vflash_image
= NULL
;
708 /* if this connection registered a debug-message receiver delete it */
709 delete_debug_msg_receiver(connection
->cmd_ctx
, gdb_service
->target
);
711 if (connection
->priv
)
713 free(connection
->priv
);
714 connection
->priv
= NULL
;
718 LOG_ERROR("BUG: connection->priv == NULL");
721 target_unregister_event_callback(gdb_target_callback_event_handler
, connection
);
722 log_remove_callback(gdb_log_callback
, connection
);
727 void gdb_send_error(connection_t
*connection
, u8 the_error
)
730 snprintf(err
, 4, "E%2.2X", the_error
);
731 gdb_put_packet(connection
, err
, 3);
734 int gdb_last_signal_packet(connection_t
*connection
, target_t
*target
, char* packet
, int packet_size
)
739 signal
= gdb_last_signal(target
);
741 snprintf(sig_reply
, 4, "S%2.2x", signal
);
742 gdb_put_packet(connection
, sig_reply
, 3);
747 /* Convert register to string of bits. NB! The # of bits in the
748 * register might be non-divisible by 8(a byte), in which
749 * case an entire byte is shown. */
750 void gdb_str_to_target(target_t
*target
, char *tstr
, reg_t
*reg
)
757 buf_len
= CEIL(reg
->size
, 8);
759 for (i
= 0; i
< buf_len
; i
++)
761 tstr
[i
*2] = DIGITS
[(buf
[i
]>>4) & 0xf];
762 tstr
[i
*2+1] = DIGITS
[buf
[i
]&0xf];
766 void gdb_target_to_str(target_t
*target
, char *tstr
, char *str
)
768 int str_len
= strlen(tstr
);
773 LOG_ERROR("BUG: gdb value with uneven number of characters encountered");
777 for (i
= 0; i
< str_len
; i
+=2)
779 str
[str_len
- i
- 1] = tstr
[i
+ 1];
780 str
[str_len
- i
- 2] = tstr
[i
];
784 int gdb_get_registers_packet(connection_t
*connection
, target_t
*target
, char* packet
, int packet_size
)
789 int reg_packet_size
= 0;
794 #ifdef _DEBUG_GDB_IO_
798 if ((retval
= target
->type
->get_gdb_reg_list(target
, ®_list
, ®_list_size
)) != ERROR_OK
)
800 return gdb_error(connection
, retval
);
803 for (i
= 0; i
< reg_list_size
; i
++)
805 reg_packet_size
+= reg_list
[i
]->size
;
808 reg_packet
= malloc(CEIL(reg_packet_size
, 8) * 2);
809 reg_packet_p
= reg_packet
;
811 for (i
= 0; i
< reg_list_size
; i
++)
813 gdb_str_to_target(target
, reg_packet_p
, reg_list
[i
]);
814 reg_packet_p
+= CEIL(reg_list
[i
]->size
, 8) * 2;
817 #ifdef _DEBUG_GDB_IO_
820 reg_packet_p
= strndup(reg_packet
, CEIL(reg_packet_size
, 8) * 2);
821 LOG_DEBUG("reg_packet: %s", reg_packet_p
);
826 gdb_put_packet(connection
, reg_packet
, CEIL(reg_packet_size
, 8) * 2);
834 int gdb_set_registers_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
842 #ifdef _DEBUG_GDB_IO_
846 /* skip command character */
852 LOG_WARNING("GDB set_registers packet with uneven characters received, dropping connection");
853 return ERROR_SERVER_REMOTE_CLOSED
;
856 if ((retval
= target
->type
->get_gdb_reg_list(target
, ®_list
, ®_list_size
)) != ERROR_OK
)
858 return gdb_error(connection
, retval
);
862 for (i
= 0; i
< reg_list_size
; i
++)
866 reg_arch_type_t
*arch_type
;
868 /* convert from GDB-string (target-endian) to hex-string (big-endian) */
869 hex_buf
= malloc(CEIL(reg_list
[i
]->size
, 8) * 2);
870 gdb_target_to_str(target
, packet_p
, hex_buf
);
872 /* convert hex-string to binary buffer */
873 bin_buf
= malloc(CEIL(reg_list
[i
]->size
, 8));
874 str_to_buf(hex_buf
, CEIL(reg_list
[i
]->size
, 8) * 2, bin_buf
, reg_list
[i
]->size
, 16);
876 /* get register arch_type, and call set method */
877 arch_type
= register_get_arch_type(reg_list
[i
]->arch_type
);
878 if (arch_type
== NULL
)
880 LOG_ERROR("BUG: encountered unregistered arch type");
883 arch_type
->set(reg_list
[i
], bin_buf
);
885 /* advance packet pointer */
886 packet_p
+= (CEIL(reg_list
[i
]->size
, 8) * 2);
892 /* free reg_t *reg_list[] array allocated by get_gdb_reg_list */
895 gdb_put_packet(connection
, "OK", 2);
900 int gdb_get_register_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
903 int reg_num
= strtoul(packet
+ 1, NULL
, 16);
908 #ifdef _DEBUG_GDB_IO_
912 if ((retval
= target
->type
->get_gdb_reg_list(target
, ®_list
, ®_list_size
)) != ERROR_OK
)
914 return gdb_error(connection
, retval
);
917 if (reg_list_size
<= reg_num
)
919 LOG_ERROR("gdb requested a non-existing register");
923 reg_packet
= malloc(CEIL(reg_list
[reg_num
]->size
, 8) * 2);
925 gdb_str_to_target(target
, reg_packet
, reg_list
[reg_num
]);
927 gdb_put_packet(connection
, reg_packet
, CEIL(reg_list
[reg_num
]->size
, 8) * 2);
935 int gdb_set_register_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
940 int reg_num
= strtoul(packet
+ 1, &separator
, 16);
944 reg_arch_type_t
*arch_type
;
948 if ((retval
= target
->type
->get_gdb_reg_list(target
, ®_list
, ®_list_size
)) != ERROR_OK
)
950 return gdb_error(connection
, retval
);
953 if (reg_list_size
< reg_num
)
955 LOG_ERROR("gdb requested a non-existing register");
956 return ERROR_SERVER_REMOTE_CLOSED
;
959 if (*separator
!= '=')
961 LOG_ERROR("GDB 'set register packet', but no '=' following the register number");
962 return ERROR_SERVER_REMOTE_CLOSED
;
965 /* convert from GDB-string (target-endian) to hex-string (big-endian) */
966 hex_buf
= malloc(CEIL(reg_list
[reg_num
]->size
, 8) * 2);
967 gdb_target_to_str(target
, separator
+ 1, hex_buf
);
969 /* convert hex-string to binary buffer */
970 bin_buf
= malloc(CEIL(reg_list
[reg_num
]->size
, 8));
971 str_to_buf(hex_buf
, CEIL(reg_list
[reg_num
]->size
, 8) * 2, bin_buf
, reg_list
[reg_num
]->size
, 16);
973 /* get register arch_type, and call set method */
974 arch_type
= register_get_arch_type(reg_list
[reg_num
]->arch_type
);
975 if (arch_type
== NULL
)
977 LOG_ERROR("BUG: encountered unregistered arch type");
980 arch_type
->set(reg_list
[reg_num
], bin_buf
);
982 gdb_put_packet(connection
, "OK", 2);
991 int gdb_error(connection_t
*connection
, int retval
)
995 case ERROR_TARGET_DATA_ABORT
:
996 gdb_send_error(connection
, EIO
);
998 case ERROR_TARGET_TRANSLATION_FAULT
:
999 gdb_send_error(connection
, EFAULT
);
1001 case ERROR_TARGET_UNALIGNED_ACCESS
:
1002 gdb_send_error(connection
, EFAULT
);
1004 case ERROR_TARGET_NOT_HALTED
:
1005 gdb_send_error(connection
, EFAULT
);
1008 /* This could be that the target reset itself. */
1009 LOG_ERROR("unexpected error %i", retval
);
1010 gdb_send_error(connection
, EFAULT
);
1017 /* We don't have to worry about the default 2 second timeout for GDB packets,
1018 * because GDB breaks up large memory reads into smaller reads.
1020 * 8191 bytes by the looks of it. Why 8191 bytes instead of 8192?????
1022 int gdb_read_memory_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1031 int retval
= ERROR_OK
;
1033 /* skip command character */
1036 addr
= strtoul(packet
, &separator
, 16);
1038 if (*separator
!= ',')
1040 LOG_ERROR("incomplete read memory packet received, dropping connection");
1041 return ERROR_SERVER_REMOTE_CLOSED
;
1044 len
= strtoul(separator
+1, NULL
, 16);
1046 buffer
= malloc(len
);
1048 LOG_DEBUG("addr: 0x%8.8x, len: 0x%8.8x", addr
, len
);
1050 retval
= target_read_buffer(target
, addr
, len
, buffer
);
1052 if ((retval
== ERROR_TARGET_DATA_ABORT
) && (!gdb_report_data_abort
))
1054 /* TODO : Here we have to lie and send back all zero's lest stack traces won't work.
1055 * At some point this might be fixed in GDB, in which case this code can be removed.
1057 * OpenOCD developers are acutely aware of this problem, but there is nothing
1058 * gained by involving the user in this problem that hopefully will get resolved
1061 * http://sourceware.org/cgi-bin/gnatsweb.pl?cmd=view%20audit-trail&database=gdb&pr=2395
1063 * For now, the default is to fix up things to make current GDB versions work.
1064 * This can be overwritten using the gdb_report_data_abort <'enable'|'disable'> command.
1066 memset(buffer
, 0, len
);
1070 if (retval
== ERROR_OK
)
1072 hex_buffer
= malloc(len
* 2 + 1);
1075 for (i
= 0; i
< len
; i
++)
1078 hex_buffer
[2 * i
] = DIGITS
[(t
>> 4) & 0xf];
1079 hex_buffer
[2 * i
+ 1] = DIGITS
[t
& 0xf];
1082 gdb_put_packet(connection
, hex_buffer
, len
* 2);
1088 retval
= gdb_error(connection
, retval
);
1096 int gdb_write_memory_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1107 /* skip command character */
1110 addr
= strtoul(packet
, &separator
, 16);
1112 if (*separator
!= ',')
1114 LOG_ERROR("incomplete write memory packet received, dropping connection");
1115 return ERROR_SERVER_REMOTE_CLOSED
;
1118 len
= strtoul(separator
+1, &separator
, 16);
1120 if (*(separator
++) != ':')
1122 LOG_ERROR("incomplete write memory packet received, dropping connection");
1123 return ERROR_SERVER_REMOTE_CLOSED
;
1126 buffer
= malloc(len
);
1128 LOG_DEBUG("addr: 0x%8.8x, len: 0x%8.8x", addr
, len
);
1130 for (i
=0; i
<len
; i
++)
1133 sscanf(separator
+ 2*i
, "%2x", &tmp
);
1137 retval
= target_write_buffer(target
, addr
, len
, buffer
);
1139 if (retval
== ERROR_OK
)
1141 gdb_put_packet(connection
, "OK", 2);
1145 retval
= gdb_error(connection
, retval
);
1153 int gdb_write_memory_binary_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1161 /* skip command character */
1164 addr
= strtoul(packet
, &separator
, 16);
1166 if (*separator
!= ',')
1168 LOG_ERROR("incomplete write memory binary packet received, dropping connection");
1169 return ERROR_SERVER_REMOTE_CLOSED
;
1172 len
= strtoul(separator
+1, &separator
, 16);
1174 if (*(separator
++) != ':')
1176 LOG_ERROR("incomplete write memory binary packet received, dropping connection");
1177 return ERROR_SERVER_REMOTE_CLOSED
;
1183 LOG_DEBUG("addr: 0x%8.8x, len: 0x%8.8x", addr
, len
);
1185 retval
= target_write_buffer(target
, addr
, len
, (u8
*)separator
);
1188 if (retval
== ERROR_OK
)
1190 gdb_put_packet(connection
, "OK", 2);
1194 if ((retval
= gdb_error(connection
, retval
)) != ERROR_OK
)
1201 void gdb_step_continue_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1208 if (packet_size
> 1)
1210 packet
[packet_size
] = 0;
1211 address
= strtoul(packet
+ 1, NULL
, 16);
1218 if (packet
[0] == 'c')
1220 LOG_DEBUG("continue");
1221 target_invoke_script(connection
->cmd_ctx
, target
, "pre_resume");
1222 target_resume(target
, current
, address
, 0, 0); /* resume at current address, don't handle breakpoints, not debugging */
1224 else if (packet
[0] == 's')
1227 target
->type
->step(target
, current
, address
, 0); /* step at current or address, don't handle breakpoints */
1231 int gdb_breakpoint_watchpoint_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1234 enum breakpoint_type bp_type
= BKPT_SOFT
/* dummy init to avoid warning */;
1235 enum watchpoint_rw wp_type
;
1243 type
= strtoul(packet
+ 1, &separator
, 16);
1245 if (type
== 0) /* memory breakpoint */
1246 bp_type
= BKPT_SOFT
;
1247 else if (type
== 1) /* hardware breakpoint */
1248 bp_type
= BKPT_HARD
;
1249 else if (type
== 2) /* write watchpoint */
1250 wp_type
= WPT_WRITE
;
1251 else if (type
== 3) /* read watchpoint */
1253 else if (type
== 4) /* access watchpoint */
1254 wp_type
= WPT_ACCESS
;
1256 if (*separator
!= ',')
1258 LOG_ERROR("incomplete breakpoint/watchpoint packet received, dropping connection");
1259 return ERROR_SERVER_REMOTE_CLOSED
;
1262 address
= strtoul(separator
+1, &separator
, 16);
1264 if (*separator
!= ',')
1266 LOG_ERROR("incomplete breakpoint/watchpoint packet received, dropping connection");
1267 return ERROR_SERVER_REMOTE_CLOSED
;
1270 size
= strtoul(separator
+1, &separator
, 16);
1276 if (packet
[0] == 'Z')
1278 if ((retval
= breakpoint_add(target
, address
, size
, bp_type
)) != ERROR_OK
)
1280 if ((retval
= gdb_error(connection
, retval
)) != ERROR_OK
)
1285 gdb_put_packet(connection
, "OK", 2);
1290 breakpoint_remove(target
, address
);
1291 gdb_put_packet(connection
, "OK", 2);
1298 if (packet
[0] == 'Z')
1300 if ((retval
= watchpoint_add(target
, address
, size
, type
-2, 0, 0xffffffffu
)) != ERROR_OK
)
1302 if ((retval
= gdb_error(connection
, retval
)) != ERROR_OK
)
1307 gdb_put_packet(connection
, "OK", 2);
1312 watchpoint_remove(target
, address
);
1313 gdb_put_packet(connection
, "OK", 2);
1324 /* print out a string and allocate more space as needed, mainly used for XML at this point */
1325 void xml_printf(int *retval
, char **xml
, int *pos
, int *size
, const char *fmt
, ...)
1327 if (*retval
!= ERROR_OK
)
1335 if ((*xml
== NULL
) || (!first
))
1337 /* start by 0 to exercise all the code paths.
1338 * Need minimum 2 bytes to fit 1 char and 0 terminator. */
1340 *size
= *size
* 2 + 2;
1342 *xml
= realloc(*xml
, *size
);
1347 *retval
= ERROR_SERVER_REMOTE_CLOSED
;
1355 ret
= vsnprintf(*xml
+ *pos
, *size
- *pos
, fmt
, ap
);
1357 if ((ret
> 0) && ((ret
+ 1) < *size
- *pos
))
1362 /* there was just enough or not enough space, allocate more. */
1367 static int decode_xfer_read(char *buf
, char **annex
, int *ofs
, unsigned int *len
)
1371 /* Extract and NUL-terminate the annex. */
1373 while (*buf
&& *buf
!= ':')
1379 /* After the read marker and annex, qXfer looks like a
1380 * traditional 'm' packet. */
1382 *ofs
= strtoul(buf
, &separator
, 16);
1384 if (*separator
!= ',')
1387 *len
= strtoul(separator
+1, NULL
, 16);
1392 int gdb_calc_blocksize(flash_bank_t
*bank
)
1395 int block_size
= 0xffffffff;
1397 /* loop through all sectors and return smallest sector size */
1399 for (i
= 0; i
< bank
->num_sectors
; i
++)
1401 if (bank
->sectors
[i
].size
< block_size
)
1402 block_size
= bank
->sectors
[i
].size
;
1408 static int compare_bank (const void * a
, const void * b
)
1410 flash_bank_t
*b1
, *b2
;
1411 b1
=*((flash_bank_t
**)a
);
1412 b2
=*((flash_bank_t
**)b
);
1414 if (b1
->base
==b2
->base
)
1417 } else if (b1
->base
>b2
->base
)
1426 int gdb_query_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1428 command_context_t
*cmd_ctx
= connection
->cmd_ctx
;
1430 if (strstr(packet
, "qRcmd,"))
1432 if (packet_size
> 6)
1436 cmd
= malloc((packet_size
- 6)/2 + 1);
1437 for (i
=0; i
< (packet_size
- 6)/2; i
++)
1440 sscanf(packet
+ 6 + 2*i
, "%2x", &tmp
);
1443 cmd
[(packet_size
- 6)/2] = 0x0;
1445 /* We want to print all debug output to GDB connection */
1446 log_add_callback(gdb_log_callback
, connection
);
1447 target_call_timer_callbacks_now();
1448 command_run_line(cmd_ctx
, cmd
);
1449 target_call_timer_callbacks_now();
1450 log_remove_callback(gdb_log_callback
, connection
);
1453 gdb_put_packet(connection
, "OK", 2);
1456 else if (strstr(packet
, "qCRC:"))
1458 if (packet_size
> 5)
1467 /* skip command character */
1470 addr
= strtoul(packet
, &separator
, 16);
1472 if (*separator
!= ',')
1474 LOG_ERROR("incomplete read memory packet received, dropping connection");
1475 return ERROR_SERVER_REMOTE_CLOSED
;
1478 len
= strtoul(separator
+ 1, NULL
, 16);
1480 retval
= target_checksum_memory(target
, addr
, len
, &checksum
);
1482 if (retval
== ERROR_OK
)
1484 snprintf(gdb_reply
, 10, "C%8.8x", checksum
);
1485 gdb_put_packet(connection
, gdb_reply
, 9);
1489 if ((retval
= gdb_error(connection
, retval
)) != ERROR_OK
)
1496 else if (strstr(packet
, "qSupported"))
1498 /* we currently support packet size and qXfer:memory-map:read (if enabled)
1499 * disable qXfer:features:read for the moment */
1500 int retval
= ERROR_OK
;
1501 char *buffer
= NULL
;
1505 xml_printf(&retval
, &buffer
, &pos
, &size
,
1506 "PacketSize=%x;qXfer:memory-map:read%c;qXfer:features:read-",
1507 (GDB_BUFFER_SIZE
- 1), ((gdb_use_memory_map
== 1)&&(flash_get_bank_count()>0)) ? '+' : '-');
1509 if (retval
!= ERROR_OK
)
1511 gdb_send_error(connection
, 01);
1515 gdb_put_packet(connection
, buffer
, strlen(buffer
));
1520 else if (strstr(packet
, "qXfer:memory-map:read::")&&(flash_get_bank_count()>0))
1522 /* We get away with only specifying flash here. Regions that are not
1523 * specified are treated as if we provided no memory map(if not we
1524 * could detect the holes and mark them as RAM).
1525 * Normally we only execute this code once, but no big deal if we
1526 * have to regenerate it a couple of times. */
1532 int retval
= ERROR_OK
;
1539 /* skip command character */
1542 offset
= strtoul(packet
, &separator
, 16);
1543 length
= strtoul(separator
+ 1, &separator
, 16);
1545 xml_printf(&retval
, &xml
, &pos
, &size
, "<memory-map>\n");
1548 sort banks in ascending order, we need to make non-flash memory be ram(or rather
1549 read/write) by default for GDB.
1550 GDB does not have a concept of non-cacheable read/write memory.
1552 flash_bank_t
**banks
=malloc(sizeof(flash_bank_t
*)*flash_get_bank_count());
1555 for (i
=0; i
<flash_get_bank_count(); i
++)
1557 p
= get_flash_bank_by_num(i
);
1561 retval
= ERROR_FAIL
;
1562 gdb_send_error(connection
, retval
);
1568 qsort(banks
, flash_get_bank_count(), sizeof(flash_bank_t
*), compare_bank
);
1571 for (i
=0; i
<flash_get_bank_count(); i
++)
1575 if (ram_start
<p
->base
)
1577 xml_printf(&retval
, &xml
, &pos
, &size
, "<memory type=\"ram\" start=\"0x%x\" length=\"0x%x\"/>\n",
1578 ram_start
, p
->base
-ram_start
);
1581 /* if device has uneven sector sizes, eg. str7, lpc
1582 * we pass the smallest sector size to gdb memory map */
1583 blocksize
= gdb_calc_blocksize(p
);
1585 xml_printf(&retval
, &xml
, &pos
, &size
, "<memory type=\"flash\" start=\"0x%x\" length=\"0x%x\">\n" \
1586 "<property name=\"blocksize\">0x%x</property>\n" \
1588 p
->base
, p
->size
, blocksize
);
1589 ram_start
=p
->base
+p
->size
;
1593 xml_printf(&retval
, &xml
, &pos
, &size
, "<memory type=\"ram\" start=\"0x%x\" length=\"0x%x\"/>\n",
1594 ram_start
, 0-ram_start
);
1597 /* a flash chip could be at the very end of the 32 bit address space, in which case
1598 ram_start will be precisely 0 */
1604 xml_printf(&retval
, &xml
, &pos
, &size
, "</memory-map>\n");
1606 if (retval
!= ERROR_OK
)
1608 gdb_send_error(connection
, retval
);
1612 if (offset
+ length
> pos
)
1614 length
= pos
- offset
;
1617 char *t
= malloc(length
+ 1);
1619 memcpy(t
+ 1, xml
+ offset
, length
);
1620 gdb_put_packet(connection
, t
, length
+ 1);
1626 else if (strstr(packet
, "qXfer:features:read:"))
1631 int retval
= ERROR_OK
;
1634 unsigned int length
;
1637 /* skip command character */
1640 if (decode_xfer_read(packet
, &annex
, &offset
, &length
) < 0)
1642 gdb_send_error(connection
, 01);
1646 if (strcmp(annex
, "target.xml") != 0)
1648 gdb_send_error(connection
, 01);
1652 xml_printf(&retval
, &xml
, &pos
, &size
, \
1653 "l<target version=\"1.0\">\n<architecture>arm</architecture>\n</target>\n");
1655 if (retval
!= ERROR_OK
)
1657 gdb_send_error(connection
, retval
);
1661 gdb_put_packet(connection
, xml
, strlen(xml
));
1667 gdb_put_packet(connection
, "", 0);
1671 int gdb_v_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1673 gdb_connection_t
*gdb_connection
= connection
->priv
;
1674 gdb_service_t
*gdb_service
= connection
->service
->priv
;
1677 /* if flash programming disabled - send a empty reply */
1679 if (gdb_flash_program
== 0)
1681 gdb_put_packet(connection
, "", 0);
1685 if (strstr(packet
, "vFlashErase:"))
1688 unsigned long length
;
1690 char *parse
= packet
+ 12;
1693 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1694 return ERROR_SERVER_REMOTE_CLOSED
;
1697 addr
= strtoul(parse
, &parse
, 16);
1699 if (*(parse
++) != ',' || *parse
== '\0')
1701 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1702 return ERROR_SERVER_REMOTE_CLOSED
;
1705 length
= strtoul(parse
, &parse
, 16);
1709 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1710 return ERROR_SERVER_REMOTE_CLOSED
;
1713 /* assume all sectors need erasing - stops any problems
1714 * when flash_write is called multiple times */
1717 /* perform any target specific operations before the erase */
1718 target_call_event_callbacks(gdb_service
->target
, TARGET_EVENT_GDB_PROGRAM
);
1721 if ((result
= flash_erase_address_range(gdb_service
->target
, addr
, length
)) != ERROR_OK
)
1723 /* GDB doesn't evaluate the actual error number returned,
1724 * treat a failed erase as an I/O error
1726 gdb_send_error(connection
, EIO
);
1727 LOG_ERROR("flash_erase returned %i", result
);
1730 gdb_put_packet(connection
, "OK", 2);
1735 if (strstr(packet
, "vFlashWrite:"))
1738 unsigned long length
;
1739 char *parse
= packet
+ 12;
1743 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1744 return ERROR_SERVER_REMOTE_CLOSED
;
1746 addr
= strtoul(parse
, &parse
, 16);
1747 if (*(parse
++) != ':')
1749 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1750 return ERROR_SERVER_REMOTE_CLOSED
;
1752 length
= packet_size
- (parse
- packet
);
1754 /* create a new image if there isn't already one */
1755 if (gdb_connection
->vflash_image
== NULL
)
1757 gdb_connection
->vflash_image
= malloc(sizeof(image_t
));
1758 image_open(gdb_connection
->vflash_image
, "", "build");
1761 /* create new section with content from packet buffer */
1762 image_add_section(gdb_connection
->vflash_image
, addr
, length
, 0x0, (u8
*)parse
);
1764 gdb_put_packet(connection
, "OK", 2);
1769 if (!strcmp(packet
, "vFlashDone"))
1773 /* process the flashing buffer. No need to erase as GDB
1774 * always issues a vFlashErase first. */
1775 if ((result
= flash_write(gdb_service
->target
, gdb_connection
->vflash_image
, &written
, 0)) != ERROR_OK
)
1777 if (result
== ERROR_FLASH_DST_OUT_OF_BANK
)
1778 gdb_put_packet(connection
, "E.memtype", 9);
1780 gdb_send_error(connection
, EIO
);
1784 LOG_DEBUG("wrote %u bytes from vFlash image to flash", written
);
1785 gdb_put_packet(connection
, "OK", 2);
1788 image_close(gdb_connection
->vflash_image
);
1789 free(gdb_connection
->vflash_image
);
1790 gdb_connection
->vflash_image
= NULL
;
1795 gdb_put_packet(connection
, "", 0);
1799 int gdb_detach(connection_t
*connection
, target_t
*target
)
1801 switch( detach_mode
)
1803 case GDB_DETACH_RESUME
:
1804 target_invoke_script(connection
->cmd_ctx
, target
, "pre_resume");
1805 target_resume(target
, 1, 0, 1, 0);
1808 case GDB_DETACH_RESET
:
1809 /* FIX?? make this configurable?? */
1810 target_process_reset(connection
->cmd_ctx
, RESET_HALT
);
1813 case GDB_DETACH_HALT
:
1814 target_halt(target
);
1817 case GDB_DETACH_NOTHING
:
1821 gdb_put_packet(connection
, "OK", 2);
1826 static void gdb_log_callback(void *priv
, const char *file
, int line
,
1827 const char *function
, const char *string
)
1829 connection_t
*connection
= priv
;
1830 gdb_connection_t
*gdb_con
= connection
->priv
;
1834 /* do not reply this using the O packet */
1838 gdb_output_con(connection
, string
);
1841 /* Do not allocate this on the stack */
1842 char gdb_packet_buffer
[GDB_BUFFER_SIZE
];
1844 int gdb_input_inner(connection_t
*connection
)
1846 gdb_service_t
*gdb_service
= connection
->service
->priv
;
1847 target_t
*target
= gdb_service
->target
;
1848 char *packet
=gdb_packet_buffer
;
1851 gdb_connection_t
*gdb_con
= connection
->priv
;
1852 static int extended_protocol
= 0;
1854 /* drain input buffer */
1857 packet_size
= GDB_BUFFER_SIZE
-1;
1858 if ((retval
= gdb_get_packet(connection
, packet
, &packet_size
)) != ERROR_OK
)
1863 /* terminate with zero */
1864 packet
[packet_size
] = 0;
1866 LOG_DEBUG("received packet: '%s'", packet
);
1868 if (packet_size
> 0)
1874 /* Hct... -- set thread
1875 * we don't have threads, send empty reply */
1876 gdb_put_packet(connection
, NULL
, 0);
1879 retval
= gdb_query_packet(connection
, target
, packet
, packet_size
);
1882 retval
= gdb_get_registers_packet(connection
, target
, packet
, packet_size
);
1885 retval
= gdb_set_registers_packet(connection
, target
, packet
, packet_size
);
1888 retval
= gdb_get_register_packet(connection
, target
, packet
, packet_size
);
1891 retval
= gdb_set_register_packet(connection
, target
, packet
, packet_size
);
1894 retval
= gdb_read_memory_packet(connection
, target
, packet
, packet_size
);
1897 retval
= gdb_write_memory_packet(connection
, target
, packet
, packet_size
);
1901 retval
= gdb_breakpoint_watchpoint_packet(connection
, target
, packet
, packet_size
);
1904 gdb_last_signal_packet(connection
, target
, packet
, packet_size
);
1909 if (target
->state
!= TARGET_HALTED
)
1911 /* If the target isn't in the halted state, then we can't
1912 * step/continue. This might be early setup, etc.
1915 snprintf(sig_reply
, 4, "T%2.2x", 2);
1916 gdb_put_packet(connection
, sig_reply
, 3);
1919 /* We're running/stepping, in which case we can
1920 * forward log output until the target is halted
1922 gdb_connection_t
*gdb_con
= connection
->priv
;
1923 gdb_con
->frontend_state
= TARGET_RUNNING
;
1924 log_add_callback(gdb_log_callback
, connection
);
1925 gdb_step_continue_packet(connection
, target
, packet
, packet_size
);
1930 retval
= gdb_v_packet(connection
, target
, packet
, packet_size
);
1933 retval
= gdb_detach(connection
, target
);
1934 extended_protocol
= 0;
1937 if ((retval
= gdb_write_memory_binary_packet(connection
, target
, packet
, packet_size
)) != ERROR_OK
)
1941 if (extended_protocol
!= 0)
1943 gdb_put_packet(connection
, "OK", 2);
1944 return ERROR_SERVER_REMOTE_CLOSED
;
1946 /* handle extended remote protocol */
1947 extended_protocol
= 1;
1948 gdb_put_packet(connection
, "OK", 2);
1951 /* handle extended restart packet */
1952 command_run_linef(connection
->cmd_ctx
, "ocd_gdb_restart %d", get_num_by_target(target
));
1955 /* ignore unkown packets */
1956 LOG_DEBUG("ignoring 0x%2.2x packet", packet
[0]);
1957 gdb_put_packet(connection
, NULL
, 0);
1961 /* if a packet handler returned an error, exit input loop */
1962 if (retval
!= ERROR_OK
)
1966 if (gdb_con
->ctrl_c
)
1968 if (target
->state
== TARGET_RUNNING
)
1970 target_halt(target
);
1971 gdb_con
->ctrl_c
= 0;
1975 } while (gdb_con
->buf_cnt
> 0);
1980 int gdb_input(connection_t
*connection
)
1982 int retval
= gdb_input_inner(connection
);
1983 gdb_connection_t
*gdb_con
= connection
->priv
;
1984 if (retval
== ERROR_SERVER_REMOTE_CLOSED
)
1987 /* logging does not propagate the error, yet can set th gdb_con->closed flag */
1988 if (gdb_con
->closed
)
1989 return ERROR_SERVER_REMOTE_CLOSED
;
1991 /* we'll recover from any other errors(e.g. temporary timeouts, etc.) */
1997 gdb_service_t
*gdb_service
;
1998 target_t
*target
= targets
;
2003 LOG_WARNING("no gdb ports allocated as no target has been specified");
2009 LOG_WARNING("no gdb port specified, using default port 3333");
2015 char service_name
[8];
2017 snprintf(service_name
, 8, "gdb-%2.2i", i
);
2019 gdb_service
= malloc(sizeof(gdb_service_t
));
2020 gdb_service
->target
= target
;
2022 add_service("gdb", CONNECTION_GDB
, gdb_port
+ i
, 1, gdb_new_connection
, gdb_input
, gdb_connection_closed
, gdb_service
);
2024 LOG_DEBUG("gdb service for target %s at port %i", target
->type
->name
, gdb_port
+ i
);
2027 target
= target
->next
;
2033 /* daemon configuration command gdb_port */
2034 int handle_gdb_port_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2039 /* only if the port wasn't overwritten by cmdline */
2041 gdb_port
= strtoul(args
[0], NULL
, 0);
2046 int handle_gdb_detach_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2050 if (strcmp(args
[0], "resume") == 0)
2052 detach_mode
= GDB_DETACH_RESUME
;
2055 else if (strcmp(args
[0], "reset") == 0)
2057 detach_mode
= GDB_DETACH_RESET
;
2060 else if (strcmp(args
[0], "halt") == 0)
2062 detach_mode
= GDB_DETACH_HALT
;
2065 else if (strcmp(args
[0], "nothing") == 0)
2067 detach_mode
= GDB_DETACH_NOTHING
;
2072 LOG_WARNING("invalid gdb_detach configuration directive: %s", args
[0]);
2076 int handle_gdb_memory_map_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2080 if (strcmp(args
[0], "enable") == 0)
2082 gdb_use_memory_map
= 1;
2085 else if (strcmp(args
[0], "disable") == 0)
2087 gdb_use_memory_map
= 0;
2092 LOG_WARNING("invalid gdb_memory_map configuration directive: %s", args
[0]);
2096 int handle_gdb_flash_program_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2100 if (strcmp(args
[0], "enable") == 0)
2102 gdb_flash_program
= 1;
2105 else if (strcmp(args
[0], "disable") == 0)
2107 gdb_flash_program
= 0;
2112 LOG_WARNING("invalid gdb_memory_map configuration directive: %s", args
[0]);
2116 int handle_gdb_report_data_abort_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2120 if (strcmp(args
[0], "enable") == 0)
2122 gdb_report_data_abort
= 1;
2125 else if (strcmp(args
[0], "disable") == 0)
2127 gdb_report_data_abort
= 0;
2132 LOG_WARNING("invalid gdb_report_data_abort configuration directive: %s", args
[0]);
2136 int gdb_register_commands(command_context_t
*command_context
)
2138 register_command(command_context
, NULL
, "gdb_port", handle_gdb_port_command
,
2139 COMMAND_CONFIG
, "");
2140 register_command(command_context
, NULL
, "gdb_detach", handle_gdb_detach_command
,
2141 COMMAND_CONFIG
, "");
2142 register_command(command_context
, NULL
, "gdb_memory_map", handle_gdb_memory_map_command
,
2143 COMMAND_CONFIG
, "");
2144 register_command(command_context
, NULL
, "gdb_flash_program", handle_gdb_flash_program_command
,
2145 COMMAND_CONFIG
, "");
2146 register_command(command_context
, NULL
, "gdb_report_data_abort", handle_gdb_report_data_abort_command
,
2147 COMMAND_CONFIG
, "");
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)