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_remove_callback(gdb_log_callback
, connection
);
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_remove_callback(gdb_log_callback
, connection
);
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 + 2);
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;
521 gdb_put_packet(connection
, hex_buffer
, bin_size
*2 + 1);
527 int gdb_output(struct command_context_s
*context
, char* line
)
529 /* this will be dumped to the log and also sent as an O packet if possible */
534 int gdb_program_handler(struct target_s
*target
, enum target_event event
, void *priv
)
537 struct command_context_s
*cmd_ctx
= priv
;
539 if (target
->gdb_program_script
)
541 script
= open_file_from_path(cmd_ctx
, target
->gdb_program_script
, "r");
544 ERROR("couldn't open script file %s", target
->gdb_program_script
);
548 INFO("executing gdb_program script '%s'", target
->gdb_program_script
);
549 command_run_file(cmd_ctx
, script
, COMMAND_EXEC
);
552 jtag_execute_queue();
558 int gdb_target_callback_event_handler(struct target_s
*target
, enum target_event event
, void *priv
)
560 connection_t
*connection
= priv
;
561 gdb_connection_t
*gdb_connection
= connection
->priv
;
567 case TARGET_EVENT_HALTED
:
568 /* In the GDB protocol when we are stepping or coninuing execution,
569 * we have a lingering reply. Upon receiving a halted event
570 * when we have that lingering packet, we reply to the original
571 * step or continue packet.
573 * Executing monitor commands can bring the target in and
574 * out of the running state so we'll see lots of TARGET_EVENT_XXX
575 * that are to be ignored.
577 if (gdb_connection
->frontend_state
== TARGET_RUNNING
)
579 /* stop forwarding log packets! */
580 log_remove_callback(gdb_log_callback
, connection
);
582 if (gdb_connection
->ctrl_c
)
585 gdb_connection
->ctrl_c
= 0;
589 signal
= gdb_last_signal(target
);
592 snprintf(sig_reply
, 4, "T%2.2x", signal
);
593 gdb_put_packet(connection
, sig_reply
, 3);
594 gdb_connection
->frontend_state
= TARGET_HALTED
;
597 case TARGET_EVENT_GDB_PROGRAM
:
598 gdb_program_handler(target
, event
, connection
->cmd_ctx
);
608 int gdb_new_connection(connection_t
*connection
)
610 gdb_connection_t
*gdb_connection
= malloc(sizeof(gdb_connection_t
));
611 gdb_service_t
*gdb_service
= connection
->service
->priv
;
615 connection
->priv
= gdb_connection
;
617 /* initialize gdb connection information */
618 gdb_connection
->buf_p
= gdb_connection
->buffer
;
619 gdb_connection
->buf_cnt
= 0;
620 gdb_connection
->ctrl_c
= 0;
621 gdb_connection
->frontend_state
= TARGET_HALTED
;
622 gdb_connection
->vflash_image
= NULL
;
623 gdb_connection
->closed
= 0;
624 gdb_connection
->busy
= 0;
626 /* output goes through gdb connection */
627 command_set_output_handler(connection
->cmd_ctx
, gdb_output
, connection
);
629 /* register callback to be informed about target events */
630 target_register_event_callback(gdb_target_callback_event_handler
, connection
);
632 /* a gdb session just attached, put the target in halt mode */
633 if (((retval
= gdb_service
->target
->type
->halt(gdb_service
->target
)) != ERROR_OK
) &&
634 (retval
!= ERROR_TARGET_ALREADY_HALTED
))
636 ERROR("error(%d) when trying to halt target, falling back to \"reset halt\"", retval
);
637 command_run_line(connection
->cmd_ctx
, "reset halt");
640 /* This will time out after 1 second */
641 command_run_line(connection
->cmd_ctx
, "wait_halt 1");
643 /* remove the initial ACK from the incoming buffer */
644 if ((retval
= gdb_get_char(connection
, &initial_ack
)) != ERROR_OK
)
647 if (initial_ack
!= '+')
648 gdb_putback_char(connection
, initial_ack
);
653 int gdb_connection_closed(connection_t
*connection
)
655 gdb_service_t
*gdb_service
= connection
->service
->priv
;
656 gdb_connection_t
*gdb_connection
= connection
->priv
;
658 /* see if an image built with vFlash commands is left */
659 if (gdb_connection
->vflash_image
)
661 image_close(gdb_connection
->vflash_image
);
662 free(gdb_connection
->vflash_image
);
663 gdb_connection
->vflash_image
= NULL
;
666 /* if this connection registered a debug-message receiver delete it */
667 delete_debug_msg_receiver(connection
->cmd_ctx
, gdb_service
->target
);
669 if (connection
->priv
)
671 free(connection
->priv
);
672 connection
->priv
= NULL
;
676 ERROR("BUG: connection->priv == NULL");
679 target_unregister_event_callback(gdb_target_callback_event_handler
, connection
);
680 log_remove_callback(gdb_log_callback
, 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_add_callback(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"))
1747 /* process the flashing buffer. No need to erase as GDB
1748 * always issues a vFlashErase first. */
1749 if ((result
= flash_write(gdb_service
->target
, gdb_connection
->vflash_image
, &written
, 0)) != ERROR_OK
)
1751 if (result
== ERROR_FLASH_DST_OUT_OF_BANK
)
1752 gdb_put_packet(connection
, "E.memtype", 9);
1754 gdb_send_error(connection
, EIO
);
1758 DEBUG("wrote %u bytes from vFlash image to flash", written
);
1759 gdb_put_packet(connection
, "OK", 2);
1762 image_close(gdb_connection
->vflash_image
);
1763 free(gdb_connection
->vflash_image
);
1764 gdb_connection
->vflash_image
= NULL
;
1769 gdb_put_packet(connection
, "", 0);
1773 int gdb_detach(connection_t
*connection
, target_t
*target
)
1775 switch( detach_mode
)
1777 case GDB_DETACH_RESUME
:
1778 target
->type
->resume(target
, 1, 0, 1, 0);
1781 case GDB_DETACH_RESET
:
1782 target_process_reset(connection
->cmd_ctx
);
1785 case GDB_DETACH_HALT
:
1786 target
->type
->halt(target
);
1789 case GDB_DETACH_NOTHING
:
1793 gdb_put_packet(connection
, "OK", 2);
1798 static void gdb_log_callback(void *priv
, const char *file
, int line
,
1799 const char *function
, const char *format
, va_list args
)
1801 connection_t
*connection
= priv
;
1802 gdb_connection_t
*gdb_con
= connection
->priv
;
1806 /* do not reply this using the O packet */
1810 char *t
= alloc_printf(format
, args
);
1814 gdb_output_con(connection
, t
);
1819 int gdb_input_inner(connection_t
*connection
)
1821 gdb_service_t
*gdb_service
= connection
->service
->priv
;
1822 target_t
*target
= gdb_service
->target
;
1823 char packet
[GDB_BUFFER_SIZE
];
1826 gdb_connection_t
*gdb_con
= connection
->priv
;
1827 static int extended_protocol
= 0;
1829 /* drain input buffer */
1832 packet_size
= GDB_BUFFER_SIZE
-1;
1833 if ((retval
= gdb_get_packet(connection
, packet
, &packet_size
)) != ERROR_OK
)
1838 /* terminate with zero */
1839 packet
[packet_size
] = 0;
1841 DEBUG("received packet: '%s'", packet
);
1843 if (packet_size
> 0)
1849 /* Hct... -- set thread
1850 * we don't have threads, send empty reply */
1851 gdb_put_packet(connection
, NULL
, 0);
1854 retval
= gdb_query_packet(connection
, target
, packet
, packet_size
);
1857 retval
= gdb_get_registers_packet(connection
, target
, packet
, packet_size
);
1860 retval
= gdb_set_registers_packet(connection
, target
, packet
, packet_size
);
1863 retval
= gdb_get_register_packet(connection
, target
, packet
, packet_size
);
1866 retval
= gdb_set_register_packet(connection
, target
, packet
, packet_size
);
1869 retval
= gdb_read_memory_packet(connection
, target
, packet
, packet_size
);
1872 retval
= gdb_write_memory_packet(connection
, target
, packet
, packet_size
);
1876 retval
= gdb_breakpoint_watchpoint_packet(connection
, target
, packet
, packet_size
);
1879 gdb_last_signal_packet(connection
, target
, packet
, packet_size
);
1884 /* We're running/stepping, in which case we can
1885 * forward log output until the target is halted */
1886 gdb_connection_t
*gdb_con
= connection
->priv
;
1887 gdb_con
->frontend_state
= TARGET_RUNNING
;
1888 log_add_callback(gdb_log_callback
, connection
);
1889 gdb_step_continue_packet(connection
, target
, packet
, packet_size
);
1893 retval
= gdb_v_packet(connection
, target
, packet
, packet_size
);
1896 retval
= gdb_detach(connection
, target
);
1897 extended_protocol
= 0;
1900 if ((retval
= gdb_write_memory_binary_packet(connection
, target
, packet
, packet_size
)) != ERROR_OK
)
1904 if (extended_protocol
!= 0)
1906 gdb_put_packet(connection
, "OK", 2);
1907 return ERROR_SERVER_REMOTE_CLOSED
;
1909 /* handle extended remote protocol */
1910 extended_protocol
= 1;
1911 gdb_put_packet(connection
, "OK", 2);
1914 /* handle extended restart packet */
1915 target_process_reset(connection
->cmd_ctx
);
1918 /* ignore unkown packets */
1919 DEBUG("ignoring 0x%2.2x packet", packet
[0]);
1920 gdb_put_packet(connection
, NULL
, 0);
1924 /* if a packet handler returned an error, exit input loop */
1925 if (retval
!= ERROR_OK
)
1929 if (gdb_con
->ctrl_c
)
1931 if (target
->state
== TARGET_RUNNING
)
1933 target
->type
->halt(target
);
1934 gdb_con
->ctrl_c
= 0;
1938 } while (gdb_con
->buf_cnt
> 0);
1943 int gdb_input(connection_t
*connection
)
1945 int retval
= gdb_input_inner(connection
);
1946 if (retval
== ERROR_SERVER_REMOTE_CLOSED
)
1948 /* we'll recover from any other errors(e.g. temporary timeouts, etc.) */
1954 gdb_service_t
*gdb_service
;
1955 target_t
*target
= targets
;
1960 WARNING("no gdb ports allocated as no target has been specified");
1966 WARNING("no gdb port specified, using default port 3333");
1972 char service_name
[8];
1974 snprintf(service_name
, 8, "gdb-%2.2i", i
);
1976 gdb_service
= malloc(sizeof(gdb_service_t
));
1977 gdb_service
->target
= target
;
1979 add_service("gdb", CONNECTION_GDB
, gdb_port
+ i
, 1, gdb_new_connection
, gdb_input
, gdb_connection_closed
, gdb_service
);
1981 DEBUG("gdb service for target %s at port %i", target
->type
->name
, gdb_port
+ i
);
1984 target
= target
->next
;
1990 /* daemon configuration command gdb_port */
1991 int handle_gdb_port_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1996 /* only if the port wasn't overwritten by cmdline */
1998 gdb_port
= strtoul(args
[0], NULL
, 0);
2003 int handle_gdb_detach_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2007 if (strcmp(args
[0], "resume") == 0)
2009 detach_mode
= GDB_DETACH_RESUME
;
2012 else if (strcmp(args
[0], "reset") == 0)
2014 detach_mode
= GDB_DETACH_RESET
;
2017 else if (strcmp(args
[0], "halt") == 0)
2019 detach_mode
= GDB_DETACH_HALT
;
2022 else if (strcmp(args
[0], "nothing") == 0)
2024 detach_mode
= GDB_DETACH_NOTHING
;
2029 WARNING("invalid gdb_detach configuration directive: %s", args
[0]);
2033 int handle_gdb_memory_map_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2037 if (strcmp(args
[0], "enable") == 0)
2039 gdb_use_memory_map
= 1;
2042 else if (strcmp(args
[0], "disable") == 0)
2044 gdb_use_memory_map
= 0;
2049 WARNING("invalid gdb_memory_map configuration directive: %s", args
[0]);
2053 int handle_gdb_flash_program_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2057 if (strcmp(args
[0], "enable") == 0)
2059 gdb_flash_program
= 1;
2062 else if (strcmp(args
[0], "disable") == 0)
2064 gdb_flash_program
= 0;
2069 WARNING("invalid gdb_memory_map configuration directive: %s", args
[0]);
2073 int handle_gdb_report_data_abort_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2077 if (strcmp(args
[0], "enable") == 0)
2079 gdb_report_data_abort
= 1;
2082 else if (strcmp(args
[0], "disable") == 0)
2084 gdb_report_data_abort
= 0;
2089 WARNING("invalid gdb_report_data_abort configuration directive: %s", args
[0]);
2093 int gdb_register_commands(command_context_t
*command_context
)
2095 register_command(command_context
, NULL
, "gdb_port", handle_gdb_port_command
,
2096 COMMAND_CONFIG
, "");
2097 register_command(command_context
, NULL
, "gdb_detach", handle_gdb_detach_command
,
2098 COMMAND_CONFIG
, "");
2099 register_command(command_context
, NULL
, "gdb_memory_map", handle_gdb_memory_map_command
,
2100 COMMAND_CONFIG
, "");
2101 register_command(command_context
, NULL
, "gdb_flash_program", handle_gdb_flash_program_command
,
2102 COMMAND_CONFIG
, "");
2103 register_command(command_context
, NULL
, "gdb_report_data_abort", handle_gdb_report_data_abort_command
,
2104 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)