* Copyright (C) 2005 by Dominic Rath *
* Dominic.Rath@gmx.de *
* *
- * Copyright (C) 2007-2009 Øyvind Harboe *
+ * Copyright (C) 2007-2010 Øyvind Harboe *
* oyvind.harboe@zylin.com *
* *
* Copyright (C) 2008 by Spencer Oliver *
bool sync; /* set flag to true if you want the next stepi to return immediately.
allowing GDB to pick up a fresh set of register values from the target
without modifying the target state. */
-
+ /* We delay reporting memory write errors until next step/continue or memory
+ * write. This improves performance of gdb load significantly as the GDB packet
+ * can be replied immediately and a new GDB packet will be ready without delay
+ * (ca. 10% or so...).
+ */
+ bool mem_write_error;
};
static enum breakpoint_type gdb_breakpoint_override_type;
static int gdb_error(struct connection *connection, int retval);
-static unsigned short gdb_port = 3333;
-static unsigned short gdb_port_next = 0;
+static const char *gdb_port;
+static const char *gdb_port_next;
static const char DIGITS[16] = "0123456789abcdef";
static void gdb_log_callback(void *priv, const char *file, unsigned line,
struct gdb_connection *gdb_con = connection->priv;
int retval = ERROR_OK;
+#ifdef _DEBUG_GDB_IO_
+ char *debug_buffer;
+#endif
for (;;)
{
- if (connection->service->type == CONNECTION_PIPE)
+ if (connection->service->type != CONNECTION_TCP)
{
gdb_con->buf_cnt = read(connection->fd, gdb_con->buffer, GDB_BUFFER_SIZE);
}
if (gdb_con->closed)
return ERROR_SERVER_REMOTE_CLOSED;
- if (connection->service->type == CONNECTION_PIPE)
+ if (connection_write(connection, data, len) == len)
{
- /* 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;
- }
+ return ERROR_OK;
}
gdb_con->closed = 1;
return ERROR_SERVER_REMOTE_CLOSED;
if (gdb_connection->frontend_state == TARGET_RUNNING)
{
char sig_reply[4];
- int signal;
+ int signal_var;
/* stop forwarding log packets! */
log_remove_callback(gdb_log_callback, connection);
if (gdb_connection->ctrl_c)
{
- signal = 0x2;
+ signal_var = 0x2;
gdb_connection->ctrl_c = 0;
}
else
{
- signal = gdb_last_signal(target);
+ signal_var = gdb_last_signal(target);
}
- snprintf(sig_reply, 4, "T%2.2x", signal);
+ snprintf(sig_reply, 4, "T%2.2x", signal_var);
gdb_put_packet(connection, sig_reply, 3);
gdb_connection->frontend_state = TARGET_HALTED;
}
gdb_connection->busy = 0;
gdb_connection->noack_mode = 0;
gdb_connection->sync = true;
+ gdb_connection->mem_write_error = false;
/* send ACK to GDB for debug request */
gdb_write(connection, "+", 1);
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);
-
/* remove the initial ACK from the incoming buffer */
if ((retval = gdb_get_char(connection, &initial_ack)) != ERROR_OK)
return retval;
gdb_putback_char(connection, initial_ack);
target_call_event_callbacks(gdb_service->target, TARGET_EVENT_GDB_ATTACH);
+ if (gdb_use_memory_map)
+ {
+ /* Connect must fail if the memory map can't be set up correctly.
+ *
+ * This will cause an auto_probe to be invoked, which is either
+ * a no-op or it will fail when the target isn't ready(e.g. not halted).
+ */
+ int i;
+ for (i = 0; i < flash_get_bank_count(); i++)
+ {
+ struct flash_bank *p;
+ retval = get_flash_bank_by_num(i, &p);
+ if (retval != ERROR_OK)
+ {
+ LOG_ERROR("Connect failed. Consider setting up a gdb-attach event for the target to prepare target for GDB connect, or use 'gdb_memory_map disable'.");
+ return retval;
+ }
+ }
+ }
+
gdb_actual_connections++;
LOG_DEBUG("New GDB Connection: %d, Target %s, state: %s",
gdb_actual_connections,
target_name(gdb_service->target),
target_state_name(gdb_service->target));
+ /* DANGER! If we fail subsequently, we must remove this handler,
+ * otherwise we occasionally see crashes as the timer can invoke the
+ * callback fn.
+ *
+ * register callback to be informed about target events */
+ target_register_event_callback(gdb_target_callback_event_handler, connection);
+
return ERROR_OK;
}
struct target *target, char* packet, int packet_size)
{
char sig_reply[4];
- int signal;
+ int signal_var;
- signal = gdb_last_signal(target);
+ signal_var = gdb_last_signal(target);
- snprintf(sig_reply, 4, "S%2.2x", signal);
+ snprintf(sig_reply, 4, "S%2.2x", signal_var);
gdb_put_packet(connection, sig_reply, 3);
return ERROR_OK;
return ERROR_OK;
}
+/* No attempt is made to translate the "retval" to
+ * GDB speak. This has to be done at the calling
+ * site as no mapping really exists.
+ */
static int gdb_error(struct connection *connection, int retval)
{
- switch (retval)
- {
- case ERROR_TARGET_DATA_ABORT:
- gdb_send_error(connection, EIO);
- break;
- case ERROR_TARGET_TRANSLATION_FAULT:
- gdb_send_error(connection, EFAULT);
- break;
- case ERROR_TARGET_UNALIGNED_ACCESS:
- gdb_send_error(connection, EFAULT);
- break;
- case ERROR_TARGET_NOT_HALTED:
- gdb_send_error(connection, EFAULT);
- break;
- default:
- /* This could be that the target reset itself. */
- LOG_ERROR("unexpected error %i", retval);
- gdb_send_error(connection, EFAULT);
- break;
- }
-
+ LOG_DEBUG("Reporting %i to GDB as generic error", retval);
+ gdb_send_error(connection, EFAULT);
return ERROR_OK;
}
uint32_t addr = 0;
uint32_t len = 0;
- int retval;
+ int retval = ERROR_OK;
/* skip command character */
packet++;
return ERROR_SERVER_REMOTE_CLOSED;
}
- retval = ERROR_OK;
- if (len)
- {
- LOG_DEBUG("addr: 0x%8.8" PRIx32 ", len: 0x%8.8" PRIx32 "", addr, len);
+ struct gdb_connection *gdb_connection = connection->priv;
- retval = target_write_buffer(target, addr, len, (uint8_t*)separator);
+ if (gdb_connection->mem_write_error)
+ {
+ retval = ERROR_FAIL;
+ /* now that we have reported the memory write error, we can clear the condition */
+ gdb_connection->mem_write_error = false;
}
+ /* By replying the packet *immediately* GDB will send us a new packet
+ * while we write the last one to the target.
+ */
if (retval == ERROR_OK)
{
gdb_put_packet(connection, "OK", 2);
return retval;
}
+ if (len)
+ {
+ LOG_DEBUG("addr: 0x%8.8" PRIx32 ", len: 0x%8.8" PRIx32 "", addr, len);
+
+ retval = target_write_buffer(target, addr, len, (uint8_t*)separator);
+ if (retval != ERROR_OK)
+ {
+ gdb_connection->mem_write_error = true;
+ }
+ }
+
return ERROR_OK;
}
return 0;
}
-static int gdb_calc_blocksize(struct flash_bank *bank)
-{
- uint32_t i;
- uint32_t block_size = 0xffffffff;
-
- /* loop through all sectors and return smallest sector size */
-
- for (i = 0; i < (uint32_t)bank->num_sectors; i++)
- {
- if (bank->sectors[i].size < block_size)
- block_size = bank->sectors[i].size;
- }
-
- return block_size;
-}
-
static int compare_bank (const void * a, const void * b)
{
struct flash_bank *b1, *b2;
int offset;
int length;
char *separator;
- int blocksize;
uint32_t ram_start = 0;
int i;
+ int target_flash_banks = 0;
/* skip command character */
packet += 23;
* it has no concept of non-cacheable read/write memory (i/o etc).
*
* FIXME Most non-flash addresses are *NOT* RAM! Don't lie.
+ * Current versions of GDB assume unlisted addresses are RAM...
*/
banks = malloc(sizeof(struct flash_bank *)*flash_get_bank_count());
for (i = 0; i < flash_get_bank_count(); i++) {
- p = get_flash_bank_by_num(i);
- if (p == NULL) {
+ retval = get_flash_bank_by_num(i, &p);
+ if (retval != ERROR_OK)
+ {
free(banks);
- retval = ERROR_FAIL;
- gdb_send_error(connection, retval);
+ gdb_error(connection, retval);
return retval;
}
- banks[i] = p;
+ if(p->target == target)
+ banks[target_flash_banks++] = p;
}
- qsort(banks, flash_get_bank_count(), sizeof(struct flash_bank *),
+ qsort(banks, target_flash_banks, sizeof(struct flash_bank *),
compare_bank);
for (i = 0; i < flash_get_bank_count(); i++) {
+ int j;
+ unsigned sector_size = 0;
+ uint32_t start, end;
+
p = banks[i];
+ start = p->base;
+ end = p->base + p->size;
if (ram_start < p->base)
xml_printf(&retval, &xml, &pos, &size,
"<memory type=\"ram\" start=\"0x%x\" "
"length=\"0x%x\"/>\n",
- ram_start, p->base-ram_start);
+ ram_start, p->base - ram_start);
- /* If device has uneven sector sizes, eg. str7, lpc
- * we pass the smallest sector size to gdb memory map
- *
- * FIXME Don't lie about flash regions with different
- * sector sizes; just tell GDB about each region as
- * if it were a separate flash device.
+ /* Report adjacent groups of same-size sectors. So for
+ * example top boot CFI flash will list an initial region
+ * with several large sectors (maybe 128KB) and several
+ * smaller ones at the end (maybe 32KB). STR7 will have
+ * regions with 8KB, 32KB, and 64KB sectors; etc.
*/
- blocksize = gdb_calc_blocksize(p);
+ for (j = 0; j < p->num_sectors; j++) {
+ unsigned group_len;
+
+ /* Maybe start a new group of sectors. */
+ if (sector_size == 0) {
+ start = p->base + p->sectors[j].offset;
+ xml_printf(&retval, &xml, &pos, &size,
+ "<memory type=\"flash\" "
+ "start=\"0x%x\" ",
+ start);
+ sector_size = p->sectors[j].size;
+ }
+
+ /* Does this finish a group of sectors?
+ * If not, continue an already-started group.
+ */
+ if (j == p->num_sectors -1)
+ group_len = (p->base + p->size) - start;
+ else if (p->sectors[j + 1].size != sector_size)
+ group_len = p->base + p->sectors[j + 1].offset
+ - start;
+ else
+ continue;
+
+ xml_printf(&retval, &xml, &pos, &size,
+ "length=\"0x%x\">\n"
+ "<property name=\"blocksize\">"
+ "0x%x</property>\n"
+ "</memory>\n",
+ group_len,
+ sector_size);
+ sector_size = 0;
+ }
- xml_printf(&retval, &xml, &pos, &size,
- "<memory type=\"flash\" start=\"0x%x\" "
- "length=\"0x%x\">\n" \
- "<property name=\"blocksize\">0x%x</property>\n" \
- "</memory>\n", \
- p->base, p->size, blocksize);
ram_start = p->base + p->size;
}
xml_printf(&retval, &xml, &pos, &size, "</memory-map>\n");
if (retval != ERROR_OK) {
- gdb_send_error(connection, retval);
+ gdb_error(connection, retval);
return retval;
}
if (retval != ERROR_OK)
{
- gdb_send_error(connection, retval);
+ gdb_error(connection, retval);
return retval;
}
struct gdb_connection *gdb_con = connection->priv;
static int extended_protocol = 0;
- /* drain input buffer */
+ /* drain input buffer. If one of the packets fail, then an error
+ * packet is replied, if applicable.
+ *
+ * This loop will terminate and the error code is returned.
+ *
+ * The calling fn will check if this error is something that
+ * can be recovered from, or if the connection must be closed.
+ *
+ * If the error is recoverable, this fn is called again to
+ * drain the rest of the buffer.
+ */
do
{
packet_size = GDB_BUFFER_SIZE-1;
case 'c':
case 's':
{
- int retval = ERROR_OK;
-
- struct gdb_connection *gdb_con = connection->priv;
log_add_callback(gdb_log_callback, connection);
+ if (gdb_con->mem_write_error)
+ {
+ LOG_ERROR("Memory write failure!");
+
+ /* now that we have reported the memory write error, we can clear the condition */
+ gdb_con->mem_write_error = false;
+ }
+
bool nostep = false;
+ bool already_running = 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);
+ LOG_WARNING("WARNING! The target is already running. "
+ "All changes GDB did to registers will be discarded! "
+ "Waiting for target to halt.");
+ already_running = true;
} else if (target->state != TARGET_HALTED)
{
LOG_WARNING("The target is not in the halted nor running stated, stepi/continue ignored.");
}
gdb_con->sync = false;
- if ((retval!=ERROR_OK) || nostep)
+ if (!already_running && nostep)
{
/* Either the target isn't in the halted state, then we can't
* step/continue. This might be early setup, etc.
*/
gdb_con->frontend_state = TARGET_RUNNING;
target_call_event_callbacks(target, TARGET_EVENT_GDB_START);
- int retval = gdb_step_continue_packet(connection, target, packet, packet_size);
- if (retval != ERROR_OK)
+
+ if (!already_running)
{
- /* we'll never receive a halted condition... issue a false one.. */
- gdb_frontend_halted(target, connection);
+ /* Here we don't want packet processing to stop even if this fails,
+ * so we use a local variable instead of retval. */
+ 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);
+ }
}
}
}
return ERROR_OK;
}
-static int gdb_target_start(struct target *target, uint16_t port)
+static int gdb_target_start(struct target *target, const char *port)
{
- bool use_pipes = 0 == port;
struct gdb_service *gdb_service = malloc(sizeof(struct gdb_service));
if (NULL == gdb_service)
return -ENOMEM;
gdb_service->target = target;
- add_service("gdb", use_pipes ? CONNECTION_PIPE : CONNECTION_TCP,
+ return add_service("gdb",
port, 1, &gdb_new_connection, &gdb_input,
&gdb_connection_closed, gdb_service);
-
- const char *name = target_name(target);
- if (use_pipes)
- LOG_DEBUG("gdb service for target '%s' using pipes", name);
- else
- LOG_DEBUG("gdb service for target '%s' on TCP port %u", name, port);
- return ERROR_OK;
}
static int gdb_target_add_one(struct target *target)
{
- if (gdb_port == 0 && server_use_pipes == 0)
- {
- LOG_INFO("gdb port disabled");
- return ERROR_OK;
- }
- if (0 == gdb_port_next)
- gdb_port_next = gdb_port;
-
- bool use_pipes = server_use_pipes;
- static bool server_started_with_pipes = false;
- if (server_started_with_pipes)
- {
- LOG_WARNING("gdb service permits one target when using pipes");
- if (0 == gdb_port)
- return ERROR_OK;
-
- use_pipes = false;
- }
-
- int e = gdb_target_start(target, use_pipes ? 0 : gdb_port_next);
- if (ERROR_OK == e)
+ int retval = gdb_target_start(target, gdb_port_next);
+ if (retval == ERROR_OK)
{
- server_started_with_pipes |= use_pipes;
- gdb_port_next++;
+ long portnumber;
+ /* If we can parse the port number
+ * then we increment the port number for the next target.
+ */
+ char *end;
+ portnumber = strtol(gdb_port_next, &end, 0);
+ if (!*end)
+ {
+ if (parse_long(gdb_port_next, &portnumber) == ERROR_OK)
+ {
+ free((void *)gdb_port_next);
+ gdb_port_next = alloc_printf("%d", portnumber+1);
+ }
+ }
}
- return e;
+ return retval;
}
int gdb_target_add_all(struct target *target)
/* daemon configuration command gdb_port */
COMMAND_HANDLER(handle_gdb_port_command)
{
- int retval = CALL_COMMAND_HANDLER(server_port_command, &gdb_port);
- if (ERROR_OK == retval)
- gdb_port_next = gdb_port;
+ int retval = CALL_COMMAND_HANDLER(server_pipe_command, &gdb_port);
+ if (ERROR_OK == retval) {
+ free((void*)gdb_port_next);
+ gdb_port_next = strdup(gdb_port);
+ }
return retval;
}
COMMAND_HANDLER(handle_gdb_memory_map_command)
{
- if (CMD_ARGC == 1)
- COMMAND_PARSE_ENABLE(CMD_ARGV[0], gdb_use_memory_map);
+ if (CMD_ARGC != 1)
+ return ERROR_COMMAND_SYNTAX_ERROR;
- return ERROR_COMMAND_SYNTAX_ERROR;
+ COMMAND_PARSE_ENABLE(CMD_ARGV[0], gdb_use_memory_map);
+ return ERROR_OK;
}
COMMAND_HANDLER(handle_gdb_flash_program_command)
{
- if (CMD_ARGC == 1)
- COMMAND_PARSE_ENABLE(CMD_ARGV[0], gdb_flash_program);
+ if (CMD_ARGC != 1)
+ return ERROR_COMMAND_SYNTAX_ERROR;
- return ERROR_COMMAND_SYNTAX_ERROR;
+ COMMAND_PARSE_ENABLE(CMD_ARGV[0], gdb_flash_program);
+ return ERROR_OK;
}
COMMAND_HANDLER(handle_gdb_report_data_abort_command)
{
- if (CMD_ARGC == 1)
- COMMAND_PARSE_ENABLE(CMD_ARGV[0], gdb_report_data_abort);
+ if (CMD_ARGC != 1)
+ return ERROR_COMMAND_SYNTAX_ERROR;
- return ERROR_COMMAND_SYNTAX_ERROR;
+ COMMAND_PARSE_ENABLE(CMD_ARGV[0], gdb_report_data_abort);
+ return ERROR_OK;
}
/* gdb_breakpoint_override */
.name = "gdb_port",
.handler = handle_gdb_port_command,
.mode = COMMAND_ANY,
- .help = "Display or specify base port on which to listen "
- "for incoming GDB connections. "
- "No arguments reports GDB port; zero disables.",
+ .help = "Normally gdb listens to a TCP/IP port. Each subsequent GDB "
+ "server listens for the next port number after the "
+ "base port number specified. "
+ "No arguments reports GDB port. \"pipe\" means listen to stdin "
+ "output to stdout, an integer is base port number, \"disable\" disables "
+ "port. Any other string is are interpreted as named pipe to listen to. "
+ "Output pipe is the same name as input pipe, but with 'o' appended.",
.usage = "[port_num]",
},
{
int gdb_register_commands(struct command_context *cmd_ctx)
{
+ gdb_port = strdup("3333");
+ gdb_port_next = strdup("3333");
return register_commands(cmd_ctx, NULL, gdb_command_handlers);
}