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 static unsigned short gdb_port
;
47 static const char *DIGITS
= "0123456789abcdef";
49 static void gdb_log_callback(void *priv
, const char *file
, int line
,
50 const char *function
, const char *format
, va_list args
);
60 /* target behaviour on gdb detach */
61 enum gdb_detach_mode detach_mode
= GDB_DETACH_RESUME
;
63 /* set if we are sending a memory map to gdb
64 * via qXfer:memory-map:read packet */
65 int gdb_use_memory_map
= 0;
66 int gdb_flash_program
= 0;
68 /* if set, data aborts cause an error to be reported in memory read packets
69 * see the code in gdb_read_memory_packet() for further explanations */
70 int gdb_report_data_abort
= 0;
72 int gdb_last_signal(target_t
*target
)
74 switch (target
->debug_reason
)
76 case DBG_REASON_DBGRQ
:
77 return 0x2; /* SIGINT */
78 case DBG_REASON_BREAKPOINT
:
79 case DBG_REASON_WATCHPOINT
:
80 case DBG_REASON_WPTANDBKPT
:
81 return 0x05; /* SIGTRAP */
82 case DBG_REASON_SINGLESTEP
:
83 return 0x05; /* SIGTRAP */
84 case DBG_REASON_NOTHALTED
:
85 return 0x0; /* no signal... shouldn't happen */
87 ERROR("BUG: undefined debug reason");
92 int gdb_get_char(connection_t
*connection
, int* next_char
)
94 gdb_connection_t
*gdb_con
= connection
->priv
;
100 if (gdb_con
->buf_cnt
-- > 0)
102 *next_char
= *(gdb_con
->buf_p
++);
103 if (gdb_con
->buf_cnt
> 0)
104 connection
->input_pending
= 1;
106 connection
->input_pending
= 0;
108 #ifdef _DEBUG_GDB_IO_
109 DEBUG("returned char '%c' (0x%2.2x)", *next_char
, *next_char
);
118 /* a non-blocking socket will block if there is 0 bytes available on the socket,
119 * but return with as many bytes as are available immediately
125 FD_SET(connection
->fd
, &read_fds
);
129 if (select(connection
->fd
+ 1, &read_fds
, NULL
, NULL
, &tv
) == 0)
131 /* This can typically be because a "monitor" command took too long
132 * before printing any progress messages
134 return ERROR_GDB_TIMEOUT
;
137 gdb_con
->buf_cnt
= read_socket(connection
->fd
, gdb_con
->buffer
, GDB_BUFFER_SIZE
);
138 if (gdb_con
->buf_cnt
> 0)
142 if (gdb_con
->buf_cnt
== 0)
145 return ERROR_SERVER_REMOTE_CLOSED
;
149 errno
= WSAGetLastError();
156 case WSAECONNABORTED
:
157 return ERROR_SERVER_REMOTE_CLOSED
;
159 return ERROR_SERVER_REMOTE_CLOSED
;
161 ERROR("read: %d", errno
);
171 return ERROR_SERVER_REMOTE_CLOSED
;
173 return ERROR_SERVER_REMOTE_CLOSED
;
175 ERROR("read: %s", strerror(errno
));
176 return ERROR_SERVER_REMOTE_CLOSED
;
181 #ifdef _DEBUG_GDB_IO_
182 debug_buffer
= malloc(gdb_con
->buf_cnt
+ 1);
183 memcpy(debug_buffer
, gdb_con
->buffer
, gdb_con
->buf_cnt
);
184 debug_buffer
[gdb_con
->buf_cnt
] = 0;
185 DEBUG("received '%s'", debug_buffer
);
189 gdb_con
->buf_p
= gdb_con
->buffer
;
191 *next_char
= *(gdb_con
->buf_p
++);
192 if (gdb_con
->buf_cnt
> 0)
193 connection
->input_pending
= 1;
195 connection
->input_pending
= 0;
196 #ifdef _DEBUG_GDB_IO_
197 DEBUG("returned char '%c' (0x%2.2x)", *next_char
, *next_char
);
203 int gdb_putback_char(connection_t
*connection
, int last_char
)
205 gdb_connection_t
*gdb_con
= connection
->priv
;
207 if (gdb_con
->buf_p
> gdb_con
->buffer
)
209 *(--gdb_con
->buf_p
) = last_char
;
214 ERROR("BUG: couldn't put character back");
220 /* The only way we can detect that the socket is closed is the first time
221 * we write to it, we will fail. Subsequent write operations will
222 * succeed. Shudder! */
223 int gdb_write(connection_t
*connection
, void *data
, int len
)
225 gdb_connection_t
*gdb_con
= connection
->priv
;
227 return ERROR_SERVER_REMOTE_CLOSED
;
229 if (write_socket(connection
->fd
, data
, len
) == len
)
234 return ERROR_SERVER_REMOTE_CLOSED
;
237 int gdb_put_packet_inner(connection_t
*connection
, char *buffer
, int len
)
240 unsigned char my_checksum
= 0;
241 #ifdef _DEBUG_GDB_IO_
246 gdb_connection_t
*gdb_con
= connection
->priv
;
248 for (i
= 0; i
< len
; i
++)
249 my_checksum
+= buffer
[i
];
253 #ifdef _DEBUG_GDB_IO_
254 debug_buffer
= malloc(len
+ 1);
255 memcpy(debug_buffer
, buffer
, len
);
256 debug_buffer
[len
] = 0;
257 DEBUG("sending packet '$%s#%2.2x'", debug_buffer
, my_checksum
);
262 gdb_write(connection
, "$", 1);
264 gdb_write(connection
, buffer
, len
);
265 gdb_write(connection
, "#", 1);
267 snprintf(checksum
, 3, "%2.2x", my_checksum
);
269 gdb_write(connection
, checksum
, 2);
271 void *allocated
= NULL
;
272 char stackAlloc
[1024];
273 char *t
= stackAlloc
;
274 int totalLen
= 1 + len
+ 1 + 2;
275 if (totalLen
> sizeof(stackAlloc
))
277 allocated
= malloc(totalLen
);
279 if (allocated
== NULL
)
281 ERROR("Ran out of memory trying to reply packet %d\n", totalLen
);
286 memcpy(t
+ 1, buffer
, len
);
288 t
[1 + len
+ 1] = DIGITS
[(my_checksum
>> 4) & 0xf];
289 t
[1 + len
+ 2] = DIGITS
[my_checksum
& 0xf];
291 gdb_write(connection
, t
, totalLen
);
298 if ((retval
= gdb_get_char(connection
, &reply
)) != ERROR_OK
)
303 else if (reply
== '-')
305 /* Stop sending output packets for now */
306 log_setCallback(NULL
, NULL
);
307 WARNING("negative reply, retrying");
309 else if (reply
== 0x3)
312 if ((retval
= gdb_get_char(connection
, &reply
)) != ERROR_OK
)
316 else if (reply
== '-')
318 /* Stop sending output packets for now */
319 log_setCallback(NULL
, NULL
);
320 WARNING("negative reply, retrying");
324 ERROR("unknown character 0x%2.2x in reply, dropping connection", reply
);
325 return ERROR_SERVER_REMOTE_CLOSED
;
330 ERROR("unknown character 0x%2.2x in reply, dropping connection", reply
);
331 return ERROR_SERVER_REMOTE_CLOSED
;
335 return ERROR_SERVER_REMOTE_CLOSED
;
340 int gdb_put_packet(connection_t
*connection
, char *buffer
, int len
)
342 gdb_connection_t
*gdb_con
= connection
->priv
;
344 int retval
= gdb_put_packet_inner(connection
, buffer
, len
);
349 int gdb_get_packet_inner(connection_t
*connection
, char *buffer
, int *len
)
355 unsigned char my_checksum
= 0;
356 gdb_connection_t
*gdb_con
= connection
->priv
;
362 if ((retval
= gdb_get_char(connection
, &character
)) != ERROR_OK
)
365 #ifdef _DEBUG_GDB_IO_
366 DEBUG("character: '%c'", character
);
374 WARNING("acknowledgment received, but no packet pending");
377 WARNING("negative acknowledgment, but no packet pending");
384 WARNING("ignoring character 0x%x", character
);
387 } while (character
!= '$');
392 gdb_connection_t
*gdb_con
= connection
->priv
;
395 /* The common case is that we have an entire packet with no escape chars.
396 * We need to leave at least 2 bytes in the buffer to have
397 * gdb_get_char() update various bits and bobs correctly.
399 if ((gdb_con
->buf_cnt
> 2) && ((gdb_con
->buf_cnt
+count
) < *len
))
401 /* The compiler will struggle a bit with constant propagation and
402 * aliasing, so we help it by showing that these values do not
403 * change inside the loop
406 char *buf
= gdb_con
->buf_p
;
407 int run
= gdb_con
->buf_cnt
- 2;
414 if (character
== '#')
416 /* Danger! character can be '#' when esc is
417 * used so we need an explicit boolean for done here.
423 if (character
== '}')
425 /* data transmitted in binary mode (X packet)
426 * uses 0x7d as escape character */
427 my_checksum
+= character
& 0xff;
430 my_checksum
+= character
& 0xff;
431 buffer
[count
++] = (character
^ 0x20) & 0xff;
434 my_checksum
+= character
& 0xff;
435 buffer
[count
++] = character
& 0xff;
439 gdb_con
->buf_cnt
-= i
;
445 ERROR("packet buffer too small");
446 return ERROR_GDB_BUFFER_TOO_SMALL
;
449 if ((retval
= gdb_get_char(connection
, &character
)) != ERROR_OK
)
452 if (character
== '#')
455 if (character
== '}')
457 /* data transmitted in binary mode (X packet)
458 * uses 0x7d as escape character */
459 my_checksum
+= character
& 0xff;
460 if ((retval
= gdb_get_char(connection
, &character
)) != ERROR_OK
)
462 my_checksum
+= character
& 0xff;
463 buffer
[count
++] = (character
^ 0x20) & 0xff;
467 my_checksum
+= character
& 0xff;
468 buffer
[count
++] = character
& 0xff;
475 if ((retval
= gdb_get_char(connection
, &character
)) != ERROR_OK
)
477 checksum
[0] = character
;
478 if ((retval
= gdb_get_char(connection
, &character
)) != ERROR_OK
)
480 checksum
[1] = character
;
483 if (my_checksum
== strtoul(checksum
, NULL
, 16))
485 gdb_write(connection
, "+", 1);
489 WARNING("checksum error, requesting retransmission");
490 gdb_write(connection
, "-", 1);
493 return ERROR_SERVER_REMOTE_CLOSED
;
498 int gdb_get_packet(connection_t
*connection
, char *buffer
, int *len
)
500 gdb_connection_t
*gdb_con
= connection
->priv
;
502 int retval
= gdb_get_packet_inner(connection
, buffer
, len
);
507 int gdb_output_con(connection_t
*connection
, char* line
)
512 bin_size
= strlen(line
);
514 hex_buffer
= malloc(bin_size
*2 + 4);
517 for (i
=0; i
<bin_size
; i
++)
518 snprintf(hex_buffer
+ 1 + i
*2, 3, "%2.2x", line
[i
]);
519 hex_buffer
[bin_size
*2+1] = '0';
520 hex_buffer
[bin_size
*2+2] = 'a';
521 hex_buffer
[bin_size
*2+3] = 0x0;
523 gdb_put_packet(connection
, hex_buffer
, bin_size
*2 + 3);
529 int gdb_output(struct command_context_s
*context
, char* line
)
531 /* this will be dumped to the log and also sent as an O packet if possible */
536 int gdb_program_handler(struct target_s
*target
, enum target_event event
, void *priv
)
539 struct command_context_s
*cmd_ctx
= priv
;
541 if (target
->gdb_program_script
)
543 script
= open_file_from_path(cmd_ctx
, target
->gdb_program_script
, "r");
546 ERROR("couldn't open script file %s", target
->gdb_program_script
);
550 INFO("executing gdb_program script '%s'", target
->gdb_program_script
);
551 command_run_file(cmd_ctx
, script
, COMMAND_EXEC
);
554 jtag_execute_queue();
560 int gdb_target_callback_event_handler(struct target_s
*target
, enum target_event event
, void *priv
)
562 connection_t
*connection
= priv
;
563 gdb_connection_t
*gdb_connection
= connection
->priv
;
569 case TARGET_EVENT_HALTED
:
570 /* In the GDB protocol when we are stepping or coninuing execution,
571 * we have a lingering reply. Upon receiving a halted event
572 * when we have that lingering packet, we reply to the original
573 * step or continue packet.
575 * Executing monitor commands can bring the target in and
576 * out of the running state so we'll see lots of TARGET_EVENT_XXX
577 * that are to be ignored.
579 if (gdb_connection
->frontend_state
== TARGET_RUNNING
)
581 /* stop forwarding log packets! */
582 log_setCallback(NULL
, NULL
);
584 if (gdb_connection
->ctrl_c
)
587 gdb_connection
->ctrl_c
= 0;
591 signal
= gdb_last_signal(target
);
594 snprintf(sig_reply
, 4, "T%2.2x", signal
);
595 gdb_put_packet(connection
, sig_reply
, 3);
596 gdb_connection
->frontend_state
= TARGET_HALTED
;
599 case TARGET_EVENT_GDB_PROGRAM
:
600 gdb_program_handler(target
, event
, connection
->cmd_ctx
);
609 int gdb_new_connection(connection_t
*connection
)
611 gdb_connection_t
*gdb_connection
= malloc(sizeof(gdb_connection_t
));
612 gdb_service_t
*gdb_service
= connection
->service
->priv
;
616 connection
->priv
= gdb_connection
;
618 /* initialize gdb connection information */
619 gdb_connection
->buf_p
= gdb_connection
->buffer
;
620 gdb_connection
->buf_cnt
= 0;
621 gdb_connection
->ctrl_c
= 0;
622 gdb_connection
->frontend_state
= TARGET_HALTED
;
623 gdb_connection
->vflash_image
= NULL
;
624 gdb_connection
->closed
= 0;
625 gdb_connection
->busy
= 0;
627 /* output goes through gdb connection */
628 command_set_output_handler(connection
->cmd_ctx
, gdb_output
, connection
);
630 /* register callback to be informed about target events */
631 target_register_event_callback(gdb_target_callback_event_handler
, connection
);
633 /* a gdb session just attached, put the target in halt mode */
634 if (((retval
= gdb_service
->target
->type
->halt(gdb_service
->target
)) != ERROR_OK
) &&
635 (retval
!= ERROR_TARGET_ALREADY_HALTED
))
637 ERROR("error(%d) when trying to halt target, falling back to \"reset halt\"", retval
);
638 command_run_line(connection
->cmd_ctx
, "reset halt");
641 /* This will time out after 1 second */
642 command_run_line(connection
->cmd_ctx
, "wait_halt 1");
644 /* remove the initial ACK from the incoming buffer */
645 if ((retval
= gdb_get_char(connection
, &initial_ack
)) != ERROR_OK
)
648 if (initial_ack
!= '+')
649 gdb_putback_char(connection
, initial_ack
);
654 int gdb_connection_closed(connection_t
*connection
)
656 gdb_service_t
*gdb_service
= connection
->service
->priv
;
657 gdb_connection_t
*gdb_connection
= connection
->priv
;
659 /* see if an image built with vFlash commands is left */
660 if (gdb_connection
->vflash_image
)
662 image_close(gdb_connection
->vflash_image
);
663 free(gdb_connection
->vflash_image
);
664 gdb_connection
->vflash_image
= NULL
;
667 /* if this connection registered a debug-message receiver delete it */
668 delete_debug_msg_receiver(connection
->cmd_ctx
, gdb_service
->target
);
670 if (connection
->priv
)
672 free(connection
->priv
);
673 connection
->priv
= NULL
;
677 ERROR("BUG: connection->priv == NULL");
680 target_unregister_event_callback(gdb_target_callback_event_handler
, connection
);
681 log_setCallback(NULL
, NULL
);
686 void gdb_send_error(connection_t
*connection
, u8 the_error
)
689 snprintf(err
, 4, "E%2.2X", the_error
);
690 gdb_put_packet(connection
, err
, 3);
693 int gdb_last_signal_packet(connection_t
*connection
, target_t
*target
, char* packet
, int packet_size
)
698 signal
= gdb_last_signal(target
);
700 snprintf(sig_reply
, 4, "S%2.2x", signal
);
701 gdb_put_packet(connection
, sig_reply
, 3);
706 /* Convert register to string of bits. NB! The # of bits in the
707 * register might be non-divisible by 8(a byte), in which
708 * case an entire byte is shown. */
709 void gdb_str_to_target(target_t
*target
, char *tstr
, reg_t
*reg
)
716 buf_len
= CEIL(reg
->size
, 8);
718 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
720 for (i
= 0; i
< buf_len
; i
++)
722 tstr
[i
*2] = DIGITS
[(buf
[i
]>>4) & 0xf];
723 tstr
[i
*2+1] = DIGITS
[buf
[i
]&0xf];
728 for (i
= 0; i
< buf_len
; i
++)
730 tstr
[(buf_len
-1-i
)*2] = DIGITS
[(buf
[i
]>>4)&0xf];
731 tstr
[(buf_len
-1-i
)*2+1] = DIGITS
[buf
[i
]&0xf];
736 void gdb_target_to_str(target_t
*target
, char *tstr
, char *str
)
738 int str_len
= strlen(tstr
);
743 ERROR("BUG: gdb value with uneven number of characters encountered");
747 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
749 for (i
= 0; i
< str_len
; i
+=2)
751 str
[str_len
- i
- 1] = tstr
[i
+ 1];
752 str
[str_len
- i
- 2] = tstr
[i
];
757 for (i
= 0; i
< str_len
; i
++)
764 int gdb_get_registers_packet(connection_t
*connection
, target_t
*target
, char* packet
, int packet_size
)
769 int reg_packet_size
= 0;
774 #ifdef _DEBUG_GDB_IO_
778 if ((retval
= target
->type
->get_gdb_reg_list(target
, ®_list
, ®_list_size
)) != ERROR_OK
)
782 case ERROR_TARGET_NOT_HALTED
:
783 ERROR("gdb requested registers but we're not halted, dropping connection");
784 return ERROR_SERVER_REMOTE_CLOSED
;
786 /* this is a bug condition - get_gdb_reg_list() may not return any other error */
787 ERROR("BUG: unexpected error returned by get_gdb_reg_list()");
792 for (i
= 0; i
< reg_list_size
; i
++)
794 reg_packet_size
+= reg_list
[i
]->size
;
797 reg_packet
= malloc(CEIL(reg_packet_size
, 8) * 2);
798 reg_packet_p
= reg_packet
;
800 for (i
= 0; i
< reg_list_size
; i
++)
802 gdb_str_to_target(target
, reg_packet_p
, reg_list
[i
]);
803 reg_packet_p
+= CEIL(reg_list
[i
]->size
, 8) * 2;
806 #ifdef _DEBUG_GDB_IO_
809 reg_packet_p
= strndup(reg_packet
, CEIL(reg_packet_size
, 8) * 2);
810 DEBUG("reg_packet: %s", reg_packet_p
);
815 gdb_put_packet(connection
, reg_packet
, CEIL(reg_packet_size
, 8) * 2);
823 int gdb_set_registers_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
831 #ifdef _DEBUG_GDB_IO_
835 /* skip command character */
841 WARNING("GDB set_registers packet with uneven characters received, dropping connection");
842 return ERROR_SERVER_REMOTE_CLOSED
;
845 if ((retval
= target
->type
->get_gdb_reg_list(target
, ®_list
, ®_list_size
)) != ERROR_OK
)
849 case ERROR_TARGET_NOT_HALTED
:
850 ERROR("gdb tried to registers but we're not halted, dropping connection");
851 return ERROR_SERVER_REMOTE_CLOSED
;
853 /* this is a bug condition - get_gdb_reg_list() may not return any other error */
854 ERROR("BUG: unexpected error returned by get_gdb_reg_list()");
860 for (i
= 0; i
< reg_list_size
; i
++)
864 reg_arch_type_t
*arch_type
;
866 /* convert from GDB-string (target-endian) to hex-string (big-endian) */
867 hex_buf
= malloc(CEIL(reg_list
[i
]->size
, 8) * 2);
868 gdb_target_to_str(target
, packet_p
, hex_buf
);
870 /* convert hex-string to binary buffer */
871 bin_buf
= malloc(CEIL(reg_list
[i
]->size
, 8));
872 str_to_buf(hex_buf
, CEIL(reg_list
[i
]->size
, 8) * 2, bin_buf
, reg_list
[i
]->size
, 16);
874 /* get register arch_type, and call set method */
875 arch_type
= register_get_arch_type(reg_list
[i
]->arch_type
);
876 if (arch_type
== NULL
)
878 ERROR("BUG: encountered unregistered arch type");
881 arch_type
->set(reg_list
[i
], bin_buf
);
883 /* advance packet pointer */
884 packet_p
+= (CEIL(reg_list
[i
]->size
, 8) * 2);
890 /* free reg_t *reg_list[] array allocated by get_gdb_reg_list */
893 gdb_put_packet(connection
, "OK", 2);
898 int gdb_get_register_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
901 int reg_num
= strtoul(packet
+ 1, NULL
, 16);
906 #ifdef _DEBUG_GDB_IO_
910 if ((retval
= target
->type
->get_gdb_reg_list(target
, ®_list
, ®_list_size
)) != ERROR_OK
)
914 case ERROR_TARGET_NOT_HALTED
:
915 ERROR("gdb requested registers but we're not halted, dropping connection");
916 return ERROR_SERVER_REMOTE_CLOSED
;
918 /* this is a bug condition - get_gdb_reg_list() may not return any other error */
919 ERROR("BUG: unexpected error returned by get_gdb_reg_list()");
924 if (reg_list_size
<= reg_num
)
926 ERROR("gdb requested a non-existing register");
930 reg_packet
= malloc(CEIL(reg_list
[reg_num
]->size
, 8) * 2);
932 gdb_str_to_target(target
, reg_packet
, reg_list
[reg_num
]);
934 gdb_put_packet(connection
, reg_packet
, CEIL(reg_list
[reg_num
]->size
, 8) * 2);
942 int gdb_set_register_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
947 int reg_num
= strtoul(packet
+ 1, &separator
, 16);
951 reg_arch_type_t
*arch_type
;
955 if ((retval
= target
->type
->get_gdb_reg_list(target
, ®_list
, ®_list_size
)) != ERROR_OK
)
959 case ERROR_TARGET_NOT_HALTED
:
960 ERROR("gdb tried to set a register but we're not halted, dropping connection");
961 return ERROR_SERVER_REMOTE_CLOSED
;
963 /* this is a bug condition - get_gdb_reg_list() may not return any other error */
964 ERROR("BUG: unexpected error returned by get_gdb_reg_list()");
969 if (reg_list_size
< reg_num
)
971 ERROR("gdb requested a non-existing register");
972 return ERROR_SERVER_REMOTE_CLOSED
;
975 if (*separator
!= '=')
977 ERROR("GDB 'set register packet', but no '=' following the register number");
978 return ERROR_SERVER_REMOTE_CLOSED
;
981 /* convert from GDB-string (target-endian) to hex-string (big-endian) */
982 hex_buf
= malloc(CEIL(reg_list
[reg_num
]->size
, 8) * 2);
983 gdb_target_to_str(target
, separator
+ 1, hex_buf
);
985 /* convert hex-string to binary buffer */
986 bin_buf
= malloc(CEIL(reg_list
[reg_num
]->size
, 8));
987 str_to_buf(hex_buf
, CEIL(reg_list
[reg_num
]->size
, 8) * 2, bin_buf
, reg_list
[reg_num
]->size
, 16);
989 /* get register arch_type, and call set method */
990 arch_type
= register_get_arch_type(reg_list
[reg_num
]->arch_type
);
991 if (arch_type
== NULL
)
993 ERROR("BUG: encountered unregistered arch type");
996 arch_type
->set(reg_list
[reg_num
], bin_buf
);
998 gdb_put_packet(connection
, "OK", 2);
1007 int gdb_memory_packet_error(connection_t
*connection
, int retval
)
1011 case ERROR_TARGET_NOT_HALTED
:
1012 ERROR("gdb tried to read memory but we're not halted, dropping connection");
1013 return ERROR_SERVER_REMOTE_CLOSED
;
1014 case ERROR_TARGET_DATA_ABORT
:
1015 gdb_send_error(connection
, EIO
);
1017 case ERROR_TARGET_TRANSLATION_FAULT
:
1018 gdb_send_error(connection
, EFAULT
);
1020 case ERROR_TARGET_UNALIGNED_ACCESS
:
1021 gdb_send_error(connection
, EFAULT
);
1024 /* This could be that the target reset itself. */
1025 ERROR("unexpected error %i. Dropping connection.", retval
);
1026 return ERROR_SERVER_REMOTE_CLOSED
;
1032 /* We don't have to worry about the default 2 second timeout for GDB packets,
1033 * because GDB breaks up large memory reads into smaller reads.
1035 * 8191 bytes by the looks of it. Why 8191 bytes instead of 8192?????
1037 int gdb_read_memory_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1046 int retval
= ERROR_OK
;
1048 /* skip command character */
1051 addr
= strtoul(packet
, &separator
, 16);
1053 if (*separator
!= ',')
1055 ERROR("incomplete read memory packet received, dropping connection");
1056 return ERROR_SERVER_REMOTE_CLOSED
;
1059 len
= strtoul(separator
+1, NULL
, 16);
1061 buffer
= malloc(len
);
1063 DEBUG("addr: 0x%8.8x, len: 0x%8.8x", addr
, len
);
1065 retval
= target_read_buffer(target
, addr
, len
, buffer
);
1067 if ((retval
== ERROR_TARGET_DATA_ABORT
) && (!gdb_report_data_abort
))
1069 /* TODO : Here we have to lie and send back all zero's lest stack traces won't work.
1070 * At some point this might be fixed in GDB, in which case this code can be removed.
1072 * OpenOCD developers are acutely aware of this problem, but there is nothing
1073 * gained by involving the user in this problem that hopefully will get resolved
1076 * http://sourceware.org/cgi-bin/gnatsweb.pl?cmd=view%20audit-trail&database=gdb&pr=2395
1078 * For now, the default is to fix up things to make current GDB versions work.
1079 * This can be overwritten using the gdb_report_data_abort <'enable'|'disable'> command.
1081 memset(buffer
, 0, len
);
1085 if (retval
== ERROR_OK
)
1087 hex_buffer
= malloc(len
* 2 + 1);
1090 for (i
= 0; i
< len
; i
++)
1093 hex_buffer
[2 * i
] = DIGITS
[(t
>> 4) & 0xf];
1094 hex_buffer
[2 * i
+ 1] = DIGITS
[t
& 0xf];
1097 gdb_put_packet(connection
, hex_buffer
, len
* 2);
1103 retval
= gdb_memory_packet_error(connection
, retval
);
1111 int gdb_write_memory_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1122 /* skip command character */
1125 addr
= strtoul(packet
, &separator
, 16);
1127 if (*separator
!= ',')
1129 ERROR("incomplete write memory packet received, dropping connection");
1130 return ERROR_SERVER_REMOTE_CLOSED
;
1133 len
= strtoul(separator
+1, &separator
, 16);
1135 if (*(separator
++) != ':')
1137 ERROR("incomplete write memory packet received, dropping connection");
1138 return ERROR_SERVER_REMOTE_CLOSED
;
1141 buffer
= malloc(len
);
1143 DEBUG("addr: 0x%8.8x, len: 0x%8.8x", addr
, len
);
1145 for (i
=0; i
<len
; i
++)
1148 sscanf(separator
+ 2*i
, "%2x", &tmp
);
1152 retval
= target_write_buffer(target
, addr
, len
, buffer
);
1154 if (retval
== ERROR_OK
)
1156 gdb_put_packet(connection
, "OK", 2);
1160 if ((retval
= gdb_memory_packet_error(connection
, retval
)) != ERROR_OK
)
1169 int gdb_write_memory_binary_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1177 /* skip command character */
1180 addr
= strtoul(packet
, &separator
, 16);
1182 if (*separator
!= ',')
1184 ERROR("incomplete write memory binary packet received, dropping connection");
1185 return ERROR_SERVER_REMOTE_CLOSED
;
1188 len
= strtoul(separator
+1, &separator
, 16);
1190 if (*(separator
++) != ':')
1192 ERROR("incomplete write memory binary packet received, dropping connection");
1193 return ERROR_SERVER_REMOTE_CLOSED
;
1199 DEBUG("addr: 0x%8.8x, len: 0x%8.8x", addr
, len
);
1201 retval
= target_write_buffer(target
, addr
, len
, (u8
*)separator
);
1204 if (retval
== ERROR_OK
)
1206 gdb_put_packet(connection
, "OK", 2);
1210 if ((retval
= gdb_memory_packet_error(connection
, retval
)) != ERROR_OK
)
1217 void gdb_step_continue_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1224 if (packet_size
> 1)
1226 packet
[packet_size
] = 0;
1227 address
= strtoul(packet
+ 1, NULL
, 16);
1234 if (packet
[0] == 'c')
1237 target
->type
->resume(target
, current
, address
, 0, 0); /* resume at current address, don't handle breakpoints, not debugging */
1239 else if (packet
[0] == 's')
1242 target
->type
->step(target
, current
, address
, 0); /* step at current or address, don't handle breakpoints */
1246 int gdb_bp_wp_packet_error(connection_t
*connection
, int retval
)
1250 case ERROR_TARGET_NOT_HALTED
:
1251 ERROR("gdb tried to set a breakpoint but we're not halted, dropping connection");
1252 return ERROR_SERVER_REMOTE_CLOSED
;
1254 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE
:
1255 gdb_send_error(connection
, EBUSY
);
1258 ERROR("BUG: unexpected error %i", retval
);
1265 int gdb_breakpoint_watchpoint_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1268 enum breakpoint_type bp_type
= BKPT_SOFT
/* dummy init to avoid warning */;
1269 enum watchpoint_rw wp_type
;
1277 type
= strtoul(packet
+ 1, &separator
, 16);
1279 if (type
== 0) /* memory breakpoint */
1280 bp_type
= BKPT_SOFT
;
1281 else if (type
== 1) /* hardware breakpoint */
1282 bp_type
= BKPT_HARD
;
1283 else if (type
== 2) /* write watchpoint */
1284 wp_type
= WPT_WRITE
;
1285 else if (type
== 3) /* read watchpoint */
1287 else if (type
== 4) /* access watchpoint */
1288 wp_type
= WPT_ACCESS
;
1290 if (*separator
!= ',')
1292 ERROR("incomplete breakpoint/watchpoint packet received, dropping connection");
1293 return ERROR_SERVER_REMOTE_CLOSED
;
1296 address
= strtoul(separator
+1, &separator
, 16);
1298 if (*separator
!= ',')
1300 ERROR("incomplete breakpoint/watchpoint packet received, dropping connection");
1301 return ERROR_SERVER_REMOTE_CLOSED
;
1304 size
= strtoul(separator
+1, &separator
, 16);
1310 if (packet
[0] == 'Z')
1312 if ((retval
= breakpoint_add(target
, address
, size
, bp_type
)) != ERROR_OK
)
1314 if ((retval
= gdb_bp_wp_packet_error(connection
, retval
)) != ERROR_OK
)
1319 gdb_put_packet(connection
, "OK", 2);
1324 breakpoint_remove(target
, address
);
1325 gdb_put_packet(connection
, "OK", 2);
1332 if (packet
[0] == 'Z')
1334 if ((retval
= watchpoint_add(target
, address
, size
, type
-2, 0, 0xffffffffu
)) != ERROR_OK
)
1336 if ((retval
= gdb_bp_wp_packet_error(connection
, retval
)) != ERROR_OK
)
1341 gdb_put_packet(connection
, "OK", 2);
1346 watchpoint_remove(target
, address
);
1347 gdb_put_packet(connection
, "OK", 2);
1358 /* print out a string and allocate more space as needed, mainly used for XML at this point */
1359 void xml_printf(int *retval
, char **xml
, int *pos
, int *size
, const char *fmt
, ...)
1361 if (*retval
!= ERROR_OK
)
1369 if ((*xml
== NULL
) || (!first
))
1371 /* start by 0 to exercise all the code paths.
1372 * Need minimum 2 bytes to fit 1 char and 0 terminator. */
1374 *size
= *size
* 2 + 2;
1376 *xml
= realloc(*xml
, *size
);
1381 *retval
= ERROR_SERVER_REMOTE_CLOSED
;
1389 ret
= vsnprintf(*xml
+ *pos
, *size
- *pos
, fmt
, ap
);
1391 if ((ret
> 0) && ((ret
+ 1) < *size
- *pos
))
1396 /* there was just enough or not enough space, allocate more. */
1401 static int decode_xfer_read(char *buf
, char **annex
, int *ofs
, unsigned int *len
)
1405 /* Extract and NUL-terminate the annex. */
1407 while (*buf
&& *buf
!= ':')
1413 /* After the read marker and annex, qXfer looks like a
1414 * traditional 'm' packet. */
1416 *ofs
= strtoul(buf
, &separator
, 16);
1418 if (*separator
!= ',')
1421 *len
= strtoul(separator
+1, NULL
, 16);
1426 int gdb_calc_blocksize(flash_bank_t
*bank
)
1429 int block_size
= 0xffffffff;
1431 /* loop through all sectors and return smallest sector size */
1433 for (i
= 0; i
< bank
->num_sectors
; i
++)
1435 if (bank
->sectors
[i
].size
< block_size
)
1436 block_size
= bank
->sectors
[i
].size
;
1442 int gdb_query_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1444 command_context_t
*cmd_ctx
= connection
->cmd_ctx
;
1446 if (strstr(packet
, "qRcmd,"))
1448 if (packet_size
> 6)
1452 cmd
= malloc((packet_size
- 6)/2 + 1);
1453 for (i
=0; i
< (packet_size
- 6)/2; i
++)
1456 sscanf(packet
+ 6 + 2*i
, "%2x", &tmp
);
1459 cmd
[(packet_size
- 6)/2] = 0x0;
1461 /* We want to print all debug output to GDB connection */
1462 log_setCallback(gdb_log_callback
, connection
);
1463 target_call_timer_callbacks();
1464 command_run_line(cmd_ctx
, cmd
);
1467 gdb_put_packet(connection
, "OK", 2);
1470 else if (strstr(packet
, "qCRC:"))
1472 if (packet_size
> 5)
1481 /* skip command character */
1484 addr
= strtoul(packet
, &separator
, 16);
1486 if (*separator
!= ',')
1488 ERROR("incomplete read memory packet received, dropping connection");
1489 return ERROR_SERVER_REMOTE_CLOSED
;
1492 len
= strtoul(separator
+ 1, NULL
, 16);
1494 retval
= target_checksum_memory(target
, addr
, len
, &checksum
);
1496 if (retval
== ERROR_OK
)
1498 snprintf(gdb_reply
, 10, "C%8.8x", checksum
);
1499 gdb_put_packet(connection
, gdb_reply
, 9);
1503 if ((retval
= gdb_memory_packet_error(connection
, retval
)) != ERROR_OK
)
1510 else if (strstr(packet
, "qSupported"))
1512 /* we currently support packet size and qXfer:memory-map:read (if enabled)
1513 * disable qXfer:features:read for the moment */
1514 int retval
= ERROR_OK
;
1515 char *buffer
= NULL
;
1519 xml_printf(&retval
, &buffer
, &pos
, &size
,
1520 "PacketSize=%x;qXfer:memory-map:read%c;qXfer:features:read-",
1521 (GDB_BUFFER_SIZE
- 1), gdb_use_memory_map
== 1 ? '+' : '-');
1523 if (retval
!= ERROR_OK
)
1525 gdb_send_error(connection
, 01);
1529 gdb_put_packet(connection
, buffer
, strlen(buffer
));
1534 else if (strstr(packet
, "qXfer:memory-map:read::"))
1536 /* We get away with only specifying flash here. Regions that are not
1537 * specified are treated as if we provided no memory map(if not we
1538 * could detect the holes and mark them as RAM).
1539 * Normally we only execute this code once, but no big deal if we
1540 * have to regenerate it a couple of times. */
1546 int retval
= ERROR_OK
;
1553 /* skip command character */
1556 offset
= strtoul(packet
, &separator
, 16);
1557 length
= strtoul(separator
+ 1, &separator
, 16);
1559 xml_printf(&retval
, &xml
, &pos
, &size
, "<memory-map>\n");
1564 p
= get_flash_bank_by_num(i
);
1568 /* if device has uneven sector sizes, eg. str7, lpc
1569 * we pass the smallest sector size to gdb memory map */
1570 blocksize
= gdb_calc_blocksize(p
);
1572 xml_printf(&retval
, &xml
, &pos
, &size
, "<memory type=\"flash\" start=\"0x%x\" length=\"0x%x\">\n" \
1573 "<property name=\"blocksize\">0x%x</property>\n" \
1575 p
->base
, p
->size
, blocksize
);
1579 xml_printf(&retval
, &xml
, &pos
, &size
, "</memory-map>\n");
1581 if (retval
!= ERROR_OK
)
1583 gdb_send_error(connection
, retval
);
1587 if (offset
+ length
> pos
)
1589 length
= pos
- offset
;
1592 char *t
= malloc(length
+ 1);
1594 memcpy(t
+ 1, xml
+ offset
, length
);
1595 gdb_put_packet(connection
, t
, length
+ 1);
1601 else if (strstr(packet
, "qXfer:features:read:"))
1606 int retval
= ERROR_OK
;
1609 unsigned int length
;
1612 /* skip command character */
1615 if (decode_xfer_read(packet
, &annex
, &offset
, &length
) < 0)
1617 gdb_send_error(connection
, 01);
1621 if (strcmp(annex
, "target.xml") != 0)
1623 gdb_send_error(connection
, 01);
1627 xml_printf(&retval
, &xml
, &pos
, &size
, \
1628 "l<target version=\"1.0\">\n<architecture>arm</architecture>\n</target>\n");
1630 if (retval
!= ERROR_OK
)
1632 gdb_send_error(connection
, retval
);
1636 gdb_put_packet(connection
, xml
, strlen(xml
) + 1);
1642 gdb_put_packet(connection
, "", 0);
1646 int gdb_v_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1648 gdb_connection_t
*gdb_connection
= connection
->priv
;
1649 gdb_service_t
*gdb_service
= connection
->service
->priv
;
1652 /* if flash programming disabled - send a empty reply */
1654 if (gdb_flash_program
== 0)
1656 gdb_put_packet(connection
, "", 0);
1660 if (strstr(packet
, "vFlashErase:"))
1663 unsigned long length
;
1665 char *parse
= packet
+ 12;
1668 ERROR("incomplete vFlashErase packet received, dropping connection");
1669 return ERROR_SERVER_REMOTE_CLOSED
;
1672 addr
= strtoul(parse
, &parse
, 16);
1674 if (*(parse
++) != ',' || *parse
== '\0')
1676 ERROR("incomplete vFlashErase packet received, dropping connection");
1677 return ERROR_SERVER_REMOTE_CLOSED
;
1680 length
= strtoul(parse
, &parse
, 16);
1684 ERROR("incomplete vFlashErase packet received, dropping connection");
1685 return ERROR_SERVER_REMOTE_CLOSED
;
1688 /* assume all sectors need erasing - stops any problems
1689 * when flash_write is called multiple times */
1692 /* perform any target specific operations before the erase */
1693 target_call_event_callbacks(gdb_service
->target
, TARGET_EVENT_GDB_PROGRAM
);
1696 if ((result
= flash_erase_address_range(gdb_service
->target
, addr
, length
)) != ERROR_OK
)
1698 /* GDB doesn't evaluate the actual error number returned,
1699 * treat a failed erase as an I/O error
1701 gdb_send_error(connection
, EIO
);
1702 ERROR("flash_erase returned %i", result
);
1705 gdb_put_packet(connection
, "OK", 2);
1710 if (strstr(packet
, "vFlashWrite:"))
1713 unsigned long length
;
1714 char *parse
= packet
+ 12;
1718 ERROR("incomplete vFlashErase packet received, dropping connection");
1719 return ERROR_SERVER_REMOTE_CLOSED
;
1721 addr
= strtoul(parse
, &parse
, 16);
1722 if (*(parse
++) != ':')
1724 ERROR("incomplete vFlashErase packet received, dropping connection");
1725 return ERROR_SERVER_REMOTE_CLOSED
;
1727 length
= packet_size
- (parse
- packet
);
1729 /* create a new image if there isn't already one */
1730 if (gdb_connection
->vflash_image
== NULL
)
1732 gdb_connection
->vflash_image
= malloc(sizeof(image_t
));
1733 image_open(gdb_connection
->vflash_image
, "", "build");
1736 /* create new section with content from packet buffer */
1737 image_add_section(gdb_connection
->vflash_image
, addr
, length
, 0x0, (u8
*)parse
);
1739 gdb_put_packet(connection
, "OK", 2);
1744 if (!strcmp(packet
, "vFlashDone"))
1748 /* process the flashing buffer. No need to erase as GDB
1749 * always issues a vFlashErase first. */
1750 if ((result
= flash_write(gdb_service
->target
, gdb_connection
->vflash_image
, &written
, 0)) != ERROR_OK
)
1752 if (result
== ERROR_FLASH_DST_OUT_OF_BANK
)
1753 gdb_put_packet(connection
, "E.memtype", 9);
1755 gdb_send_error(connection
, EIO
);
1759 DEBUG("wrote %u bytes from vFlash image to flash", written
);
1760 gdb_put_packet(connection
, "OK", 2);
1763 image_close(gdb_connection
->vflash_image
);
1764 free(gdb_connection
->vflash_image
);
1765 gdb_connection
->vflash_image
= NULL
;
1770 gdb_put_packet(connection
, "", 0);
1774 int gdb_detach(connection_t
*connection
, target_t
*target
)
1776 switch( detach_mode
)
1778 case GDB_DETACH_RESUME
:
1779 target
->type
->resume(target
, 1, 0, 1, 0);
1782 case GDB_DETACH_RESET
:
1783 target_process_reset(connection
->cmd_ctx
);
1786 case GDB_DETACH_HALT
:
1787 target
->type
->halt(target
);
1790 case GDB_DETACH_NOTHING
:
1794 gdb_put_packet(connection
, "OK", 2);
1799 static void gdb_log_callback(void *priv
, const char *file
, int line
,
1800 const char *function
, const char *format
, va_list args
)
1802 connection_t
*connection
= priv
;
1803 gdb_connection_t
*gdb_con
= connection
->priv
;
1807 /* do not reply this using the O packet */
1811 char *t
= allocPrintf(format
, args
);
1815 gdb_output_con(connection
, t
);
1820 int gdb_input_inner(connection_t
*connection
)
1822 gdb_service_t
*gdb_service
= connection
->service
->priv
;
1823 target_t
*target
= gdb_service
->target
;
1824 char packet
[GDB_BUFFER_SIZE
];
1827 gdb_connection_t
*gdb_con
= connection
->priv
;
1828 static int extended_protocol
= 0;
1830 /* drain input buffer */
1833 packet_size
= GDB_BUFFER_SIZE
-1;
1834 if ((retval
= gdb_get_packet(connection
, packet
, &packet_size
)) != ERROR_OK
)
1839 /* terminate with zero */
1840 packet
[packet_size
] = 0;
1842 DEBUG("received packet: '%s'", packet
);
1844 if (packet_size
> 0)
1850 /* Hct... -- set thread
1851 * we don't have threads, send empty reply */
1852 gdb_put_packet(connection
, NULL
, 0);
1855 retval
= gdb_query_packet(connection
, target
, packet
, packet_size
);
1858 retval
= gdb_get_registers_packet(connection
, target
, packet
, packet_size
);
1861 retval
= gdb_set_registers_packet(connection
, target
, packet
, packet_size
);
1864 retval
= gdb_get_register_packet(connection
, target
, packet
, packet_size
);
1867 retval
= gdb_set_register_packet(connection
, target
, packet
, packet_size
);
1870 retval
= gdb_read_memory_packet(connection
, target
, packet
, packet_size
);
1873 retval
= gdb_write_memory_packet(connection
, target
, packet
, packet_size
);
1877 retval
= gdb_breakpoint_watchpoint_packet(connection
, target
, packet
, packet_size
);
1880 gdb_last_signal_packet(connection
, target
, packet
, packet_size
);
1885 /* We're running/stepping, in which case we can
1886 * forward log output until the target is halted */
1887 gdb_connection_t
*gdb_con
= connection
->priv
;
1888 gdb_con
->frontend_state
= TARGET_RUNNING
;
1889 log_setCallback(gdb_log_callback
, connection
);
1890 gdb_step_continue_packet(connection
, target
, packet
, packet_size
);
1894 retval
= gdb_v_packet(connection
, target
, packet
, packet_size
);
1897 retval
= gdb_detach(connection
, target
);
1898 extended_protocol
= 0;
1901 if ((retval
= gdb_write_memory_binary_packet(connection
, target
, packet
, packet_size
)) != ERROR_OK
)
1905 if (extended_protocol
!= 0)
1907 gdb_put_packet(connection
, "OK", 2);
1908 return ERROR_SERVER_REMOTE_CLOSED
;
1910 /* handle extended remote protocol */
1911 extended_protocol
= 1;
1912 gdb_put_packet(connection
, "OK", 2);
1915 /* handle extended restart packet */
1916 target_process_reset(connection
->cmd_ctx
);
1919 /* ignore unkown packets */
1920 DEBUG("ignoring 0x%2.2x packet", packet
[0]);
1921 gdb_put_packet(connection
, NULL
, 0);
1925 /* if a packet handler returned an error, exit input loop */
1926 if (retval
!= ERROR_OK
)
1930 if (gdb_con
->ctrl_c
)
1932 if (target
->state
== TARGET_RUNNING
)
1934 target
->type
->halt(target
);
1935 gdb_con
->ctrl_c
= 0;
1939 } while (gdb_con
->buf_cnt
> 0);
1944 int gdb_input(connection_t
*connection
)
1946 int retval
= gdb_input_inner(connection
);
1947 if (retval
== ERROR_SERVER_REMOTE_CLOSED
)
1949 /* we'll recover from any other errors(e.g. temporary timeouts, etc.) */
1955 gdb_service_t
*gdb_service
;
1956 target_t
*target
= targets
;
1961 WARNING("no gdb ports allocated as no target has been specified");
1967 WARNING("no gdb port specified, using default port 3333");
1973 char service_name
[8];
1975 snprintf(service_name
, 8, "gdb-%2.2i", i
);
1977 gdb_service
= malloc(sizeof(gdb_service_t
));
1978 gdb_service
->target
= target
;
1980 add_service("gdb", CONNECTION_GDB
, gdb_port
+ i
, 1, gdb_new_connection
, gdb_input
, gdb_connection_closed
, gdb_service
);
1982 DEBUG("gdb service for target %s at port %i", target
->type
->name
, gdb_port
+ i
);
1985 target
= target
->next
;
1991 /* daemon configuration command gdb_port */
1992 int handle_gdb_port_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1997 /* only if the port wasn't overwritten by cmdline */
1999 gdb_port
= strtoul(args
[0], NULL
, 0);
2004 int handle_gdb_detach_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2008 if (strcmp(args
[0], "resume") == 0)
2010 detach_mode
= GDB_DETACH_RESUME
;
2013 else if (strcmp(args
[0], "reset") == 0)
2015 detach_mode
= GDB_DETACH_RESET
;
2018 else if (strcmp(args
[0], "halt") == 0)
2020 detach_mode
= GDB_DETACH_HALT
;
2023 else if (strcmp(args
[0], "nothing") == 0)
2025 detach_mode
= GDB_DETACH_NOTHING
;
2030 WARNING("invalid gdb_detach configuration directive: %s", args
[0]);
2034 int handle_gdb_memory_map_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2038 if (strcmp(args
[0], "enable") == 0)
2040 gdb_use_memory_map
= 1;
2043 else if (strcmp(args
[0], "disable") == 0)
2045 gdb_use_memory_map
= 0;
2050 WARNING("invalid gdb_memory_map configuration directive: %s", args
[0]);
2054 int handle_gdb_flash_program_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2058 if (strcmp(args
[0], "enable") == 0)
2060 gdb_flash_program
= 1;
2063 else if (strcmp(args
[0], "disable") == 0)
2065 gdb_flash_program
= 0;
2070 WARNING("invalid gdb_memory_map configuration directive: %s", args
[0]);
2074 int handle_gdb_report_data_abort_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2078 if (strcmp(args
[0], "enable") == 0)
2080 gdb_report_data_abort
= 1;
2083 else if (strcmp(args
[0], "disable") == 0)
2085 gdb_report_data_abort
= 0;
2090 WARNING("invalid gdb_report_data_abort configuration directive: %s", args
[0]);
2094 int gdb_register_commands(command_context_t
*command_context
)
2096 register_command(command_context
, NULL
, "gdb_port", handle_gdb_port_command
,
2097 COMMAND_CONFIG
, "");
2098 register_command(command_context
, NULL
, "gdb_detach", handle_gdb_detach_command
,
2099 COMMAND_CONFIG
, "");
2100 register_command(command_context
, NULL
, "gdb_memory_map", handle_gdb_memory_map_command
,
2101 COMMAND_CONFIG
, "");
2102 register_command(command_context
, NULL
, "gdb_flash_program", handle_gdb_flash_program_command
,
2103 COMMAND_CONFIG
, "");
2104 register_command(command_context
, NULL
, "gdb_report_data_abort", handle_gdb_report_data_abort_command
,
2105 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)