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_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 ? '+' : '-');
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::"))
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_resume(target
, 1, 0, 1, 0);
1807 case GDB_DETACH_RESET
:
1808 target_process_reset(connection
->cmd_ctx
);
1811 case GDB_DETACH_HALT
:
1812 target_halt(target
);
1815 case GDB_DETACH_NOTHING
:
1819 gdb_put_packet(connection
, "OK", 2);
1824 static void gdb_log_callback(void *priv
, const char *file
, int line
,
1825 const char *function
, const char *string
)
1827 connection_t
*connection
= priv
;
1828 gdb_connection_t
*gdb_con
= connection
->priv
;
1832 /* do not reply this using the O packet */
1836 gdb_output_con(connection
, string
);
1839 /* Do not allocate this on the stack */
1840 char gdb_packet_buffer
[GDB_BUFFER_SIZE
];
1842 int gdb_input_inner(connection_t
*connection
)
1844 gdb_service_t
*gdb_service
= connection
->service
->priv
;
1845 target_t
*target
= gdb_service
->target
;
1846 char *packet
=gdb_packet_buffer
;
1849 gdb_connection_t
*gdb_con
= connection
->priv
;
1850 static int extended_protocol
= 0;
1852 /* drain input buffer */
1855 packet_size
= GDB_BUFFER_SIZE
-1;
1856 if ((retval
= gdb_get_packet(connection
, packet
, &packet_size
)) != ERROR_OK
)
1861 /* terminate with zero */
1862 packet
[packet_size
] = 0;
1864 LOG_DEBUG("received packet: '%s'", packet
);
1866 if (packet_size
> 0)
1872 /* Hct... -- set thread
1873 * we don't have threads, send empty reply */
1874 gdb_put_packet(connection
, NULL
, 0);
1877 retval
= gdb_query_packet(connection
, target
, packet
, packet_size
);
1880 retval
= gdb_get_registers_packet(connection
, target
, packet
, packet_size
);
1883 retval
= gdb_set_registers_packet(connection
, target
, packet
, packet_size
);
1886 retval
= gdb_get_register_packet(connection
, target
, packet
, packet_size
);
1889 retval
= gdb_set_register_packet(connection
, target
, packet
, packet_size
);
1892 retval
= gdb_read_memory_packet(connection
, target
, packet
, packet_size
);
1895 retval
= gdb_write_memory_packet(connection
, target
, packet
, packet_size
);
1899 retval
= gdb_breakpoint_watchpoint_packet(connection
, target
, packet
, packet_size
);
1902 gdb_last_signal_packet(connection
, target
, packet
, packet_size
);
1907 if (target
->state
!= TARGET_HALTED
)
1909 /* If the target isn't in the halted state, then we can't
1910 * step/continue. This might be early setup, etc.
1913 snprintf(sig_reply
, 4, "T%2.2x", 2);
1914 gdb_put_packet(connection
, sig_reply
, 3);
1917 /* We're running/stepping, in which case we can
1918 * forward log output until the target is halted
1920 gdb_connection_t
*gdb_con
= connection
->priv
;
1921 gdb_con
->frontend_state
= TARGET_RUNNING
;
1922 log_add_callback(gdb_log_callback
, connection
);
1923 gdb_step_continue_packet(connection
, target
, packet
, packet_size
);
1928 retval
= gdb_v_packet(connection
, target
, packet
, packet_size
);
1931 retval
= gdb_detach(connection
, target
);
1932 extended_protocol
= 0;
1935 if ((retval
= gdb_write_memory_binary_packet(connection
, target
, packet
, packet_size
)) != ERROR_OK
)
1939 if (extended_protocol
!= 0)
1941 gdb_put_packet(connection
, "OK", 2);
1942 return ERROR_SERVER_REMOTE_CLOSED
;
1944 /* handle extended remote protocol */
1945 extended_protocol
= 1;
1946 gdb_put_packet(connection
, "OK", 2);
1949 /* handle extended restart packet */
1950 target_process_reset(connection
->cmd_ctx
);
1953 /* ignore unkown packets */
1954 LOG_DEBUG("ignoring 0x%2.2x packet", packet
[0]);
1955 gdb_put_packet(connection
, NULL
, 0);
1959 /* if a packet handler returned an error, exit input loop */
1960 if (retval
!= ERROR_OK
)
1964 if (gdb_con
->ctrl_c
)
1966 if (target
->state
== TARGET_RUNNING
)
1968 target_halt(target
);
1969 gdb_con
->ctrl_c
= 0;
1973 } while (gdb_con
->buf_cnt
> 0);
1978 int gdb_input(connection_t
*connection
)
1980 int retval
= gdb_input_inner(connection
);
1981 gdb_connection_t
*gdb_con
= connection
->priv
;
1982 if (retval
== ERROR_SERVER_REMOTE_CLOSED
)
1985 /* logging does not propagate the error, yet can set th gdb_con->closed flag */
1986 if (gdb_con
->closed
)
1987 return ERROR_SERVER_REMOTE_CLOSED
;
1989 /* we'll recover from any other errors(e.g. temporary timeouts, etc.) */
1995 gdb_service_t
*gdb_service
;
1996 target_t
*target
= targets
;
2001 LOG_WARNING("no gdb ports allocated as no target has been specified");
2007 LOG_WARNING("no gdb port specified, using default port 3333");
2013 char service_name
[8];
2015 snprintf(service_name
, 8, "gdb-%2.2i", i
);
2017 gdb_service
= malloc(sizeof(gdb_service_t
));
2018 gdb_service
->target
= target
;
2020 add_service("gdb", CONNECTION_GDB
, gdb_port
+ i
, 1, gdb_new_connection
, gdb_input
, gdb_connection_closed
, gdb_service
);
2022 LOG_DEBUG("gdb service for target %s at port %i", target
->type
->name
, gdb_port
+ i
);
2025 target
= target
->next
;
2031 /* daemon configuration command gdb_port */
2032 int handle_gdb_port_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2037 /* only if the port wasn't overwritten by cmdline */
2039 gdb_port
= strtoul(args
[0], NULL
, 0);
2044 int handle_gdb_detach_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2048 if (strcmp(args
[0], "resume") == 0)
2050 detach_mode
= GDB_DETACH_RESUME
;
2053 else if (strcmp(args
[0], "reset") == 0)
2055 detach_mode
= GDB_DETACH_RESET
;
2058 else if (strcmp(args
[0], "halt") == 0)
2060 detach_mode
= GDB_DETACH_HALT
;
2063 else if (strcmp(args
[0], "nothing") == 0)
2065 detach_mode
= GDB_DETACH_NOTHING
;
2070 LOG_WARNING("invalid gdb_detach configuration directive: %s", args
[0]);
2074 int handle_gdb_memory_map_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2078 if (strcmp(args
[0], "enable") == 0)
2080 gdb_use_memory_map
= 1;
2083 else if (strcmp(args
[0], "disable") == 0)
2085 gdb_use_memory_map
= 0;
2090 LOG_WARNING("invalid gdb_memory_map configuration directive: %s", args
[0]);
2094 int handle_gdb_flash_program_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2098 if (strcmp(args
[0], "enable") == 0)
2100 gdb_flash_program
= 1;
2103 else if (strcmp(args
[0], "disable") == 0)
2105 gdb_flash_program
= 0;
2110 LOG_WARNING("invalid gdb_memory_map configuration directive: %s", args
[0]);
2114 int handle_gdb_report_data_abort_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2118 if (strcmp(args
[0], "enable") == 0)
2120 gdb_report_data_abort
= 1;
2123 else if (strcmp(args
[0], "disable") == 0)
2125 gdb_report_data_abort
= 0;
2130 LOG_WARNING("invalid gdb_report_data_abort configuration directive: %s", args
[0]);
2134 int gdb_register_commands(command_context_t
*command_context
)
2136 register_command(command_context
, NULL
, "gdb_port", handle_gdb_port_command
,
2137 COMMAND_CONFIG
, "");
2138 register_command(command_context
, NULL
, "gdb_detach", handle_gdb_detach_command
,
2139 COMMAND_CONFIG
, "");
2140 register_command(command_context
, NULL
, "gdb_memory_map", handle_gdb_memory_map_command
,
2141 COMMAND_CONFIG
, "");
2142 register_command(command_context
, NULL
, "gdb_flash_program", handle_gdb_flash_program_command
,
2143 COMMAND_CONFIG
, "");
2144 register_command(command_context
, NULL
, "gdb_report_data_abort", handle_gdb_report_data_abort_command
,
2145 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)