X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Fserver%2Fgdb_server.c;h=b6921ff25f304d5ff52891649d7096fec90b4036;hp=76c3e363e9971396c3012df0ed533694ced21ad1;hb=f6315d5e5b7b71515ef051711e5f818a42d6b3b3;hpb=9f26aff39c047d813047b4f4bae1f5de3cfc56b1 diff --git a/src/server/gdb_server.c b/src/server/gdb_server.c index 76c3e363e9..b6921ff25f 100644 --- a/src/server/gdb_server.c +++ b/src/server/gdb_server.c @@ -8,6 +8,12 @@ * Copyright (C) 2008 by Spencer Oliver * * spen@spen-soft.co.uk * * * + * Copyright (C) 2011 by Broadcom Corporation * + * Evan Hunter - ehunter@broadcom.com * + * * + * Copyright (C) ST-Ericsson SA 2011 * + * michel.jaouen@stericsson.com : smp minimum support * + * * * 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 * @@ -35,6 +41,8 @@ #include "gdb_server.h" #include #include +#include "rtos/rtos.h" +#include "target/smp.h" /** @@ -58,7 +66,7 @@ struct gdb_connection int closed; int busy; int noack_mode; - bool sync; /* set flag to true if you want the next stepi to return immediately. + 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 @@ -80,8 +88,8 @@ static int gdb_breakpoint_override; 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, @@ -176,7 +184,7 @@ static int gdb_get_char_inner(struct connection *connection, int* next_char) #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); } @@ -328,20 +336,9 @@ static int gdb_write(struct connection *connection, void *data, int len) if (gdb_con->closed) return ERROR_SERVER_REMOTE_CLOSED; - if (connection->service->type == CONNECTION_PIPE) - { - /* write to stdout */ - if (write(STDOUT_FILENO, data, len) == len) - { - return ERROR_OK; - } - } - else + if (connection_write(connection, data, len) == len) { - if (write_socket(connection->fd, data, len) == len) - { - return ERROR_OK; - } + return ERROR_OK; } gdb_con->closed = 1; return ERROR_SERVER_REMOTE_CLOSED; @@ -490,7 +487,7 @@ static int gdb_put_packet_inner(struct connection *connection, return ERROR_OK; } -static int gdb_put_packet(struct connection *connection, char *buffer, int len) +int gdb_put_packet(struct connection *connection, char *buffer, int len) { struct gdb_connection *gdb_con = connection->priv; gdb_con->busy = 1; @@ -778,6 +775,7 @@ static void gdb_frontend_halted(struct target *target, struct connection *connec snprintf(sig_reply, 4, "T%2.2x", signal_var); gdb_put_packet(connection, sig_reply, 3); gdb_connection->frontend_state = TARGET_HALTED; + rtos_update_threads( target ); } } @@ -844,9 +842,6 @@ static int gdb_new_connection(struct connection *connection) 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; @@ -872,7 +867,7 @@ static int gdb_new_connection(struct connection *connection) 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."); + 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; } } @@ -884,6 +879,13 @@ static int gdb_new_connection(struct connection *connection) 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; } @@ -1041,6 +1043,12 @@ static int gdb_get_registers_packet(struct connection *connection, LOG_DEBUG("-"); #endif + if ( ( target->rtos != NULL ) && + ( ERROR_FAIL != rtos_get_gdb_reg_list( connection, target, ®_list, ®_list_size) ) ) + { + return ERROR_OK; + } + if ((retval = target_get_gdb_reg_list(target, ®_list, ®_list_size)) != ERROR_OK) { return gdb_error(connection, retval); @@ -1056,6 +1064,8 @@ static int gdb_get_registers_packet(struct connection *connection, for (i = 0; i < reg_list_size; i++) { + if (!reg_list[i]->valid) + reg_list[i]->type->get(reg_list[i]); gdb_str_to_target(target, reg_packet_p, reg_list[i]); reg_packet_p += DIV_ROUND_UP(reg_list[i]->size, 8) * 2; } @@ -1160,6 +1170,9 @@ static int gdb_get_register_packet(struct connection *connection, exit(-1); } + if (!reg_list[reg_num]->valid) + reg_list[reg_num]->type->get(reg_list[reg_num]); + reg_packet = malloc(DIV_ROUND_UP(reg_list[reg_num]->size, 8) * 2); gdb_str_to_target(target, reg_packet, reg_list[reg_num]); @@ -1718,11 +1731,10 @@ static int gdb_memory_map(struct connection *connection, for (i = 0; i < flash_get_bank_count(); i++) { int j; unsigned sector_size = 0; - uint32_t start, end; + uint32_t start; p = banks[i]; start = p->base; - end = p->base + p->size; if (ram_start < p->base) xml_printf(&retval, &xml, &pos, &size, @@ -2194,16 +2206,23 @@ static int gdb_input_inner(struct connection *connection) retval = ERROR_OK; switch (packet[0]) { - case 'H': - /* Hct... -- set thread - * we don't have threads, send empty reply */ - gdb_put_packet(connection, NULL, 0); - break; + case 'T': // Is thread alive? + gdb_thread_packet(connection, target, packet, packet_size); + break; + case 'H': // Set current thread ( 'c' for step and continue, 'g' for all other operations ) + gdb_thread_packet(connection, target, packet, packet_size); + break; case 'q': case 'Q': - retval = gdb_query_packet(connection, - target, packet, - packet_size); + retval = gdb_thread_packet(connection, + target, packet, + packet_size); + if ( retval == GDB_THREAD_PACKET_NOT_CONSUMED ) + { + retval = gdb_query_packet(connection, + target, packet, + packet_size); + } break; case 'g': retval = gdb_get_registers_packet( @@ -2348,7 +2367,26 @@ static int gdb_input_inner(struct connection *connection) command_run_linef(connection->cmd_ctx, "ocd_gdb_restart %s", target_name(target)); + gdb_put_packet(connection, "OK", 2); + break; + + case 'j': + /* packet supported only by smp target i.e cortex_a.c*/ + /* handle smp packet replying coreid played to gbd */ + gdb_read_smp_packet( + connection, target, + packet, packet_size); break; + + case 'J': + /* packet supported only by smp target i.e cortex_a.c */ + /* handle smp packet setting coreid to be played at next + * resume to gdb */ + gdb_write_smp_packet( + connection, target, + packet, packet_size); + break; + default: /* ignore unknown packets */ LOG_DEBUG("ignoring 0x%2.2x packet", packet[0]); @@ -2398,55 +2436,62 @@ static int gdb_input(struct connection *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)); + + struct gdb_service *gdb_service; + int ret; + gdb_service = malloc(sizeof(struct gdb_service)); + if (NULL == gdb_service) return -ENOMEM; gdb_service->target = target; + gdb_service->core[0] = -1; + gdb_service->core[1] = -1; + target->gdb_service = gdb_service; - add_service("gdb", use_pipes ? CONNECTION_PIPE : CONNECTION_TCP, + ret = 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; + /* initialialize all targets gdb service with the same pointer */ + { + struct target_list *head; + struct target *curr; + head = target->head; + while(head != (struct target_list*)NULL) + { + curr = head->target; + if (curr != target) curr->gdb_service = gdb_service; + head = head->next; + } + } + return ret; } 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) - { - server_started_with_pipes |= use_pipes; - gdb_port_next++; + /* one gdb instance per smp list */ + if ((target->smp) && (target->gdb_service)) return ERROR_OK; + int retval = gdb_target_start(target, gdb_port_next); + if (retval == ERROR_OK) + { + 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) @@ -2491,9 +2536,11 @@ COMMAND_HANDLER(handle_gdb_sync_command) /* 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; } @@ -2571,9 +2618,13 @@ static const struct command_registration gdb_command_handlers[] = { .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]", }, { @@ -2610,5 +2661,7 @@ static const struct command_registration gdb_command_handlers[] = { 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); }