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.
294 if ((retval
=check_pending(connection
, 0, &gotdata
))!=ERROR_OK
)
298 if ((retval
= gdb_get_char(connection
, &reply
)) != ERROR_OK
)
300 LOG_WARNING("Discard unexpected char %c", reply
);
307 #ifdef _DEBUG_GDB_IO_
308 debug_buffer
= malloc(len
+ 1);
309 memcpy(debug_buffer
, buffer
, len
);
310 debug_buffer
[len
] = 0;
311 LOG_DEBUG("sending packet '$%s#%2.2x'", debug_buffer
, my_checksum
);
315 char local_buffer
[1024];
316 local_buffer
[0] = '$';
317 if (len
+4 <= sizeof(local_buffer
))
319 /* performance gain on smaller packets by only a single call to gdb_write() */
320 memcpy(local_buffer
+1, buffer
, len
++);
321 local_buffer
[len
++] = '#';
322 local_buffer
[len
++] = DIGITS
[(my_checksum
>> 4) & 0xf];
323 local_buffer
[len
++] = DIGITS
[my_checksum
& 0xf];
324 gdb_write(connection
, local_buffer
, len
);
328 /* larger packets are transmitted directly from caller supplied buffer
329 by several calls to gdb_write() to avoid dynamic allocation */
330 local_buffer
[1] = '#';
331 local_buffer
[2] = DIGITS
[(my_checksum
>> 4) & 0xf];
332 local_buffer
[3] = DIGITS
[my_checksum
& 0xf];
333 gdb_write(connection
, local_buffer
, 1);
334 gdb_write(connection
, buffer
, len
);
335 gdb_write(connection
, local_buffer
+1, 3);
338 if ((retval
= gdb_get_char(connection
, &reply
)) != ERROR_OK
)
343 else if (reply
== '-')
345 /* Stop sending output packets for now */
346 log_remove_callback(gdb_log_callback
, connection
);
347 LOG_WARNING("negative reply, retrying");
349 else if (reply
== 0x3)
352 if ((retval
= gdb_get_char(connection
, &reply
)) != ERROR_OK
)
356 else if (reply
== '-')
358 /* Stop sending output packets for now */
359 log_remove_callback(gdb_log_callback
, connection
);
360 LOG_WARNING("negative reply, retrying");
364 LOG_ERROR("unknown character 0x%2.2x in reply, dropping connection", reply
);
366 return ERROR_SERVER_REMOTE_CLOSED
;
371 LOG_ERROR("unknown character 0x%2.2x in reply, dropping connection", reply
);
373 return ERROR_SERVER_REMOTE_CLOSED
;
377 return ERROR_SERVER_REMOTE_CLOSED
;
382 int gdb_put_packet(connection_t
*connection
, char *buffer
, int len
)
384 gdb_connection_t
*gdb_con
= connection
->priv
;
386 int retval
= gdb_put_packet_inner(connection
, buffer
, len
);
391 int gdb_get_packet_inner(connection_t
*connection
, char *buffer
, int *len
)
397 unsigned char my_checksum
= 0;
398 gdb_connection_t
*gdb_con
= connection
->priv
;
404 if ((retval
= gdb_get_char(connection
, &character
)) != ERROR_OK
)
407 #ifdef _DEBUG_GDB_IO_
408 LOG_DEBUG("character: '%c'", character
);
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;
517 if ((retval
= gdb_get_char(connection
, &character
)) != ERROR_OK
)
519 checksum
[0] = character
;
520 if ((retval
= gdb_get_char(connection
, &character
)) != ERROR_OK
)
522 checksum
[1] = character
;
525 if (my_checksum
== strtoul(checksum
, NULL
, 16))
527 gdb_write(connection
, "+", 1);
531 LOG_WARNING("checksum error, requesting retransmission");
532 gdb_write(connection
, "-", 1);
535 return ERROR_SERVER_REMOTE_CLOSED
;
540 int gdb_get_packet(connection_t
*connection
, char *buffer
, int *len
)
542 gdb_connection_t
*gdb_con
= connection
->priv
;
544 int retval
= gdb_get_packet_inner(connection
, buffer
, len
);
549 int gdb_output_con(connection_t
*connection
, const char* line
)
554 bin_size
= strlen(line
);
556 hex_buffer
= malloc(bin_size
*2 + 2);
557 if (hex_buffer
== NULL
)
558 return ERROR_GDB_BUFFER_TOO_SMALL
;
561 for (i
=0; i
<bin_size
; i
++)
562 snprintf(hex_buffer
+ 1 + i
*2, 3, "%2.2x", line
[i
]);
563 hex_buffer
[bin_size
*2+1] = 0;
565 gdb_put_packet(connection
, hex_buffer
, bin_size
*2 + 1);
571 int gdb_output(struct command_context_s
*context
, const char* line
)
573 /* this will be dumped to the log and also sent as an O packet if possible */
574 LOG_USER_N("%s", line
);
578 int gdb_program_handler(struct target_s
*target
, enum target_event event
, void *priv
)
580 struct command_context_s
*cmd_ctx
= priv
;
582 target_invoke_script(cmd_ctx
, target
, "gdb_program");
583 jtag_execute_queue();
588 int gdb_target_callback_event_handler(struct target_s
*target
, enum target_event event
, void *priv
)
590 connection_t
*connection
= priv
;
591 gdb_connection_t
*gdb_connection
= connection
->priv
;
597 case TARGET_EVENT_HALTED
:
598 /* In the GDB protocol when we are stepping or coninuing execution,
599 * we have a lingering reply. Upon receiving a halted event
600 * when we have that lingering packet, we reply to the original
601 * step or continue packet.
603 * Executing monitor commands can bring the target in and
604 * out of the running state so we'll see lots of TARGET_EVENT_XXX
605 * that are to be ignored.
607 if (gdb_connection
->frontend_state
== TARGET_RUNNING
)
609 /* stop forwarding log packets! */
610 log_remove_callback(gdb_log_callback
, connection
);
612 if (gdb_connection
->ctrl_c
)
615 gdb_connection
->ctrl_c
= 0;
619 signal
= gdb_last_signal(target
);
622 snprintf(sig_reply
, 4, "T%2.2x", signal
);
623 gdb_put_packet(connection
, sig_reply
, 3);
624 gdb_connection
->frontend_state
= TARGET_HALTED
;
627 case TARGET_EVENT_GDB_PROGRAM
:
628 gdb_program_handler(target
, event
, connection
->cmd_ctx
);
638 int gdb_new_connection(connection_t
*connection
)
640 gdb_connection_t
*gdb_connection
= malloc(sizeof(gdb_connection_t
));
641 gdb_service_t
*gdb_service
= connection
->service
->priv
;
645 connection
->priv
= gdb_connection
;
647 /* initialize gdb connection information */
648 gdb_connection
->buf_p
= gdb_connection
->buffer
;
649 gdb_connection
->buf_cnt
= 0;
650 gdb_connection
->ctrl_c
= 0;
651 gdb_connection
->frontend_state
= TARGET_HALTED
;
652 gdb_connection
->vflash_image
= NULL
;
653 gdb_connection
->closed
= 0;
654 gdb_connection
->busy
= 0;
656 /* send ACK to GDB for debug request */
657 gdb_write(connection
, "+", 1);
659 /* output goes through gdb connection */
660 command_set_output_handler(connection
->cmd_ctx
, gdb_output
, connection
);
662 /* register callback to be informed about target events */
663 target_register_event_callback(gdb_target_callback_event_handler
, connection
);
665 /* a gdb session just attached, try to put the target in halt mode.
669 * If the halt fails(e.g. target needs a reset, JTAG communication not
670 * working, etc.), then the GDB connect will succeed as
671 * the get_gdb_reg_list() will lie and return a register list with
674 * This allows GDB monitor commands to be run from a GDB init script to
675 * initialize the target
677 * Also, since the halt() is asynchronous target connect will be
678 * instantaneous and thus avoiding annoying timeout problems during
681 target_halt(gdb_service
->target
);
683 /* remove the initial ACK from the incoming buffer */
684 if ((retval
= gdb_get_char(connection
, &initial_ack
)) != ERROR_OK
)
687 /* FIX!!!??? would we actually ever receive a + here???
690 if (initial_ack
!= '+')
691 gdb_putback_char(connection
, initial_ack
);
696 int gdb_connection_closed(connection_t
*connection
)
698 gdb_service_t
*gdb_service
= connection
->service
->priv
;
699 gdb_connection_t
*gdb_connection
= connection
->priv
;
701 /* see if an image built with vFlash commands is left */
702 if (gdb_connection
->vflash_image
)
704 image_close(gdb_connection
->vflash_image
);
705 free(gdb_connection
->vflash_image
);
706 gdb_connection
->vflash_image
= NULL
;
709 /* if this connection registered a debug-message receiver delete it */
710 delete_debug_msg_receiver(connection
->cmd_ctx
, gdb_service
->target
);
712 if (connection
->priv
)
714 free(connection
->priv
);
715 connection
->priv
= NULL
;
719 LOG_ERROR("BUG: connection->priv == NULL");
722 target_unregister_event_callback(gdb_target_callback_event_handler
, connection
);
723 log_remove_callback(gdb_log_callback
, connection
);
728 void gdb_send_error(connection_t
*connection
, u8 the_error
)
731 snprintf(err
, 4, "E%2.2X", the_error
);
732 gdb_put_packet(connection
, err
, 3);
735 int gdb_last_signal_packet(connection_t
*connection
, target_t
*target
, char* packet
, int packet_size
)
740 signal
= gdb_last_signal(target
);
742 snprintf(sig_reply
, 4, "S%2.2x", signal
);
743 gdb_put_packet(connection
, sig_reply
, 3);
748 /* Convert register to string of bits. NB! The # of bits in the
749 * register might be non-divisible by 8(a byte), in which
750 * case an entire byte is shown. */
751 void gdb_str_to_target(target_t
*target
, char *tstr
, reg_t
*reg
)
758 buf_len
= CEIL(reg
->size
, 8);
760 for (i
= 0; i
< buf_len
; i
++)
762 tstr
[i
*2] = DIGITS
[(buf
[i
]>>4) & 0xf];
763 tstr
[i
*2+1] = DIGITS
[buf
[i
]&0xf];
767 void gdb_target_to_str(target_t
*target
, char *tstr
, char *str
)
769 int str_len
= strlen(tstr
);
774 LOG_ERROR("BUG: gdb value with uneven number of characters encountered");
778 for (i
= 0; i
< str_len
; i
+=2)
780 str
[str_len
- i
- 1] = tstr
[i
+ 1];
781 str
[str_len
- i
- 2] = tstr
[i
];
785 int gdb_get_registers_packet(connection_t
*connection
, target_t
*target
, char* packet
, int packet_size
)
790 int reg_packet_size
= 0;
795 #ifdef _DEBUG_GDB_IO_
799 if ((retval
= target
->type
->get_gdb_reg_list(target
, ®_list
, ®_list_size
)) != ERROR_OK
)
801 return gdb_error(connection
, retval
);
804 for (i
= 0; i
< reg_list_size
; i
++)
806 reg_packet_size
+= reg_list
[i
]->size
;
809 reg_packet
= malloc(CEIL(reg_packet_size
, 8) * 2);
810 reg_packet_p
= reg_packet
;
812 for (i
= 0; i
< reg_list_size
; i
++)
814 gdb_str_to_target(target
, reg_packet_p
, reg_list
[i
]);
815 reg_packet_p
+= CEIL(reg_list
[i
]->size
, 8) * 2;
818 #ifdef _DEBUG_GDB_IO_
821 reg_packet_p
= strndup(reg_packet
, CEIL(reg_packet_size
, 8) * 2);
822 LOG_DEBUG("reg_packet: %s", reg_packet_p
);
827 gdb_put_packet(connection
, reg_packet
, CEIL(reg_packet_size
, 8) * 2);
835 int gdb_set_registers_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
843 #ifdef _DEBUG_GDB_IO_
847 /* skip command character */
853 LOG_WARNING("GDB set_registers packet with uneven characters received, dropping connection");
854 return ERROR_SERVER_REMOTE_CLOSED
;
857 if ((retval
= target
->type
->get_gdb_reg_list(target
, ®_list
, ®_list_size
)) != ERROR_OK
)
859 return gdb_error(connection
, retval
);
863 for (i
= 0; i
< reg_list_size
; i
++)
867 reg_arch_type_t
*arch_type
;
869 /* convert from GDB-string (target-endian) to hex-string (big-endian) */
870 hex_buf
= malloc(CEIL(reg_list
[i
]->size
, 8) * 2);
871 gdb_target_to_str(target
, packet_p
, hex_buf
);
873 /* convert hex-string to binary buffer */
874 bin_buf
= malloc(CEIL(reg_list
[i
]->size
, 8));
875 str_to_buf(hex_buf
, CEIL(reg_list
[i
]->size
, 8) * 2, bin_buf
, reg_list
[i
]->size
, 16);
877 /* get register arch_type, and call set method */
878 arch_type
= register_get_arch_type(reg_list
[i
]->arch_type
);
879 if (arch_type
== NULL
)
881 LOG_ERROR("BUG: encountered unregistered arch type");
884 arch_type
->set(reg_list
[i
], bin_buf
);
886 /* advance packet pointer */
887 packet_p
+= (CEIL(reg_list
[i
]->size
, 8) * 2);
893 /* free reg_t *reg_list[] array allocated by get_gdb_reg_list */
896 gdb_put_packet(connection
, "OK", 2);
901 int gdb_get_register_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
904 int reg_num
= strtoul(packet
+ 1, NULL
, 16);
909 #ifdef _DEBUG_GDB_IO_
913 if ((retval
= target
->type
->get_gdb_reg_list(target
, ®_list
, ®_list_size
)) != ERROR_OK
)
915 return gdb_error(connection
, retval
);
918 if (reg_list_size
<= reg_num
)
920 LOG_ERROR("gdb requested a non-existing register");
924 reg_packet
= malloc(CEIL(reg_list
[reg_num
]->size
, 8) * 2);
926 gdb_str_to_target(target
, reg_packet
, reg_list
[reg_num
]);
928 gdb_put_packet(connection
, reg_packet
, CEIL(reg_list
[reg_num
]->size
, 8) * 2);
936 int gdb_set_register_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
941 int reg_num
= strtoul(packet
+ 1, &separator
, 16);
945 reg_arch_type_t
*arch_type
;
949 if ((retval
= target
->type
->get_gdb_reg_list(target
, ®_list
, ®_list_size
)) != ERROR_OK
)
951 return gdb_error(connection
, retval
);
954 if (reg_list_size
< reg_num
)
956 LOG_ERROR("gdb requested a non-existing register");
957 return ERROR_SERVER_REMOTE_CLOSED
;
960 if (*separator
!= '=')
962 LOG_ERROR("GDB 'set register packet', but no '=' following the register number");
963 return ERROR_SERVER_REMOTE_CLOSED
;
966 /* convert from GDB-string (target-endian) to hex-string (big-endian) */
967 hex_buf
= malloc(CEIL(reg_list
[reg_num
]->size
, 8) * 2);
968 gdb_target_to_str(target
, separator
+ 1, hex_buf
);
970 /* convert hex-string to binary buffer */
971 bin_buf
= malloc(CEIL(reg_list
[reg_num
]->size
, 8));
972 str_to_buf(hex_buf
, CEIL(reg_list
[reg_num
]->size
, 8) * 2, bin_buf
, reg_list
[reg_num
]->size
, 16);
974 /* get register arch_type, and call set method */
975 arch_type
= register_get_arch_type(reg_list
[reg_num
]->arch_type
);
976 if (arch_type
== NULL
)
978 LOG_ERROR("BUG: encountered unregistered arch type");
981 arch_type
->set(reg_list
[reg_num
], bin_buf
);
983 gdb_put_packet(connection
, "OK", 2);
992 int gdb_error(connection_t
*connection
, int retval
)
996 case ERROR_TARGET_DATA_ABORT
:
997 gdb_send_error(connection
, EIO
);
999 case ERROR_TARGET_TRANSLATION_FAULT
:
1000 gdb_send_error(connection
, EFAULT
);
1002 case ERROR_TARGET_UNALIGNED_ACCESS
:
1003 gdb_send_error(connection
, EFAULT
);
1005 case ERROR_TARGET_NOT_HALTED
:
1006 gdb_send_error(connection
, EFAULT
);
1009 /* This could be that the target reset itself. */
1010 LOG_ERROR("unexpected error %i", retval
);
1011 gdb_send_error(connection
, EFAULT
);
1018 /* We don't have to worry about the default 2 second timeout for GDB packets,
1019 * because GDB breaks up large memory reads into smaller reads.
1021 * 8191 bytes by the looks of it. Why 8191 bytes instead of 8192?????
1023 int gdb_read_memory_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1032 int retval
= ERROR_OK
;
1034 /* skip command character */
1037 addr
= strtoul(packet
, &separator
, 16);
1039 if (*separator
!= ',')
1041 LOG_ERROR("incomplete read memory packet received, dropping connection");
1042 return ERROR_SERVER_REMOTE_CLOSED
;
1045 len
= strtoul(separator
+1, NULL
, 16);
1047 buffer
= malloc(len
);
1049 LOG_DEBUG("addr: 0x%8.8x, len: 0x%8.8x", addr
, len
);
1051 retval
= target_read_buffer(target
, addr
, len
, buffer
);
1053 if ((retval
== ERROR_TARGET_DATA_ABORT
) && (!gdb_report_data_abort
))
1055 /* TODO : Here we have to lie and send back all zero's lest stack traces won't work.
1056 * At some point this might be fixed in GDB, in which case this code can be removed.
1058 * OpenOCD developers are acutely aware of this problem, but there is nothing
1059 * gained by involving the user in this problem that hopefully will get resolved
1062 * http://sourceware.org/cgi-bin/gnatsweb.pl?cmd=view%20audit-trail&database=gdb&pr=2395
1064 * For now, the default is to fix up things to make current GDB versions work.
1065 * This can be overwritten using the gdb_report_data_abort <'enable'|'disable'> command.
1067 memset(buffer
, 0, len
);
1071 if (retval
== ERROR_OK
)
1073 hex_buffer
= malloc(len
* 2 + 1);
1076 for (i
= 0; i
< len
; i
++)
1079 hex_buffer
[2 * i
] = DIGITS
[(t
>> 4) & 0xf];
1080 hex_buffer
[2 * i
+ 1] = DIGITS
[t
& 0xf];
1083 gdb_put_packet(connection
, hex_buffer
, len
* 2);
1089 retval
= gdb_error(connection
, retval
);
1097 int gdb_write_memory_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1108 /* skip command character */
1111 addr
= strtoul(packet
, &separator
, 16);
1113 if (*separator
!= ',')
1115 LOG_ERROR("incomplete write memory packet received, dropping connection");
1116 return ERROR_SERVER_REMOTE_CLOSED
;
1119 len
= strtoul(separator
+1, &separator
, 16);
1121 if (*(separator
++) != ':')
1123 LOG_ERROR("incomplete write memory packet received, dropping connection");
1124 return ERROR_SERVER_REMOTE_CLOSED
;
1127 buffer
= malloc(len
);
1129 LOG_DEBUG("addr: 0x%8.8x, len: 0x%8.8x", addr
, len
);
1131 for (i
=0; i
<len
; i
++)
1134 sscanf(separator
+ 2*i
, "%2x", &tmp
);
1138 retval
= target_write_buffer(target
, addr
, len
, buffer
);
1140 if (retval
== ERROR_OK
)
1142 gdb_put_packet(connection
, "OK", 2);
1146 retval
= gdb_error(connection
, retval
);
1154 int gdb_write_memory_binary_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1162 /* skip command character */
1165 addr
= strtoul(packet
, &separator
, 16);
1167 if (*separator
!= ',')
1169 LOG_ERROR("incomplete write memory binary packet received, dropping connection");
1170 return ERROR_SERVER_REMOTE_CLOSED
;
1173 len
= strtoul(separator
+1, &separator
, 16);
1175 if (*(separator
++) != ':')
1177 LOG_ERROR("incomplete write memory binary packet received, dropping connection");
1178 return ERROR_SERVER_REMOTE_CLOSED
;
1184 LOG_DEBUG("addr: 0x%8.8x, len: 0x%8.8x", addr
, len
);
1186 retval
= target_write_buffer(target
, addr
, len
, (u8
*)separator
);
1189 if (retval
== ERROR_OK
)
1191 gdb_put_packet(connection
, "OK", 2);
1195 if ((retval
= gdb_error(connection
, retval
)) != ERROR_OK
)
1202 void gdb_step_continue_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1209 if (packet_size
> 1)
1211 packet
[packet_size
] = 0;
1212 address
= strtoul(packet
+ 1, NULL
, 16);
1219 if (packet
[0] == 'c')
1221 LOG_DEBUG("continue");
1222 target_invoke_script(connection
->cmd_ctx
, target
, "pre_resume");
1223 target_resume(target
, current
, address
, 0, 0); /* resume at current address, don't handle breakpoints, not debugging */
1225 else if (packet
[0] == 's')
1228 target
->type
->step(target
, current
, address
, 0); /* step at current or address, don't handle breakpoints */
1232 int gdb_breakpoint_watchpoint_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1235 enum breakpoint_type bp_type
= BKPT_SOFT
/* dummy init to avoid warning */;
1236 enum watchpoint_rw wp_type
;
1244 type
= strtoul(packet
+ 1, &separator
, 16);
1246 if (type
== 0) /* memory breakpoint */
1247 bp_type
= BKPT_SOFT
;
1248 else if (type
== 1) /* hardware breakpoint */
1249 bp_type
= BKPT_HARD
;
1250 else if (type
== 2) /* write watchpoint */
1251 wp_type
= WPT_WRITE
;
1252 else if (type
== 3) /* read watchpoint */
1254 else if (type
== 4) /* access watchpoint */
1255 wp_type
= WPT_ACCESS
;
1257 if (*separator
!= ',')
1259 LOG_ERROR("incomplete breakpoint/watchpoint packet received, dropping connection");
1260 return ERROR_SERVER_REMOTE_CLOSED
;
1263 address
= strtoul(separator
+1, &separator
, 16);
1265 if (*separator
!= ',')
1267 LOG_ERROR("incomplete breakpoint/watchpoint packet received, dropping connection");
1268 return ERROR_SERVER_REMOTE_CLOSED
;
1271 size
= strtoul(separator
+1, &separator
, 16);
1277 if (packet
[0] == 'Z')
1279 if ((retval
= breakpoint_add(target
, address
, size
, bp_type
)) != ERROR_OK
)
1281 if ((retval
= gdb_error(connection
, retval
)) != ERROR_OK
)
1286 gdb_put_packet(connection
, "OK", 2);
1291 breakpoint_remove(target
, address
);
1292 gdb_put_packet(connection
, "OK", 2);
1299 if (packet
[0] == 'Z')
1301 if ((retval
= watchpoint_add(target
, address
, size
, type
-2, 0, 0xffffffffu
)) != ERROR_OK
)
1303 if ((retval
= gdb_error(connection
, retval
)) != ERROR_OK
)
1308 gdb_put_packet(connection
, "OK", 2);
1313 watchpoint_remove(target
, address
);
1314 gdb_put_packet(connection
, "OK", 2);
1325 /* print out a string and allocate more space as needed, mainly used for XML at this point */
1326 void xml_printf(int *retval
, char **xml
, int *pos
, int *size
, const char *fmt
, ...)
1328 if (*retval
!= ERROR_OK
)
1336 if ((*xml
== NULL
) || (!first
))
1338 /* start by 0 to exercise all the code paths.
1339 * Need minimum 2 bytes to fit 1 char and 0 terminator. */
1341 *size
= *size
* 2 + 2;
1343 *xml
= realloc(*xml
, *size
);
1348 *retval
= ERROR_SERVER_REMOTE_CLOSED
;
1356 ret
= vsnprintf(*xml
+ *pos
, *size
- *pos
, fmt
, ap
);
1358 if ((ret
> 0) && ((ret
+ 1) < *size
- *pos
))
1363 /* there was just enough or not enough space, allocate more. */
1368 static int decode_xfer_read(char *buf
, char **annex
, int *ofs
, unsigned int *len
)
1372 /* Extract and NUL-terminate the annex. */
1374 while (*buf
&& *buf
!= ':')
1380 /* After the read marker and annex, qXfer looks like a
1381 * traditional 'm' packet. */
1383 *ofs
= strtoul(buf
, &separator
, 16);
1385 if (*separator
!= ',')
1388 *len
= strtoul(separator
+1, NULL
, 16);
1393 int gdb_calc_blocksize(flash_bank_t
*bank
)
1396 int block_size
= 0xffffffff;
1398 /* loop through all sectors and return smallest sector size */
1400 for (i
= 0; i
< bank
->num_sectors
; i
++)
1402 if (bank
->sectors
[i
].size
< block_size
)
1403 block_size
= bank
->sectors
[i
].size
;
1409 static int compare_bank (const void * a
, const void * b
)
1411 flash_bank_t
*b1
, *b2
;
1412 b1
=*((flash_bank_t
**)a
);
1413 b2
=*((flash_bank_t
**)b
);
1415 if (b1
->base
==b2
->base
)
1418 } else if (b1
->base
>b2
->base
)
1427 int gdb_query_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1429 command_context_t
*cmd_ctx
= connection
->cmd_ctx
;
1431 if (strstr(packet
, "qRcmd,"))
1433 if (packet_size
> 6)
1437 cmd
= malloc((packet_size
- 6)/2 + 1);
1438 for (i
=0; i
< (packet_size
- 6)/2; i
++)
1441 sscanf(packet
+ 6 + 2*i
, "%2x", &tmp
);
1444 cmd
[(packet_size
- 6)/2] = 0x0;
1446 /* We want to print all debug output to GDB connection */
1447 log_add_callback(gdb_log_callback
, connection
);
1448 target_call_timer_callbacks_now();
1449 command_run_line(cmd_ctx
, cmd
);
1450 target_call_timer_callbacks_now();
1451 log_remove_callback(gdb_log_callback
, connection
);
1454 gdb_put_packet(connection
, "OK", 2);
1457 else if (strstr(packet
, "qCRC:"))
1459 if (packet_size
> 5)
1468 /* skip command character */
1471 addr
= strtoul(packet
, &separator
, 16);
1473 if (*separator
!= ',')
1475 LOG_ERROR("incomplete read memory packet received, dropping connection");
1476 return ERROR_SERVER_REMOTE_CLOSED
;
1479 len
= strtoul(separator
+ 1, NULL
, 16);
1481 retval
= target_checksum_memory(target
, addr
, len
, &checksum
);
1483 if (retval
== ERROR_OK
)
1485 snprintf(gdb_reply
, 10, "C%8.8x", checksum
);
1486 gdb_put_packet(connection
, gdb_reply
, 9);
1490 if ((retval
= gdb_error(connection
, retval
)) != ERROR_OK
)
1497 else if (strstr(packet
, "qSupported"))
1499 /* we currently support packet size and qXfer:memory-map:read (if enabled)
1500 * disable qXfer:features:read for the moment */
1501 int retval
= ERROR_OK
;
1502 char *buffer
= NULL
;
1506 xml_printf(&retval
, &buffer
, &pos
, &size
,
1507 "PacketSize=%x;qXfer:memory-map:read%c;qXfer:features:read-",
1508 (GDB_BUFFER_SIZE
- 1), gdb_use_memory_map
== 1 ? '+' : '-');
1510 if (retval
!= ERROR_OK
)
1512 gdb_send_error(connection
, 01);
1516 gdb_put_packet(connection
, buffer
, strlen(buffer
));
1521 else if (strstr(packet
, "qXfer:memory-map:read::"))
1523 /* We get away with only specifying flash here. Regions that are not
1524 * specified are treated as if we provided no memory map(if not we
1525 * could detect the holes and mark them as RAM).
1526 * Normally we only execute this code once, but no big deal if we
1527 * have to regenerate it a couple of times. */
1533 int retval
= ERROR_OK
;
1540 /* skip command character */
1543 offset
= strtoul(packet
, &separator
, 16);
1544 length
= strtoul(separator
+ 1, &separator
, 16);
1546 xml_printf(&retval
, &xml
, &pos
, &size
, "<memory-map>\n");
1549 sort banks in ascending order, we need to make non-flash memory be ram(or rather
1550 read/write) by default for GDB.
1551 GDB does not have a concept of non-cacheable read/write memory.
1553 flash_bank_t
**banks
=malloc(sizeof(flash_bank_t
*)*flash_get_bank_count());
1556 for (i
=0; i
<flash_get_bank_count(); i
++)
1558 p
= get_flash_bank_by_num(i
);
1562 retval
= ERROR_FAIL
;
1563 gdb_send_error(connection
, retval
);
1569 qsort(banks
, flash_get_bank_count(), sizeof(flash_bank_t
*), compare_bank
);
1572 for (i
=0; i
<flash_get_bank_count(); i
++)
1576 if (ram_start
<p
->base
)
1578 xml_printf(&retval
, &xml
, &pos
, &size
, "<memory type=\"ram\" start=\"0x%x\" length=\"0x%x\"/>\n",
1579 ram_start
, p
->base
-ram_start
);
1582 /* if device has uneven sector sizes, eg. str7, lpc
1583 * we pass the smallest sector size to gdb memory map */
1584 blocksize
= gdb_calc_blocksize(p
);
1586 xml_printf(&retval
, &xml
, &pos
, &size
, "<memory type=\"flash\" start=\"0x%x\" length=\"0x%x\">\n" \
1587 "<property name=\"blocksize\">0x%x</property>\n" \
1589 p
->base
, p
->size
, blocksize
);
1590 ram_start
=p
->base
+p
->size
;
1594 xml_printf(&retval
, &xml
, &pos
, &size
, "<memory type=\"ram\" start=\"0x%x\" length=\"0x%x\"/>\n",
1595 ram_start
, 0-ram_start
);
1598 /* a flash chip could be at the very end of the 32 bit address space, in which case
1599 ram_start will be precisely 0 */
1605 xml_printf(&retval
, &xml
, &pos
, &size
, "</memory-map>\n");
1607 if (retval
!= ERROR_OK
)
1609 gdb_send_error(connection
, retval
);
1613 if (offset
+ length
> pos
)
1615 length
= pos
- offset
;
1618 char *t
= malloc(length
+ 1);
1620 memcpy(t
+ 1, xml
+ offset
, length
);
1621 gdb_put_packet(connection
, t
, length
+ 1);
1627 else if (strstr(packet
, "qXfer:features:read:"))
1632 int retval
= ERROR_OK
;
1635 unsigned int length
;
1638 /* skip command character */
1641 if (decode_xfer_read(packet
, &annex
, &offset
, &length
) < 0)
1643 gdb_send_error(connection
, 01);
1647 if (strcmp(annex
, "target.xml") != 0)
1649 gdb_send_error(connection
, 01);
1653 xml_printf(&retval
, &xml
, &pos
, &size
, \
1654 "l<target version=\"1.0\">\n<architecture>arm</architecture>\n</target>\n");
1656 if (retval
!= ERROR_OK
)
1658 gdb_send_error(connection
, retval
);
1662 gdb_put_packet(connection
, xml
, strlen(xml
));
1668 gdb_put_packet(connection
, "", 0);
1672 int gdb_v_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1674 gdb_connection_t
*gdb_connection
= connection
->priv
;
1675 gdb_service_t
*gdb_service
= connection
->service
->priv
;
1678 /* if flash programming disabled - send a empty reply */
1680 if (gdb_flash_program
== 0)
1682 gdb_put_packet(connection
, "", 0);
1686 if (strstr(packet
, "vFlashErase:"))
1689 unsigned long length
;
1691 char *parse
= packet
+ 12;
1694 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1695 return ERROR_SERVER_REMOTE_CLOSED
;
1698 addr
= strtoul(parse
, &parse
, 16);
1700 if (*(parse
++) != ',' || *parse
== '\0')
1702 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1703 return ERROR_SERVER_REMOTE_CLOSED
;
1706 length
= strtoul(parse
, &parse
, 16);
1710 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1711 return ERROR_SERVER_REMOTE_CLOSED
;
1714 /* assume all sectors need erasing - stops any problems
1715 * when flash_write is called multiple times */
1718 /* perform any target specific operations before the erase */
1719 target_call_event_callbacks(gdb_service
->target
, TARGET_EVENT_GDB_PROGRAM
);
1722 if ((result
= flash_erase_address_range(gdb_service
->target
, addr
, length
)) != ERROR_OK
)
1724 /* GDB doesn't evaluate the actual error number returned,
1725 * treat a failed erase as an I/O error
1727 gdb_send_error(connection
, EIO
);
1728 LOG_ERROR("flash_erase returned %i", result
);
1731 gdb_put_packet(connection
, "OK", 2);
1736 if (strstr(packet
, "vFlashWrite:"))
1739 unsigned long length
;
1740 char *parse
= packet
+ 12;
1744 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1745 return ERROR_SERVER_REMOTE_CLOSED
;
1747 addr
= strtoul(parse
, &parse
, 16);
1748 if (*(parse
++) != ':')
1750 LOG_ERROR("incomplete vFlashErase packet received, dropping connection");
1751 return ERROR_SERVER_REMOTE_CLOSED
;
1753 length
= packet_size
- (parse
- packet
);
1755 /* create a new image if there isn't already one */
1756 if (gdb_connection
->vflash_image
== NULL
)
1758 gdb_connection
->vflash_image
= malloc(sizeof(image_t
));
1759 image_open(gdb_connection
->vflash_image
, "", "build");
1762 /* create new section with content from packet buffer */
1763 image_add_section(gdb_connection
->vflash_image
, addr
, length
, 0x0, (u8
*)parse
);
1765 gdb_put_packet(connection
, "OK", 2);
1770 if (!strcmp(packet
, "vFlashDone"))
1774 /* process the flashing buffer. No need to erase as GDB
1775 * always issues a vFlashErase first. */
1776 if ((result
= flash_write(gdb_service
->target
, gdb_connection
->vflash_image
, &written
, 0)) != ERROR_OK
)
1778 if (result
== ERROR_FLASH_DST_OUT_OF_BANK
)
1779 gdb_put_packet(connection
, "E.memtype", 9);
1781 gdb_send_error(connection
, EIO
);
1785 LOG_DEBUG("wrote %u bytes from vFlash image to flash", written
);
1786 gdb_put_packet(connection
, "OK", 2);
1789 image_close(gdb_connection
->vflash_image
);
1790 free(gdb_connection
->vflash_image
);
1791 gdb_connection
->vflash_image
= NULL
;
1796 gdb_put_packet(connection
, "", 0);
1800 int gdb_detach(connection_t
*connection
, target_t
*target
)
1802 switch( detach_mode
)
1804 case GDB_DETACH_RESUME
:
1805 target_invoke_script(connection
->cmd_ctx
, target
, "pre_resume");
1806 target_resume(target
, 1, 0, 1, 0);
1809 case GDB_DETACH_RESET
:
1810 /* FIX?? make this configurable?? */
1811 target_process_reset(connection
->cmd_ctx
, RESET_HALT
);
1814 case GDB_DETACH_HALT
:
1815 target_halt(target
);
1818 case GDB_DETACH_NOTHING
:
1822 gdb_put_packet(connection
, "OK", 2);
1827 static void gdb_log_callback(void *priv
, const char *file
, int line
,
1828 const char *function
, const char *string
)
1830 connection_t
*connection
= priv
;
1831 gdb_connection_t
*gdb_con
= connection
->priv
;
1835 /* do not reply this using the O packet */
1839 gdb_output_con(connection
, string
);
1842 /* Do not allocate this on the stack */
1843 char gdb_packet_buffer
[GDB_BUFFER_SIZE
];
1845 int gdb_input_inner(connection_t
*connection
)
1847 gdb_service_t
*gdb_service
= connection
->service
->priv
;
1848 target_t
*target
= gdb_service
->target
;
1849 char *packet
=gdb_packet_buffer
;
1852 gdb_connection_t
*gdb_con
= connection
->priv
;
1853 static int extended_protocol
= 0;
1855 /* drain input buffer */
1858 packet_size
= GDB_BUFFER_SIZE
-1;
1859 if ((retval
= gdb_get_packet(connection
, packet
, &packet_size
)) != ERROR_OK
)
1864 /* terminate with zero */
1865 packet
[packet_size
] = 0;
1867 LOG_DEBUG("received packet: '%s'", packet
);
1869 if (packet_size
> 0)
1875 /* Hct... -- set thread
1876 * we don't have threads, send empty reply */
1877 gdb_put_packet(connection
, NULL
, 0);
1880 retval
= gdb_query_packet(connection
, target
, packet
, packet_size
);
1883 retval
= gdb_get_registers_packet(connection
, target
, packet
, packet_size
);
1886 retval
= gdb_set_registers_packet(connection
, target
, packet
, packet_size
);
1889 retval
= gdb_get_register_packet(connection
, target
, packet
, packet_size
);
1892 retval
= gdb_set_register_packet(connection
, target
, packet
, packet_size
);
1895 retval
= gdb_read_memory_packet(connection
, target
, packet
, packet_size
);
1898 retval
= gdb_write_memory_packet(connection
, target
, packet
, packet_size
);
1902 retval
= gdb_breakpoint_watchpoint_packet(connection
, target
, packet
, packet_size
);
1905 gdb_last_signal_packet(connection
, target
, packet
, packet_size
);
1910 if (target
->state
!= TARGET_HALTED
)
1912 /* If the target isn't in the halted state, then we can't
1913 * step/continue. This might be early setup, etc.
1916 snprintf(sig_reply
, 4, "T%2.2x", 2);
1917 gdb_put_packet(connection
, sig_reply
, 3);
1920 /* We're running/stepping, in which case we can
1921 * forward log output until the target is halted
1923 gdb_connection_t
*gdb_con
= connection
->priv
;
1924 gdb_con
->frontend_state
= TARGET_RUNNING
;
1925 log_add_callback(gdb_log_callback
, connection
);
1926 gdb_step_continue_packet(connection
, target
, packet
, packet_size
);
1931 retval
= gdb_v_packet(connection
, target
, packet
, packet_size
);
1934 retval
= gdb_detach(connection
, target
);
1935 extended_protocol
= 0;
1938 if ((retval
= gdb_write_memory_binary_packet(connection
, target
, packet
, packet_size
)) != ERROR_OK
)
1942 if (extended_protocol
!= 0)
1944 gdb_put_packet(connection
, "OK", 2);
1945 return ERROR_SERVER_REMOTE_CLOSED
;
1947 /* handle extended remote protocol */
1948 extended_protocol
= 1;
1949 gdb_put_packet(connection
, "OK", 2);
1952 /* handle extended restart packet */
1953 command_run_linef(connection
->cmd_ctx
, "gdb_restart");
1956 /* ignore unkown packets */
1957 LOG_DEBUG("ignoring 0x%2.2x packet", packet
[0]);
1958 gdb_put_packet(connection
, NULL
, 0);
1962 /* if a packet handler returned an error, exit input loop */
1963 if (retval
!= ERROR_OK
)
1967 if (gdb_con
->ctrl_c
)
1969 if (target
->state
== TARGET_RUNNING
)
1971 target_halt(target
);
1972 gdb_con
->ctrl_c
= 0;
1976 } while (gdb_con
->buf_cnt
> 0);
1981 int gdb_input(connection_t
*connection
)
1983 int retval
= gdb_input_inner(connection
);
1984 gdb_connection_t
*gdb_con
= connection
->priv
;
1985 if (retval
== ERROR_SERVER_REMOTE_CLOSED
)
1988 /* logging does not propagate the error, yet can set th gdb_con->closed flag */
1989 if (gdb_con
->closed
)
1990 return ERROR_SERVER_REMOTE_CLOSED
;
1992 /* we'll recover from any other errors(e.g. temporary timeouts, etc.) */
1998 gdb_service_t
*gdb_service
;
1999 target_t
*target
= targets
;
2004 LOG_WARNING("no gdb ports allocated as no target has been specified");
2010 LOG_WARNING("no gdb port specified, using default port 3333");
2016 char service_name
[8];
2018 snprintf(service_name
, 8, "gdb-%2.2i", i
);
2020 gdb_service
= malloc(sizeof(gdb_service_t
));
2021 gdb_service
->target
= target
;
2023 add_service("gdb", CONNECTION_GDB
, gdb_port
+ i
, 1, gdb_new_connection
, gdb_input
, gdb_connection_closed
, gdb_service
);
2025 LOG_DEBUG("gdb service for target %s at port %i", target
->type
->name
, gdb_port
+ i
);
2028 target
= target
->next
;
2034 /* daemon configuration command gdb_port */
2035 int handle_gdb_port_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2040 /* only if the port wasn't overwritten by cmdline */
2042 gdb_port
= strtoul(args
[0], NULL
, 0);
2047 int handle_gdb_detach_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2051 if (strcmp(args
[0], "resume") == 0)
2053 detach_mode
= GDB_DETACH_RESUME
;
2056 else if (strcmp(args
[0], "reset") == 0)
2058 detach_mode
= GDB_DETACH_RESET
;
2061 else if (strcmp(args
[0], "halt") == 0)
2063 detach_mode
= GDB_DETACH_HALT
;
2066 else if (strcmp(args
[0], "nothing") == 0)
2068 detach_mode
= GDB_DETACH_NOTHING
;
2073 LOG_WARNING("invalid gdb_detach configuration directive: %s", args
[0]);
2077 int handle_gdb_memory_map_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2081 if (strcmp(args
[0], "enable") == 0)
2083 gdb_use_memory_map
= 1;
2086 else if (strcmp(args
[0], "disable") == 0)
2088 gdb_use_memory_map
= 0;
2093 LOG_WARNING("invalid gdb_memory_map configuration directive: %s", args
[0]);
2097 int handle_gdb_flash_program_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2101 if (strcmp(args
[0], "enable") == 0)
2103 gdb_flash_program
= 1;
2106 else if (strcmp(args
[0], "disable") == 0)
2108 gdb_flash_program
= 0;
2113 LOG_WARNING("invalid gdb_memory_map configuration directive: %s", args
[0]);
2117 int handle_gdb_report_data_abort_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2121 if (strcmp(args
[0], "enable") == 0)
2123 gdb_report_data_abort
= 1;
2126 else if (strcmp(args
[0], "disable") == 0)
2128 gdb_report_data_abort
= 0;
2133 LOG_WARNING("invalid gdb_report_data_abort configuration directive: %s", args
[0]);
2137 int gdb_register_commands(command_context_t
*command_context
)
2139 register_command(command_context
, NULL
, "gdb_port", handle_gdb_port_command
,
2140 COMMAND_CONFIG
, "");
2141 register_command(command_context
, NULL
, "gdb_detach", handle_gdb_detach_command
,
2142 COMMAND_CONFIG
, "");
2143 register_command(command_context
, NULL
, "gdb_memory_map", handle_gdb_memory_map_command
,
2144 COMMAND_CONFIG
, "");
2145 register_command(command_context
, NULL
, "gdb_flash_program", handle_gdb_flash_program_command
,
2146 COMMAND_CONFIG
, "");
2147 register_command(command_context
, NULL
, "gdb_report_data_abort", handle_gdb_report_data_abort_command
,
2148 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)