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_put_packet(connection_t
*connection
, char *buffer
, int len
)
144 unsigned char my_checksum
= 0;
149 gdb_connection_t
*gdb_con
= connection
->priv
;
151 for (i
= 0; i
< len
; i
++)
152 my_checksum
+= buffer
[i
];
157 debug_buffer
= malloc(len
+ 1);
158 memcpy(debug_buffer
, buffer
, len
);
159 debug_buffer
[len
] = 0;
160 DEBUG("sending packet '$%s#%2.2x'", debug_buffer
, my_checksum
);
163 write_socket(connection
->fd
, "$", 1);
165 write_socket(connection
->fd
, buffer
, len
);
166 write_socket(connection
->fd
, "#", 1);
168 snprintf(checksum
, 3, "%2.2x", my_checksum
);
170 write_socket(connection
->fd
, checksum
, 2);
172 if ((retval
= gdb_get_char(connection
, &reply
)) != ERROR_OK
)
177 else if (reply
== '-')
178 WARNING("negative reply, retrying");
179 else if (reply
== 0x3)
182 if ((retval
= gdb_get_char(connection
, &reply
)) != ERROR_OK
)
186 else if (reply
== '-')
187 WARNING("negative reply, retrying");
190 ERROR("unknown character 0x%2.2x in reply, dropping connection", reply
);
191 return ERROR_SERVER_REMOTE_CLOSED
;
196 ERROR("unknown character 0x%2.2x in reply, dropping connection", reply
);
197 return ERROR_SERVER_REMOTE_CLOSED
;
204 int gdb_get_packet(connection_t
*connection
, char *buffer
, int *len
)
212 unsigned char my_checksum
= 0;
213 gdb_connection_t
*gdb_con
= connection
->priv
;
219 if ((retval
= gdb_get_char(connection
, &character
)) != ERROR_OK
)
227 WARNING("acknowledgment received, but no packet pending");
230 WARNING("negative acknowledgment, but no packet pending");
237 WARNING("ignoring character 0x%x", character
);
240 } while (character
!= '$');
246 if ((retval
= gdb_get_char(connection
, &character
)) != ERROR_OK
)
250 packet_type
= character
;
254 if( packet_type
== 'X' )
261 /* data transmitted in binary mode (X packet)
262 * uses 0x7d as escape character */
263 my_checksum
+= character
& 0xff;
264 gdb_get_char(connection
, &character
);
265 my_checksum
+= character
& 0xff;
266 buffer
[count
++] = (character
^ 0x20) & 0xff;
269 ERROR("packet buffer too small");
270 return ERROR_GDB_BUFFER_TOO_SMALL
;
274 buffer
[count
++] = character
& 0xff;
275 my_checksum
+= character
& 0xff;
278 ERROR("packet buffer too small");
279 return ERROR_GDB_BUFFER_TOO_SMALL
;
294 buffer
[count
++] = character
& 0xff;
295 my_checksum
+= character
& 0xff;
298 ERROR("packet buffer too small");
299 return ERROR_GDB_BUFFER_TOO_SMALL
;
304 } while (character
!= '#');
308 if ((retval
= gdb_get_char(connection
, &character
)) != ERROR_OK
)
310 checksum
[0] = character
;
311 if ((retval
= gdb_get_char(connection
, &character
)) != ERROR_OK
)
313 checksum
[1] = character
;
316 if (my_checksum
== strtoul(checksum
, NULL
, 16))
318 write_socket(connection
->fd
, "+", 1);
322 WARNING("checksum error, requesting retransmission");
323 write_socket(connection
->fd
, "-", 1);
329 int gdb_output(struct command_context_s
*context
, char* line
)
331 connection_t
*connection
= context
->output_handler_priv
;
335 bin_size
= strlen(line
);
337 hex_buffer
= malloc(bin_size
*2 + 4);
340 for (i
=0; i
<bin_size
; i
++)
341 snprintf(hex_buffer
+ 1 + i
*2, 3, "%2.2x", line
[i
]);
342 hex_buffer
[bin_size
*2+1] = '0';
343 hex_buffer
[bin_size
*2+2] = 'a';
344 hex_buffer
[bin_size
*2+3] = 0x0;
346 gdb_put_packet(connection
, hex_buffer
, bin_size
*2 + 3);
352 int gdb_target_callback_event_handler(struct target_s
*target
, enum target_event event
, void *priv
)
354 connection_t
*connection
= priv
;
355 gdb_connection_t
*gdb_connection
= connection
->priv
;
361 case TARGET_EVENT_HALTED
:
362 if (gdb_connection
->frontend_state
== TARGET_RUNNING
)
364 if (gdb_connection
->ctrl_c
)
367 gdb_connection
->ctrl_c
= 0;
371 signal
= gdb_last_signal(target
);
374 snprintf(sig_reply
, 4, "T%2.2x", signal
);
375 gdb_put_packet(connection
, sig_reply
, 3);
376 gdb_connection
->frontend_state
= TARGET_HALTED
;
379 case TARGET_EVENT_RESUMED
:
380 if (gdb_connection
->frontend_state
== TARGET_HALTED
)
382 gdb_connection
->frontend_state
= TARGET_RUNNING
;
392 int gdb_new_connection(connection_t
*connection
)
394 gdb_connection_t
*gdb_connection
= malloc(sizeof(gdb_connection_t
));
395 gdb_service_t
*gdb_service
= connection
->service
->priv
;
399 connection
->priv
= gdb_connection
;
401 /* initialize gdb connection information */
402 gdb_connection
->buf_p
= gdb_connection
->buffer
;
403 gdb_connection
->buf_cnt
= 0;
404 gdb_connection
->ctrl_c
= 0;
405 gdb_connection
->frontend_state
= TARGET_HALTED
;
407 /* output goes through gdb connection */
408 command_set_output_handler(connection
->cmd_ctx
, gdb_output
, connection
);
410 /* register callback to be informed about target events */
411 target_register_event_callback(gdb_target_callback_event_handler
, connection
);
413 /* a gdb session just attached, put the target in halt mode */
414 if (((retval
= gdb_service
->target
->type
->halt(gdb_service
->target
)) != ERROR_OK
) &&
415 (retval
!= ERROR_TARGET_ALREADY_HALTED
))
417 ERROR("error when trying to halt target");
421 while (gdb_service
->target
->state
!= TARGET_HALTED
)
423 gdb_service
->target
->type
->poll(gdb_service
->target
);
426 /* remove the initial ACK from the incoming buffer */
427 if ((retval
= gdb_get_char(connection
, &initial_ack
)) != ERROR_OK
)
433 int gdb_connection_closed(connection_t
*connection
)
435 if (connection
->priv
)
436 free(connection
->priv
);
438 ERROR("BUG: connection->priv == NULL");
440 target_unregister_event_callback(gdb_target_callback_event_handler
, connection
);
445 int gdb_last_signal_packet(connection_t
*connection
, target_t
*target
, char* packet
, int packet_size
)
450 signal
= gdb_last_signal(target
);
452 snprintf(sig_reply
, 4, "S%2.2x", signal
);
453 gdb_put_packet(connection
, sig_reply
, 3);
458 void gdb_get_registers_packet(connection_t
*connection
, target_t
*target
, char* packet
, int packet_size
)
463 int reg_packet_size
= 0;
470 if ((retval
= target
->type
->get_gdb_reg_list(target
, ®_list
, ®_list_size
)) != ERROR_OK
)
474 case ERROR_TARGET_NOT_HALTED
:
475 ERROR("gdb requested registers, but we're not halted");
478 ERROR("BUG: unexpected error returned by get_gdb_reg_list()");
483 for (i
= 0; i
< reg_list_size
; i
++)
485 reg_packet_size
+= reg_list
[i
]->size
;
488 reg_packet
= malloc(CEIL(reg_packet_size
, 8) * 2);
489 reg_packet_p
= reg_packet
;
491 for (i
= 0; i
< reg_list_size
; i
++)
494 char *hex_buf
= buf_to_char(reg_list
[i
]->value
, reg_list
[i
]->size
);
495 DEBUG("hex_buf: %s", hex_buf
);
496 for (j
= CEIL(reg_list
[i
]->size
, 8) * 2; j
> 0; j
-= 2)
498 *reg_packet_p
++ = hex_buf
[j
- 2];
499 *reg_packet_p
++ = hex_buf
[j
- 1];
504 reg_packet_p
= strndup(reg_packet
, CEIL(reg_packet_size
, 8) * 2);
505 DEBUG("reg_packet: %s", reg_packet_p
);
508 gdb_put_packet(connection
, reg_packet
, CEIL(reg_packet_size
, 8) * 2);
513 void gdb_set_registers_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
523 /* skip command character */
529 WARNING("GDB set_registers packet with uneven characters received");
533 if ((retval
= target
->type
->get_gdb_reg_list(target
, ®_list
, ®_list_size
)) != ERROR_OK
)
537 case ERROR_TARGET_NOT_HALTED
:
538 ERROR("gdb requested registers, but we're not halted");
541 ERROR("BUG: unexpected error returned by get_gdb_reg_list()");
547 for (i
= 0; i
< reg_list_size
; i
++)
549 char_to_buf(packet
, CEIL(reg_list
[i
]->size
, 8) * 2, reg_list
[i
]->value
, reg_list
[i
]->size
);
550 reg_list
[i
]->dirty
= 1;
553 gdb_put_packet(connection
, "OK", 2);
556 void gdb_get_register_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
561 int reg_num
= strtoul(packet
+ 1, NULL
, 16);
569 if ((retval
= target
->type
->get_gdb_reg_list(target
, ®_list
, ®_list_size
)) != ERROR_OK
)
573 case ERROR_TARGET_NOT_HALTED
:
574 ERROR("gdb requested registers, but we're not halted");
577 ERROR("BUG: unexpected error returned by get_gdb_reg_list()");
582 if (reg_list_size
<= reg_num
)
584 ERROR("gdb requested a non-existing register");
588 hex_buf
= buf_to_char(reg_list
[reg_num
]->value
, reg_list
[reg_num
]->size
);
589 reg_packet
= reg_packet_p
= malloc(CEIL(reg_list
[reg_num
]->size
, 8) * 2);
591 for (i
= CEIL(reg_list
[reg_num
]->size
, 8) * 2; i
> 0; i
-= 2)
593 *reg_packet_p
++ = hex_buf
[i
- 2];
594 *reg_packet_p
++ = hex_buf
[i
- 1];
597 gdb_put_packet(connection
, reg_packet
, CEIL(reg_list
[reg_num
]->size
, 8) * 2);
604 void gdb_set_register_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
607 int reg_num
= strtoul(packet
+ 1, &separator
, 16);
614 if ((retval
= target
->type
->get_gdb_reg_list(target
, ®_list
, ®_list_size
)) != ERROR_OK
)
618 case ERROR_TARGET_NOT_HALTED
:
619 ERROR("gdb requested registers, but we're not halted");
622 ERROR("BUG: unexpected error returned by get_gdb_reg_list()");
627 if (reg_list_size
< reg_num
)
629 ERROR("gdb requested a non-existing register");
633 if (*separator
!= '=')
635 ERROR("GDB set register packet, but no '=' following the register number");
639 char_to_buf(separator
+ 1, CEIL(reg_list
[reg_num
]->size
, 8) * 2, reg_list
[reg_num
]->value
, reg_list
[reg_num
]->size
);
640 reg_list
[reg_num
]->dirty
= 1;
642 gdb_put_packet(connection
, "OK", 2);
646 void gdb_read_memory_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
657 /* skip command character */
660 addr
= strtoul(packet
, &separator
, 16);
662 if (*separator
!= ',')
665 len
= strtoul(separator
+1, NULL
, 16);
667 buffer
= malloc(len
);
669 DEBUG("addr: 0x%8.8x, len: 0x%8.8x", addr
, len
);
675 target
->type
->read_memory(target
, addr
, 4, 1, buffer
);
677 target
->type
->read_memory(target
, addr
, 1, len
, buffer
);
681 target
->type
->read_memory(target
, addr
, 2, 1, buffer
);
683 target
->type
->read_memory(target
, addr
, 1, len
, buffer
);
686 if (((addr
% 4) == 0) && ((len
% 4) == 0))
687 target
->type
->read_memory(target
, addr
, 4, len
/ 4, buffer
);
689 target
->type
->read_memory(target
, addr
, 1, len
, buffer
);
692 hex_buffer
= malloc(len
* 2 + 1);
694 for (i
=0; i
<len
; i
++)
695 snprintf(hex_buffer
+ 2*i
, 3, "%2.2x", buffer
[i
]);
697 gdb_put_packet(connection
, hex_buffer
, len
* 2);
703 void gdb_write_memory_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
713 /* skip command character */
716 addr
= strtoul(packet
, &separator
, 16);
718 if (*separator
!= ',')
721 len
= strtoul(separator
+1, &separator
, 16);
723 if (*(separator
++) != ':')
726 buffer
= malloc(len
);
728 DEBUG("addr: 0x%8.8x, len: 0x%8.8x", addr
, len
);
730 for (i
=0; i
<len
; i
++)
733 sscanf(separator
+ 2*i
, "%2x", &tmp
);
739 /* handle sized writes */
742 target
->type
->write_memory(target
, addr
, 4, 1, buffer
);
744 target
->type
->write_memory(target
, addr
, 1, len
, buffer
);
748 target
->type
->write_memory(target
, addr
, 2, 1, buffer
);
750 target
->type
->write_memory(target
, addr
, 1, len
, buffer
);
754 target
->type
->write_memory(target
, addr
, 1, len
, buffer
);
756 /* handle bulk writes */
758 target_write_buffer(target
, addr
, len
, buffer
);
762 gdb_put_packet(connection
, "OK", 2);
767 void gdb_write_memory_binary_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
775 /* skip command character */
778 addr
= strtoul(packet
, &separator
, 16);
780 if (*separator
!= ',')
783 len
= strtoul(separator
+1, &separator
, 16);
785 if (*(separator
++) != ':')
790 buffer
= malloc(len
);
792 DEBUG("addr: 0x%8.8x, len: 0x%8.8x", addr
, len
);
794 memcpy( buffer
, separator
, len
);
800 target
->type
->write_memory(target
, addr
, 4, 1, buffer
);
802 target
->type
->write_memory(target
, addr
, 1, len
, buffer
);
806 target
->type
->write_memory(target
, addr
, 2, 1, buffer
);
808 target
->type
->write_memory(target
, addr
, 1, len
, buffer
);
812 target
->type
->write_memory(target
, addr
, 1, len
, buffer
);
815 target_write_buffer(target
, addr
, len
, buffer
);
822 gdb_put_packet(connection
, "OK", 2);
825 void gdb_step_continue_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
835 packet
[packet_size
] = 0;
836 address
= strtoul(packet
+ 1, NULL
, 16);
843 if (packet
[0] == 'c')
846 target
->type
->resume(target
, current
, address
, 0, 0); /* resume at current address, don't handle breakpoints, not debugging */
848 else if (packet
[0] == 's')
851 target
->type
->step(target
, current
, address
, 0); /* step at current or address, don't handle breakpoints */
855 void gdb_breakpoint_watchpoint_packet(connection_t
*connection
, target_t
*target
, char *packet
, int packet_size
)
858 enum breakpoint_type bp_type
;
859 enum watchpoint_rw wp_type
;
867 type
= strtoul(packet
+ 1, &separator
, 16);
869 if (type
== 0) /* memory breakpoint */
871 else if (type
== 1) /* hardware breakpoint */
873 else if (type
== 2) /* write watchpoint */
875 else if (type
== 3) /* read watchpoint */
877 else if (type
== 4) /* access watchpoint */
878 wp_type
= WPT_ACCESS
;
880 if (*separator
!= ',')
883 address
= strtoul(separator
+1, &separator
, 16);
885 if (*separator
!= ',')
888 size
= strtoul(separator
+1, &separator
, 16);
894 if (packet
[0] == 'Z')
896 if ((retval
= breakpoint_add(target
, address
, size
, bp_type
)) != ERROR_OK
)
898 if (retval
== ERROR_TARGET_RESOURCE_NOT_AVAILABLE
)
900 gdb_put_packet(connection
, "E00", 3);
907 breakpoint_remove(target
, address
);
909 gdb_put_packet(connection
, "OK", 2);
915 if (packet
[0] == 'Z')
916 watchpoint_add(target
, address
, size
, type
-2, 0, 0xffffffffu
);
918 watchpoint_remove(target
, address
);
919 gdb_put_packet(connection
, "OK", 2);
928 void gdb_query_packet(connection_t
*connection
, char *packet
, int packet_size
)
930 command_context_t
*cmd_ctx
= connection
->cmd_ctx
;
931 gdb_service_t
*gdb_service
= connection
->service
->priv
;
932 target_t
*target
= gdb_service
->target
;
934 if (strstr(packet
, "qRcmd,"))
940 cmd
= malloc((packet_size
- 6)/2 + 1);
941 for (i
=0; i
< (packet_size
- 6)/2; i
++)
944 sscanf(packet
+ 6 + 2*i
, "%2x", &tmp
);
947 cmd
[(packet_size
- 6)/2] = 0x0;
948 command_run_line(cmd_ctx
, cmd
);
951 gdb_put_packet(connection
, "OK", 2);
955 gdb_put_packet(connection
, "", 0);
958 int gdb_input(connection_t
*connection
)
960 gdb_service_t
*gdb_service
= connection
->service
->priv
;
961 target_t
*target
= gdb_service
->target
;
962 char packet
[GDB_BUFFER_SIZE
];
965 gdb_connection_t
*gdb_con
= connection
->priv
;
967 /* drain input buffer */
970 packet_size
= GDB_BUFFER_SIZE
-1;
971 if ((retval
= gdb_get_packet(connection
, packet
, &packet_size
)) != ERROR_OK
)
975 case ERROR_GDB_BUFFER_TOO_SMALL
:
976 ERROR("BUG: buffer supplied for gdb packet was too small");
978 case ERROR_SERVER_REMOTE_CLOSED
:
979 return ERROR_SERVER_REMOTE_CLOSED
;
981 ERROR("unexpected error");
986 /* terminate with zero */
987 packet
[packet_size
] = 0;
989 DEBUG("recevied packet: '%s'", packet
);
996 /* Hct... -- set thread
997 * we don't have threads, send empty reply */
998 gdb_put_packet(connection
, NULL
, 0);
1001 gdb_query_packet(connection
, packet
, packet_size
);
1004 gdb_get_registers_packet(connection
, target
, packet
, packet_size
);
1007 gdb_set_registers_packet(connection
, target
, packet
, packet_size
);
1010 gdb_get_register_packet(connection
, target
, packet
, packet_size
);
1013 gdb_set_register_packet(connection
, target
, packet
, packet_size
);
1016 gdb_read_memory_packet(connection
, target
, packet
, packet_size
);
1019 gdb_write_memory_packet(connection
, target
, packet
, packet_size
);
1023 gdb_breakpoint_watchpoint_packet(connection
, target
, packet
, packet_size
);
1026 gdb_last_signal_packet(connection
, target
, packet
, packet_size
);
1030 gdb_step_continue_packet(connection
, target
, packet
, packet_size
);
1033 target
->type
->resume(target
, 1, 0, 1, 0);
1034 gdb_put_packet(connection
, "OK", 2);
1037 gdb_write_memory_binary_packet(connection
, target
, packet
, packet_size
);
1040 gdb_put_packet(connection
, "OK", 2);
1041 return ERROR_SERVER_REMOTE_CLOSED
;
1043 /* ignore unkown packets */
1044 DEBUG("ignoring 0x%2.2x packet", packet
[0]);
1045 gdb_put_packet(connection
, NULL
, 0);
1050 if (gdb_con
->ctrl_c
)
1052 if (target
->state
== TARGET_RUNNING
)
1054 target
->type
->halt(target
);
1055 gdb_con
->ctrl_c
= 0;
1059 } while (gdb_con
->buf_cnt
> 0);
1066 gdb_service_t
*gdb_service
;
1067 target_t
*target
= targets
;
1072 WARNING("no gdb ports allocated as no target has been specified");
1078 WARNING("no gdb port specified, using default port 3333");
1084 char service_name
[8];
1086 snprintf(service_name
, 8, "gdb-%2.2i", i
);
1088 gdb_service
= malloc(sizeof(gdb_service_t
));
1089 gdb_service
->target
= target
;
1091 add_service("gdb", CONNECTION_GDB
, gdb_port
+ i
, 1, gdb_new_connection
, gdb_input
, gdb_connection_closed
, gdb_service
);
1093 DEBUG("gdb service for target %s at port %i", target
->type
->name
, gdb_port
+ i
);
1096 target
= target
->next
;
1102 /* daemon configuration command gdb_port */
1103 int handle_gdb_port_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1108 /* only if the port wasn't overwritten by cmdline */
1110 gdb_port
= strtoul(args
[0], NULL
, 0);
1115 int gdb_register_commands(command_context_t
*command_context
)
1117 register_command(command_context
, NULL
, "gdb_port", handle_gdb_port_command
,
1118 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)