X-Git-Url: https://review.openocd.org/gitweb?a=blobdiff_plain;f=src%2Fserver%2Fgdb_server.c;h=3f9e1e71a7dd0cbb50030acbc43b67eda735565f;hb=2a781c0346fbb6817411fb0dbfb4ff3b6576d676;hp=562eb13a4076a016d91d8eccf00db020d2dd1e55;hpb=2de5a007d1d5ae35cb8c45cf95de4f1d707854a1;p=openocd.git diff --git a/src/server/gdb_server.c b/src/server/gdb_server.c index 562eb13a40..3f9e1e71a7 100644 --- a/src/server/gdb_server.c +++ b/src/server/gdb_server.c @@ -37,6 +37,7 @@ #include "jtag.h" #include "breakpoints.h" #include "flash.h" +#include "target.h" #include "target_request.h" #include "configuration.h" @@ -168,10 +169,18 @@ int gdb_get_char(connection_t *connection, int* next_char) for (;;) { - retval=check_pending(connection, 1, NULL); - if (retval!=ERROR_OK) - return retval; - gdb_con->buf_cnt = read_socket(connection->fd, gdb_con->buffer, GDB_BUFFER_SIZE); + if (connection->service->type == CONNECTION_PIPE) + { + gdb_con->buf_cnt = read(connection->fd, gdb_con->buffer, GDB_BUFFER_SIZE); + } + else + { + retval = check_pending(connection, 1, NULL); + if (retval != ERROR_OK) + return retval; + gdb_con->buf_cnt = read_socket(connection->fd, gdb_con->buffer, GDB_BUFFER_SIZE); + } + if (gdb_con->buf_cnt > 0) { break; @@ -268,9 +277,20 @@ int gdb_write(connection_t *connection, void *data, int len) if (gdb_con->closed) return ERROR_SERVER_REMOTE_CLOSED; - if (write_socket(connection->fd, data, len) == len) + if (connection->service->type == CONNECTION_PIPE) { - return ERROR_OK; + /* write to stdout */ + if (write(STDOUT_FILENO, data, len) == len) + { + return ERROR_OK; + } + } + else + { + if (write_socket(connection->fd, data, len) == len) + { + return ERROR_OK; + } } gdb_con->closed = 1; return ERROR_SERVER_REMOTE_CLOSED; @@ -305,8 +325,8 @@ int gdb_put_packet_inner(connection_t *connection, char *buffer, int len) break; if ((retval = gdb_get_char(connection, &reply)) != ERROR_OK) return retval; - if( reply == '$' ){ - // fix a problem with some IAR tools + if( reply == '$' ){ + /* fix a problem with some IAR tools */ gdb_putback_char( connection, reply ); LOG_DEBUG("Unexpected start of new packet"); break; @@ -393,17 +413,17 @@ int gdb_put_packet_inner(connection_t *connection, char *buffer, int len) gdb_putback_char( connection, reply ); return ERROR_OK; } else { - + LOG_ERROR("unknown character(1) 0x%2.2x in reply, dropping connection", reply); gdb_con->closed=1; return ERROR_SERVER_REMOTE_CLOSED; } - } + } else if( reply == '$' ){ LOG_ERROR("GDB missing ack(2) - assumed good"); gdb_putback_char( connection, reply ); return ERROR_OK; - } + } else { LOG_ERROR("unknown character(2) 0x%2.2x in reply, dropping connection", reply); @@ -670,6 +690,7 @@ static void gdb_frontend_halted(struct target_s *target, connection_t *connectio { char sig_reply[4]; int signal; + /* stop forwarding log packets! */ log_remove_callback(gdb_log_callback, connection); @@ -700,6 +721,9 @@ int gdb_target_callback_event_handler(struct target_s *target, enum target_event case TARGET_EVENT_EARLY_HALTED: gdb_frontend_halted(target, connection); break; + case TARGET_EVENT_HALTED: + target_call_event_callbacks(target, TARGET_EVENT_GDB_END); + break; case TARGET_EVENT_GDB_FLASH_ERASE_START: target_handle_event( target, TARGET_EVENT_OLD_gdb_program_config ); if((retval = jtag_execute_queue()) != ERROR_OK) @@ -714,7 +738,6 @@ int gdb_target_callback_event_handler(struct target_s *target, enum target_event return ERROR_OK; } - int gdb_new_connection(connection_t *connection) { gdb_connection_t *gdb_connection = malloc(sizeof(gdb_connection_t)); @@ -787,7 +810,7 @@ int gdb_new_connection(connection_t *connection) return ERROR_OK; } -void gdb_connection_closed(connection_t *connection) +int gdb_connection_closed(connection_t *connection) { gdb_service_t *gdb_service = connection->service->priv; gdb_connection_t *gdb_connection = connection->priv; @@ -814,9 +837,12 @@ void gdb_connection_closed(connection_t *connection) } target_unregister_event_callback(gdb_target_callback_event_handler, connection); + target_call_event_callbacks(gdb_service->target, TARGET_EVENT_GDB_END); log_remove_callback(gdb_log_callback, connection); target_call_event_callbacks(gdb_service->target, TARGET_EVENT_GDB_DETACH ); + + return ERROR_OK; } void gdb_send_error(connection_t *connection, u8 the_error) @@ -839,9 +865,23 @@ int gdb_last_signal_packet(connection_t *connection, target_t *target, char* pac return ERROR_OK; } -/* Convert register to string of bits. NB! The # of bits in the +static int gdb_reg_pos(target_t *target, int pos, int len) +{ + if (target->endianness == TARGET_LITTLE_ENDIAN) + return pos; + else + return len - 1 - pos; +} + +/* Convert register to string of bytes. NB! The # of bits in the * register might be non-divisible by 8(a byte), in which - * case an entire byte is shown. */ + * case an entire byte is shown. + * + * NB! the format on the wire is the target endianess + * + * The format of reg->value is little endian + * + */ void gdb_str_to_target(target_t *target, char *tstr, reg_t *reg) { int i; @@ -853,26 +893,44 @@ void gdb_str_to_target(target_t *target, char *tstr, reg_t *reg) for (i = 0; i < buf_len; i++) { - tstr[i*2] = DIGITS[(buf[i]>>4) & 0xf]; - tstr[i*2+1] = DIGITS[buf[i]&0xf]; + int j = gdb_reg_pos(target, i, buf_len); + tstr[i*2] = DIGITS[(buf[j]>>4) & 0xf]; + tstr[i*2+1] = DIGITS[buf[j]&0xf]; } } -void gdb_target_to_str(target_t *target, char *tstr, char *str) +static int hextoint(char c) { - int str_len = strlen(tstr); - int i; + if (c>='0'&&c<='9') + { + return c-'0'; + } + c=toupper(c); + if (c>='A'&&c<='F') + { + return c-'A'+10; + } + LOG_ERROR("BUG: invalid register value %08x", c); + return 0; +} +/* copy over in register buffer */ +void gdb_target_to_reg(target_t *target, char *tstr, int str_len, u8 *bin) +{ if (str_len % 2) { LOG_ERROR("BUG: gdb value with uneven number of characters encountered"); exit(-1); } + int i; for (i = 0; i < str_len; i+=2) { - str[str_len - i - 1] = tstr[i + 1]; - str[str_len - i - 2] = tstr[i]; + u8 t = hextoint(tstr[i])<<4; + t |= hextoint(tstr[i+1]); + + int j = gdb_reg_pos(target, i/2, str_len/2); + bin[j] = t; } } @@ -957,16 +1015,16 @@ int gdb_set_registers_packet(connection_t *connection, target_t *target, char *p for (i = 0; i < reg_list_size; i++) { u8 *bin_buf; - char *hex_buf; - reg_arch_type_t *arch_type; + int chars = (CEIL(reg_list[i]->size, 8) * 2); - /* convert from GDB-string (target-endian) to hex-string (big-endian) */ - hex_buf = malloc(CEIL(reg_list[i]->size, 8) * 2); - gdb_target_to_str(target, packet_p, hex_buf); + if (packet_p + chars > packet + packet_size) + { + LOG_ERROR("BUG: register packet is too small for registers"); + } - /* convert hex-string to binary buffer */ + reg_arch_type_t *arch_type; bin_buf = malloc(CEIL(reg_list[i]->size, 8)); - str_to_buf(hex_buf, CEIL(reg_list[i]->size, 8) * 2, bin_buf, reg_list[i]->size, 16); + gdb_target_to_reg(target, packet_p, chars, bin_buf); /* get register arch_type, and call set method */ arch_type = register_get_arch_type(reg_list[i]->arch_type); @@ -974,10 +1032,10 @@ int gdb_set_registers_packet(connection_t *connection, target_t *target, char *p arch_type->set(reg_list[i], bin_buf); /* advance packet pointer */ - packet_p += (CEIL(reg_list[i]->size, 8) * 2); + packet_p += chars; + free(bin_buf); - free(hex_buf); } /* free reg_t *reg_list[] array allocated by get_gdb_reg_list */ @@ -1026,7 +1084,6 @@ int gdb_get_register_packet(connection_t *connection, target_t *target, char *pa int gdb_set_register_packet(connection_t *connection, target_t *target, char *packet, int packet_size) { char *separator; - char *hex_buf; u8 *bin_buf; int reg_num = strtoul(packet + 1, &separator, 16); reg_t **reg_list; @@ -1054,21 +1111,20 @@ int gdb_set_register_packet(connection_t *connection, target_t *target, char *pa } /* convert from GDB-string (target-endian) to hex-string (big-endian) */ - hex_buf = malloc(CEIL(reg_list[reg_num]->size, 8) * 2); - gdb_target_to_str(target, separator + 1, hex_buf); - - /* convert hex-string to binary buffer */ bin_buf = malloc(CEIL(reg_list[reg_num]->size, 8)); - str_to_buf(hex_buf, CEIL(reg_list[reg_num]->size, 8) * 2, bin_buf, reg_list[reg_num]->size, 16); + int chars = (CEIL(reg_list[reg_num]->size, 8) * 2); + + /* fix!!! add some sanity checks on packet size here */ - /* get register arch_type, and call set method */ + gdb_target_to_reg(target, separator + 1, chars, bin_buf); + + /* get register arch_type, and call set method */ arch_type = register_get_arch_type(reg_list[reg_num]->arch_type); arch_type->set(reg_list[reg_num], bin_buf); gdb_put_packet(connection, "OK", 2); free(bin_buf); - free(hex_buf); free(reg_list); return ERROR_OK; @@ -1135,7 +1191,7 @@ int gdb_read_memory_packet(connection_t *connection, target_t *target, char *pac retval = target_read_buffer(target, addr, len, buffer); - if ((retval == ERROR_TARGET_DATA_ABORT) && (!gdb_report_data_abort)) + if ((retval!=ERROR_OK)&&!gdb_report_data_abort) { /* TODO : Here we have to lie and send back all zero's lest stack traces won't work. * At some point this might be fixed in GDB, in which case this code can be removed. @@ -1982,7 +2038,7 @@ int gdb_input_inner(connection_t *connection) if( LOG_LEVEL_IS( LOG_LVL_DEBUG ) ){ if( packet[0] == 'X' ){ - // binary packets spew junk into the debug log stream + // binary packets spew junk into the debug log stream char buf[ 50 ]; int x; for( x = 0 ; (x < 49) && (packet[x] != ':') ; x++ ){ @@ -2051,6 +2107,7 @@ int gdb_input_inner(connection_t *connection) gdb_connection_t *gdb_con = connection->priv; gdb_con->frontend_state = TARGET_RUNNING; log_add_callback(gdb_log_callback, connection); + target_call_event_callbacks(target, TARGET_EVENT_GDB_START); int retval=gdb_step_continue_packet(connection, target, packet, packet_size); if (retval!=ERROR_OK) { @@ -2120,7 +2177,7 @@ int gdb_input(connection_t *connection) if (retval == ERROR_SERVER_REMOTE_CLOSED) return retval; - /* logging does not propagate the error, yet can set th gdb_con->closed flag */ + /* logging does not propagate the error, yet can set the gdb_con->closed flag */ if (gdb_con->closed) return ERROR_SERVER_REMOTE_CLOSED; @@ -2139,32 +2196,35 @@ int gdb_init(void) return ERROR_OK; } - if (gdb_port == 0) + if (gdb_port == 0 && server_use_pipes == 0) { LOG_WARNING("no gdb port specified, using default port 3333"); gdb_port = 3333; } - while (target) + if (server_use_pipes) { - char service_name[8]; - - snprintf(service_name, 8, "gdb-%2.2i", target->target_number); + /* only a single gdb connection when using a pipe */ gdb_service = malloc(sizeof(gdb_service_t)); gdb_service->target = target; - add_service("gdb", CONNECTION_GDB, - gdb_port + target->target_number, - 1, gdb_new_connection, gdb_input, - gdb_connection_closed, - gdb_service); + add_service("gdb", CONNECTION_PIPE, 0, 1, gdb_new_connection, gdb_input, gdb_connection_closed, gdb_service); - LOG_DEBUG("gdb service for target %s at port %i", - target->type->name, - gdb_port + target->target_number); + LOG_DEBUG("gdb service for target %s using pipes", target->type->name); + } + else + { + while (target) + { + gdb_service = malloc(sizeof(gdb_service_t)); + gdb_service->target = target; + + add_service("gdb", CONNECTION_TCP, gdb_port + target->target_number, 1, gdb_new_connection, gdb_input, gdb_connection_closed, gdb_service); - target = target->next; + LOG_DEBUG("gdb service for target %s at port %i", target->type->name, gdb_port + target->target_number); + target = target->next; + } } return ERROR_OK; @@ -2174,7 +2234,10 @@ int gdb_init(void) int handle_gdb_port_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { if (argc == 0) + { + command_print(cmd_ctx, "%d", gdb_port); return ERROR_OK; + } /* only if the port wasn't overwritten by cmdline */ if (gdb_port == 0) @@ -2207,10 +2270,11 @@ int handle_gdb_detach_command(struct command_context_s *cmd_ctx, char *cmd, char detach_mode = GDB_DETACH_NOTHING; return ERROR_OK; } + else + LOG_WARNING("invalid gdb_detach configuration directive: %s", args[0]); } - LOG_WARNING("invalid gdb_detach configuration directive: %s", args[0]); - return ERROR_OK; + return ERROR_COMMAND_SYNTAX_ERROR; } int handle_gdb_memory_map_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) @@ -2227,10 +2291,11 @@ int handle_gdb_memory_map_command(struct command_context_s *cmd_ctx, char *cmd, gdb_use_memory_map = 0; return ERROR_OK; } + else + LOG_WARNING("invalid gdb_memory_map configuration directive %s", args[0]); } - LOG_WARNING("invalid gdb_memory_map configuration directive: %s", args[0]); - return ERROR_OK; + return ERROR_COMMAND_SYNTAX_ERROR; } int handle_gdb_flash_program_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) @@ -2247,10 +2312,11 @@ int handle_gdb_flash_program_command(struct command_context_s *cmd_ctx, char *cm gdb_flash_program = 0; return ERROR_OK; } + else + LOG_WARNING("invalid gdb_flash_program configuration directive: %s", args[0]); } - LOG_WARNING("invalid gdb_memory_map configuration directive: %s", args[0]); - return ERROR_OK; + return ERROR_COMMAND_SYNTAX_ERROR; } int handle_gdb_report_data_abort_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) @@ -2267,13 +2333,14 @@ int handle_gdb_report_data_abort_command(struct command_context_s *cmd_ctx, char gdb_report_data_abort = 0; return ERROR_OK; } + else + LOG_WARNING("invalid gdb_report_data_abort configuration directive: %s", args[0]); } - LOG_WARNING("invalid gdb_report_data_abort configuration directive: %s", args[0]); - return ERROR_OK; + return ERROR_COMMAND_SYNTAX_ERROR; } -/* daemon configuration command gdb_port */ +/* gdb_breakpoint_override */ int handle_gdb_breakpoint_override_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { if (argc == 0) @@ -2307,19 +2374,18 @@ int handle_gdb_breakpoint_override_command(struct command_context_s *cmd_ctx, ch return ERROR_OK; } - int gdb_register_commands(command_context_t *command_context) { register_command(command_context, NULL, "gdb_port", handle_gdb_port_command, - COMMAND_CONFIG, ""); + COMMAND_ANY, "daemon configuration command gdb_port"); register_command(command_context, NULL, "gdb_detach", handle_gdb_detach_command, COMMAND_CONFIG, ""); register_command(command_context, NULL, "gdb_memory_map", handle_gdb_memory_map_command, - COMMAND_CONFIG, ""); + COMMAND_CONFIG, "enable or disable memory map"); register_command(command_context, NULL, "gdb_flash_program", handle_gdb_flash_program_command, - COMMAND_CONFIG, ""); + COMMAND_CONFIG, "enable or disable flash program"); register_command(command_context, NULL, "gdb_report_data_abort", handle_gdb_report_data_abort_command, - COMMAND_CONFIG, ""); + COMMAND_CONFIG, "enable or disable report data"); register_command(command_context, NULL, "gdb_breakpoint_override", handle_gdb_breakpoint_override_command, COMMAND_EXEC, "hard/soft/disabled - force breakpoint type for gdb 'break' commands." "The raison d'etre for this option is to support GDB GUI's without "