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
);
685 void gdb_send_error(connection_t
*connection
, u8 the_error
)
688 snprintf(err
, 4, "E%2.2X", the_error
);
689 gdb_put_packet(connection
, err
, 3);
692 int gdb_last_signal_packet(connection_t
*connection
, target_t
*target
, char* packet
, int packet_size
)
697 signal
= gdb_last_signal(target
);
699 snprintf(sig_reply
, 4, "S%2.2x", signal
);
700 gdb_put_packet(connection
, sig_reply
, 3);
705 /* Convert register to string of bits. NB! The # of bits in the
706 * register might be non-divisible by 8(a byte), in which
707 * case an entire byte is shown. */
708 void gdb_str_to_target(target_t
*target
, char *tstr
, reg_t
*reg
)
715 buf_len
= CEIL(reg
->size
, 8);
717 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
719 for (i
= 0; i
< buf_len
; i
++)
721 tstr
[i
*2] = DIGITS
[(buf
[i
]>>4) & 0xf];
722 tstr
[i
*2+1] = DIGITS
[buf
[i
]&0xf];
727 for (i
= 0; i
< buf_len
; i
++)
729 tstr
[(buf_len
-1-i
)*2] = DIGITS
[(buf
[i
]>>4)&0xf];
730 tstr
[(buf_len
-1-i
)*2+1] = DIGITS
[buf
[i
]&0xf];
735 void gdb_target_to_str(target_t
*target
, char *tstr
, char *str
)
737 int str_len
= strlen(tstr
);
742 ERROR("BUG: gdb value with uneven number of characters encountered");
746 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
748 for (i
= 0; i
< str_len
; i
+=2)
750 str
[str_len
- i
- 1] = tstr
[i
+ 1];
751 str
[str_len
- i
- 2] = tstr
[i
];
756 for (i
= 0; i
< str_len
; i
++)
763 int gdb_get_registers_packet(connection_t
*connection
, target_t
*target
, char* packet
, int packet_size
)
768 int reg_packet_size
= 0;
773 #ifdef _DEBUG_GDB_IO_
777 if ((retval
= target
->type
->get_gdb_reg_list(target
, ®_list
, ®_list_size
)) != ERROR_OK
)
781 case ERROR_TARGET_NOT_HALTED
:
782 ERROR("gdb requested registers but we're not halted, dropping connection");
783 return ERROR_SERVER_REMOTE_CLOSED
;
785 /* this is a bug condition - get_gdb_reg_list() may not return any other error */
786 ERROR("BUG: unexpected error returned by get_gdb_reg_list()");
791 for (i
= 0; i
< reg_list_size
; i
++)
793 reg_packet_size
+= reg_list
[i
]->size
;
796 reg_packet
= malloc(CEIL(reg_packet_size
, 8) * 2);
797 reg_packet_p
= reg_packet
;
799 for (i
= 0; i
< reg_list_size
; i
++)
801 gdb_str_to_target(target
, reg_packet_p
, reg_list
[i
]);
802 reg_packet_p
+= CEIL(reg_list
[i
]->size
, 8) * 2;
805 #ifdef _DEBUG_GDB_IO_
808 reg_packet_p
= strndup(reg_packet
, CEIL(reg_packet_size
, 8) * 2);
809 DEBUG("reg_packet: %s", reg_packet_p
);
814 gdb_put_packet(connection
, reg_packet
, CEIL(reg_packet_size
, 8) * 2);
822 int gdb_set_registers_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
830 #ifdef _DEBUG_GDB_IO_
834 /* skip command character */
840 WARNING("GDB set_registers packet with uneven characters received, dropping connection");
841 return ERROR_SERVER_REMOTE_CLOSED
;
844 if ((retval
= target
->type
->get_gdb_reg_list(target
, ®_list
, ®_list_size
)) != ERROR_OK
)
848 case ERROR_TARGET_NOT_HALTED
:
849 ERROR("gdb tried to registers but we're not halted, dropping connection");
850 return ERROR_SERVER_REMOTE_CLOSED
;
852 /* this is a bug condition - get_gdb_reg_list() may not return any other error */
853 ERROR("BUG: unexpected error returned by get_gdb_reg_list()");
859 for (i
= 0; i
< reg_list_size
; i
++)
863 reg_arch_type_t
*arch_type
;
865 /* convert from GDB-string (target-endian) to hex-string (big-endian) */
866 hex_buf
= malloc(CEIL(reg_list
[i
]->size
, 8) * 2);
867 gdb_target_to_str(target
, packet_p
, hex_buf
);
869 /* convert hex-string to binary buffer */
870 bin_buf
= malloc(CEIL(reg_list
[i
]->size
, 8));
871 str_to_buf(hex_buf
, CEIL(reg_list
[i
]->size
, 8) * 2, bin_buf
, reg_list
[i
]->size
, 16);
873 /* get register arch_type, and call set method */
874 arch_type
= register_get_arch_type(reg_list
[i
]->arch_type
);
875 if (arch_type
== NULL
)
877 ERROR("BUG: encountered unregistered arch type");
880 arch_type
->set(reg_list
[i
], bin_buf
);
882 /* advance packet pointer */
883 packet_p
+= (CEIL(reg_list
[i
]->size
, 8) * 2);
889 /* free reg_t *reg_list[] array allocated by get_gdb_reg_list */
892 gdb_put_packet(connection
, "OK", 2);
897 int gdb_get_register_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
900 int reg_num
= strtoul(packet
+ 1, NULL
, 16);
905 #ifdef _DEBUG_GDB_IO_
909 if ((retval
= target
->type
->get_gdb_reg_list(target
, ®_list
, ®_list_size
)) != ERROR_OK
)
913 case ERROR_TARGET_NOT_HALTED
:
914 ERROR("gdb requested registers but we're not halted, dropping connection");
915 return ERROR_SERVER_REMOTE_CLOSED
;
917 /* this is a bug condition - get_gdb_reg_list() may not return any other error */
918 ERROR("BUG: unexpected error returned by get_gdb_reg_list()");
923 if (reg_list_size
<= reg_num
)
925 ERROR("gdb requested a non-existing register");
929 reg_packet
= malloc(CEIL(reg_list
[reg_num
]->size
, 8) * 2);
931 gdb_str_to_target(target
, reg_packet
, reg_list
[reg_num
]);
933 gdb_put_packet(connection
, reg_packet
, CEIL(reg_list
[reg_num
]->size
, 8) * 2);
941 int gdb_set_register_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
946 int reg_num
= strtoul(packet
+ 1, &separator
, 16);
950 reg_arch_type_t
*arch_type
;
954 if ((retval
= target
->type
->get_gdb_reg_list(target
, ®_list
, ®_list_size
)) != ERROR_OK
)
958 case ERROR_TARGET_NOT_HALTED
:
959 ERROR("gdb tried to set a register but we're not halted, dropping connection");
960 return ERROR_SERVER_REMOTE_CLOSED
;
962 /* this is a bug condition - get_gdb_reg_list() may not return any other error */
963 ERROR("BUG: unexpected error returned by get_gdb_reg_list()");
968 if (reg_list_size
< reg_num
)
970 ERROR("gdb requested a non-existing register");
971 return ERROR_SERVER_REMOTE_CLOSED
;
974 if (*separator
!= '=')
976 ERROR("GDB 'set register packet', but no '=' following the register number");
977 return ERROR_SERVER_REMOTE_CLOSED
;
980 /* convert from GDB-string (target-endian) to hex-string (big-endian) */
981 hex_buf
= malloc(CEIL(reg_list
[reg_num
]->size
, 8) * 2);
982 gdb_target_to_str(target
, separator
+ 1, hex_buf
);
984 /* convert hex-string to binary buffer */
985 bin_buf
= malloc(CEIL(reg_list
[reg_num
]->size
, 8));
986 str_to_buf(hex_buf
, CEIL(reg_list
[reg_num
]->size
, 8) * 2, bin_buf
, reg_list
[reg_num
]->size
, 16);
988 /* get register arch_type, and call set method */
989 arch_type
= register_get_arch_type(reg_list
[reg_num
]->arch_type
);
990 if (arch_type
== NULL
)
992 ERROR("BUG: encountered unregistered arch type");
995 arch_type
->set(reg_list
[reg_num
], bin_buf
);
997 gdb_put_packet(connection
, "OK", 2);
1006 int gdb_memory_packet_error(connection_t
*connection
, int retval
)
1010 case ERROR_TARGET_NOT_HALTED
:
1011 ERROR("gdb tried to read memory but we're not halted, dropping connection");
1012 return ERROR_SERVER_REMOTE_CLOSED
;
1013 case ERROR_TARGET_DATA_ABORT
:
1014 gdb_send_error(connection
, EIO
);
1016 case ERROR_TARGET_TRANSLATION_FAULT
:
1017 gdb_send_error(connection
, EFAULT
);
1019 case ERROR_TARGET_UNALIGNED_ACCESS
:
1020 gdb_send_error(connection
, EFAULT
);
1023 /* This could be that the target reset itself. */
1024 ERROR("unexpected error %i. Dropping connection.", retval
);
1025 return ERROR_SERVER_REMOTE_CLOSED
;
1031 /* We don't have to worry about the default 2 second timeout for GDB packets,
1032 * because GDB breaks up large memory reads into smaller reads.
1034 * 8191 bytes by the looks of it. Why 8191 bytes instead of 8192?????
1036 int gdb_read_memory_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1045 int retval
= ERROR_OK
;
1047 /* skip command character */
1050 addr
= strtoul(packet
, &separator
, 16);
1052 if (*separator
!= ',')
1054 ERROR("incomplete read memory packet received, dropping connection");
1055 return ERROR_SERVER_REMOTE_CLOSED
;
1058 len
= strtoul(separator
+1, NULL
, 16);
1060 buffer
= malloc(len
);
1062 DEBUG("addr: 0x%8.8x, len: 0x%8.8x", addr
, len
);
1064 retval
= target_read_buffer(target
, addr
, len
, buffer
);
1066 if ((retval
== ERROR_TARGET_DATA_ABORT
) && (!gdb_report_data_abort
))
1068 /* TODO : Here we have to lie and send back all zero's lest stack traces won't work.
1069 * At some point this might be fixed in GDB, in which case this code can be removed.
1071 * OpenOCD developers are acutely aware of this problem, but there is nothing
1072 * gained by involving the user in this problem that hopefully will get resolved
1075 * http://sourceware.org/cgi-bin/gnatsweb.pl?cmd=view%20audit-trail&database=gdb&pr=2395
1077 * For now, the default is to fix up things to make current GDB versions work.
1078 * This can be overwritten using the gdb_report_data_abort <'enable'|'disable'> command.
1080 memset(buffer
, 0, len
);
1084 if (retval
== ERROR_OK
)
1086 hex_buffer
= malloc(len
* 2 + 1);
1089 for (i
= 0; i
< len
; i
++)
1092 hex_buffer
[2 * i
] = DIGITS
[(t
>> 4) & 0xf];
1093 hex_buffer
[2 * i
+ 1] = DIGITS
[t
& 0xf];
1096 gdb_put_packet(connection
, hex_buffer
, len
* 2);
1102 retval
= gdb_memory_packet_error(connection
, retval
);
1110 int gdb_write_memory_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1121 /* skip command character */
1124 addr
= strtoul(packet
, &separator
, 16);
1126 if (*separator
!= ',')
1128 ERROR("incomplete write memory packet received, dropping connection");
1129 return ERROR_SERVER_REMOTE_CLOSED
;
1132 len
= strtoul(separator
+1, &separator
, 16);
1134 if (*(separator
++) != ':')
1136 ERROR("incomplete write memory packet received, dropping connection");
1137 return ERROR_SERVER_REMOTE_CLOSED
;
1140 buffer
= malloc(len
);
1142 DEBUG("addr: 0x%8.8x, len: 0x%8.8x", addr
, len
);
1144 for (i
=0; i
<len
; i
++)
1147 sscanf(separator
+ 2*i
, "%2x", &tmp
);
1151 retval
= target_write_buffer(target
, addr
, len
, buffer
);
1153 if (retval
== ERROR_OK
)
1155 gdb_put_packet(connection
, "OK", 2);
1159 if ((retval
= gdb_memory_packet_error(connection
, retval
)) != ERROR_OK
)
1168 int gdb_write_memory_binary_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1176 /* skip command character */
1179 addr
= strtoul(packet
, &separator
, 16);
1181 if (*separator
!= ',')
1183 ERROR("incomplete write memory binary packet received, dropping connection");
1184 return ERROR_SERVER_REMOTE_CLOSED
;
1187 len
= strtoul(separator
+1, &separator
, 16);
1189 if (*(separator
++) != ':')
1191 ERROR("incomplete write memory binary packet received, dropping connection");
1192 return ERROR_SERVER_REMOTE_CLOSED
;
1198 DEBUG("addr: 0x%8.8x, len: 0x%8.8x", addr
, len
);
1200 retval
= target_write_buffer(target
, addr
, len
, (u8
*)separator
);
1203 if (retval
== ERROR_OK
)
1205 gdb_put_packet(connection
, "OK", 2);
1209 if ((retval
= gdb_memory_packet_error(connection
, retval
)) != ERROR_OK
)
1216 void gdb_step_continue_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1223 if (packet_size
> 1)
1225 packet
[packet_size
] = 0;
1226 address
= strtoul(packet
+ 1, NULL
, 16);
1233 if (packet
[0] == 'c')
1236 target
->type
->resume(target
, current
, address
, 0, 0); /* resume at current address, don't handle breakpoints, not debugging */
1238 else if (packet
[0] == 's')
1241 target
->type
->step(target
, current
, address
, 0); /* step at current or address, don't handle breakpoints */
1245 int gdb_bp_wp_packet_error(connection_t
*connection
, int retval
)
1249 case ERROR_TARGET_NOT_HALTED
:
1250 ERROR("gdb tried to set a breakpoint but we're not halted, dropping connection");
1251 return ERROR_SERVER_REMOTE_CLOSED
;
1253 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE
:
1254 gdb_send_error(connection
, EBUSY
);
1257 ERROR("BUG: unexpected error %i", retval
);
1264 int gdb_breakpoint_watchpoint_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1267 enum breakpoint_type bp_type
= BKPT_SOFT
/* dummy init to avoid warning */;
1268 enum watchpoint_rw wp_type
;
1276 type
= strtoul(packet
+ 1, &separator
, 16);
1278 if (type
== 0) /* memory breakpoint */
1279 bp_type
= BKPT_SOFT
;
1280 else if (type
== 1) /* hardware breakpoint */
1281 bp_type
= BKPT_HARD
;
1282 else if (type
== 2) /* write watchpoint */
1283 wp_type
= WPT_WRITE
;
1284 else if (type
== 3) /* read watchpoint */
1286 else if (type
== 4) /* access watchpoint */
1287 wp_type
= WPT_ACCESS
;
1289 if (*separator
!= ',')
1291 ERROR("incomplete breakpoint/watchpoint packet received, dropping connection");
1292 return ERROR_SERVER_REMOTE_CLOSED
;
1295 address
= strtoul(separator
+1, &separator
, 16);
1297 if (*separator
!= ',')
1299 ERROR("incomplete breakpoint/watchpoint packet received, dropping connection");
1300 return ERROR_SERVER_REMOTE_CLOSED
;
1303 size
= strtoul(separator
+1, &separator
, 16);
1309 if (packet
[0] == 'Z')
1311 if ((retval
= breakpoint_add(target
, address
, size
, bp_type
)) != ERROR_OK
)
1313 if ((retval
= gdb_bp_wp_packet_error(connection
, retval
)) != ERROR_OK
)
1318 gdb_put_packet(connection
, "OK", 2);
1323 breakpoint_remove(target
, address
);
1324 gdb_put_packet(connection
, "OK", 2);
1331 if (packet
[0] == 'Z')
1333 if ((retval
= watchpoint_add(target
, address
, size
, type
-2, 0, 0xffffffffu
)) != ERROR_OK
)
1335 if ((retval
= gdb_bp_wp_packet_error(connection
, retval
)) != ERROR_OK
)
1340 gdb_put_packet(connection
, "OK", 2);
1345 watchpoint_remove(target
, address
);
1346 gdb_put_packet(connection
, "OK", 2);
1357 /* print out a string and allocate more space as needed, mainly used for XML at this point */
1358 void xml_printf(int *retval
, char **xml
, int *pos
, int *size
, const char *fmt
, ...)
1360 if (*retval
!= ERROR_OK
)
1368 if ((*xml
== NULL
) || (!first
))
1370 /* start by 0 to exercise all the code paths.
1371 * Need minimum 2 bytes to fit 1 char and 0 terminator. */
1373 *size
= *size
* 2 + 2;
1375 *xml
= realloc(*xml
, *size
);
1380 *retval
= ERROR_SERVER_REMOTE_CLOSED
;
1388 ret
= vsnprintf(*xml
+ *pos
, *size
- *pos
, fmt
, ap
);
1390 if ((ret
> 0) && ((ret
+ 1) < *size
- *pos
))
1395 /* there was just enough or not enough space, allocate more. */
1400 static int decode_xfer_read(char *buf
, char **annex
, int *ofs
, unsigned int *len
)
1404 /* Extract and NUL-terminate the annex. */
1406 while (*buf
&& *buf
!= ':')
1412 /* After the read marker and annex, qXfer looks like a
1413 * traditional 'm' packet. */
1415 *ofs
= strtoul(buf
, &separator
, 16);
1417 if (*separator
!= ',')
1420 *len
= strtoul(separator
+1, NULL
, 16);
1425 int gdb_calc_blocksize(flash_bank_t
*bank
)
1428 int block_size
= 0xffffffff;
1430 /* loop through all sectors and return smallest sector size */
1432 for (i
= 0; i
< bank
->num_sectors
; i
++)
1434 if (bank
->sectors
[i
].size
< block_size
)
1435 block_size
= bank
->sectors
[i
].size
;
1441 int gdb_query_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1443 command_context_t
*cmd_ctx
= connection
->cmd_ctx
;
1445 if (strstr(packet
, "qRcmd,"))
1447 if (packet_size
> 6)
1451 cmd
= malloc((packet_size
- 6)/2 + 1);
1452 for (i
=0; i
< (packet_size
- 6)/2; i
++)
1455 sscanf(packet
+ 6 + 2*i
, "%2x", &tmp
);
1458 cmd
[(packet_size
- 6)/2] = 0x0;
1460 /* We want to print all debug output to GDB connection */
1461 log_setCallback(gdb_log_callback
, connection
);
1462 target_call_timer_callbacks();
1463 command_run_line(cmd_ctx
, cmd
);
1466 gdb_put_packet(connection
, "OK", 2);
1469 else if (strstr(packet
, "qCRC:"))
1471 if (packet_size
> 5)
1480 /* skip command character */
1483 addr
= strtoul(packet
, &separator
, 16);
1485 if (*separator
!= ',')
1487 ERROR("incomplete read memory packet received, dropping connection");
1488 return ERROR_SERVER_REMOTE_CLOSED
;
1491 len
= strtoul(separator
+ 1, NULL
, 16);
1493 retval
= target_checksum_memory(target
, addr
, len
, &checksum
);
1495 if (retval
== ERROR_OK
)
1497 snprintf(gdb_reply
, 10, "C%8.8x", checksum
);
1498 gdb_put_packet(connection
, gdb_reply
, 9);
1502 if ((retval
= gdb_memory_packet_error(connection
, retval
)) != ERROR_OK
)
1509 else if (strstr(packet
, "qSupported"))
1511 /* we currently support packet size and qXfer:memory-map:read (if enabled)
1512 * disable qXfer:features:read for the moment */
1513 int retval
= ERROR_OK
;
1514 char *buffer
= NULL
;
1518 xml_printf(&retval
, &buffer
, &pos
, &size
,
1519 "PacketSize=%x;qXfer:memory-map:read%c;qXfer:features:read-",
1520 (GDB_BUFFER_SIZE
- 1), gdb_use_memory_map
== 1 ? '+' : '-');
1522 if (retval
!= ERROR_OK
)
1524 gdb_send_error(connection
, 01);
1528 gdb_put_packet(connection
, buffer
, strlen(buffer
));
1533 else if (strstr(packet
, "qXfer:memory-map:read::"))
1535 /* We get away with only specifying flash here. Regions that are not
1536 * specified are treated as if we provided no memory map(if not we
1537 * could detect the holes and mark them as RAM).
1538 * Normally we only execute this code once, but no big deal if we
1539 * have to regenerate it a couple of times. */
1545 int retval
= ERROR_OK
;
1552 /* skip command character */
1555 offset
= strtoul(packet
, &separator
, 16);
1556 length
= strtoul(separator
+ 1, &separator
, 16);
1558 xml_printf(&retval
, &xml
, &pos
, &size
, "<memory-map>\n");
1563 p
= get_flash_bank_by_num(i
);
1567 /* if device has uneven sector sizes, eg. str7, lpc
1568 * we pass the smallest sector size to gdb memory map */
1569 blocksize
= gdb_calc_blocksize(p
);
1571 xml_printf(&retval
, &xml
, &pos
, &size
, "<memory type=\"flash\" start=\"0x%x\" length=\"0x%x\">\n" \
1572 "<property name=\"blocksize\">0x%x</property>\n" \
1574 p
->base
, p
->size
, blocksize
);
1578 xml_printf(&retval
, &xml
, &pos
, &size
, "</memory-map>\n");
1580 if (retval
!= ERROR_OK
)
1582 gdb_send_error(connection
, retval
);
1586 if (offset
+ length
> pos
)
1588 length
= pos
- offset
;
1591 char *t
= malloc(length
+ 1);
1593 memcpy(t
+ 1, xml
+ offset
, length
);
1594 gdb_put_packet(connection
, t
, length
+ 1);
1600 else if (strstr(packet
, "qXfer:features:read:"))
1605 int retval
= ERROR_OK
;
1608 unsigned int length
;
1611 /* skip command character */
1614 if (decode_xfer_read(packet
, &annex
, &offset
, &length
) < 0)
1616 gdb_send_error(connection
, 01);
1620 if (strcmp(annex
, "target.xml") != 0)
1622 gdb_send_error(connection
, 01);
1626 xml_printf(&retval
, &xml
, &pos
, &size
, \
1627 "l<target version=\"1.0\">\n<architecture>arm</architecture>\n</target>\n");
1629 if (retval
!= ERROR_OK
)
1631 gdb_send_error(connection
, retval
);
1635 gdb_put_packet(connection
, xml
, strlen(xml
) + 1);
1641 gdb_put_packet(connection
, "", 0);
1645 int gdb_v_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1647 gdb_connection_t
*gdb_connection
= connection
->priv
;
1648 gdb_service_t
*gdb_service
= connection
->service
->priv
;
1651 /* if flash programming disabled - send a empty reply */
1653 if (gdb_flash_program
== 0)
1655 gdb_put_packet(connection
, "", 0);
1659 if (strstr(packet
, "vFlashErase:"))
1662 unsigned long length
;
1664 char *parse
= packet
+ 12;
1667 ERROR("incomplete vFlashErase packet received, dropping connection");
1668 return ERROR_SERVER_REMOTE_CLOSED
;
1671 addr
= strtoul(parse
, &parse
, 16);
1673 if (*(parse
++) != ',' || *parse
== '\0')
1675 ERROR("incomplete vFlashErase packet received, dropping connection");
1676 return ERROR_SERVER_REMOTE_CLOSED
;
1679 length
= strtoul(parse
, &parse
, 16);
1683 ERROR("incomplete vFlashErase packet received, dropping connection");
1684 return ERROR_SERVER_REMOTE_CLOSED
;
1687 /* assume all sectors need erasing - stops any problems
1688 * when flash_write is called multiple times */
1691 /* perform any target specific operations before the erase */
1692 target_call_event_callbacks(gdb_service
->target
, TARGET_EVENT_GDB_PROGRAM
);
1695 if ((result
= flash_erase_address_range(gdb_service
->target
, addr
, length
)) != ERROR_OK
)
1697 /* GDB doesn't evaluate the actual error number returned,
1698 * treat a failed erase as an I/O error
1700 gdb_send_error(connection
, EIO
);
1701 ERROR("flash_erase returned %i", result
);
1704 gdb_put_packet(connection
, "OK", 2);
1709 if (strstr(packet
, "vFlashWrite:"))
1712 unsigned long length
;
1713 char *parse
= packet
+ 12;
1717 ERROR("incomplete vFlashErase packet received, dropping connection");
1718 return ERROR_SERVER_REMOTE_CLOSED
;
1720 addr
= strtoul(parse
, &parse
, 16);
1721 if (*(parse
++) != ':')
1723 ERROR("incomplete vFlashErase packet received, dropping connection");
1724 return ERROR_SERVER_REMOTE_CLOSED
;
1726 length
= packet_size
- (parse
- packet
);
1728 /* create a new image if there isn't already one */
1729 if (gdb_connection
->vflash_image
== NULL
)
1731 gdb_connection
->vflash_image
= malloc(sizeof(image_t
));
1732 image_open(gdb_connection
->vflash_image
, "", "build");
1735 /* create new section with content from packet buffer */
1736 image_add_section(gdb_connection
->vflash_image
, addr
, length
, 0x0, (u8
*)parse
);
1738 gdb_put_packet(connection
, "OK", 2);
1743 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
, &error_str
, NULL
, 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 ERROR("flash writing failed: %s", error_str
);
1765 DEBUG("wrote %u bytes from vFlash image to flash", written
);
1766 gdb_put_packet(connection
, "OK", 2);
1769 image_close(gdb_connection
->vflash_image
);
1770 free(gdb_connection
->vflash_image
);
1771 gdb_connection
->vflash_image
= NULL
;
1776 gdb_put_packet(connection
, "", 0);
1780 int gdb_detach(connection_t
*connection
, target_t
*target
)
1782 switch( detach_mode
)
1784 case GDB_DETACH_RESUME
:
1785 target
->type
->resume(target
, 1, 0, 1, 0);
1788 case GDB_DETACH_RESET
:
1789 target_process_reset(connection
->cmd_ctx
);
1792 case GDB_DETACH_HALT
:
1793 target
->type
->halt(target
);
1796 case GDB_DETACH_NOTHING
:
1800 gdb_put_packet(connection
, "OK", 2);
1805 static void gdb_log_callback(void *priv
, const char *file
, int line
,
1806 const char *function
, const char *format
, va_list args
)
1808 connection_t
*connection
= priv
;
1809 gdb_connection_t
*gdb_con
= connection
->priv
;
1813 /* do not reply this using the O packet */
1817 char *t
= allocPrintf(format
, args
);
1821 gdb_output_con(connection
, t
);
1826 int gdb_input_inner(connection_t
*connection
)
1828 gdb_service_t
*gdb_service
= connection
->service
->priv
;
1829 target_t
*target
= gdb_service
->target
;
1830 char packet
[GDB_BUFFER_SIZE
];
1833 gdb_connection_t
*gdb_con
= connection
->priv
;
1834 static int extended_protocol
= 0;
1836 /* drain input buffer */
1839 packet_size
= GDB_BUFFER_SIZE
-1;
1840 if ((retval
= gdb_get_packet(connection
, packet
, &packet_size
)) != ERROR_OK
)
1845 /* terminate with zero */
1846 packet
[packet_size
] = 0;
1848 DEBUG("received packet: '%s'", packet
);
1850 if (packet_size
> 0)
1856 /* Hct... -- set thread
1857 * we don't have threads, send empty reply */
1858 gdb_put_packet(connection
, NULL
, 0);
1861 retval
= gdb_query_packet(connection
, target
, packet
, packet_size
);
1864 retval
= gdb_get_registers_packet(connection
, target
, packet
, packet_size
);
1867 retval
= gdb_set_registers_packet(connection
, target
, packet
, packet_size
);
1870 retval
= gdb_get_register_packet(connection
, target
, packet
, packet_size
);
1873 retval
= gdb_set_register_packet(connection
, target
, packet
, packet_size
);
1876 retval
= gdb_read_memory_packet(connection
, target
, packet
, packet_size
);
1879 retval
= gdb_write_memory_packet(connection
, target
, packet
, packet_size
);
1883 retval
= gdb_breakpoint_watchpoint_packet(connection
, target
, packet
, packet_size
);
1886 gdb_last_signal_packet(connection
, target
, packet
, packet_size
);
1891 /* We're running/stepping, in which case we can
1892 * forward log output until the target is halted */
1893 gdb_connection_t
*gdb_con
= connection
->priv
;
1894 gdb_con
->frontend_state
= TARGET_RUNNING
;
1895 log_setCallback(gdb_log_callback
, connection
);
1896 gdb_step_continue_packet(connection
, target
, packet
, packet_size
);
1900 retval
= gdb_v_packet(connection
, target
, packet
, packet_size
);
1903 retval
= gdb_detach(connection
, target
);
1904 extended_protocol
= 0;
1907 if ((retval
= gdb_write_memory_binary_packet(connection
, target
, packet
, packet_size
)) != ERROR_OK
)
1911 if (extended_protocol
!= 0)
1913 gdb_put_packet(connection
, "OK", 2);
1914 return ERROR_SERVER_REMOTE_CLOSED
;
1916 /* handle extended remote protocol */
1917 extended_protocol
= 1;
1918 gdb_put_packet(connection
, "OK", 2);
1921 /* handle extended restart packet */
1922 target_process_reset(connection
->cmd_ctx
);
1925 /* ignore unkown packets */
1926 DEBUG("ignoring 0x%2.2x packet", packet
[0]);
1927 gdb_put_packet(connection
, NULL
, 0);
1931 /* if a packet handler returned an error, exit input loop */
1932 if (retval
!= ERROR_OK
)
1936 if (gdb_con
->ctrl_c
)
1938 if (target
->state
== TARGET_RUNNING
)
1940 target
->type
->halt(target
);
1941 gdb_con
->ctrl_c
= 0;
1945 } while (gdb_con
->buf_cnt
> 0);
1950 int gdb_input(connection_t
*connection
)
1952 int retval
= gdb_input_inner(connection
);
1953 if (retval
== ERROR_SERVER_REMOTE_CLOSED
)
1955 /* we'll recover from any other errors(e.g. temporary timeouts, etc.) */
1961 gdb_service_t
*gdb_service
;
1962 target_t
*target
= targets
;
1967 WARNING("no gdb ports allocated as no target has been specified");
1973 WARNING("no gdb port specified, using default port 3333");
1979 char service_name
[8];
1981 snprintf(service_name
, 8, "gdb-%2.2i", i
);
1983 gdb_service
= malloc(sizeof(gdb_service_t
));
1984 gdb_service
->target
= target
;
1986 add_service("gdb", CONNECTION_GDB
, gdb_port
+ i
, 1, gdb_new_connection
, gdb_input
, gdb_connection_closed
, gdb_service
);
1988 DEBUG("gdb service for target %s at port %i", target
->type
->name
, gdb_port
+ i
);
1991 target
= target
->next
;
1997 /* daemon configuration command gdb_port */
1998 int handle_gdb_port_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2003 /* only if the port wasn't overwritten by cmdline */
2005 gdb_port
= strtoul(args
[0], NULL
, 0);
2010 int handle_gdb_detach_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2014 if (strcmp(args
[0], "resume") == 0)
2016 detach_mode
= GDB_DETACH_RESUME
;
2019 else if (strcmp(args
[0], "reset") == 0)
2021 detach_mode
= GDB_DETACH_RESET
;
2024 else if (strcmp(args
[0], "halt") == 0)
2026 detach_mode
= GDB_DETACH_HALT
;
2029 else if (strcmp(args
[0], "nothing") == 0)
2031 detach_mode
= GDB_DETACH_NOTHING
;
2036 WARNING("invalid gdb_detach configuration directive: %s", args
[0]);
2040 int handle_gdb_memory_map_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2044 if (strcmp(args
[0], "enable") == 0)
2046 gdb_use_memory_map
= 1;
2049 else if (strcmp(args
[0], "disable") == 0)
2051 gdb_use_memory_map
= 0;
2056 WARNING("invalid gdb_memory_map configuration directive: %s", args
[0]);
2060 int handle_gdb_flash_program_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2064 if (strcmp(args
[0], "enable") == 0)
2066 gdb_flash_program
= 1;
2069 else if (strcmp(args
[0], "disable") == 0)
2071 gdb_flash_program
= 0;
2076 WARNING("invalid gdb_memory_map configuration directive: %s", args
[0]);
2080 int handle_gdb_report_data_abort_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2084 if (strcmp(args
[0], "enable") == 0)
2086 gdb_report_data_abort
= 1;
2089 else if (strcmp(args
[0], "disable") == 0)
2091 gdb_report_data_abort
= 0;
2096 WARNING("invalid gdb_report_data_abort configuration directive: %s", args
[0]);
2100 int gdb_register_commands(command_context_t
*command_context
)
2102 register_command(command_context
, NULL
, "gdb_port", handle_gdb_port_command
,
2103 COMMAND_CONFIG
, "");
2104 register_command(command_context
, NULL
, "gdb_detach", handle_gdb_detach_command
,
2105 COMMAND_CONFIG
, "");
2106 register_command(command_context
, NULL
, "gdb_memory_map", handle_gdb_memory_map_command
,
2107 COMMAND_CONFIG
, "");
2108 register_command(command_context
, NULL
, "gdb_flash_program", handle_gdb_flash_program_command
,
2109 COMMAND_CONFIG
, "");
2110 register_command(command_context
, NULL
, "gdb_report_data_abort", handle_gdb_report_data_abort_command
,
2111 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)