X-Git-Url: https://review.openocd.org/gitweb?a=blobdiff_plain;f=src%2Fserver%2Fgdb_server.c;h=3ed2b1fc4c0310b92bf7268e8ef748f5144f0a9b;hb=af84cd33a2e0b8af31d4c7dbd64cfd0348d65a0e;hp=1c217838ab4eaa219488381d2d5d57b5fdb2846b;hpb=8959de9f679cfd0436d731fd91b88a68b9a75fa6;p=openocd.git diff --git a/src/server/gdb_server.c b/src/server/gdb_server.c index 1c217838ab..3ed2b1fc4c 100644 --- a/src/server/gdb_server.c +++ b/src/server/gdb_server.c @@ -2,7 +2,7 @@ * Copyright (C) 2005 by Dominic Rath * * Dominic.Rath@gmx.de * * * - * Copyright (C) 2007,2008 Øyvind Harboe * + * Copyright (C) 2007,2008 Øyvind Harboe * * oyvind.harboe@zylin.com * * * * Copyright (C) 2008 by Spencer Oliver * @@ -40,6 +40,8 @@ #define _DEBUG_GDB_IO_ #endif +static gdb_connection_t *current_gdb_connection; + static int gdb_breakpoint_override; static enum breakpoint_type gdb_breakpoint_override_type; @@ -50,17 +52,6 @@ static const char *DIGITS = "0123456789abcdef"; static void gdb_log_callback(void *priv, const char *file, int line, const char *function, const char *string); -enum gdb_detach_mode -{ - GDB_DETACH_RESUME, - GDB_DETACH_RESET, - GDB_DETACH_HALT, - GDB_DETACH_NOTHING -}; - -/* target behaviour on gdb detach */ -enum gdb_detach_mode detach_mode = GDB_DETACH_RESUME; - /* number of gdb connections, mainly to supress gdb related debugging spam * in helper/log.c when no gdb connections are actually active */ int gdb_actual_connections; @@ -109,7 +100,7 @@ int check_pending(connection_t *connection, int timeout_s, int *got_data) got_data=&t; *got_data = 0; - if (gdb_con->buf_cnt>0) + if (gdb_con->buf_cnt > 0) { *got_data = 1; return ERROR_OK; @@ -125,7 +116,7 @@ int check_pending(connection_t *connection, int timeout_s, int *got_data) /* This can typically be because a "monitor" command took too long * before printing any progress messages */ - if (timeout_s>0) + if (timeout_s > 0) { return ERROR_GDB_TIMEOUT; } else @@ -319,9 +310,9 @@ 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 == '$' ){ + if (reply == '$') { /* fix a problem with some IAR tools */ - gdb_putback_char( connection, reply ); + gdb_putback_char(connection, reply); LOG_DEBUG("Unexpected start of new packet"); break; } @@ -402,9 +393,9 @@ int gdb_put_packet_inner(connection_t *connection, char *buffer, int len) log_remove_callback(gdb_log_callback, connection); LOG_WARNING("negative reply, retrying"); } - else if ( reply == '$' ){ + else if (reply == '$') { LOG_ERROR("GDB missing ack(1) - assumed good"); - gdb_putback_char( connection, reply ); + gdb_putback_char(connection, reply); return ERROR_OK; } else { @@ -413,9 +404,9 @@ int gdb_put_packet_inner(connection_t *connection, char *buffer, int len) return ERROR_SERVER_REMOTE_CLOSED; } } - else if ( reply == '$' ){ + else if (reply == '$') { LOG_ERROR("GDB missing ack(2) - assumed good"); - gdb_putback_char( connection, reply ); + gdb_putback_char(connection, reply); return ERROR_OK; } else @@ -649,7 +640,7 @@ int gdb_output_con(connection_t *connection, const char* line) return ERROR_GDB_BUFFER_TOO_SMALL; hex_buffer[0] = 'O'; - for (i = 0; ipriv; - /* In the GDB protocol when we are stepping or coninuing execution, + /* In the GDB protocol when we are stepping or continuing execution, * we have a lingering reply. Upon receiving a halted event * when we have that lingering packet, we reply to the original * step or continue packet. @@ -709,17 +700,17 @@ int gdb_target_callback_event_handler(struct target_s *target, enum target_event int retval; connection_t *connection = priv; - target_handle_event( target, event ); + target_handle_event(target, event); switch (event) { - case TARGET_EVENT_EARLY_HALTED: + case TARGET_EVENT_GDB_HALT: 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 ); + target_handle_event(target, TARGET_EVENT_OLD_gdb_program_config); if ((retval = jtag_execute_queue()) != ERROR_OK) { return retval; @@ -750,6 +741,7 @@ int gdb_new_connection(connection_t *connection) gdb_connection->closed = 0; gdb_connection->busy = 0; gdb_connection->noack_mode = 0; + gdb_connection->sync = true; /* send ACK to GDB for debug request */ gdb_write(connection, "+", 1); @@ -767,30 +759,6 @@ int gdb_new_connection(connection_t *connection) /* register callback to be informed about target events */ target_register_event_callback(gdb_target_callback_event_handler, connection); - /* a gdb session just attached, try to put the target in halt mode. - * - * DANGER!!!! - * - * If the halt fails(e.g. target needs a reset, JTAG communication not - * working, etc.), then the GDB connect will succeed as - * the get_gdb_reg_list() will lie and return a register list with - * dummy values. - * - * This allows GDB monitor commands to be run from a GDB init script to - * initialize the target - * - * Also, since the halt() is asynchronous target connect will be - * instantaneous and thus avoiding annoying timeout problems during - * connect. - */ - target_halt(gdb_service->target); - /* FIX!!!! could extended-remote work better here? - * - * wait a tiny bit for halted state or we just continue. The - * GDB register packet will then contain garbage - */ - target_wait_state(gdb_service->target, TARGET_HALTED, 500); - /* remove the initial ACK from the incoming buffer */ if ((retval = gdb_get_char(connection, &initial_ack)) != ERROR_OK) return retval; @@ -800,9 +768,13 @@ int gdb_new_connection(connection_t *connection) */ if (initial_ack != '+') gdb_putback_char(connection, initial_ack); - target_call_event_callbacks(gdb_service->target, TARGET_EVENT_GDB_ATTACH ); + target_call_event_callbacks(gdb_service->target, TARGET_EVENT_GDB_ATTACH); gdb_actual_connections++; + LOG_DEBUG("New GDB Connection: %d, Target %s, state: %s", + gdb_actual_connections, + gdb_service->target->cmd_name, + target_state_name(gdb_service->target)); return ERROR_OK; } @@ -812,7 +784,16 @@ int gdb_connection_closed(connection_t *connection) gdb_service_t *gdb_service = connection->service->priv; gdb_connection_t *gdb_connection = connection->priv; + /* we're done forwarding messages. Tear down callback before + * cleaning up connection. + */ + log_remove_callback(gdb_log_callback, connection); + gdb_actual_connections--; + LOG_DEBUG("GDB Close, Target: %s, state: %s, gdb_actual_connections=%d", + gdb_service->target->cmd_name, + target_state_name(gdb_service->target), + gdb_actual_connections); /* see if an image built with vFlash commands is left */ if (gdb_connection->vflash_image) @@ -835,11 +816,12 @@ int gdb_connection_closed(connection_t *connection) LOG_ERROR("BUG: connection->priv == NULL"); } + 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 ); + target_call_event_callbacks(gdb_service->target, TARGET_EVENT_GDB_DETACH); return ERROR_OK; } @@ -847,7 +829,7 @@ int gdb_connection_closed(connection_t *connection) void gdb_send_error(connection_t *connection, uint8_t the_error) { char err[4]; - snprintf(err, 4, "E%2.2X", the_error ); + snprintf(err, 4, "E%2.2X", the_error); gdb_put_packet(connection, err, 3); } @@ -1268,7 +1250,7 @@ int gdb_write_memory_packet(connection_t *connection, target_t *target, char *pa LOG_DEBUG("addr: 0x%8.8" PRIx32 ", len: 0x%8.8" PRIx32 "", addr, len); - for (i = 0; ibase == b2->base) { return 0; - } else if (b1->base>b2->base) + } else if (b1->base > b2->base) { return 1; } else @@ -1595,7 +1577,11 @@ int gdb_query_packet(connection_t *connection, target_t *target, char *packet, i /* We want to print all debug output to GDB connection */ log_add_callback(gdb_log_callback, connection); target_call_timer_callbacks_now(); + /* some commands need to know the GDB connection, make note of current + * GDB connection. */ + current_gdb_connection = gdb_connection; command_run_line(cmd_ctx, cmd); + current_gdb_connection = NULL; target_call_timer_callbacks_now(); log_remove_callback(gdb_log_callback, connection); free(cmd); @@ -1654,7 +1640,7 @@ int gdb_query_packet(connection_t *connection, target_t *target, char *packet, i xml_printf(&retval, &buffer, &pos, &size, "PacketSize=%x;qXfer:memory-map:read%c;qXfer:features:read-;QStartNoAckMode+", - (GDB_BUFFER_SIZE - 1), ((gdb_use_memory_map == 1) && (flash_get_bank_count()>0)) ? '+' : '-'); + (GDB_BUFFER_SIZE - 1), ((gdb_use_memory_map == 1) && (flash_get_bank_count() > 0)) ? '+' : '-'); if (retval != ERROR_OK) { @@ -1667,7 +1653,7 @@ int gdb_query_packet(connection_t *connection, target_t *target, char *packet, i return ERROR_OK; } - else if (strstr(packet, "qXfer:memory-map:read::") && (flash_get_bank_count()>0)) + else if (strstr(packet, "qXfer:memory-map:read::") && (flash_get_bank_count() > 0)) { /* We get away with only specifying flash here. Regions that are not * specified are treated as if we provided no memory map(if not we @@ -1702,7 +1688,7 @@ int gdb_query_packet(connection_t *connection, target_t *target, char *packet, i flash_bank_t **banks = malloc(sizeof(flash_bank_t *)*flash_get_bank_count()); int i; - for (i = 0; ibase) + if (ram_start < p->base) { xml_printf(&retval, &xml, &pos, &size, "\n", ram_start, p->base-ram_start); @@ -1800,7 +1786,7 @@ int gdb_query_packet(connection_t *connection, target_t *target, char *packet, i } xml_printf(&retval, &xml, &pos, &size, \ - "l\narm\n\n"); + "l < target version=\"1.0\">\n < architecture > arm\n\n"); if (retval != ERROR_OK) { @@ -1872,7 +1858,7 @@ int gdb_v_packet(connection_t *connection, target_t *target, char *packet, int p /* perform any target specific operations before the erase */ target_call_event_callbacks(gdb_service->target, TARGET_EVENT_GDB_FLASH_ERASE_START); - result = flash_erase_address_range(gdb_service->target, addr, length ); + result = flash_erase_address_range(gdb_service->target, addr, length); target_call_event_callbacks(gdb_service->target, TARGET_EVENT_GDB_FLASH_ERASE_END); /* perform erase */ @@ -1937,7 +1923,7 @@ int gdb_v_packet(connection_t *connection, target_t *target, char *packet, int p target_call_event_callbacks(gdb_service->target, TARGET_EVENT_GDB_FLASH_WRITE_START); result = flash_write(gdb_service->target, gdb_connection->vflash_image, &written, 0); target_call_event_callbacks(gdb_service->target, TARGET_EVENT_GDB_FLASH_WRITE_END); - if ( result != ERROR_OK) + if (result != ERROR_OK) { if (result == ERROR_FLASH_DST_OUT_OF_BANK) gdb_put_packet(connection, "E.memtype", 9); @@ -1963,29 +1949,11 @@ int gdb_v_packet(connection_t *connection, target_t *target, char *packet, int p int gdb_detach(connection_t *connection, target_t *target) { + gdb_service_t *gdb_service = connection->service->priv; - switch ( detach_mode ) - { - case GDB_DETACH_RESUME: - target_handle_event( target, TARGET_EVENT_OLD_pre_resume ); - target_resume(target, 1, 0, 1, 0); - break; - - case GDB_DETACH_RESET: - /* FIX?? make this configurable?? */ - target_process_reset(connection->cmd_ctx, RESET_HALT); - break; - - case GDB_DETACH_HALT: - target_halt(target); - break; - - case GDB_DETACH_NOTHING: - break; - } + target_call_event_callbacks(gdb_service->target, TARGET_EVENT_GDB_DETACH); - gdb_put_packet(connection, "OK", 2); - return ERROR_OK; + return gdb_put_packet(connection, "OK", 2); } static void gdb_log_callback(void *priv, const char *file, int line, @@ -2036,18 +2004,18 @@ int gdb_input_inner(connection_t *connection) /* terminate with zero */ packet[packet_size] = 0; - if ( LOG_LEVEL_IS( LOG_LVL_DEBUG ) ){ - if ( packet[0] == 'X' ){ + if (LOG_LEVEL_IS(LOG_LVL_DEBUG)) { + if (packet[0] == 'X') { // binary packets spew junk into the debug log stream char buf[ 50 ]; int x; - for ( x = 0 ; (x < 49) && (packet[x] != ':') ; x++ ){ + for (x = 0 ; (x < 49) && (packet[x] != ':') ; x++) { buf[x] = packet[x]; } buf[x] = 0; - LOG_DEBUG("received packet: '%s:'", buf ); + LOG_DEBUG("received packet: '%s:'", buf); } else { - LOG_DEBUG("received packet: '%s'", packet ); + LOG_DEBUG("received packet: '%s'", packet); } } @@ -2093,20 +2061,52 @@ int gdb_input_inner(connection_t *connection) case 'c': case 's': { - if (target->state != TARGET_HALTED) + int retval = ERROR_OK; + + gdb_connection_t *gdb_con = connection->priv; + log_add_callback(gdb_log_callback, connection); + + bool nostep = false; + if (target->state == TARGET_RUNNING) + { + LOG_WARNING("The target is already running. Halt target before stepi/continue."); + retval = target_halt(target); + if (retval == ERROR_OK) + retval = target_wait_state(target, TARGET_HALTED, 100); + } else if (target->state != TARGET_HALTED) + { + LOG_WARNING("The target is not in the halted nor running stated, stepi/continue ignored."); + nostep = true; + } else if ((packet[0] == 's') && gdb_con->sync) { - /* If the target isn't in the halted state, then we can't + /* Hmm..... when you issue a continue in GDB, then a "stepi" is + * sent by GDB first to OpenOCD, thus defeating the check to + * make only the single stepping have the sync feature... + */ + nostep = true; + LOG_WARNING("stepi ignored. GDB will now fetch the register state from the target."); + } + gdb_con->sync = false; + + if ((retval!=ERROR_OK) || nostep) + { + /* Either the target isn't in the halted state, then we can't * step/continue. This might be early setup, etc. + * + * Or we want to allow GDB to pick up a fresh set of + * register values without modifying the target state. + * */ gdb_sig_halted(connection); + + /* stop forwarding log packets! */ + log_remove_callback(gdb_log_callback, connection); } else { /* We're running/stepping, in which case we can * forward log output until the target is halted */ - 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) @@ -2142,7 +2142,9 @@ int gdb_input_inner(connection_t *connection) /* handle extended restart packet */ breakpoint_clear_target(gdb_service->target); watchpoint_clear_target(gdb_service->target); - command_run_linef(connection->cmd_ctx, "ocd_gdb_restart %d", get_num_by_target(target)); + command_run_linef(connection->cmd_ctx, + "ocd_gdb_restart %s", + target->cmd_name); break; default: /* ignore unkown packets */ @@ -2160,8 +2162,16 @@ int gdb_input_inner(connection_t *connection) { if (target->state == TARGET_RUNNING) { - target_halt(target); + retval = target_halt(target); + if (retval != ERROR_OK) + { + target_call_event_callbacks(target, TARGET_EVENT_GDB_HALT); + } gdb_con->ctrl_c = 0; + } else + { + LOG_INFO("The target is not running when halt was requested, stopping GDB."); + target_call_event_callbacks(target, TARGET_EVENT_GDB_HALT); } } @@ -2216,68 +2226,52 @@ int gdb_init(void) } else { + unsigned short port = gdb_port; + 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); + add_service("gdb", CONNECTION_TCP, + port, 1, + gdb_new_connection, gdb_input, + gdb_connection_closed, gdb_service); - LOG_DEBUG("gdb service for target %s at port %i", + LOG_DEBUG("gdb service for target %s at TCP port %i", target_get_name(target), - gdb_port + target->target_number); + port); target = target->next; + port++; } } return ERROR_OK; } -/* daemon configuration command gdb_port */ -int handle_gdb_port_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +int handle_gdb_sync_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { - if (argc == 0) + if (argc != 0) { - command_print(cmd_ctx, "%d", gdb_port); - return ERROR_OK; + return ERROR_COMMAND_SYNTAX_ERROR; } - /* only if the port wasn't overwritten by cmdline */ - if (gdb_port == 0) - gdb_port = strtoul(args[0], NULL, 0); + if (current_gdb_connection == NULL) + { + command_print(cmd_ctx, + "gdb_sync command can only be run from within gdb using \"monitor gdb_sync\""); + return ERROR_FAIL; + } + + current_gdb_connection->sync = true; return ERROR_OK; } -int handle_gdb_detach_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +/* daemon configuration command gdb_port */ +int handle_gdb_port_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { - if (argc == 1) - { - if (strcmp(args[0], "resume") == 0) - { - detach_mode = GDB_DETACH_RESUME; - return ERROR_OK; - } - else if (strcmp(args[0], "reset") == 0) - { - detach_mode = GDB_DETACH_RESET; - return ERROR_OK; - } - else if (strcmp(args[0], "halt") == 0) - { - detach_mode = GDB_DETACH_HALT; - return ERROR_OK; - } - else if (strcmp(args[0], "nothing") == 0) - { - detach_mode = GDB_DETACH_NOTHING; - return ERROR_OK; - } - else - LOG_WARNING("invalid gdb_detach configuration directive: %s", args[0]); - } - - return ERROR_COMMAND_SYNTAX_ERROR; + return server_port_command(cmd_ctx, cmd, args, argc, &gdb_port); } int handle_gdb_memory_map_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) @@ -2379,11 +2373,10 @@ int handle_gdb_breakpoint_override_command(struct command_context_s *cmd_ctx, ch int gdb_register_commands(command_context_t *command_context) { + register_command(command_context, NULL, "gdb_sync", handle_gdb_sync_command, + COMMAND_ANY, "next stepi will return immediately allowing GDB fetch register state without affecting target state"); register_command(command_context, NULL, "gdb_port", handle_gdb_port_command, COMMAND_ANY, "daemon configuration command gdb_port"); - register_command(command_context, NULL, "gdb_detach", handle_gdb_detach_command, - COMMAND_CONFIG, "resume/reset/halt/nothing - " - "specify behavior when GDB detaches from the target"); register_command(command_context, NULL, "gdb_memory_map", handle_gdb_memory_map_command, COMMAND_CONFIG, "enable or disable memory map"); register_command(command_context, NULL, "gdb_flash_program", handle_gdb_flash_program_command,