X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Fserver%2Fgdb_server.c;h=21dc24c9e1c74b2a51033b1bb0e4338a30242591;hp=a0077e93e6fe99a2cec16dbf434be587b2fef76c;hb=410fab9ea8c6632da2e4967d960f66eecc7821ec;hpb=22aff82cae0de384f931b4cea89c4f52ec976407

diff --git a/src/server/gdb_server.c b/src/server/gdb_server.c
index a0077e93e6..21dc24c9e1 100644
--- a/src/server/gdb_server.c
+++ b/src/server/gdb_server.c
@@ -27,11 +27,12 @@
 #include "config.h"
 #endif
 
-#include "gdb_server.h"
+#include "breakpoints.h"
 #include "target_request.h"
 #include "register.h"
 #include "server.h"
 #include "flash.h"
+#include "gdb_server.h"
 #include "image.h"
 #include "jtag.h"
 
@@ -40,29 +41,18 @@
 #define _DEBUG_GDB_IO_
 #endif
 
-static gdb_connection_t *current_gdb_connection;
+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;
@@ -78,7 +68,7 @@ int gdb_flash_program = 1;
  * see the code in gdb_read_memory_packet() for further explanations */
 int gdb_report_data_abort = 0;
 
-int gdb_last_signal(target_t *target)
+int gdb_last_signal(struct target *target)
 {
 	switch (target->debug_reason)
 	{
@@ -98,14 +88,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;
@@ -139,9 +129,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_
@@ -247,9 +237,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)
 	{
@@ -267,9 +257,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;
 
@@ -292,7 +282,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;
@@ -301,7 +291,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];
@@ -433,9 +423,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;
@@ -446,14 +436,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;
@@ -555,11 +545,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)
 	{
@@ -630,16 +620,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;
@@ -661,7 +651,7 @@ int gdb_output_con(connection_t *connection, const char* line)
 	return retval;
 }
 
