X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Fserver%2Fgdb_server.c;h=732f68be96b3d05796206ff52fa08c6ef3abc1d5;hp=9151caa8509973ce4569d42deb6ada424e126c6d;hb=dfecfd5fd471708ac15af08b52964e8f8da9f4be;hpb=8b994145b849c40b0a195c3fb332b9770b2f9097

diff --git a/src/server/gdb_server.c b/src/server/gdb_server.c
index 9151caa850..732f68be96 100644
--- a/src/server/gdb_server.c
+++ b/src/server/gdb_server.c
@@ -40,27 +40,18 @@
 #define _DEBUG_GDB_IO_
 #endif
 
+static struct gdb_connection *current_gdb_connection;
+
 static int gdb_breakpoint_override;
 static enum breakpoint_type gdb_breakpoint_override_type;
 
-extern int gdb_error(connection_t *connection, int retval);
+extern int gdb_error(struct connection *connection, int retval);
 static unsigned short gdb_port = 3333;
 static const char *DIGITS = "0123456789abcdef";
 
-static void gdb_log_callback(void *priv, const char *file, int line,
+static void gdb_log_callback(void *priv, const char *file, unsigned 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;
@@ -96,14 +87,14 @@ int gdb_last_signal(target_t *target)
 	}
 }
 
-int check_pending(connection_t *connection, int timeout_s, int *got_data)
+int check_pending(struct connection *connection, int timeout_s, int *got_data)
 {
 	/* a non-blocking socket will block if there is 0 bytes available on the socket,
 	 * but return with as many bytes as are available immediately
 	 */
 	struct timeval tv;
 	fd_set read_fds;
-	gdb_connection_t *gdb_con = connection->priv;
+	struct gdb_connection *gdb_con = connection->priv;
 	int t;
 	if (got_data == NULL)
 		got_data=&t;
@@ -137,9 +128,9 @@ int check_pending(connection_t *connection, int timeout_s, int *got_data)
 	return ERROR_OK;
 }
 
-int gdb_get_char(connection_t *connection, int* next_char)
+int gdb_get_char(struct connection *connection, int* next_char)
 {
-	gdb_connection_t *gdb_con = connection->priv;
+	struct gdb_connection *gdb_con = connection->priv;
 	int retval = ERROR_OK;
 
 #ifdef _DEBUG_GDB_IO_
@@ -245,9 +236,9 @@ int gdb_get_char(connection_t *connection, int* next_char)
 	return retval;
 }
 
