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"
31 #include "breakpoints.h"
40 #define _DEBUG_GDB_IO_
43 static unsigned short gdb_port
;
45 int gdb_last_signal(target_t
*target
)
47 switch (target
->debug_reason
)
49 case DBG_REASON_DBGRQ
:
50 return 0x2; /* SIGINT */
51 case DBG_REASON_BREAKPOINT
:
52 case DBG_REASON_WATCHPOINT
:
53 case DBG_REASON_WPTANDBKPT
:
54 return 0x05; /* SIGTRAP */
55 case DBG_REASON_SINGLESTEP
:
56 return 0x05; /* SIGTRAP */
57 case DBG_REASON_NOTHALTED
:
58 return 0x0; /* no signal... shouldn't happen */
60 ERROR("BUG: undefined debug reason");
65 int gdb_get_char(connection_t
*connection
, int* next_char
)
67 gdb_connection_t
*gdb_con
= connection
->priv
;
70 if (gdb_con
->buf_cnt
-- > 0)
72 *next_char
= *(gdb_con
->buf_p
++);
73 if (gdb_con
->buf_cnt
> 0)
74 connection
->input_pending
= 1;
76 connection
->input_pending
= 0;
79 DEBUG("returned char '%c' (0x%2.2x)", *next_char
, *next_char
);
85 while ((gdb_con
->buf_cnt
= read_socket(connection
->fd
, gdb_con
->buffer
, GDB_BUFFER_SIZE
)) <= 0)
87 if (gdb_con
->buf_cnt
== 0)
88 return ERROR_SERVER_REMOTE_CLOSED
;
91 errno
= WSAGetLastError();
99 return ERROR_SERVER_REMOTE_CLOSED
;
101 ERROR("read: %d", strerror(errno
));
111 return ERROR_SERVER_REMOTE_CLOSED
;
113 return ERROR_SERVER_REMOTE_CLOSED
;
115 ERROR("read: %s", strerror(errno
));
121 debug_buffer
= malloc(gdb_con
->buf_cnt
+ 1);
122 memcpy(debug_buffer
, gdb_con
->buffer
, gdb_con
->buf_cnt
);
123 debug_buffer
[gdb_con
->buf_cnt
] = 0;
124 DEBUG("received '%s'", debug_buffer
);
127 gdb_con
->buf_p
= gdb_con
->buffer
;
129 *next_char
= *(gdb_con
->buf_p
++);
130 if (gdb_con
->buf_cnt
> 0)
131 connection
->input_pending
= 1;
133 connection
->input_pending
= 0;
134 #ifdef _DEBUG_GDB_IO_
135 DEBUG("returned char '%c' (0x%2.2x)", *next_char
, *next_char
);
141 int gdb_putback_char(connection_t
*connection
, int last_char
)
143 gdb_connection_t
*gdb_con
= connection
->priv
;
145 if (gdb_con
->buf_p
> gdb_con
->buffer
)
147 *(--gdb_con
->buf_p
) = last_char
;
152 ERROR("BUG: couldn't put character back");
158 int gdb_put_packet(connection_t
*connection
, char *buffer
, int len
)
161 unsigned char my_checksum
= 0;
166 gdb_connection_t
*gdb_con
= connection
->priv
;
168 for (i
= 0; i
< len
; i
++)
169 my_checksum
+= buffer
[i
];
174 debug_buffer
= malloc(len
+ 1);
175 memcpy(debug_buffer
, buffer
, len
);
176 debug_buffer
[len
] = 0;
177 DEBUG("sending packet '$%s#%2.2x'", debug_buffer
, my_checksum
);
180 write_socket(connection
->fd
, "$", 1);
182 write_socket(connection
->fd
, buffer
, len
);
183 write_socket(connection
->fd
, "#", 1);
185 snprintf(checksum
, 3, "%2.2x", my_checksum
);
187 write_socket(connection
->fd
, checksum
, 2);
189 if ((retval
= gdb_get_char(connection
, &reply
)) != ERROR_OK
)
194 else if (reply
== '-')
195 WARNING("negative reply, retrying");
196 else if (reply
== 0x3)
199 if ((retval
= gdb_get_char(connection
, &reply
)) != ERROR_OK
)
203 else if (reply
== '-')
204 WARNING("negative reply, retrying");
207 ERROR("unknown character 0x%2.2x in reply, dropping connection", reply
);
208 return ERROR_SERVER_REMOTE_CLOSED
;
213 ERROR("unknown character 0x%2.2x in reply, dropping connection", reply
);
214 return ERROR_SERVER_REMOTE_CLOSED
;
221 int gdb_get_packet(connection_t
*connection
, char *buffer
, int *len
)
229 unsigned char my_checksum
= 0;
230 gdb_connection_t
*gdb_con
= connection
->priv
;
236 if ((retval
= gdb_get_char(connection
, &character
)) != ERROR_OK
)
239 DEBUG("character: '%c'", character
);
246 WARNING("acknowledgment received, but no packet pending");
249 WARNING("negative acknowledgment, but no packet pending");
256 WARNING("ignoring character 0x%x", character
);
259 } while (character
!= '$');
265 if ((retval
= gdb_get_char(connection
, &character
)) != ERROR_OK
)
269 packet_type
= character
;
273 if( packet_type
== 'X' )
280 /* data transmitted in binary mode (X packet)
281 * uses 0x7d as escape character */
282 my_checksum
+= character
& 0xff;
283 gdb_get_char(connection
, &character
);
284 my_checksum
+= character
& 0xff;
285 buffer
[count
++] = (character
^ 0x20) & 0xff;
288 ERROR("packet buffer too small");
289 return ERROR_GDB_BUFFER_TOO_SMALL
;
293 buffer
[count
++] = character
& 0xff;
294 my_checksum
+= character
& 0xff;
297 ERROR("packet buffer too small");
298 return ERROR_GDB_BUFFER_TOO_SMALL
;
313 buffer
[count
++] = character
& 0xff;
314 my_checksum
+= character
& 0xff;
317 ERROR("packet buffer too small");
318 return ERROR_GDB_BUFFER_TOO_SMALL
;
323 } while (character
!= '#');
327 if ((retval
= gdb_get_char(connection
, &character
)) != ERROR_OK
)
329 checksum
[0] = character
;
330 if ((retval
= gdb_get_char(connection
, &character
)) != ERROR_OK
)
332 checksum
[1] = character
;
335 if (my_checksum
== strtoul(checksum
, NULL
, 16))
337 write_socket(connection
->fd
, "+", 1);
341 WARNING("checksum error, requesting retransmission");
342 write_socket(connection
->fd
, "-", 1);
348 int gdb_output(struct command_context_s
*context
, char* line
)
350 connection_t
*connection
= context
->output_handler_priv
;
354 bin_size
= strlen(line
);
356 hex_buffer
= malloc(bin_size
*2 + 4);
359 for (i
=0; i
<bin_size
; i
++)
360 snprintf(hex_buffer
+ 1 + i
*2, 3, "%2.2x", line
[i
]);
361 hex_buffer
[bin_size
*2+1] = '0';
362 hex_buffer
[bin_size
*2+2] = 'a';
363 hex_buffer
[bin_size
*2+3] = 0x0;
365 gdb_put_packet(connection
, hex_buffer
, bin_size
*2 + 3);
371 int gdb_target_callback_event_handler(struct target_s
*target
, enum target_event event
, void *priv
)
373 connection_t
*connection
= priv
;
374 gdb_connection_t
*gdb_connection
= connection
->priv
;
380 case TARGET_EVENT_HALTED
:
381 if (gdb_connection
->frontend_state
== TARGET_RUNNING
)
383 if (gdb_connection
->ctrl_c
)
386 gdb_connection
->ctrl_c
= 0;
390 signal
= gdb_last_signal(target
);
393 snprintf(sig_reply
, 4, "T%2.2x", signal
);
394 gdb_put_packet(connection
, sig_reply
, 3);
395 gdb_connection
->frontend_state
= TARGET_HALTED
;
398 case TARGET_EVENT_RESUMED
:
399 if (gdb_connection
->frontend_state
== TARGET_HALTED
)
401 gdb_connection
->frontend_state
= TARGET_RUNNING
;
411 int gdb_new_connection(connection_t
*connection
)
413 gdb_connection_t
*gdb_connection
= malloc(sizeof(gdb_connection_t
));
414 gdb_service_t
*gdb_service
= connection
->service
->priv
;
418 connection
->priv
= gdb_connection
;
420 /* initialize gdb connection information */
421 gdb_connection
->buf_p
= gdb_connection
->buffer
;
422 gdb_connection
->buf_cnt
= 0;
423 gdb_connection
->ctrl_c
= 0;
424 gdb_connection
->frontend_state
= TARGET_HALTED
;
426 /* output goes through gdb connection */
427 command_set_output_handler(connection
->cmd_ctx
, gdb_output
, connection
);
429 /* register callback to be informed about target events */
430 target_register_event_callback(gdb_target_callback_event_handler
, connection
);
432 /* a gdb session just attached, put the target in halt mode */
433 if (((retval
= gdb_service
->target
->type
->halt(gdb_service
->target
)) != ERROR_OK
) &&
434 (retval
!= ERROR_TARGET_ALREADY_HALTED
))
436 ERROR("error when trying to halt target");
440 while (gdb_service
->target
->state
!= TARGET_HALTED
)
442 gdb_service
->target
->type
->poll(gdb_service
->target
);
445 /* remove the initial ACK from the incoming buffer */
446 if ((retval
= gdb_get_char(connection
, &initial_ack
)) != ERROR_OK
)
449 if (initial_ack
!= '+')
450 gdb_putback_char(connection
, initial_ack
);
455 int gdb_connection_closed(connection_t
*connection
)
457 if (connection
->priv
)
458 free(connection
->priv
);
460 ERROR("BUG: connection->priv == NULL");
462 target_unregister_event_callback(gdb_target_callback_event_handler
, connection
);
467 void gdb_send_error(connection_t
*connection
, u8 the_error
)
470 snprintf(err
, 4, "E%2.2X", the_error
);
471 gdb_put_packet(connection
, err
, 3);
474 int gdb_last_signal_packet(connection_t
*connection
, target_t
*target
, char* packet
, int packet_size
)
479 signal
= gdb_last_signal(target
);
481 snprintf(sig_reply
, 4, "S%2.2x", signal
);
482 gdb_put_packet(connection
, sig_reply
, 3);
487 void gdb_str_to_target(target_t
*target
, char *str
, char *tstr
)
489 int str_len
= strlen(str
);
494 ERROR("BUG: gdb value with uneven number of characters encountered");
498 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
500 for (i
= 0; i
< str_len
; i
+=2)
502 tstr
[str_len
- i
- 1] = str
[i
+ 1];
503 tstr
[str_len
- i
- 2] = str
[i
];
508 for (i
= 0; i
< str_len
; i
++)
515 void gdb_target_to_str(target_t
*target
, char *tstr
, char *str
)
517 int str_len
= strlen(tstr
);
522 ERROR("BUG: gdb value with uneven number of characters encountered");
526 if (target
->endianness
== TARGET_LITTLE_ENDIAN
)
528 for (i
= 0; i
< str_len
; i
+=2)
530 str
[str_len
- i
- 1] = tstr
[i
+ 1];
531 str
[str_len
- i
- 2] = tstr
[i
];
536 for (i
= 0; i
< str_len
; i
++)
543 int gdb_get_registers_packet(connection_t
*connection
, target_t
*target
, char* packet
, int packet_size
)
548 int reg_packet_size
= 0;
555 if ((retval
= target
->type
->get_gdb_reg_list(target
, ®_list
, ®_list_size
)) != ERROR_OK
)
559 case ERROR_TARGET_NOT_HALTED
:
560 ERROR("gdb requested registers but we're not halted, dropping connection");
561 return ERROR_SERVER_REMOTE_CLOSED
;
563 /* this is a bug condition - get_gdb_reg_list() may not return any other error */
564 ERROR("BUG: unexpected error returned by get_gdb_reg_list()");
569 for (i
= 0; i
< reg_list_size
; i
++)
571 reg_packet_size
+= reg_list
[i
]->size
;
574 reg_packet
= malloc(CEIL(reg_packet_size
, 8) * 2);
575 reg_packet_p
= reg_packet
;
577 for (i
= 0; i
< reg_list_size
; i
++)
579 char *hex_buf
= buf_to_str(reg_list
[i
]->value
, reg_list
[i
]->size
, 16);
580 DEBUG("hex_buf: %s", hex_buf
);
581 gdb_str_to_target(target
, hex_buf
, reg_packet_p
);
582 reg_packet_p
+= CEIL(reg_list
[i
]->size
, 8) * 2;
586 reg_packet_p
= strndup(reg_packet
, CEIL(reg_packet_size
, 8) * 2);
587 DEBUG("reg_packet: %s", reg_packet_p
);
590 gdb_put_packet(connection
, reg_packet
, CEIL(reg_packet_size
, 8) * 2);
598 int gdb_set_registers_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
608 /* skip command character */
614 WARNING("GDB set_registers packet with uneven characters received, dropping connection");
615 return ERROR_SERVER_REMOTE_CLOSED
;
618 if ((retval
= target
->type
->get_gdb_reg_list(target
, ®_list
, ®_list_size
)) != ERROR_OK
)
622 case ERROR_TARGET_NOT_HALTED
:
623 ERROR("gdb tried to registers but we're not halted, dropping connection");
624 return ERROR_SERVER_REMOTE_CLOSED
;
626 /* this is a bug condition - get_gdb_reg_list() may not return any other error */
627 ERROR("BUG: unexpected error returned by get_gdb_reg_list()");
633 for (i
= 0; i
< reg_list_size
; i
++)
637 reg_arch_type_t
*arch_type
;
639 /* convert from GDB-string (target-endian) to hex-string (big-endian) */
640 hex_buf
= malloc(CEIL(reg_list
[i
]->size
, 8) * 2);
641 gdb_target_to_str(target
, packet_p
, hex_buf
);
643 /* convert hex-string to binary buffer */
644 bin_buf
= malloc(CEIL(reg_list
[i
]->size
, 8));
645 str_to_buf(hex_buf
, CEIL(reg_list
[i
]->size
, 8) * 2, bin_buf
, reg_list
[i
]->size
, 16);
647 /* get register arch_type, and call set method */
648 arch_type
= register_get_arch_type(reg_list
[i
]->arch_type
);
649 if (arch_type
== NULL
)
651 ERROR("BUG: encountered unregistered arch type");
654 arch_type
->set(reg_list
[i
], bin_buf
);
656 /* advance packet pointer */
657 packet_p
+= (CEIL(reg_list
[i
]->size
, 8) * 2);
663 /* free reg_t *reg_list[] array allocated by get_gdb_reg_list */
666 gdb_put_packet(connection
, "OK", 2);
671 int gdb_get_register_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
674 int reg_num
= strtoul(packet
+ 1, NULL
, 16);
682 if ((retval
= target
->type
->get_gdb_reg_list(target
, ®_list
, ®_list_size
)) != ERROR_OK
)
686 case ERROR_TARGET_NOT_HALTED
:
687 ERROR("gdb requested registers but we're not halted, dropping connection");
688 return ERROR_SERVER_REMOTE_CLOSED
;
690 /* this is a bug condition - get_gdb_reg_list() may not return any other error */
691 ERROR("BUG: unexpected error returned by get_gdb_reg_list()");
696 if (reg_list_size
<= reg_num
)
698 ERROR("gdb requested a non-existing register");
702 reg_packet
= malloc(CEIL(reg_list
[reg_num
]->size
, 8) * 2);
704 hex_buf
= buf_to_str(reg_list
[reg_num
]->value
, reg_list
[reg_num
]->size
, 16);
706 gdb_str_to_target(target
, reg_packet
, hex_buf
);
708 gdb_put_packet(connection
, reg_packet
, CEIL(reg_list
[reg_num
]->size
, 8) * 2);
717 int gdb_set_register_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
722 int reg_num
= strtoul(packet
+ 1, &separator
, 16);
726 reg_arch_type_t
*arch_type
;
730 if ((retval
= target
->type
->get_gdb_reg_list(target
, ®_list
, ®_list_size
)) != ERROR_OK
)
734 case ERROR_TARGET_NOT_HALTED
:
735 ERROR("gdb tried to set a register but we're not halted, dropping connection");
736 return ERROR_SERVER_REMOTE_CLOSED
;
738 /* this is a bug condition - get_gdb_reg_list() may not return any other error */
739 ERROR("BUG: unexpected error returned by get_gdb_reg_list()");
744 if (reg_list_size
< reg_num
)
746 ERROR("gdb requested a non-existing register");
747 return ERROR_SERVER_REMOTE_CLOSED
;
750 if (*separator
!= '=')
752 ERROR("GDB 'set register packet', but no '=' following the register number");
753 return ERROR_SERVER_REMOTE_CLOSED
;
756 /* convert from GDB-string (target-endian) to hex-string (big-endian) */
757 hex_buf
= malloc(CEIL(reg_list
[reg_num
]->size
, 8) * 2);
758 gdb_target_to_str(target
, separator
+ 1, hex_buf
);
760 /* convert hex-string to binary buffer */
761 bin_buf
= malloc(CEIL(reg_list
[reg_num
]->size
, 8));
762 str_to_buf(hex_buf
, CEIL(reg_list
[reg_num
]->size
, 8) * 2, bin_buf
, reg_list
[reg_num
]->size
, 16);
764 /* get register arch_type, and call set method */
765 arch_type
= register_get_arch_type(reg_list
[reg_num
]->arch_type
);
766 if (arch_type
== NULL
)
768 ERROR("BUG: encountered unregistered arch type");
771 arch_type
->set(reg_list
[reg_num
], bin_buf
);
773 gdb_put_packet(connection
, "OK", 2);
782 int gdb_memory_packet_error(connection_t
*connection
, int retval
)
786 case ERROR_TARGET_NOT_HALTED
:
787 ERROR("gdb tried to read memory but we're not halted, dropping connection");
788 return ERROR_SERVER_REMOTE_CLOSED
;
790 case ERROR_TARGET_DATA_ABORT
:
791 gdb_send_error(connection
, EIO
);
793 case ERROR_TARGET_TRANSLATION_FAULT
:
794 gdb_send_error(connection
, EFAULT
);
796 case ERROR_TARGET_UNALIGNED_ACCESS
:
797 gdb_send_error(connection
, EFAULT
);
800 ERROR("BUG: unexpected error %i", retval
);
807 int gdb_read_memory_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
819 /* skip command character */
822 addr
= strtoul(packet
, &separator
, 16);
824 if (*separator
!= ',')
826 ERROR("incomplete read memory packet received, dropping connection");
827 return ERROR_SERVER_REMOTE_CLOSED
;
830 len
= strtoul(separator
+1, NULL
, 16);
832 buffer
= malloc(len
);
834 DEBUG("addr: 0x%8.8x, len: 0x%8.8x", addr
, len
);
840 retval
= target
->type
->read_memory(target
, addr
, 4, 1, buffer
);
842 retval
= target
->type
->read_memory(target
, addr
, 1, len
, buffer
);
846 retval
= target
->type
->read_memory(target
, addr
, 2, 1, buffer
);
848 retval
= target
->type
->read_memory(target
, addr
, 1, len
, buffer
);
851 if (((addr
% 4) == 0) && ((len
% 4) == 0))
852 retval
= target
->type
->read_memory(target
, addr
, 4, len
/ 4, buffer
);
854 retval
= target
->type
->read_memory(target
, addr
, 1, len
, buffer
);
857 if (retval
== ERROR_OK
)
859 hex_buffer
= malloc(len
* 2 + 1);
861 for (i
=0; i
<len
; i
++)
862 snprintf(hex_buffer
+ 2*i
, 3, "%2.2x", buffer
[i
]);
864 gdb_put_packet(connection
, hex_buffer
, len
* 2);
870 if ((retval
= gdb_memory_packet_error(connection
, retval
)) != ERROR_OK
)
879 int gdb_write_memory_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
890 /* skip command character */
893 addr
= strtoul(packet
, &separator
, 16);
895 if (*separator
!= ',')
897 ERROR("incomplete write memory packet received, dropping connection");
898 return ERROR_SERVER_REMOTE_CLOSED
;
901 len
= strtoul(separator
+1, &separator
, 16);
903 if (*(separator
++) != ':')
905 ERROR("incomplete write memory packet received, dropping connection");
906 return ERROR_SERVER_REMOTE_CLOSED
;
909 buffer
= malloc(len
);
911 DEBUG("addr: 0x%8.8x, len: 0x%8.8x", addr
, len
);
913 for (i
=0; i
<len
; i
++)
916 sscanf(separator
+ 2*i
, "%2x", &tmp
);
922 /* handle sized writes */
925 retval
= target
->type
->write_memory(target
, addr
, 4, 1, buffer
);
927 retval
= target
->type
->write_memory(target
, addr
, 1, len
, buffer
);
931 retval
= target
->type
->write_memory(target
, addr
, 2, 1, buffer
);
933 retval
= target
->type
->write_memory(target
, addr
, 1, len
, buffer
);
937 retval
= target
->type
->write_memory(target
, addr
, 1, len
, buffer
);
939 /* handle bulk writes */
941 retval
= target_write_buffer(target
, addr
, len
, buffer
);
945 if (retval
== ERROR_OK
)
947 gdb_put_packet(connection
, "OK", 2);
951 if ((retval
= gdb_memory_packet_error(connection
, retval
)) != ERROR_OK
)
960 int gdb_write_memory_binary_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
969 /* skip command character */
972 addr
= strtoul(packet
, &separator
, 16);
974 if (*separator
!= ',')
976 ERROR("incomplete write memory binary packet received, dropping connection");
977 return ERROR_SERVER_REMOTE_CLOSED
;
980 len
= strtoul(separator
+1, &separator
, 16);
982 if (*(separator
++) != ':')
984 ERROR("incomplete write memory binary packet received, dropping connection");
985 return ERROR_SERVER_REMOTE_CLOSED
;
990 buffer
= malloc(len
);
992 DEBUG("addr: 0x%8.8x, len: 0x%8.8x", addr
, len
);
994 memcpy( buffer
, separator
, len
);
1000 retval
= target
->type
->write_memory(target
, addr
, 4, 1, buffer
);
1002 retval
= target
->type
->write_memory(target
, addr
, 1, len
, buffer
);
1005 if ((addr
% 2) == 0)
1006 retval
= target
->type
->write_memory(target
, addr
, 2, 1, buffer
);
1008 retval
= target
->type
->write_memory(target
, addr
, 1, len
, buffer
);
1012 retval
= target
->type
->write_memory(target
, addr
, 1, len
, buffer
);
1015 retval
= target_write_buffer(target
, addr
, len
, buffer
);
1022 if (retval
== ERROR_OK
)
1024 gdb_put_packet(connection
, "OK", 2);
1028 if ((retval
= gdb_memory_packet_error(connection
, retval
)) != ERROR_OK
)
1035 void gdb_step_continue_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1042 if (packet_size
> 1)
1044 packet
[packet_size
] = 0;
1045 address
= strtoul(packet
+ 1, NULL
, 16);
1052 if (packet
[0] == 'c')
1055 target
->type
->resume(target
, current
, address
, 0, 0); /* resume at current address, don't handle breakpoints, not debugging */
1057 else if (packet
[0] == 's')
1060 target
->type
->step(target
, current
, address
, 0); /* step at current or address, don't handle breakpoints */
1064 int gdb_bp_wp_packet_error(connection_t
*connection
, int retval
)
1068 case ERROR_TARGET_NOT_HALTED
:
1069 ERROR("gdb tried to set a breakpoint but we're not halted, dropping connection");
1070 return ERROR_SERVER_REMOTE_CLOSED
;
1072 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE
:
1073 gdb_send_error(connection
, EBUSY
);
1076 ERROR("BUG: unexpected error %i", retval
);
1083 int gdb_breakpoint_watchpoint_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
1086 enum breakpoint_type bp_type
;
1087 enum watchpoint_rw wp_type
;
1095 type
= strtoul(packet
+ 1, &separator
, 16);
1097 if (type
== 0) /* memory breakpoint */
1098 bp_type
= BKPT_SOFT
;
1099 else if (type
== 1) /* hardware breakpoint */
1100 bp_type
= BKPT_HARD
;
1101 else if (type
== 2) /* write watchpoint */
1102 wp_type
= WPT_WRITE
;
1103 else if (type
== 3) /* read watchpoint */
1105 else if (type
== 4) /* access watchpoint */
1106 wp_type
= WPT_ACCESS
;
1108 if (*separator
!= ',')
1110 ERROR("incomplete breakpoint/watchpoint packet received, dropping connection");
1111 return ERROR_SERVER_REMOTE_CLOSED
;
1114 address
= strtoul(separator
+1, &separator
, 16);
1116 if (*separator
!= ',')
1118 ERROR("incomplete breakpoint/watchpoint packet received, dropping connection");
1119 return ERROR_SERVER_REMOTE_CLOSED
;
1122 size
= strtoul(separator
+1, &separator
, 16);
1128 if (packet
[0] == 'Z')
1130 if ((retval
= breakpoint_add(target
, address
, size
, bp_type
)) != ERROR_OK
)
1132 if ((retval
= gdb_bp_wp_packet_error(connection
, retval
)) != ERROR_OK
)
1137 gdb_put_packet(connection
, "OK", 2);
1142 breakpoint_remove(target
, address
);
1143 gdb_put_packet(connection
, "OK", 2);
1150 if (packet
[0] == 'Z')
1152 if ((retval
= watchpoint_add(target
, address
, size
, type
-2, 0, 0xffffffffu
)) != ERROR_OK
)
1154 if ((retval
= gdb_bp_wp_packet_error(connection
, retval
)) != ERROR_OK
)
1159 gdb_put_packet(connection
, "OK", 2);
1164 watchpoint_remove(target
, address
);
1165 gdb_put_packet(connection
, "OK", 2);
1176 void gdb_query_packet(connection_t
*connection
, char *packet
, int packet_size
)
1178 command_context_t
*cmd_ctx
= connection
->cmd_ctx
;
1180 if (strstr(packet
, "qRcmd,"))
1182 if (packet_size
> 6)
1186 cmd
= malloc((packet_size
- 6)/2 + 1);
1187 for (i
=0; i
< (packet_size
- 6)/2; i
++)
1190 sscanf(packet
+ 6 + 2*i
, "%2x", &tmp
);
1193 cmd
[(packet_size
- 6)/2] = 0x0;
1194 command_run_line(cmd_ctx
, cmd
);
1197 gdb_put_packet(connection
, "OK", 2);
1201 gdb_put_packet(connection
, "", 0);
1204 int gdb_input(connection_t
*connection
)
1206 gdb_service_t
*gdb_service
= connection
->service
->priv
;
1207 target_t
*target
= gdb_service
->target
;
1208 char packet
[GDB_BUFFER_SIZE
];
1211 gdb_connection_t
*gdb_con
= connection
->priv
;
1213 /* drain input buffer */
1216 packet_size
= GDB_BUFFER_SIZE
-1;
1217 if ((retval
= gdb_get_packet(connection
, packet
, &packet_size
)) != ERROR_OK
)
1221 case ERROR_GDB_BUFFER_TOO_SMALL
:
1222 ERROR("BUG: buffer supplied for gdb packet was too small");
1224 case ERROR_SERVER_REMOTE_CLOSED
:
1225 return ERROR_SERVER_REMOTE_CLOSED
;
1227 ERROR("BUG: unexpected error");
1232 /* terminate with zero */
1233 packet
[packet_size
] = 0;
1235 DEBUG("recevied packet: '%s'", packet
);
1237 if (packet_size
> 0)
1243 /* Hct... -- set thread
1244 * we don't have threads, send empty reply */
1245 gdb_put_packet(connection
, NULL
, 0);
1248 gdb_query_packet(connection
, packet
, packet_size
);
1251 retval
= gdb_get_registers_packet(connection
, target
, packet
, packet_size
);
1254 retval
= gdb_set_registers_packet(connection
, target
, packet
, packet_size
);
1257 retval
= gdb_get_register_packet(connection
, target
, packet
, packet_size
);
1260 retval
= gdb_set_register_packet(connection
, target
, packet
, packet_size
);
1263 retval
= gdb_read_memory_packet(connection
, target
, packet
, packet_size
);
1266 retval
= gdb_write_memory_packet(connection
, target
, packet
, packet_size
);
1270 retval
= gdb_breakpoint_watchpoint_packet(connection
, target
, packet
, packet_size
);
1273 gdb_last_signal_packet(connection
, target
, packet
, packet_size
);
1277 gdb_step_continue_packet(connection
, target
, packet
, packet_size
);
1280 target
->type
->resume(target
, 1, 0, 1, 0);
1281 gdb_put_packet(connection
, "OK", 2);
1284 if ((retval
= gdb_write_memory_binary_packet(connection
, target
, packet
, packet_size
)) != ERROR_OK
)
1288 gdb_put_packet(connection
, "OK", 2);
1289 return ERROR_SERVER_REMOTE_CLOSED
;
1291 /* ignore unkown packets */
1292 DEBUG("ignoring 0x%2.2x packet", packet
[0]);
1293 gdb_put_packet(connection
, NULL
, 0);
1297 /* if a packet handler returned an error, exit input loop */
1298 if (retval
!= ERROR_OK
)
1302 if (gdb_con
->ctrl_c
)
1304 if (target
->state
== TARGET_RUNNING
)
1306 target
->type
->halt(target
);
1307 gdb_con
->ctrl_c
= 0;
1311 } while (gdb_con
->buf_cnt
> 0);
1318 gdb_service_t
*gdb_service
;
1319 target_t
*target
= targets
;
1324 WARNING("no gdb ports allocated as no target has been specified");
1330 WARNING("no gdb port specified, using default port 3333");
1336 char service_name
[8];
1338 snprintf(service_name
, 8, "gdb-%2.2i", i
);
1340 gdb_service
= malloc(sizeof(gdb_service_t
));
1341 gdb_service
->target
= target
;
1343 add_service("gdb", CONNECTION_GDB
, gdb_port
+ i
, 1, gdb_new_connection
, gdb_input
, gdb_connection_closed
, gdb_service
);
1345 DEBUG("gdb service for target %s at port %i", target
->type
->name
, gdb_port
+ i
);
1348 target
= target
->next
;
1354 /* daemon configuration command gdb_port */
1355 int handle_gdb_port_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1360 /* only if the port wasn't overwritten by cmdline */
1362 gdb_port
= strtoul(args
[0], NULL
, 0);
1367 int gdb_register_commands(command_context_t
*command_context
)
1369 register_command(command_context
, NULL
, "gdb_port", handle_gdb_port_command
,
1370 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)