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 ***************************************************************************/
20 #include "gdb_server.h"
24 #include "binarybuffer.h"
25 #include "breakpoints.h"
36 char * strndup(char * str
, int n
) {
37 unsigned char * tmp
= malloc((size_t)n
+1);
38 if (! tmp
) perror("gdb_server malloc failed");
39 if (strlcpy(tmp
, str
, n
) > n
) perror("gdb_server strndup: too long");
44 #define _DEBUG_GDB_IO_
47 static unsigned short gdb_port
;
49 int gdb_last_signal(target_t
*target
)
51 switch (target
->debug_reason
)
53 case DBG_REASON_DBGRQ
:
54 return 0x2; /* SIGINT */
55 case DBG_REASON_BREAKPOINT
:
56 case DBG_REASON_WATCHPOINT
:
57 case DBG_REASON_WPTANDBKPT
:
58 return 0x05; /* SIGTRAP */
59 case DBG_REASON_SINGLESTEP
:
60 return 0x05; /* SIGTRAP */
61 case DBG_REASON_NOTHALTED
:
62 return 0x0; /* no signal... shouldn't happen */
64 ERROR("BUG: undefined debug reason");
69 int gdb_get_char(connection_t
*connection
, int* next_char
)
71 gdb_connection_t
*gdb_con
= connection
->priv
;
74 if (gdb_con
->buf_cnt
-- > 0)
76 *next_char
= *(gdb_con
->buf_p
++);
77 if (gdb_con
->buf_cnt
> 0)
78 connection
->input_pending
= 1;
80 connection
->input_pending
= 0;
83 DEBUG("returned char '%c' (0x%2.2x)", *next_char
, *next_char
);
89 while ((gdb_con
->buf_cnt
= read(connection
->fd
, gdb_con
->buffer
, GDB_BUFFER_SIZE
)) <= 0)
91 if (gdb_con
->buf_cnt
== 0)
92 return ERROR_SERVER_REMOTE_CLOSED
;
100 return ERROR_SERVER_REMOTE_CLOSED
;
102 return ERROR_SERVER_REMOTE_CLOSED
;
104 ERROR("read: %s", strerror(errno
));
109 debug_buffer
= malloc(gdb_con
->buf_cnt
+ 1);
110 memcpy(debug_buffer
, gdb_con
->buffer
, gdb_con
->buf_cnt
);
111 debug_buffer
[gdb_con
->buf_cnt
] = 0;
112 DEBUG("received '%s'", debug_buffer
);
115 gdb_con
->buf_p
= gdb_con
->buffer
;
117 *next_char
= *(gdb_con
->buf_p
++);
118 if (gdb_con
->buf_cnt
> 0)
119 connection
->input_pending
= 1;
121 connection
->input_pending
= 0;
122 #ifdef _DEBUG_GDB_IO_
123 DEBUG("returned char '%c' (0x%2.2x)", *next_char
, *next_char
);
129 int gdb_put_packet(connection_t
*connection
, char *buffer
, int len
)
132 unsigned char my_checksum
= 0;
137 gdb_connection_t
*gdb_con
= connection
->priv
;
139 for (i
= 0; i
< len
; i
++)
140 my_checksum
+= buffer
[i
];
145 debug_buffer
= malloc(len
+ 1);
146 memcpy(debug_buffer
, buffer
, len
);
147 debug_buffer
[len
] = 0;
148 DEBUG("sending packet '$%s#%2.2x'", debug_buffer
, my_checksum
);
151 write(connection
->fd
, "$", 1);
153 write(connection
->fd
, buffer
, len
);
154 write(connection
->fd
, "#", 1);
156 snprintf(checksum
, 3, "%2.2x", my_checksum
);
158 write(connection
->fd
, checksum
, 2);
160 if ((retval
= gdb_get_char(connection
, &reply
)) != ERROR_OK
)
165 else if (reply
== '-')
166 WARNING("negative reply, retrying");
167 else if (reply
== 0x3)
170 if ((retval
= gdb_get_char(connection
, &reply
)) != ERROR_OK
)
174 else if (reply
== '-')
175 WARNING("negative reply, retrying");
178 ERROR("unknown character 0x%2.2x in reply, dropping connection", reply
);
179 return ERROR_SERVER_REMOTE_CLOSED
;
184 ERROR("unknown character 0x%2.2x in reply, dropping connection", reply
);
185 return ERROR_SERVER_REMOTE_CLOSED
;
192 int gdb_get_packet(connection_t
*connection
, char *buffer
, int *len
)
200 unsigned char my_checksum
= 0;
201 gdb_connection_t
*gdb_con
= connection
->priv
;
207 if ((retval
= gdb_get_char(connection
, &character
)) != ERROR_OK
)
215 WARNING("acknowledgment received, but no packet pending");
218 WARNING("negative acknowledgment, but no packet pending");
225 WARNING("ignoring character 0x%x", character
);
228 } while (character
!= '$');
234 if ((retval
= gdb_get_char(connection
, &character
)) != ERROR_OK
)
238 packet_type
= character
;
242 if( packet_type
== 'X' )
249 /* data transmitted in binary mode (X packet)
250 * uses 0x7d as escape character */
251 my_checksum
+= character
& 0xff;
252 gdb_get_char(connection
, &character
);
253 my_checksum
+= character
& 0xff;
254 buffer
[count
++] = (character
^ 0x20) & 0xff;
257 ERROR("packet buffer too small");
258 return ERROR_GDB_BUFFER_TOO_SMALL
;
262 buffer
[count
++] = character
& 0xff;
263 my_checksum
+= character
& 0xff;
266 ERROR("packet buffer too small");
267 return ERROR_GDB_BUFFER_TOO_SMALL
;
282 buffer
[count
++] = character
& 0xff;
283 my_checksum
+= character
& 0xff;
286 ERROR("packet buffer too small");
287 return ERROR_GDB_BUFFER_TOO_SMALL
;
292 } while (character
!= '#');
296 if ((retval
= gdb_get_char(connection
, &character
)) != ERROR_OK
)
298 checksum
[0] = character
;
299 if ((retval
= gdb_get_char(connection
, &character
)) != ERROR_OK
)
301 checksum
[1] = character
;
304 if (my_checksum
== strtoul(checksum
, NULL
, 16))
306 write (connection
->fd
, "+", 1);
310 WARNING("checksum error, requesting retransmission");
311 write(connection
->fd
, "-", 1);
317 int gdb_output(struct command_context_s
*context
, char* line
)
319 connection_t
*connection
= context
->output_handler_priv
;
323 bin_size
= strlen(line
);
325 hex_buffer
= malloc(bin_size
*2 + 4);
328 for (i
=0; i
<bin_size
; i
++)
329 snprintf(hex_buffer
+ 1 + i
*2, 3, "%2.2x", line
[i
]);
330 hex_buffer
[bin_size
*2+1] = '0';
331 hex_buffer
[bin_size
*2+2] = 'a';
332 hex_buffer
[bin_size
*2+3] = 0x0;
334 gdb_put_packet(connection
, hex_buffer
, bin_size
*2 + 3);
340 int gdb_target_callback_event_handler(struct target_s
*target
, enum target_event event
, void *priv
)
342 connection_t
*connection
= priv
;
343 gdb_connection_t
*gdb_connection
= connection
->priv
;
349 case TARGET_EVENT_HALTED
:
350 if (gdb_connection
->frontend_state
== TARGET_RUNNING
)
352 if (gdb_connection
->ctrl_c
)
355 gdb_connection
->ctrl_c
= 0;
359 signal
= gdb_last_signal(target
);
362 snprintf(sig_reply
, 4, "T%2.2x", signal
);
363 gdb_put_packet(connection
, sig_reply
, 3);
364 gdb_connection
->frontend_state
= TARGET_HALTED
;
367 case TARGET_EVENT_RESUMED
:
368 if (gdb_connection
->frontend_state
== TARGET_HALTED
)
370 gdb_connection
->frontend_state
= TARGET_RUNNING
;
380 int gdb_new_connection(connection_t
*connection
)
382 gdb_connection_t
*gdb_connection
= malloc(sizeof(gdb_connection_t
));
383 gdb_service_t
*gdb_service
= connection
->service
->priv
;
387 connection
->priv
= gdb_connection
;
389 /* initialize gdb connection information */
390 gdb_connection
->buf_p
= gdb_connection
->buffer
;
391 gdb_connection
->buf_cnt
= 0;
392 gdb_connection
->ctrl_c
= 0;
393 gdb_connection
->frontend_state
= TARGET_HALTED
;
395 /* output goes through gdb connection */
396 command_set_output_handler(connection
->cmd_ctx
, gdb_output
, connection
);
398 /* register callback to be informed about target events */
399 target_register_event_callback(gdb_target_callback_event_handler
, connection
);
401 /* a gdb session just attached, put the target in halt mode */
402 if (((retval
= gdb_service
->target
->type
->halt(gdb_service
->target
)) != ERROR_OK
) &&
403 (retval
!= ERROR_TARGET_ALREADY_HALTED
))
405 ERROR("error when trying to halt target");
409 while (gdb_service
->target
->state
!= TARGET_HALTED
)
411 gdb_service
->target
->type
->poll(gdb_service
->target
);
414 /* remove the initial ACK from the incoming buffer */
415 if ((retval
= gdb_get_char(connection
, &initial_ack
)) != ERROR_OK
)
421 int gdb_connection_closed(connection_t
*connection
)
423 if (connection
->priv
)
424 free(connection
->priv
);
426 ERROR("BUG: connection->priv == NULL");
428 target_unregister_event_callback(gdb_target_callback_event_handler
, connection
);
433 int gdb_last_signal_packet(connection_t
*connection
, target_t
*target
, char* packet
, int packet_size
)
438 signal
= gdb_last_signal(target
);
440 snprintf(sig_reply
, 4, "S%2.2x", signal
);
441 gdb_put_packet(connection
, sig_reply
, 3);
446 void gdb_get_registers_packet(connection_t
*connection
, target_t
*target
, char* packet
, int packet_size
)
451 int reg_packet_size
= 0;
458 if ((retval
= target
->type
->get_gdb_reg_list(target
, ®_list
, ®_list_size
)) != ERROR_OK
)
462 case ERROR_TARGET_NOT_HALTED
:
463 ERROR("gdb requested registers, but we're not halted");
466 ERROR("BUG: unexpected error returned by get_gdb_reg_list()");
471 for (i
= 0; i
< reg_list_size
; i
++)
473 reg_packet_size
+= reg_list
[i
]->size
;
476 reg_packet
= malloc(CEIL(reg_packet_size
, 8) * 2);
477 reg_packet_p
= reg_packet
;
479 for (i
= 0; i
< reg_list_size
; i
++)
482 char *hex_buf
= buf_to_char(reg_list
[i
]->value
, reg_list
[i
]->size
);
483 DEBUG("hex_buf: %s", hex_buf
);
484 for (j
= CEIL(reg_list
[i
]->size
, 8) * 2; j
> 0; j
-= 2)
486 *reg_packet_p
++ = hex_buf
[j
- 2];
487 *reg_packet_p
++ = hex_buf
[j
- 1];
492 reg_packet_p
= strndup(reg_packet
, CEIL(reg_packet_size
, 8) * 2);
493 DEBUG("reg_packet: %s", reg_packet_p
);
496 gdb_put_packet(connection
, reg_packet
, CEIL(reg_packet_size
, 8) * 2);
501 void gdb_set_registers_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
511 /* skip command character */
517 WARNING("GDB set_registers packet with uneven characters received");
521 if ((retval
= target
->type
->get_gdb_reg_list(target
, ®_list
, ®_list_size
)) != ERROR_OK
)
525 case ERROR_TARGET_NOT_HALTED
:
526 ERROR("gdb requested registers, but we're not halted");
529 ERROR("BUG: unexpected error returned by get_gdb_reg_list()");
535 for (i
= 0; i
< reg_list_size
; i
++)
537 char_to_buf(packet
, CEIL(reg_list
[i
]->size
, 8) * 2, reg_list
[i
]->value
, reg_list
[i
]->size
);
538 reg_list
[i
]->dirty
= 1;
541 gdb_put_packet(connection
, "OK", 2);
544 void gdb_get_register_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
549 int reg_num
= strtoul(packet
+ 1, NULL
, 16);
557 if ((retval
= target
->type
->get_gdb_reg_list(target
, ®_list
, ®_list_size
)) != ERROR_OK
)
561 case ERROR_TARGET_NOT_HALTED
:
562 ERROR("gdb requested registers, but we're not halted");
565 ERROR("BUG: unexpected error returned by get_gdb_reg_list()");
570 if (reg_list_size
<= reg_num
)
572 ERROR("gdb requested a non-existing register");
576 hex_buf
= buf_to_char(reg_list
[reg_num
]->value
, reg_list
[reg_num
]->size
);
577 reg_packet
= reg_packet_p
= malloc(CEIL(reg_list
[reg_num
]->size
, 8) * 2);
579 for (i
= CEIL(reg_list
[reg_num
]->size
, 8) * 2; i
> 0; i
-= 2)
581 *reg_packet_p
++ = hex_buf
[i
- 2];
582 *reg_packet_p
++ = hex_buf
[i
- 1];
585 gdb_put_packet(connection
, reg_packet
, CEIL(reg_list
[reg_num
]->size
, 8) * 2);
592 void gdb_set_register_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
595 int reg_num
= strtoul(packet
+ 1, &separator
, 16);
602 if ((retval
= target
->type
->get_gdb_reg_list(target
, ®_list
, ®_list_size
)) != ERROR_OK
)
606 case ERROR_TARGET_NOT_HALTED
:
607 ERROR("gdb requested registers, but we're not halted");
610 ERROR("BUG: unexpected error returned by get_gdb_reg_list()");
615 if (reg_list_size
< reg_num
)
617 ERROR("gdb requested a non-existing register");
621 if (*separator
!= '=')
623 ERROR("GDB set register packet, but no '=' following the register number");
627 char_to_buf(separator
+ 1, CEIL(reg_list
[reg_num
]->size
, 8) * 2, reg_list
[reg_num
]->value
, reg_list
[reg_num
]->size
);
628 reg_list
[reg_num
]->dirty
= 1;
630 gdb_put_packet(connection
, "OK", 2);
634 void gdb_read_memory_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
645 /* skip command character */
648 addr
= strtoul(packet
, &separator
, 16);
650 if (*separator
!= ',')
653 len
= strtoul(separator
+1, NULL
, 16);
655 buffer
= malloc(len
);
657 DEBUG("addr: 0x%8.8x, len: 0x%8.8x", addr
, len
);
663 target
->type
->read_memory(target
, addr
, 4, 1, buffer
);
665 target
->type
->read_memory(target
, addr
, 1, len
, buffer
);
669 target
->type
->read_memory(target
, addr
, 2, 1, buffer
);
671 target
->type
->read_memory(target
, addr
, 1, len
, buffer
);
674 if (((addr
% 4) == 0) && ((len
% 4) == 0))
675 target
->type
->read_memory(target
, addr
, 4, len
/ 4, buffer
);
677 target
->type
->read_memory(target
, addr
, 1, len
, buffer
);
680 hex_buffer
= malloc(len
* 2 + 1);
682 for (i
=0; i
<len
; i
++)
683 snprintf(hex_buffer
+ 2*i
, 3, "%2.2x", buffer
[i
]);
685 gdb_put_packet(connection
, hex_buffer
, len
* 2);
691 void gdb_write_memory_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
701 /* skip command character */
704 addr
= strtoul(packet
, &separator
, 16);
706 if (*separator
!= ',')
709 len
= strtoul(separator
+1, &separator
, 16);
711 if (*(separator
++) != ':')
714 buffer
= malloc(len
);
716 DEBUG("addr: 0x%8.8x, len: 0x%8.8x", addr
, len
);
718 for (i
=0; i
<len
; i
++)
721 sscanf(separator
+ 2*i
, "%2x", &tmp
);
727 /* handle sized writes */
730 target
->type
->write_memory(target
, addr
, 4, 1, buffer
);
732 target
->type
->write_memory(target
, addr
, 1, len
, buffer
);
736 target
->type
->write_memory(target
, addr
, 2, 1, buffer
);
738 target
->type
->write_memory(target
, addr
, 1, len
, buffer
);
742 target
->type
->write_memory(target
, addr
, 1, len
, buffer
);
744 /* handle bulk writes */
746 target_write_buffer(target
, addr
, len
, buffer
);
750 gdb_put_packet(connection
, "OK", 2);
755 void gdb_write_memory_binary_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
763 /* skip command character */
766 addr
= strtoul(packet
, &separator
, 16);
768 if (*separator
!= ',')
771 len
= strtoul(separator
+1, &separator
, 16);
773 if (*(separator
++) != ':')
778 buffer
= malloc(len
);
780 DEBUG("addr: 0x%8.8x, len: 0x%8.8x", addr
, len
);
782 memcpy( buffer
, separator
, len
);
788 target
->type
->write_memory(target
, addr
, 4, 1, buffer
);
790 target
->type
->write_memory(target
, addr
, 1, len
, buffer
);
794 target
->type
->write_memory(target
, addr
, 2, 1, buffer
);
796 target
->type
->write_memory(target
, addr
, 1, len
, buffer
);
800 target
->type
->write_memory(target
, addr
, 1, len
, buffer
);
803 target_write_buffer(target
, addr
, len
, buffer
);
810 gdb_put_packet(connection
, "OK", 2);
813 void gdb_step_continue_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
823 packet
[packet_size
] = 0;
824 address
= strtoul(packet
+ 1, NULL
, 16);
831 if (packet
[0] == 'c')
834 target
->type
->resume(target
, current
, address
, 0, 0); /* resume at current address, don't handle breakpoints, not debugging */
836 else if (packet
[0] == 's')
839 target
->type
->step(target
, current
, address
, 0); /* step at current or address, don't handle breakpoints */
843 void gdb_breakpoint_watchpoint_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
846 enum breakpoint_type bp_type
;
847 enum watchpoint_rw wp_type
;
855 type
= strtoul(packet
+ 1, &separator
, 16);
857 if (type
== 0) /* memory breakpoint */
859 else if (type
== 1) /* hardware breakpoint */
861 else if (type
== 2) /* write watchpoint */
863 else if (type
== 3) /* read watchpoint */
865 else if (type
== 4) /* access watchpoint */
866 wp_type
= WPT_ACCESS
;
868 if (*separator
!= ',')
871 address
= strtoul(separator
+1, &separator
, 16);
873 if (*separator
!= ',')
876 size
= strtoul(separator
+1, &separator
, 16);
882 if (packet
[0] == 'Z')
884 if ((retval
= breakpoint_add(target
, address
, size
, bp_type
)) != ERROR_OK
)
886 if (retval
== ERROR_TARGET_RESOURCE_NOT_AVAILABLE
)
888 gdb_put_packet(connection
, "E00", 3);
895 breakpoint_remove(target
, address
);
897 gdb_put_packet(connection
, "OK", 2);
903 if (packet
[0] == 'Z')
904 watchpoint_add(target
, address
, size
, type
-2, 0, 0xffffffffu
);
906 watchpoint_remove(target
, address
);
907 gdb_put_packet(connection
, "OK", 2);
916 void gdb_query_packet(connection_t
*connection
, char *packet
, int packet_size
)
918 command_context_t
*cmd_ctx
= connection
->cmd_ctx
;
919 gdb_service_t
*gdb_service
= connection
->service
->priv
;
920 target_t
*target
= gdb_service
->target
;
922 if (strstr(packet
, "qRcmd,"))
928 cmd
= malloc((packet_size
- 6)/2 + 1);
929 for (i
=0; i
< (packet_size
- 6)/2; i
++)
932 sscanf(packet
+ 6 + 2*i
, "%2x", &tmp
);
935 cmd
[(packet_size
- 6)/2] = 0x0;
936 command_run_line(cmd_ctx
, cmd
);
939 gdb_put_packet(connection
, "OK", 2);
943 gdb_put_packet(connection
, "", 0);
946 int gdb_input(connection_t
*connection
)
948 gdb_service_t
*gdb_service
= connection
->service
->priv
;
949 target_t
*target
= gdb_service
->target
;
950 char packet
[GDB_BUFFER_SIZE
];
953 gdb_connection_t
*gdb_con
= connection
->priv
;
955 /* drain input buffer */
958 packet_size
= GDB_BUFFER_SIZE
-1;
959 if ((retval
= gdb_get_packet(connection
, packet
, &packet_size
)) != ERROR_OK
)
963 case ERROR_GDB_BUFFER_TOO_SMALL
:
964 ERROR("BUG: buffer supplied for gdb packet was too small");
966 case ERROR_SERVER_REMOTE_CLOSED
:
967 return ERROR_SERVER_REMOTE_CLOSED
;
969 ERROR("unexpected error");
974 /* terminate with zero */
975 packet
[packet_size
] = 0;
977 DEBUG("recevied packet: '%s'", packet
);
984 /* Hct... -- set thread
985 * we don't have threads, send empty reply */
986 gdb_put_packet(connection
, NULL
, 0);
989 gdb_query_packet(connection
, packet
, packet_size
);
992 gdb_get_registers_packet(connection
, target
, packet
, packet_size
);
995 gdb_set_registers_packet(connection
, target
, packet
, packet_size
);
998 gdb_get_register_packet(connection
, target
, packet
, packet_size
);
1001 gdb_set_register_packet(connection
, target
, packet
, packet_size
);
1004 gdb_read_memory_packet(connection
, target
, packet
, packet_size
);
1007 gdb_write_memory_packet(connection
, target
, packet
, packet_size
);
1011 gdb_breakpoint_watchpoint_packet(connection
, target
, packet
, packet_size
);
1014 gdb_last_signal_packet(connection
, target
, packet
, packet_size
);
1018 gdb_step_continue_packet(connection
, target
, packet
, packet_size
);
1021 target
->type
->resume(target
, 1, 0, 1, 0);
1022 gdb_put_packet(connection
, "OK", 2);
1025 gdb_write_memory_binary_packet(connection
, target
, packet
, packet_size
);
1028 gdb_put_packet(connection
, "OK", 2);
1029 return ERROR_SERVER_REMOTE_CLOSED
;
1031 /* ignore unkown packets */
1032 DEBUG("ignoring 0x%2.2x packet", packet
[0]);
1033 gdb_put_packet(connection
, NULL
, 0);
1038 if (gdb_con
->ctrl_c
)
1040 if (target
->state
== TARGET_RUNNING
)
1042 target
->type
->halt(target
);
1043 gdb_con
->ctrl_c
= 0;
1047 } while (gdb_con
->buf_cnt
> 0);
1054 gdb_service_t
*gdb_service
;
1055 target_t
*target
= targets
;
1060 WARNING("no gdb ports allocated as no target has been specified");
1066 WARNING("no gdb port specified, using default port 3333");
1072 char service_name
[8];
1074 snprintf(service_name
, 8, "gdb-%2.2i", i
);
1076 gdb_service
= malloc(sizeof(gdb_service_t
));
1077 gdb_service
->target
= target
;
1079 add_service("gdb", CONNECTION_GDB
, gdb_port
+ i
, 1, gdb_new_connection
, gdb_input
, gdb_connection_closed
, gdb_service
);
1081 DEBUG("gdb service for target %s at port %i", target
->type
->name
, gdb_port
+ i
);
1083 target
= target
->next
;
1089 /* daemon configuration command gdb_port */
1090 int handle_gdb_port_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1095 /* only if the port wasn't overwritten by cmdline */
1097 gdb_port
= strtoul(args
[0], NULL
, 0);
1102 int gdb_register_commands(command_context_t
*command_context
)
1104 register_command(command_context
, NULL
, "gdb_port", handle_gdb_port_command
,
1105 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)