-int gdb_putback_char(connection_t *connection, int last_char)
+int gdb_putback_char(struct connection *connection, int last_char)
 {
-	gdb_connection_t *gdb_con = connection->priv;
+	struct gdb_connection *gdb_con = connection->priv;
 
 	if (gdb_con->buf_p > gdb_con->buffer)
 	{
@@ -265,9 +256,9 @@ int gdb_putback_char(connection_t *connection, int last_char)
 /* The only way we can detect that the socket is closed is the first time
  * we write to it, we will fail. Subsequent write operations will
  * succeed. Shudder! */
-int gdb_write(connection_t *connection, void *data, int len)
+int gdb_write(struct connection *connection, void *data, int len)
 {
-	gdb_connection_t *gdb_con = connection->priv;
+	struct gdb_connection *gdb_con = connection->priv;
 	if (gdb_con->closed)
 		return ERROR_SERVER_REMOTE_CLOSED;
 
@@ -290,7 +281,7 @@ int gdb_write(connection_t *connection, void *data, int len)
 	return ERROR_SERVER_REMOTE_CLOSED;
 }
 
-int gdb_put_packet_inner(connection_t *connection, char *buffer, int len)
+int gdb_put_packet_inner(struct connection *connection, char *buffer, int len)
 {
 	int i;
 	unsigned char my_checksum = 0;
@@ -299,7 +290,7 @@ int gdb_put_packet_inner(connection_t *connection, char *buffer, int len)
 #endif
 	int reply;
 	int retval;
-	gdb_connection_t *gdb_con = connection->priv;
+	struct gdb_connection *gdb_con = connection->priv;
 
 	for (i = 0; i < len; i++)
 		my_checksum += buffer[i];
@@ -431,9 +422,9 @@ int gdb_put_packet_inner(connection_t *connection, char *buffer, int len)
 	return ERROR_OK;
 }
 
-int gdb_put_packet(connection_t *connection, char *buffer, int len)
+int gdb_put_packet(struct connection *connection, char *buffer, int len)
 {
-	gdb_connection_t *gdb_con = connection->priv;
+	struct gdb_connection *gdb_con = connection->priv;
 	gdb_con->busy = 1;
 	int retval = gdb_put_packet_inner(connection, buffer, len);
 	gdb_con->busy = 0;
@@ -444,14 +435,14 @@ int gdb_put_packet(connection_t *connection, char *buffer, int len)
 	return retval;
 }
 
-static __inline__ int fetch_packet(connection_t *connection, int *checksum_ok, int noack, int *len, char *buffer)
+static __inline__ int fetch_packet(struct connection *connection, int *checksum_ok, int noack, int *len, char *buffer)
 {
 	unsigned char my_checksum = 0;
 	char checksum[3];
 	int character;
 	int retval;
 
-	gdb_connection_t *gdb_con = connection->priv;
+	struct gdb_connection *gdb_con = connection->priv;
 	my_checksum = 0;
 	int count = 0;
 	count = 0;
@@ -553,11 +544,11 @@ static __inline__ int fetch_packet(connection_t *connection, int *checksum_ok, i
 	return ERROR_OK;
 }
 
-int gdb_get_packet_inner(connection_t *connection, char *buffer, int *len)
+int gdb_get_packet_inner(struct connection *connection, char *buffer, int *len)
 {
 	int character;
 	int retval;
-	gdb_connection_t *gdb_con = connection->priv;
+	struct gdb_connection *gdb_con = connection->priv;
 
 	while (1)
 	{
@@ -628,16 +619,16 @@ int gdb_get_packet_inner(connection_t *connection, char *buffer, int *len)
 	return ERROR_OK;
 }
 
-int gdb_get_packet(connection_t *connection, char *buffer, int *len)
+int gdb_get_packet(struct connection *connection, char *buffer, int *len)
 {
-	gdb_connection_t *gdb_con = connection->priv;
+	struct gdb_connection *gdb_con = connection->priv;
 	gdb_con->busy = 1;
 	int retval = gdb_get_packet_inner(connection, buffer, len);
 	gdb_con->busy = 0;
 	return retval;
 }
 
-int gdb_output_con(connection_t *connection, const char* line)
+int gdb_output_con(struct connection *connection, const char* line)
 {
 	char *hex_buffer;
 	int i, bin_size;
@@ -667,9 +658,9 @@ int gdb_output(struct command_context_s *context, const char* line)
 }
 
 
-static void gdb_frontend_halted(struct target_s *target, connection_t *connection)
+static void gdb_frontend_halted(struct target_s *target, struct connection *connection)
 {
-	gdb_connection_t *gdb_connection = connection->priv;
+	struct gdb_connection *gdb_connection = connection->priv;
 
 	/* In the GDB protocol when we are stepping or continuing execution,
 	 * we have a lingering reply. Upon receiving a halted event
@@ -707,12 +698,12 @@ static void gdb_frontend_halted(struct target_s *target, connection_t *connectio
 int gdb_target_callback_event_handler(struct target_s *target, enum target_event event, void *priv)
 {
 	int retval;
-	connection_t *connection = priv;
+	struct connection *connection = priv;
 
 	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:
@@ -732,10 +723,10 @@ int gdb_target_callback_event_handler(struct target_s *target, enum target_event
 	return ERROR_OK;
 }
 
-int gdb_new_connection(connection_t *connection)
+int gdb_new_connection(struct connection *connection)
 {
-	gdb_connection_t *gdb_connection = malloc(sizeof(gdb_connection_t));
-	gdb_service_t *gdb_service = connection->service->priv;
+	struct gdb_connection *gdb_connection = malloc(sizeof(struct gdb_connection));
+	struct gdb_service *gdb_service = connection->service->priv;
 	int retval;
 	int initial_ack;
 
@@ -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;
@@ -811,13 +779,18 @@ int gdb_new_connection(connection_t *connection)
 	return ERROR_OK;
 }
 
-int gdb_connection_closed(connection_t *connection)
+int gdb_connection_closed(struct connection *connection)
 {
-	gdb_service_t *gdb_service = connection->service->priv;
-	gdb_connection_t *gdb_connection = connection->priv;
+	struct gdb_service *gdb_service = connection->service->priv;
+	struct gdb_connection *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", 
+	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);
@@ -843,23 +816,24 @@ 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);
 
 	return ERROR_OK;
 }
 
-void gdb_send_error(connection_t *connection, uint8_t the_error)
+void gdb_send_error(struct connection *connection, uint8_t the_error)
 {
 	char err[4];
 	snprintf(err, 4, "E%2.2X", the_error);
 	gdb_put_packet(connection, err, 3);
 }
 
-int gdb_last_signal_packet(connection_t *connection, target_t *target, char* packet, int packet_size)
+int gdb_last_signal_packet(struct connection *connection, target_t *target, char* packet, int packet_size)
 {
 	char sig_reply[4];
 	int signal;
@@ -941,7 +915,7 @@ void gdb_target_to_reg(target_t *target, char *tstr, int str_len, uint8_t *bin)
 	}
 }
 
-int gdb_get_registers_packet(connection_t *connection, target_t *target, char* packet, int packet_size)
+int gdb_get_registers_packet(struct connection *connection, target_t *target, char* packet, int packet_size)
 {
 	reg_t **reg_list;
 	int reg_list_size;
@@ -991,7 +965,7 @@ int gdb_get_registers_packet(connection_t *connection, target_t *target, char* p
 	return ERROR_OK;
 }
 
-int gdb_set_registers_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
+int gdb_set_registers_packet(struct connection *connection, target_t *target, char *packet, int packet_size)
 {
 	int i;
 	reg_t **reg_list;
@@ -1029,7 +1003,7 @@ int gdb_set_registers_packet(connection_t *connection, target_t *target, char *p
 			LOG_ERROR("BUG: register packet is too small for registers");
 		}
 
-		reg_arch_type_t *arch_type;
+		struct reg_arch_type *arch_type;
 		bin_buf = malloc(CEIL(reg_list[i]->size, 8));
 		gdb_target_to_reg(target, packet_p, chars, bin_buf);
 
@@ -1053,7 +1027,7 @@ int gdb_set_registers_packet(connection_t *connection, target_t *target, char *p
 	return ERROR_OK;
 }
 
-int gdb_get_register_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
+int gdb_get_register_packet(struct connection *connection, target_t *target, char *packet, int packet_size)
 {
 	char *reg_packet;
 	int reg_num = strtoul(packet + 1, NULL, 16);
@@ -1088,7 +1062,7 @@ int gdb_get_register_packet(connection_t *connection, target_t *target, char *pa
 	return ERROR_OK;
 }
 
-int gdb_set_register_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
+int gdb_set_register_packet(struct connection *connection, target_t *target, char *packet, int packet_size)
 {
 	char *separator;
 	uint8_t *bin_buf;
@@ -1096,7 +1070,7 @@ int gdb_set_register_packet(connection_t *connection, target_t *target, char *pa
 	reg_t **reg_list;
 	int reg_list_size;
 	int retval;
-	reg_arch_type_t *arch_type;
+	struct reg_arch_type *arch_type;
 
 	LOG_DEBUG("-");
 
@@ -1137,7 +1111,7 @@ int gdb_set_register_packet(connection_t *connection, target_t *target, char *pa
 	return ERROR_OK;
 }
 
-int gdb_error(connection_t *connection, int retval)
+int gdb_error(struct connection *connection, int retval)
 {
 	switch (retval)
 	{
@@ -1168,7 +1142,7 @@ int gdb_error(connection_t *connection, int retval)
  *
  * 8191 bytes by the looks of it. Why 8191 bytes instead of 8192?????
  */
-int gdb_read_memory_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
+int gdb_read_memory_packet(struct connection *connection, target_t *target, char *packet, int packet_size)
 {
 	char *separator;
 	uint32_t addr = 0;
@@ -1242,7 +1216,7 @@ int gdb_read_memory_packet(connection_t *connection, target_t *target, char *pac
 	return retval;
 }
 
-int gdb_write_memory_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
+int gdb_write_memory_packet(struct connection *connection, target_t *target, char *packet, int packet_size)
 {
 	char *separator;
 	uint32_t addr = 0;
@@ -1299,7 +1273,7 @@ int gdb_write_memory_packet(connection_t *connection, target_t *target, char *pa
 	return retval;
 }
 
-int gdb_write_memory_binary_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
+int gdb_write_memory_binary_packet(struct connection *connection, target_t *target, char *packet, int packet_size)
 {
 	char *separator;
 	uint32_t addr = 0;
@@ -1347,7 +1321,7 @@ int gdb_write_memory_binary_packet(connection_t *connection, target_t *target, c
 	return ERROR_OK;
 }
 
-int gdb_step_continue_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
+int gdb_step_continue_packet(struct connection *connection, target_t *target, char *packet, int packet_size)
 {
 	int current = 0;
 	uint32_t address = 0x0;
@@ -1380,7 +1354,7 @@ int gdb_step_continue_packet(connection_t *connection, target_t *target, char *p
 	return retval;
 }
 
-int gdb_breakpoint_watchpoint_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
+int gdb_breakpoint_watchpoint_packet(struct connection *connection, target_t *target, char *packet, int packet_size)
 {
 	int type;
 	enum breakpoint_type bp_type = BKPT_SOFT /* dummy init to avoid warning */;
@@ -1580,10 +1554,10 @@ 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)
+int gdb_query_packet(struct connection *connection, target_t *target, char *packet, int packet_size)
 {
 	command_context_t *cmd_ctx = connection->cmd_ctx;
-	gdb_connection_t *gdb_connection = connection->priv;
+	struct gdb_connection *gdb_connection = connection->priv;
 
 	if (strstr(packet, "qRcmd,"))
 	{
@@ -1603,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);
@@ -1832,10 +1810,10 @@ int gdb_query_packet(connection_t *connection, target_t *target, char *packet, i
 	return ERROR_OK;
 }
 
-int gdb_v_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
+int gdb_v_packet(struct connection *connection, target_t *target, char *packet, int packet_size)
 {
-	gdb_connection_t *gdb_connection = connection->priv;
-	gdb_service_t *gdb_service = connection->service->priv;
+	struct gdb_connection *gdb_connection = connection->priv;
+	struct gdb_service *gdb_service = connection->service->priv;
 	int result;
 
 	/* if flash programming disabled - send a empty reply */
@@ -1921,7 +1899,7 @@ int gdb_v_packet(connection_t *connection, target_t *target, char *packet, int p
 		/* create a new image if there isn't already one */
 		if (gdb_connection->vflash_image == NULL)
 		{
-			gdb_connection->vflash_image = malloc(sizeof(image_t));
+			gdb_connection->vflash_image = malloc(sizeof(struct image));
 			image_open(gdb_connection->vflash_image, "", "build");
 		}
 
@@ -1969,38 +1947,20 @@ int gdb_v_packet(connection_t *connection, target_t *target, char *packet, int p
 	return ERROR_OK;
 }
 
-int gdb_detach(connection_t *connection, target_t *target)
+int gdb_detach(struct connection *connection, target_t *target)
 {
+	struct gdb_service *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,
+static void gdb_log_callback(void *priv, const char *file, unsigned line,
 		const char *function, const char *string)
 {
-	connection_t *connection = priv;
-	gdb_connection_t *gdb_con = connection->priv;
+	struct connection *connection = priv;
+	struct gdb_connection *gdb_con = connection->priv;
 
 	if (gdb_con->busy)
 	{
@@ -2014,7 +1974,7 @@ 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)
+static void gdb_sig_halted(struct connection *connection)
 {
 	char sig_reply[4];
 	snprintf(sig_reply, 4, "T%2.2x", 2);
@@ -2022,14 +1982,14 @@ static void gdb_sig_halted(connection_t *connection)
 
 }
 
-int gdb_input_inner(connection_t *connection)
+int gdb_input_inner(struct connection *connection)
 {
-	gdb_service_t *gdb_service = connection->service->priv;
+	struct gdb_service *gdb_service = connection->service->priv;
 	target_t *target = gdb_service->target;
 	char *packet = gdb_packet_buffer;
 	int packet_size;
 	int retval;
-	gdb_connection_t *gdb_con = connection->priv;
+	struct gdb_connection *gdb_con = connection->priv;
 	static int extended_protocol = 0;
 
 	/* drain input buffer */
@@ -2101,20 +2061,52 @@ int gdb_input_inner(connection_t *connection)
 				case 'c':
 				case 's':
 					{
-						if (target->state != TARGET_HALTED)
+						int retval = ERROR_OK;
+
+						struct gdb_connection *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)
 						{
-							/* If the target isn't in the halted state, then we can't
+							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)
+						{
+							/* 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)
@@ -2150,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 */
@@ -2168,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);
 			}
 		}
 
@@ -2178,10 +2180,10 @@ int gdb_input_inner(connection_t *connection)
 	return ERROR_OK;
 }
 
-int gdb_input(connection_t *connection)
+int gdb_input(struct connection *connection)
 {
 	int retval = gdb_input_inner(connection);
-	gdb_connection_t *gdb_con = connection->priv;
+	struct gdb_connection *gdb_con = connection->priv;
 	if (retval == ERROR_SERVER_REMOTE_CLOSED)
 		return retval;
 
@@ -2195,7 +2197,7 @@ int gdb_input(connection_t *connection)
 
 int gdb_init(void)
 {
-	gdb_service_t *gdb_service;
+	struct gdb_service *gdb_service;
 	target_t *target = all_targets;
 
 	if (!target)
@@ -2214,7 +2216,7 @@ int gdb_init(void)
 	{
 		/* only a single gdb connection when using a pipe */
 
-		gdb_service = malloc(sizeof(gdb_service_t));
+		gdb_service = malloc(sizeof(struct gdb_service));
 		gdb_service->target = target;
 
 		add_service("gdb", CONNECTION_PIPE, 0, 1, gdb_new_connection, gdb_input, gdb_connection_closed, gdb_service);
@@ -2224,69 +2226,55 @@ int gdb_init(void)
 	}
 	else
 	{
+		unsigned short port = gdb_port;
+
 		while (target)
 		{
-			gdb_service = malloc(sizeof(gdb_service_t));
+			gdb_service = malloc(sizeof(struct gdb_service));
 			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)
+COMMAND_HANDLER(handle_gdb_sync_command)
 {
-	if (argc == 0)
+	if (argc != 0)
 	{
-		command_print(cmd_ctx, "%d", gdb_port);
-		return ERROR_OK;
+		return ERROR_COMMAND_SYNTAX_ERROR;
+	}
+
+	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;
 	}
 
-	gdb_port = strtoul(args[0], NULL, 0);
+	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 */
+COMMAND_HANDLER(handle_gdb_port_command)
 {
-	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 CALL_COMMAND_HANDLER(server_port_command, &gdb_port);
 }
 
-int handle_gdb_memory_map_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+COMMAND_HANDLER(handle_gdb_memory_map_command)
 {
 	if (argc == 1)
 	{
@@ -2307,7 +2295,7 @@ int handle_gdb_memory_map_command(struct command_context_s *cmd_ctx, char *cmd,
 	return ERROR_COMMAND_SYNTAX_ERROR;
 }
 
-int handle_gdb_flash_program_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+COMMAND_HANDLER(handle_gdb_flash_program_command)
 {
 	if (argc == 1)
 	{
@@ -2328,7 +2316,7 @@ int handle_gdb_flash_program_command(struct command_context_s *cmd_ctx, char *cm
 	return ERROR_COMMAND_SYNTAX_ERROR;
 }
 
-int handle_gdb_report_data_abort_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+COMMAND_HANDLER(handle_gdb_report_data_abort_command)
 {
 	if (argc == 1)
 	{
@@ -2350,7 +2338,7 @@ int handle_gdb_report_data_abort_command(struct command_context_s *cmd_ctx, char
 }
 
 /* gdb_breakpoint_override */
-int handle_gdb_breakpoint_override_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+COMMAND_HANDLER(handle_gdb_breakpoint_override_command)
 {
 	if (argc == 0)
 	{
@@ -2385,18 +2373,25 @@ 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_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,
-			COMMAND_CONFIG, "enable or disable flash program");
-	register_command(command_context, NULL, "gdb_report_data_abort", handle_gdb_report_data_abort_command,
-			COMMAND_CONFIG, "enable or disable reporting data aborts");
-	register_command(command_context, NULL, "gdb_breakpoint_override", handle_gdb_breakpoint_override_command,
-			COMMAND_EXEC, "hard/soft/disable - force breakpoint type for gdb 'break' commands.");
+	register_command(command_context, NULL, "gdb_sync",
+			handle_gdb_sync_command, COMMAND_ANY,
+			"next stepi will return immediately allowing GDB to "
+			"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_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, COMMAND_CONFIG,
+			"enable or disable flash program");
+	register_command(command_context, NULL, "gdb_report_data_abort",
+			handle_gdb_report_data_abort_command, COMMAND_CONFIG,
+			"enable or disable reporting data aborts");
+	register_command(command_context, NULL, "gdb_breakpoint_override",
+			handle_gdb_breakpoint_override_command, COMMAND_EXEC,
+			"hard/soft/disable - force type of breakpoint "
+			"used by gdb 'break' commands.");
 	return ERROR_OK;
 }