-int gdb_output(struct command_context_s *context, const char* line)
+int gdb_output(struct command_context *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);
@@ -669,9 +659,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 *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
@@ -706,10 +696,10 @@ 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 gdb_target_callback_event_handler(struct target *target, enum target_event event, void *priv)
 {
 	int retval;
-	connection_t *connection = priv;
+	struct connection *connection = priv;
 
 	target_handle_event(target, event);
 	switch (event)
@@ -734,10 +724,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;
 
@@ -790,10 +780,10 @@ 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.
@@ -837,14 +827,14 @@ int gdb_connection_closed(connection_t *connection)
 	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, struct target *target, char* packet, int packet_size)
 {
 	char sig_reply[4];
 	int signal;
@@ -857,7 +847,7 @@ int gdb_last_signal_packet(connection_t *connection, target_t *target, char* pac
 	return ERROR_OK;
 }
 
-static int gdb_reg_pos(target_t *target, int pos, int len)
+static int gdb_reg_pos(struct target *target, int pos, int len)
 {
 	if (target->endianness == TARGET_LITTLE_ENDIAN)
 		return pos;
@@ -874,14 +864,14 @@ static int gdb_reg_pos(target_t *target, int pos, int len)
  * The format of reg->value is little endian
  *
  */
-void gdb_str_to_target(target_t *target, char *tstr, reg_t *reg)
+void gdb_str_to_target(struct target *target, char *tstr, struct reg *reg)
 {
 	int i;
 
 	uint8_t *buf;
 	int buf_len;
 	buf = reg->value;
-	buf_len = CEIL(reg->size, 8);
+	buf_len = DIV_ROUND_UP(reg->size, 8);
 
 	for (i = 0; i < buf_len; i++)
 	{
@@ -907,7 +897,7 @@ static int hextoint(char c)
 }
 
 /* copy over in register buffer */
-void gdb_target_to_reg(target_t *target, char *tstr, int str_len, uint8_t *bin)
+void gdb_target_to_reg(struct target *target, char *tstr, int str_len, uint8_t *bin)
 {
 	if (str_len % 2)
 	{
@@ -926,9 +916,9 @@ 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, struct target *target, char* packet, int packet_size)
 {
-	reg_t **reg_list;
+	struct reg **reg_list;
 	int reg_list_size;
 	int retval;
 	int reg_packet_size = 0;
@@ -950,25 +940,25 @@ int gdb_get_registers_packet(connection_t *connection, target_t *target, char* p
 		reg_packet_size += reg_list[i]->size;
 	}
 
-	reg_packet = malloc(CEIL(reg_packet_size, 8) * 2);
+	reg_packet = malloc(DIV_ROUND_UP(reg_packet_size, 8) * 2);
 	reg_packet_p = reg_packet;
 
 	for (i = 0; i < reg_list_size; i++)
 	{
 		gdb_str_to_target(target, reg_packet_p, reg_list[i]);
-		reg_packet_p += CEIL(reg_list[i]->size, 8) * 2;
+		reg_packet_p += DIV_ROUND_UP(reg_list[i]->size, 8) * 2;
 	}
 
 #ifdef _DEBUG_GDB_IO_
 	{
 		char *reg_packet_p;
-		reg_packet_p = strndup(reg_packet, CEIL(reg_packet_size, 8) * 2);
+		reg_packet_p = strndup(reg_packet, DIV_ROUND_UP(reg_packet_size, 8) * 2);
 		LOG_DEBUG("reg_packet: %s", reg_packet_p);
 		free(reg_packet_p);
 	}
 #endif
 
-	gdb_put_packet(connection, reg_packet, CEIL(reg_packet_size, 8) * 2);
+	gdb_put_packet(connection, reg_packet, DIV_ROUND_UP(reg_packet_size, 8) * 2);
 	free(reg_packet);
 
 	free(reg_list);
@@ -976,10 +966,10 @@ 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, struct target *target, char *packet, int packet_size)
 {
 	int i;
-	reg_t **reg_list;
+	struct reg **reg_list;
 	int reg_list_size;
 	int retval;
 	char *packet_p;
@@ -1007,21 +997,17 @@ int gdb_set_registers_packet(connection_t *connection, target_t *target, char *p
 	for (i = 0; i < reg_list_size; i++)
 	{
 		uint8_t *bin_buf;
-		int chars = (CEIL(reg_list[i]->size, 8) * 2);
+		int chars = (DIV_ROUND_UP(reg_list[i]->size, 8) * 2);
 
 		if (packet_p + chars > packet + packet_size)
 		{
 			LOG_ERROR("BUG: register packet is too small for registers");
 		}
 
-		reg_arch_type_t *arch_type;
-		bin_buf = malloc(CEIL(reg_list[i]->size, 8));
+		bin_buf = malloc(DIV_ROUND_UP(reg_list[i]->size, 8));
 		gdb_target_to_reg(target, packet_p, chars, bin_buf);
 
-		/* get register arch_type, and call set method */
-		arch_type = register_get_arch_type(reg_list[i]->arch_type);
-
-		arch_type->set(reg_list[i], bin_buf);
+		reg_list[i]->type->set(reg_list[i], bin_buf);
 
 		/* advance packet pointer */
 		packet_p += chars;
@@ -1030,7 +1016,7 @@ int gdb_set_registers_packet(connection_t *connection, target_t *target, char *p
 		free(bin_buf);
 	}
 
-	/* free reg_t *reg_list[] array allocated by get_gdb_reg_list */
+	/* free struct reg *reg_list[] array allocated by get_gdb_reg_list */
 	free(reg_list);
 
 	gdb_put_packet(connection, "OK", 2);
@@ -1038,11 +1024,11 @@ 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, struct target *target, char *packet, int packet_size)
 {
 	char *reg_packet;
 	int reg_num = strtoul(packet + 1, NULL, 16);
-	reg_t **reg_list;
+	struct reg **reg_list;
 	int reg_list_size;
 	int retval;
 
@@ -1061,11 +1047,11 @@ int gdb_get_register_packet(connection_t *connection, target_t *target, char *pa
 		exit(-1);
 	}
 
-	reg_packet = malloc(CEIL(reg_list[reg_num]->size, 8) * 2);
+	reg_packet = malloc(DIV_ROUND_UP(reg_list[reg_num]->size, 8) * 2);
 
 	gdb_str_to_target(target, reg_packet, reg_list[reg_num]);
 
-	gdb_put_packet(connection, reg_packet, CEIL(reg_list[reg_num]->size, 8) * 2);
+	gdb_put_packet(connection, reg_packet, DIV_ROUND_UP(reg_list[reg_num]->size, 8) * 2);
 
 	free(reg_list);
 	free(reg_packet);
@@ -1073,15 +1059,14 @@ 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, struct target *target, char *packet, int packet_size)
 {
 	char *separator;
 	uint8_t *bin_buf;
 	int reg_num = strtoul(packet + 1, &separator, 16);
-	reg_t **reg_list;
+	struct reg **reg_list;
 	int reg_list_size;
 	int retval;
-	reg_arch_type_t *arch_type;
 
 	LOG_DEBUG("-");
 
@@ -1103,16 +1088,14 @@ int gdb_set_register_packet(connection_t *connection, target_t *target, char *pa
 	}
 
 	/* convert from GDB-string (target-endian) to hex-string (big-endian) */
-	bin_buf = malloc(CEIL(reg_list[reg_num]->size, 8));
-	int chars = (CEIL(reg_list[reg_num]->size, 8) * 2);
+	bin_buf = malloc(DIV_ROUND_UP(reg_list[reg_num]->size, 8));
+	int chars = (DIV_ROUND_UP(reg_list[reg_num]->size, 8) * 2);
 
 	/* fix!!! add some sanity checks on packet size here */
 
 	gdb_target_to_reg(target, separator + 1, chars, bin_buf);
 
-		/* get register arch_type, and call set method */
-	arch_type = register_get_arch_type(reg_list[reg_num]->arch_type);
-	arch_type->set(reg_list[reg_num], bin_buf);
+	reg_list[reg_num]->type->set(reg_list[reg_num], bin_buf);
 
 	gdb_put_packet(connection, "OK", 2);
 
@@ -1122,7 +1105,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)
 	{
@@ -1153,7 +1136,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, struct target *target, char *packet, int packet_size)
 {
 	char *separator;
 	uint32_t addr = 0;
@@ -1227,7 +1210,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, struct target *target, char *packet, int packet_size)
 {
 	char *separator;
 	uint32_t addr = 0;
@@ -1284,7 +1267,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, struct target *target, char *packet, int packet_size)
 {
 	char *separator;
 	uint32_t addr = 0;
@@ -1332,7 +1315,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, struct target *target, char *packet, int packet_size)
 {
 	int current = 0;
 	uint32_t address = 0x0;
@@ -1365,7 +1348,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, struct target *target, char *packet, int packet_size)
 {
 	int type;
 	enum breakpoint_type bp_type = BKPT_SOFT /* dummy init to avoid warning */;
@@ -1531,7 +1514,7 @@ static int decode_xfer_read(char *buf, char **annex, int *ofs, unsigned int *len
 	return 0;
 }
 
-int gdb_calc_blocksize(flash_bank_t *bank)
+int gdb_calc_blocksize(struct flash_bank *bank)
 {
 	uint32_t i;
 	uint32_t block_size = 0xffffffff;
@@ -1549,9 +1532,9 @@ int gdb_calc_blocksize(flash_bank_t *bank)
 
 static int compare_bank (const void * a, const void * b)
 {
-	flash_bank_t *b1, *b2;
-	b1=*((flash_bank_t **)a);
-	b2=*((flash_bank_t **)b);
+	struct flash_bank *b1, *b2;
+	b1=*((struct flash_bank **)a);
+	b2=*((struct flash_bank **)b);
 
 	if (b1->base == b2->base)
 	{
@@ -1565,10 +1548,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, struct target *target, char *packet, int packet_size)
 {
-	command_context_t *cmd_ctx = connection->cmd_ctx;
-	gdb_connection_t *gdb_connection = connection->priv;
+	struct command_context *cmd_ctx = connection->cmd_ctx;
+	struct gdb_connection *gdb_connection = connection->priv;
 
 	if (strstr(packet, "qRcmd,"))
 	{
@@ -1672,7 +1655,7 @@ int gdb_query_packet(connection_t *connection, target_t *target, char *packet, i
 		 * Normally we only execute this code once, but no big deal if we
 		 * have to regenerate it a couple of times. */
 
-		flash_bank_t *p;
+		struct flash_bank *p;
 		char *xml = NULL;
 		int size = 0;
 		int pos = 0;
@@ -1696,7 +1679,7 @@ int gdb_query_packet(connection_t *connection, target_t *target, char *packet, i
 		read/write) by default for GDB.
 		GDB does not have a concept of non-cacheable read/write memory.
 		 */
-		flash_bank_t **banks = malloc(sizeof(flash_bank_t *)*flash_get_bank_count());
+		struct flash_bank **banks = malloc(sizeof(struct flash_bank *)*flash_get_bank_count());
 		int i;
 
 		for (i = 0; i < flash_get_bank_count(); i++)
@@ -1712,7 +1695,7 @@ int gdb_query_packet(connection_t *connection, target_t *target, char *packet, i
 			banks[i]=p;
 		}
 
-		qsort(banks, flash_get_bank_count(), sizeof(flash_bank_t *), compare_bank);
+		qsort(banks, flash_get_bank_count(), sizeof(struct flash_bank *), compare_bank);
 
 		uint32_t ram_start = 0;
 		for (i = 0; i < flash_get_bank_count(); i++)
@@ -1821,10 +1804,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, struct target *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 */
@@ -1910,7 +1893,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");
 		}
 
@@ -1958,38 +1941,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, struct target *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)
 	{
@@ -2003,7 +1968,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);
@@ -2011,14 +1976,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;
-	target_t *target = gdb_service->target;
+	struct gdb_service *gdb_service = connection->service->priv;
+	struct target *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 */
@@ -2092,7 +2057,7 @@ int gdb_input_inner(connection_t *connection)
 					{
 						int retval = ERROR_OK;
 
-						gdb_connection_t *gdb_con = connection->priv;
+						struct gdb_connection *gdb_con = connection->priv;
 						log_add_callback(gdb_log_callback, connection);
 
 						bool nostep = false;
@@ -2191,8 +2156,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);
 			}
 		}
 
@@ -2201,10 +2174,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;
 
@@ -2218,8 +2191,8 @@ int gdb_input(connection_t *connection)
 
 int gdb_init(void)
 {
-	gdb_service_t *gdb_service;
-	target_t *target = all_targets;
+	struct gdb_service *gdb_service;
+	struct target *target = all_targets;
 
 	if (!target)
 	{
@@ -2237,7 +2210,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);
@@ -2251,7 +2224,7 @@ int gdb_init(void)
 
 		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,
@@ -2270,16 +2243,16 @@ int gdb_init(void)
 	return ERROR_OK;
 }
 
-int handle_gdb_sync_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+COMMAND_HANDLER(handle_gdb_sync_command)
 {
-	if (argc != 0)
+	if (CMD_ARGC != 0)
 	{
 		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
 	if (current_gdb_connection == NULL)
 	{
-		command_print(cmd_ctx,
+		command_print(CMD_CTX,
 				"gdb_sync command can only be run from within gdb using \"monitor gdb_sync\"");
 		return ERROR_FAIL;
 	}
@@ -2290,129 +2263,51 @@ int handle_gdb_sync_command(struct command_context_s *cmd_ctx, char *cmd, char *
 }
 
 /* daemon configuration command gdb_port */
-int handle_gdb_port_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
-{
-	if (argc == 0)
-	{
-		command_print(cmd_ctx, "%d", gdb_port);
-		return ERROR_OK;
-	}
-
-	gdb_port = strtoul(args[0], NULL, 0);
-
-	return ERROR_OK;
-}
-
-int handle_gdb_detach_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+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)
-	{
-		if (strcmp(args[0], "enable") == 0)
-		{
-			gdb_use_memory_map = 1;
-			return ERROR_OK;
-		}
-		else if (strcmp(args[0], "disable") == 0)
-		{
-			gdb_use_memory_map = 0;
-			return ERROR_OK;
-		}
-		else
-			LOG_WARNING("invalid gdb_memory_map configuration directive %s", args[0]);
-	}
+	if (CMD_ARGC == 1)
+		COMMAND_PARSE_ENABLE(CMD_ARGV[0], gdb_use_memory_map);
 
 	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)
-	{
-		if (strcmp(args[0], "enable") == 0)
-		{
-			gdb_flash_program = 1;
-			return ERROR_OK;
-		}
-		else if (strcmp(args[0], "disable") == 0)
-		{
-			gdb_flash_program = 0;
-			return ERROR_OK;
-		}
-		else
-			LOG_WARNING("invalid gdb_flash_program configuration directive: %s", args[0]);
-	}
+	if (CMD_ARGC == 1)
+		COMMAND_PARSE_ENABLE(CMD_ARGV[0], gdb_flash_program);
 
 	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)
-	{
-		if (strcmp(args[0], "enable") == 0)
-		{
-			gdb_report_data_abort = 1;
-			return ERROR_OK;
-		}
-		else if (strcmp(args[0], "disable") == 0)
-		{
-			gdb_report_data_abort = 0;
-			return ERROR_OK;
-		}
-		else
-			LOG_WARNING("invalid gdb_report_data_abort configuration directive: %s", args[0]);
-	}
+	if (CMD_ARGC == 1)
+		COMMAND_PARSE_ENABLE(CMD_ARGV[0], gdb_report_data_abort);
 
 	return ERROR_COMMAND_SYNTAX_ERROR;
 }
 
 /* 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)
+	if (CMD_ARGC == 0)
 	{
 
-	} else if (argc == 1)
+	} else if (CMD_ARGC == 1)
 	{
 		gdb_breakpoint_override = 1;
-		if (strcmp(args[0], "hard") == 0)
+		if (strcmp(CMD_ARGV[0], "hard") == 0)
 		{
 			gdb_breakpoint_override_type = BKPT_HARD;
-		} else if (strcmp(args[0], "soft") == 0)
+		} else if (strcmp(CMD_ARGV[0], "soft") == 0)
 		{
 			gdb_breakpoint_override_type = BKPT_SOFT;
-		} else if (strcmp(args[0], "disable") == 0)
+		} else if (strcmp(CMD_ARGV[0], "disable") == 0)
 		{
 			gdb_breakpoint_override = 0;
 		}
@@ -2431,22 +2326,27 @@ int handle_gdb_breakpoint_override_command(struct command_context_s *cmd_ctx, ch
 	return ERROR_OK;
 }
 
-int gdb_register_commands(command_context_t *command_context)
+int gdb_register_commands(struct command_context *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,
-			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;
 }