X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Fserver%2Fgdb_server.c;h=c293f5b057235f829bd6228c94b0459c23dff4b9;hp=d4cc2744c63f48839748a84be6b1b40c45cd1008;hb=47b8cf84202bf792cf66fbfa01169e9592236b8a;hpb=9b2577742cc49683ab0ea8506d93e3e285b53bbd

diff --git a/src/server/gdb_server.c b/src/server/gdb_server.c
index d4cc2744c6..c293f5b057 100644
--- a/src/server/gdb_server.c
+++ b/src/server/gdb_server.c
@@ -31,9 +31,7 @@
  *   GNU General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
- *   along with this program; if not, write to the                         *
- *   Free Software Foundation, Inc.,                                       *
- *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.           *
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>. *
  ***************************************************************************/
 
 #ifdef HAVE_CONFIG_H
@@ -92,6 +90,8 @@ struct gdb_connection {
 	bool attached;
 	/* temporarily used for target description support */
 	struct target_desc_format target_desc;
+	/* temporarily used for thread list support */
+	char *thread_list;
 };
 
 #if 0
@@ -628,7 +628,7 @@ static int gdb_get_packet_inner(struct connection *connection,
 					 * warning only about subsequent ACK's. */
 					if (gdb_con->noack_mode > 1) {
 						LOG_WARNING("acknowledgment received, but no packet pending");
-					} else {
+					} else if (gdb_con->noack_mode) {
 						LOG_DEBUG("Received first acknowledgment after entering noack mode. Ignoring it.");
 						gdb_con->noack_mode = 2;
 					}
@@ -697,7 +697,8 @@ static int gdb_output_con(struct connection *connection, const char *line)
 		return ERROR_GDB_BUFFER_TOO_SMALL;
 
 	hex_buffer[0] = 'O';
-	int pkt_len = hexify(hex_buffer + 1, line, bin_size, bin_size * 2 + 1);
+	size_t pkt_len = hexify(hex_buffer + 1, (const uint8_t *)line, bin_size,
+		bin_size * 2 + 1);
 	int retval = gdb_put_packet(connection, hex_buffer, pkt_len + 1);
 
 	free(hex_buffer);
@@ -714,11 +715,14 @@ static int gdb_output(struct command_context *context, const char *line)
 static void gdb_signal_reply(struct target *target, struct connection *connection)
 {
 	struct gdb_connection *gdb_connection = connection->priv;
-	char sig_reply[20];
+	char sig_reply[45];
 	char stop_reason[20];
+	char current_thread[25];
 	int sig_reply_len;
 	int signal_var;
 
+	rtos_update_threads(target);
+
 	if (target->debug_reason == DBG_REASON_EXIT) {
 		sig_reply_len = snprintf(sig_reply, sizeof(sig_reply), "W00");
 	} else {
@@ -731,22 +735,22 @@ static void gdb_signal_reply(struct target *target, struct connection *connectio
 		stop_reason[0] = '\0';
 		if (target->debug_reason == DBG_REASON_WATCHPOINT) {
 			enum watchpoint_rw hit_wp_type;
-			uint32_t hit_wp_address;
+			target_addr_t hit_wp_address;
 
 			if (watchpoint_hit(target, &hit_wp_type, &hit_wp_address) == ERROR_OK) {
 
 				switch (hit_wp_type) {
 					case WPT_WRITE:
 						snprintf(stop_reason, sizeof(stop_reason),
-								"watch:%08" PRIx32 ";", hit_wp_address);
+								"watch:%08" TARGET_PRIxADDR ";", hit_wp_address);
 						break;
 					case WPT_READ:
 						snprintf(stop_reason, sizeof(stop_reason),
-								"rwatch:%08" PRIx32 ";", hit_wp_address);
+								"rwatch:%08" TARGET_PRIxADDR ";", hit_wp_address);
 						break;
 					case WPT_ACCESS:
 						snprintf(stop_reason, sizeof(stop_reason),
-								"awatch:%08" PRIx32 ";", hit_wp_address);
+								"awatch:%08" TARGET_PRIxADDR ";", hit_wp_address);
 						break;
 					default:
 						break;
@@ -754,13 +758,18 @@ static void gdb_signal_reply(struct target *target, struct connection *connectio
 			}
 		}
 
-		sig_reply_len = snprintf(sig_reply, sizeof(sig_reply), "T%2.2x%s",
-				signal_var, stop_reason);
+		current_thread[0] = '\0';
+		if (target->rtos != NULL) {
+			snprintf(current_thread, sizeof(current_thread), "thread:%016" PRIx64 ";", target->rtos->current_thread);
+			target->rtos->current_threadid = target->rtos->current_thread;
+		}
+
+		sig_reply_len = snprintf(sig_reply, sizeof(sig_reply), "T%2.2x%s%s",
+				signal_var, stop_reason, current_thread);
 	}
 
 	gdb_put_packet(connection, sig_reply, sig_reply_len);
 	gdb_connection->frontend_state = TARGET_HALTED;
-	rtos_update_threads(target);
 }
 
 static void gdb_fileio_reply(struct target *target, struct connection *connection)
@@ -928,6 +937,7 @@ static int gdb_new_connection(struct connection *connection)
 	gdb_connection->attached = true;
 	gdb_connection->target_desc.tdesc = NULL;
 	gdb_connection->target_desc.tdesc_length = 0;
+	gdb_connection->thread_list = NULL;
 
 	/* send ACK to GDB for debug request */
 	gdb_write(connection, "+", 1);
@@ -1151,6 +1161,9 @@ static int gdb_get_registers_packet(struct connection *connection,
 	assert(reg_packet_size > 0);
 
 	reg_packet = malloc(reg_packet_size + 1); /* plus one for string termination null */
+	if (reg_packet == NULL)
+		return ERROR_FAIL;
+
 	reg_packet_p = reg_packet;
 
 	for (i = 0; i < reg_list_size; i++) {
@@ -1395,7 +1408,7 @@ static int gdb_read_memory_packet(struct connection *connection,
 	if (retval == ERROR_OK) {
 		hex_buffer = malloc(len * 2 + 1);
 
-		int pkt_len = hexify(hex_buffer, (char *)buffer, len, len * 2 + 1);
+		size_t pkt_len = hexify(hex_buffer, buffer, len, len * 2 + 1);
 
 		gdb_put_packet(connection, hex_buffer, pkt_len);
 
@@ -1440,7 +1453,7 @@ static int gdb_write_memory_packet(struct connection *connection,
 
 	LOG_DEBUG("addr: 0x%8.8" PRIx32 ", len: 0x%8.8" PRIx32 "", addr, len);
 
-	if (unhexify((char *)buffer, separator, len) != (int)len)
+	if (unhexify(buffer, separator, len) != len)
 		LOG_ERROR("unable to decode memory packet");
 
 	retval = target_write_buffer(target, addr, len, buffer);
@@ -1464,6 +1477,10 @@ static int gdb_write_memory_binary_packet(struct connection *connection,
 	uint32_t len = 0;
 
 	int retval = ERROR_OK;
+	/* Packets larger than fast_limit bytes will be acknowledged instantly on
+	 * the assumption that we're in a download and it's important to go as fast
+	 * as possible. */
+	uint32_t fast_limit = 8;
 
 	/* skip command character */
 	packet++;
@@ -1484,19 +1501,23 @@ static int gdb_write_memory_binary_packet(struct connection *connection,
 
 	struct gdb_connection *gdb_connection = connection->priv;
 
-	if (gdb_connection->mem_write_error) {
+	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);
-	else {
+	if (retval == ERROR_OK) {
+		if (len >= fast_limit) {
+			/* By replying the packet *immediately* GDB will send us a new packet
+			 * while we write the last one to the target.
+			 * We only do this for larger writes, so that users who do something like:
+			 * p *((int*)0xdeadbeef)=8675309
+			 * will get immediate feedback that that write failed.
+			 */
+			gdb_put_packet(connection, "OK", 2);
+		}
+	} else {
 		retval = gdb_error(connection, retval);
+		/* now that we have reported the memory write error, we can clear the condition */
+		gdb_connection->mem_write_error = false;
 		if (retval != ERROR_OK)
 			return retval;
 	}
@@ -1509,6 +1530,15 @@ static int gdb_write_memory_binary_packet(struct connection *connection,
 			gdb_connection->mem_write_error = true;
 	}
 
+	if (len < fast_limit) {
+		if (retval != ERROR_OK) {
+			gdb_error(connection, retval);
+			gdb_connection->mem_write_error = false;
+		} else {
+			gdb_put_packet(connection, "OK", 2);
+		}
+	}
+
 	return ERROR_OK;
 }
 
@@ -1669,41 +1699,31 @@ static void xml_printf(int *retval, char **xml, int *pos, int *size,
 	}
 }
 
-static int decode_xfer_read(char const *_buf, char **annex, int *ofs, unsigned int *len)
+static int decode_xfer_read(char const *buf, char **annex, int *ofs, unsigned int *len)
 {
-	int ret = 0;
-	char *buf = strdup(_buf);
-	char *_annex;
-	char *separator;
-
-	/* Extract and NUL-terminate the annex. */
-	_annex = buf;
-	while (*buf && *buf != ':')
-		buf++;
-	if (*buf == '\0') {
-		ret = -1;
-		goto out;
-	}
-	*buf++ = 0;
-
-	/* Return annex as copy because "buf" will be freed in this function */
-	*annex = strdup(_annex);
+	/* Locate the annex. */
+	const char *annex_end = strchr(buf, ':');
+	if (annex_end == NULL)
+		return ERROR_FAIL;
 
 	/* After the read marker and annex, qXfer looks like a
 	 * traditional 'm' packet. */
+	char *separator;
+	*ofs = strtoul(annex_end + 1, &separator, 16);
 
-	*ofs = strtoul(buf, &separator, 16);
-
-	if (*separator != ',') {
-		ret = -1;
-		goto out;
-	}
+	if (*separator != ',')
+		return ERROR_FAIL;
 
 	*len = strtoul(separator + 1, NULL, 16);
 
-out:
-	free(buf);
-	return ret;
+	/* Extract the annex if needed */
+	if (annex != NULL) {
+		*annex = strndup(buf, annex_end - buf);
+		if (*annex == NULL)
+			return ERROR_FAIL;
+	}
+
+	return ERROR_OK;
 }
 
 static int compare_bank(const void *a, const void *b)
@@ -2008,7 +2028,7 @@ static int gdb_generate_reg_type_description(struct target *target,
 /* Get a list of available target registers features. feature_list must
  * be freed by caller.
  */
-static int get_reg_features_list(struct target *target, char **feature_list[], int *feature_list_size,
+static int get_reg_features_list(struct target *target, char const **feature_list[], int *feature_list_size,
 		struct reg **reg_list, int reg_list_size)
 {
 	int tbl_sz = 0;
@@ -2029,7 +2049,7 @@ static int get_reg_features_list(struct target *target, char **feature_list[], i
 			 */
 			for (int j = 0; j < (tbl_sz + 1); j++) {
 				if (!((*feature_list)[j])) {
-					(*feature_list)[tbl_sz++] = strdup(reg_list[i]->feature->name);
+					(*feature_list)[tbl_sz++] = reg_list[i]->feature->name;
 					*feature_list = realloc(*feature_list, sizeof(char *) * (tbl_sz + 1));
 					(*feature_list)[tbl_sz] = NULL;
 					break;
@@ -2050,8 +2070,10 @@ static int get_reg_features_list(struct target *target, char **feature_list[], i
 static int gdb_generate_target_description(struct target *target, char **tdesc_out)
 {
 	int retval = ERROR_OK;
-	struct reg **reg_list;
+	struct reg **reg_list = NULL;
 	int reg_list_size;
+	char const **features = NULL;
+	int feature_list_size = 0;
 	char *tdesc = NULL;
 	int pos = 0;
 	int size = 0;
@@ -2061,21 +2083,22 @@ static int gdb_generate_target_description(struct target *target, char **tdesc_o
 
 	if (retval != ERROR_OK) {
 		LOG_ERROR("get register list failed");
-		return ERROR_FAIL;
+		retval = ERROR_FAIL;
+		goto error;
 	}
 
 	if (reg_list_size <= 0) {
-		free(reg_list);
-		return ERROR_FAIL;
+		LOG_ERROR("get register list failed");
+		retval = ERROR_FAIL;
+		goto error;
 	}
 
-	char **features = NULL;
 	/* Get a list of available target registers features */
-	retval = get_reg_features_list(target, &features, NULL, reg_list, reg_list_size);
+	retval = get_reg_features_list(target, &features, &feature_list_size, reg_list, reg_list_size);
 	if (retval != ERROR_OK) {
 		LOG_ERROR("Can't get the registers feature list");
-		free(reg_list);
-		return ERROR_FAIL;
+		retval = ERROR_FAIL;
+		goto error;
 	}
 
 	/* If we found some features associated with registers, create sections */
@@ -2155,8 +2178,9 @@ static int gdb_generate_target_description(struct target *target, char **tdesc_o
 	xml_printf(&retval, &tdesc, &pos, &size,
 			"</target>\n");
 
-	free(reg_list);
+error:
 	free(features);
+	free(reg_list);
 
 	if (retval == ERROR_OK)
 		*tdesc_out = tdesc;
@@ -2225,8 +2249,8 @@ static int gdb_target_description_supported(struct target *target, int *supporte
 	int retval = ERROR_OK;
 	struct reg **reg_list = NULL;
 	int reg_list_size = 0;
+	char const **features = NULL;
 	int feature_list_size = 0;
-	char **features = NULL;
 
 	retval = target_get_gdb_reg_list(target, &reg_list,
 			&reg_list_size, REG_CLASS_ALL);
@@ -2236,6 +2260,7 @@ static int gdb_target_description_supported(struct target *target, int *supporte
 	}
 
 	if (reg_list_size <= 0) {
+		LOG_ERROR("get register list failed");
 		retval = ERROR_FAIL;
 		goto error;
 	}
@@ -2255,15 +2280,102 @@ static int gdb_target_description_supported(struct target *target, int *supporte
 	}
 
 error:
-	if (reg_list != NULL)
-		free(reg_list);
+	free(features);
 
-	if (features != NULL)
-		free(features);
+	free(reg_list);
 
 	return retval;
 }
 
+static int gdb_generate_thread_list(struct target *target, char **thread_list_out)
+{
+	struct rtos *rtos = target->rtos;
+	int retval = ERROR_OK;
+	char *thread_list = NULL;
+	int pos = 0;
+	int size = 0;
+
+	xml_printf(&retval, &thread_list, &pos, &size,
+		   "<?xml version=\"1.0\"?>\n"
+		   "<threads>\n");
+
+	if (rtos != NULL) {
+		for (int i = 0; i < rtos->thread_count; i++) {
+			struct thread_detail *thread_detail = &rtos->thread_details[i];
+
+			if (!thread_detail->exists)
+				continue;
+
+			xml_printf(&retval, &thread_list, &pos, &size,
+				   "<thread id=\"%" PRIx64 "\">", thread_detail->threadid);
+
+			if (thread_detail->thread_name_str != NULL)
+				xml_printf(&retval, &thread_list, &pos, &size,
+					   "Name: %s", thread_detail->thread_name_str);
+
+			if (thread_detail->extra_info_str != NULL) {
+				if (thread_detail->thread_name_str != NULL)
+					xml_printf(&retval, &thread_list, &pos, &size,
+						   ", ");
+				xml_printf(&retval, &thread_list, &pos, &size,
+					   thread_detail->extra_info_str);
+			}
+
+			xml_printf(&retval, &thread_list, &pos, &size,
+				   "</thread>\n");
+		}
+	}
+
+	xml_printf(&retval, &thread_list, &pos, &size,
+		   "</threads>\n");
+
+	if (retval == ERROR_OK)
+		*thread_list_out = thread_list;
+	else
+		free(thread_list);
+
+	return retval;
+}
+
+static int gdb_get_thread_list_chunk(struct target *target, char **thread_list,
+		char **chunk, int32_t offset, uint32_t length)
+{
+	if (*thread_list == NULL) {
+		int retval = gdb_generate_thread_list(target, thread_list);
+		if (retval != ERROR_OK) {
+			LOG_ERROR("Unable to Generate Thread List");
+			return ERROR_FAIL;
+		}
+	}
+
+	size_t thread_list_length = strlen(*thread_list);
+	char transfer_type;
+
+	length = MIN(length, thread_list_length - offset);
+	if (length < (thread_list_length - offset))
+		transfer_type = 'm';
+	else
+		transfer_type = 'l';
+
+	*chunk = malloc(length + 2);
+	if (*chunk == NULL) {
+		LOG_ERROR("Unable to allocate memory");
+		return ERROR_FAIL;
+	}
+
+	(*chunk)[0] = transfer_type;
+	strncpy((*chunk) + 1, (*thread_list) + offset, length);
+	(*chunk)[1 + length] = '\0';
+
+	/* After gdb-server sends out last chunk, invalidate thread list. */
+	if (transfer_type == 'l') {
+		free(*thread_list);
+		*thread_list = NULL;
+	}
+
+	return ERROR_OK;
+}
+
 static int gdb_query_packet(struct connection *connection,
 		char const *packet, int packet_size)
 {
@@ -2275,7 +2387,7 @@ static int gdb_query_packet(struct connection *connection,
 		if (packet_size > 6) {
 			char *cmd;
 			cmd = malloc((packet_size - 6) / 2 + 1);
-			int len = unhexify(cmd, packet + 6, (packet_size - 6) / 2);
+			size_t len = unhexify((uint8_t *)cmd, packet + 6, (packet_size - 6) / 2);
 			cmd[len] = 0;
 
 			/* We want to print all debug output to GDB connection */
@@ -2353,7 +2465,7 @@ static int gdb_query_packet(struct connection *connection,
 			&buffer,
 			&pos,
 			&size,
-			"PacketSize=%x;qXfer:memory-map:read%c;qXfer:features:read%c;QStartNoAckMode+",
+			"PacketSize=%x;qXfer:memory-map:read%c;qXfer:features:read%c;qXfer:threads:read+;QStartNoAckMode+",
 			(GDB_BUFFER_SIZE - 1),
 			((gdb_use_memory_map == 1) && (flash_get_bank_count() > 0)) ? '+' : '-',
 			(gdb_target_desc_supported == 1) ? '+' : '-');
@@ -2376,16 +2488,14 @@ static int gdb_query_packet(struct connection *connection,
 
 		int offset;
 		unsigned int length;
-		char *annex = NULL;
 
 		/* skip command character */
 		packet += 20;
 
-		if (decode_xfer_read(packet, &annex, &offset, &length) < 0) {
+		if (decode_xfer_read(packet, NULL, &offset, &length) < 0) {
 			gdb_send_error(connection, 01);
 			return ERROR_OK;
 		}
-		free(annex);
 
 		/* Target should prepare correct target description for annex.
 		 * The first character of returned xml is 'm' or 'l'. 'm' for
@@ -2401,6 +2511,37 @@ static int gdb_query_packet(struct connection *connection,
 
 		gdb_put_packet(connection, xml, strlen(xml));
 
+		free(xml);
+		return ERROR_OK;
+	} else if (strncmp(packet, "qXfer:threads:read:", 19) == 0) {
+		char *xml = NULL;
+		int retval = ERROR_OK;
+
+		int offset;
+		unsigned int length;
+
+		/* skip command character */
+		packet += 19;
+
+		if (decode_xfer_read(packet, NULL, &offset, &length) < 0) {
+			gdb_send_error(connection, 01);
+			return ERROR_OK;
+		}
+
+		/* Target should prepare correct thread list for annex.
+		 * The first character of returned xml is 'm' or 'l'. 'm' for
+		 * there are *more* chunks to transfer. 'l' for it is the *last*
+		 * chunk of target description.
+		 */
+		retval = gdb_get_thread_list_chunk(target, &gdb_connection->thread_list,
+						   &xml, offset, length);
+		if (retval != ERROR_OK) {
+			gdb_error(connection, retval);
+			return retval;
+		}
+
+		gdb_put_packet(connection, xml, strlen(xml));
+
 		free(xml);
 		return ERROR_OK;
 	} else if (strncmp(packet, "QStartNoAckMode", 15) == 0) {
@@ -2921,6 +3062,11 @@ static int gdb_target_start(struct target *target, const char *port)
 
 static int gdb_target_add_one(struct target *target)
 {
+	if (strcmp(gdb_port, "disabled") == 0) {
+		LOG_INFO("gdb port disabled");
+		return ERROR_OK;
+	}
+
 	/*  one gdb instance per smp list */
 	if ((target->smp) && (target->gdb_service))
 		return ERROR_OK;
@@ -2944,6 +3090,11 @@ static int gdb_target_add_one(struct target *target)
 
 int gdb_target_add_all(struct target *target)
 {
+	if (strcmp(gdb_port, "disabled") == 0) {
+		LOG_INFO("gdb server disabled");
+		return ERROR_OK;
+	}
+
 	if (NULL == target) {
 		LOG_WARNING("gdb services need one or more targets defined");
 		return ERROR_OK;
@@ -3061,7 +3212,7 @@ COMMAND_HANDLER(handle_gdb_save_tdesc_command)
 
 	tdesc_length = strlen(tdesc);
 
-	struct fileio fileio;
+	struct fileio *fileio;
 	size_t size_written;
 
 	char *tdesc_filename = alloc_printf("%s.xml", target_type_name(target));
@@ -3077,9 +3228,9 @@ COMMAND_HANDLER(handle_gdb_save_tdesc_command)
 		goto out;
 	}
 
-	retval = fileio_write(&fileio, tdesc_length, tdesc, &size_written);
+	retval = fileio_write(fileio, tdesc_length, tdesc, &size_written);
 
-	fileio_close(&fileio);
+	fileio_close(fileio);
 
 	if (retval != ERROR_OK)
 		LOG_ERROR("Error while writing the tdesc file");
@@ -3109,7 +3260,7 @@ static const struct command_registration gdb_command_handlers[] = {
 			"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 "
+			"output to stdout, an integer is base port number, \"disabled\" 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]",