X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Fserver%2Fgdb_server.c;h=8fb3b64f954f1c539516f14cc7024e6585f6600e;hp=c2c18baf208d7bf69824d32d397b606751f33ac0;hb=8d73c2a9b0c00c870694a57f7cfbc23e354855ac;hpb=ee793f0fcbd2d7e4ad08e61d242ba178e8909b45 diff --git a/src/server/gdb_server.c b/src/server/gdb_server.c index c2c18baf20..8fb3b64f95 100644 --- a/src/server/gdb_server.c +++ b/src/server/gdb_server.c @@ -2,6 +2,9 @@ * Copyright (C) 2005 by Dominic Rath * * Dominic.Rath@gmx.de * * * + * Copyright (C) 2007,2008 Øyvind Harboe * + * oyvind.harboe@zylin.com * + * * * This program is free software; you can redistribute it and/or modify * * it under the terms of the GNU General Public License as published by * * the Free Software Foundation; either version 2 of the License, or * @@ -43,6 +46,9 @@ #define _DEBUG_GDB_IO_ #endif +static int gdb_breakpoint_override; +static enum breakpoint_type gdb_breakpoint_override_type; + extern int gdb_error(connection_t *connection, int retval); static unsigned short gdb_port; static const char *DIGITS = "0123456789abcdef"; @@ -287,7 +293,6 @@ int gdb_put_packet_inner(connection_t *connection, char *buffer, int len) * however sometimes '-' is sent even though we've already received * an ACK (+) for everything we've sent off. */ -#ifndef _WIN32 int gotdata; for (;;) { @@ -299,7 +304,6 @@ int gdb_put_packet_inner(connection_t *connection, char *buffer, int len) return retval; LOG_WARNING("Discard unexpected char %c", reply); } -#endif #endif while (1) @@ -334,7 +338,10 @@ int gdb_put_packet_inner(connection_t *connection, char *buffer, int len) gdb_write(connection, buffer, len); gdb_write(connection, local_buffer+1, 3); } - + + if (gdb_con->noack_mode) + break; + if ((retval = gdb_get_char(connection, &reply)) != ERROR_OK) return retval; @@ -413,6 +420,8 @@ int gdb_get_packet_inner(connection_t *connection, char *buffer, int *len) case '$': break; case '+': + /* gdb sends a dummy ack '+' at every remote connect - see remote_start_remote (remote.c) + * incase anyone tries to debug why they receive this warning every time */ LOG_WARNING("acknowledgment received, but no packet pending"); break; case '-': @@ -471,7 +480,8 @@ int gdb_get_packet_inner(connection_t *connection, char *buffer, int *len) i++; my_checksum += character & 0xff; buffer[count++] = (character ^ 0x20) & 0xff; - } else + } + else { my_checksum += character & 0xff; buffer[count++] = character & 0xff; @@ -509,7 +519,6 @@ int gdb_get_packet_inner(connection_t *connection, char *buffer, int *len) my_checksum += character & 0xff; buffer[count++] = character & 0xff; } - } *len = count; @@ -524,12 +533,22 @@ int gdb_get_packet_inner(connection_t *connection, char *buffer, int *len) if (my_checksum == strtoul(checksum, NULL, 16)) { + if (gdb_con->noack_mode) + break; gdb_write(connection, "+", 1); break; } - LOG_WARNING("checksum error, requesting retransmission"); - gdb_write(connection, "-", 1); + if (!gdb_con->noack_mode) + { + LOG_WARNING("checksum error, requesting retransmission"); + gdb_write(connection, "-", 1); + } + else + { + LOG_WARNING("checksum error, no-ack-mode"); + break; + } } if (gdb_con->closed) return ERROR_SERVER_REMOTE_CLOSED; @@ -568,7 +587,7 @@ int gdb_output_con(connection_t *connection, const char* line) return ERROR_OK; } -int gdb_output(struct command_context_s *context, char* line) +int gdb_output(struct command_context_s *context, const char* line) { /* this will be dumped to the log and also sent as an O packet if possible */ LOG_USER_N("%s", line); @@ -577,68 +596,60 @@ int gdb_output(struct command_context_s *context, char* line) int gdb_program_handler(struct target_s *target, enum target_event event, void *priv) { - FILE *script; struct command_context_s *cmd_ctx = priv; - if (target->gdb_program_script) + target_invoke_script(cmd_ctx, target, "gdb_program"); + jtag_execute_queue(); + + return ERROR_OK; +} + +static void gdb_frontend_halted(struct target_s *target, connection_t *connection) +{ + gdb_connection_t *gdb_connection = connection->priv; + + /* In the GDB protocol when we are stepping or coninuing 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. + * + * Executing monitor commands can bring the target in and + * out of the running state so we'll see lots of TARGET_EVENT_XXX + * that are to be ignored. + */ + if (gdb_connection->frontend_state == TARGET_RUNNING) { - script = open_file_from_path(target->gdb_program_script, "r"); - if (!script) + char sig_reply[4]; + int signal; + /* stop forwarding log packets! */ + log_remove_callback(gdb_log_callback, connection); + + if (gdb_connection->ctrl_c) { - LOG_ERROR("couldn't open script file %s", target->gdb_program_script); - return ERROR_OK; + signal = 0x2; + gdb_connection->ctrl_c = 0; + } + else + { + signal = gdb_last_signal(target); } - LOG_INFO("executing gdb_program script '%s'", target->gdb_program_script); - command_run_file(cmd_ctx, script, COMMAND_EXEC); - fclose(script); - - jtag_execute_queue(); + snprintf(sig_reply, 4, "T%2.2x", signal); + gdb_put_packet(connection, sig_reply, 3); + gdb_connection->frontend_state = TARGET_HALTED; } - - return ERROR_OK; } int gdb_target_callback_event_handler(struct target_s *target, enum target_event event, void *priv) { connection_t *connection = priv; - gdb_connection_t *gdb_connection = connection->priv; - char sig_reply[4]; - int signal; switch (event) { case TARGET_EVENT_HALTED: - /* In the GDB protocol when we are stepping or coninuing 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. - * - * Executing monitor commands can bring the target in and - * out of the running state so we'll see lots of TARGET_EVENT_XXX - * that are to be ignored. - */ - if (gdb_connection->frontend_state == TARGET_RUNNING) - { - /* stop forwarding log packets! */ - log_remove_callback(gdb_log_callback, connection); - - if (gdb_connection->ctrl_c) - { - signal = 0x2; - gdb_connection->ctrl_c = 0; - } - else - { - signal = gdb_last_signal(target); - } - - snprintf(sig_reply, 4, "T%2.2x", signal); - gdb_put_packet(connection, sig_reply, 3); - gdb_connection->frontend_state = TARGET_HALTED; - } + gdb_frontend_halted(target, connection); break; - case TARGET_EVENT_GDB_PROGRAM: + case TARGET_EVENT_GDB_FLASH_ERASE_START: gdb_program_handler(target, event, connection->cmd_ctx); break; default: @@ -666,6 +677,7 @@ int gdb_new_connection(connection_t *connection) gdb_connection->vflash_image = NULL; gdb_connection->closed = 0; gdb_connection->busy = 0; + gdb_connection->noack_mode = 0; /* send ACK to GDB for debug request */ gdb_write(connection, "+", 1); @@ -673,6 +685,13 @@ int gdb_new_connection(connection_t *connection) /* output goes through gdb connection */ command_set_output_handler(connection->cmd_ctx, gdb_output, connection); + /* we must remove all breakpoints registered to the target as a previous + * GDB session could leave dangling breakpoints if e.g. communication + * timed out. + */ + breakpoint_clear_target(gdb_service->target); + watchpoint_clear_target(gdb_service->target); + /* register callback to be informed about target events */ target_register_event_callback(gdb_target_callback_event_handler, connection); @@ -693,6 +712,12 @@ int gdb_new_connection(connection_t *connection) * 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) @@ -1213,10 +1238,11 @@ int gdb_write_memory_binary_packet(connection_t *connection, target_t *target, c return ERROR_OK; } -void gdb_step_continue_packet(connection_t *connection, target_t *target, char *packet, int packet_size) +int gdb_step_continue_packet(connection_t *connection, target_t *target, char *packet, int packet_size) { int current = 0; u32 address = 0x0; + int retval=ERROR_OK; LOG_DEBUG("-"); @@ -1233,13 +1259,15 @@ void gdb_step_continue_packet(connection_t *connection, target_t *target, char * if (packet[0] == 'c') { LOG_DEBUG("continue"); - target_resume(target, current, address, 0, 0); /* resume at current address, don't handle breakpoints, not debugging */ + target_invoke_script(connection->cmd_ctx, target, "pre_resume"); + retval=target_resume(target, current, address, 0, 0); /* resume at current address, don't handle breakpoints, not debugging */ } else if (packet[0] == 's') { LOG_DEBUG("step"); - target->type->step(target, current, address, 0); /* step at current or address, don't handle breakpoints */ + retval=target->type->step(target, current, address, 0); /* step at current or address, don't handle breakpoints */ } + return retval; } int gdb_breakpoint_watchpoint_packet(connection_t *connection, target_t *target, char *packet, int packet_size) @@ -1266,6 +1294,11 @@ int gdb_breakpoint_watchpoint_packet(connection_t *connection, target_t *target, wp_type = WPT_READ; else if (type == 4) /* access watchpoint */ wp_type = WPT_ACCESS; + + if (gdb_breakpoint_override&&((bp_type==BKPT_SOFT)||(bp_type==BKPT_HARD))) + { + bp_type=gdb_breakpoint_override_type; + } if (*separator != ',') { @@ -1440,7 +1473,8 @@ static int compare_bank (const void * a, const void * b) int gdb_query_packet(connection_t *connection, target_t *target, char *packet, int packet_size) { command_context_t *cmd_ctx = connection->cmd_ctx; - + gdb_connection_t *gdb_connection = connection->priv; + if (strstr(packet, "qRcmd,")) { if (packet_size > 6) @@ -1517,8 +1551,8 @@ int gdb_query_packet(connection_t *connection, target_t *target, char *packet, i int size = 0; xml_printf(&retval, &buffer, &pos, &size, - "PacketSize=%x;qXfer:memory-map:read%c;qXfer:features:read-", - (GDB_BUFFER_SIZE - 1), gdb_use_memory_map == 1 ? '+' : '-'); + "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)) ? '+' : '-'); if (retval != ERROR_OK) { @@ -1531,7 +1565,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::")) + 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 @@ -1677,6 +1711,12 @@ int gdb_query_packet(connection_t *connection, target_t *target, char *packet, i free(xml); return ERROR_OK; } + else if (strstr(packet, "QStartNoAckMode")) + { + gdb_connection->noack_mode = 1; + gdb_put_packet(connection, "OK", 2); + return ERROR_OK; + } gdb_put_packet(connection, "", 0); return ERROR_OK; @@ -1729,7 +1769,7 @@ int gdb_v_packet(connection_t *connection, target_t *target, char *packet, int p flash_set_dirty(); /* perform any target specific operations before the erase */ - target_call_event_callbacks(gdb_service->target, TARGET_EVENT_GDB_PROGRAM); + target_call_event_callbacks(gdb_service->target, TARGET_EVENT_GDB_FLASH_ERASE_START); /* perform erase */ if ((result = flash_erase_address_range(gdb_service->target, addr, length)) != ERROR_OK) @@ -1815,11 +1855,13 @@ int gdb_detach(connection_t *connection, target_t *target) switch( detach_mode ) { case GDB_DETACH_RESUME: + target_invoke_script(connection->cmd_ctx, target, "pre_resume"); target_resume(target, 1, 0, 1, 0); break; case GDB_DETACH_RESET: - target_process_reset(connection->cmd_ctx); + /* FIX?? make this configurable?? */ + target_process_reset(connection->cmd_ctx, RESET_HALT); break; case GDB_DETACH_HALT: @@ -1853,6 +1895,14 @@ static void gdb_log_callback(void *priv, const char *file, int line, /* Do not allocate this on the stack */ char gdb_packet_buffer[GDB_BUFFER_SIZE]; +static void gdb_sig_halted(connection_t *connection) +{ + char sig_reply[4]; + snprintf(sig_reply, 4, "T%2.2x", 2); + gdb_put_packet(connection, sig_reply, 3); + +} + int gdb_input_inner(connection_t *connection) { gdb_service_t *gdb_service = connection->service->priv; @@ -1888,6 +1938,7 @@ int gdb_input_inner(connection_t *connection) gdb_put_packet(connection, NULL, 0); break; case 'q': + case 'Q': retval = gdb_query_packet(connection, target, packet, packet_size); break; case 'g': @@ -1923,9 +1974,7 @@ int gdb_input_inner(connection_t *connection) /* If the target isn't in the halted state, then we can't * step/continue. This might be early setup, etc. */ - char sig_reply[4]; - snprintf(sig_reply, 4, "T%2.2x", 2); - gdb_put_packet(connection, sig_reply, 3); + gdb_sig_halted(connection); } else { /* We're running/stepping, in which case we can @@ -1934,7 +1983,12 @@ 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); - gdb_step_continue_packet(connection, target, packet, packet_size); + int retval=gdb_step_continue_packet(connection, target, packet, packet_size); + if (retval!=ERROR_OK) + { + /* we'll never receive a halted condition... issue a false one.. */ + gdb_frontend_halted(target, connection); + } } } break; @@ -1961,7 +2015,9 @@ int gdb_input_inner(connection_t *connection) break; case 'R': /* handle extended restart packet */ - target_process_reset(connection->cmd_ctx); + 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)); break; default: /* ignore unkown packets */ @@ -2004,11 +2060,10 @@ int gdb_input(connection_t *connection) return ERROR_OK; } -int gdb_init() +int gdb_init(void) { gdb_service_t *gdb_service; - target_t *target = targets; - int i = 0; + target_t *target = all_targets; if (!target) { @@ -2026,16 +2081,21 @@ int gdb_init() { char service_name[8]; - snprintf(service_name, 8, "gdb-%2.2i", i); + snprintf(service_name, 8, "gdb-%2.2i", target->target_number); gdb_service = malloc(sizeof(gdb_service_t)); gdb_service->target = target; - add_service("gdb", CONNECTION_GDB, gdb_port + i, 1, gdb_new_connection, gdb_input, gdb_connection_closed, gdb_service); + add_service("gdb", CONNECTION_GDB, + gdb_port + target->target_number, + 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 + i); + LOG_DEBUG("gdb service for target %s at port %i", + target->type->name, + gdb_port + target->target_number); - i++; target = target->next; } @@ -2145,6 +2205,41 @@ int handle_gdb_report_data_abort_command(struct command_context_s *cmd_ctx, char return ERROR_OK; } +/* daemon configuration command gdb_port */ +int handle_gdb_breakpoint_override_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +{ + if (argc == 0) + { + + } else if (argc==1) + { + gdb_breakpoint_override = 1; + if (strcmp(args[0], "hard")==0) + { + gdb_breakpoint_override_type=BKPT_HARD; + } else if (strcmp(args[0], "soft")==0) + { + gdb_breakpoint_override_type=BKPT_SOFT; + } else if (strcmp(args[0], "disable") == 0) + { + gdb_breakpoint_override = 0; + } + } else + { + return ERROR_COMMAND_SYNTAX_ERROR; + } + if (gdb_breakpoint_override) + { + LOG_USER("force %s breakpoints", (gdb_breakpoint_override_type==BKPT_HARD)?"hard":"soft"); + } else + { + LOG_USER("breakpoint type is not overriden"); + } + + return ERROR_OK; +} + + int gdb_register_commands(command_context_t *command_context) { register_command(command_context, NULL, "gdb_port", handle_gdb_port_command, @@ -2157,5 +2252,10 @@ int gdb_register_commands(command_context_t *command_context) COMMAND_CONFIG, ""); register_command(command_context, NULL, "gdb_report_data_abort", handle_gdb_report_data_abort_command, COMMAND_CONFIG, ""); + 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 " + "a hard/soft breakpoint concept where the default OpenOCD behaviour " + "is not sufficient"); return ERROR_OK; }