Use real filename to determine relocation for remote GDB

Author: fwsGonzo

lib/CMakeLists.txt

@@ -15,6 +15,7 @@ endif()
 
 set (SOURCES
 	tinykvm/machine.cpp
+	tinykvm/machine_debug.cpp
 	tinykvm/machine_elf.cpp
 	tinykvm/machine_env.cpp
 	tinykvm/machine_utils.cpp

lib/tinykvm/machine.hpp

@@ -212,6 +212,7 @@ struct Machine
 	void print_registers() const { vcpu.print_registers(); }
 	void print_pagetables() const;
 	void print_exception_handlers() const;
+	void print_remote_gdb_backtrace(const std::string& filename, const std::string& gdb_path = "/usr/bin/gdb");
 
 	void install_memory(uint32_t idx, const VirtualMem&, bool ro);
 	void delete_memory(uint32_t idx);

lib/tinykvm/machine_debug.cpp

@@ -0,0 +1,71 @@
+#include "machine.hpp"
+
+#include <cstring>
+#include <stdexcept>
+#include <unistd.h>
+#include "rsp_client.hpp"
+extern char** environ;
+
+namespace tinykvm {
+void Machine::print_remote_gdb_backtrace(
+	const std::string& filename,
+	const std::string& gdb_path)
+{
+	const uint16_t port = 2159;
+
+	if (0 == fork())
+	{
+		char scrname[64];
+		strncpy(scrname, "/tmp/dbgscript-XXXXXX", sizeof(scrname));
+		const int fd = mkstemp(scrname);
+		if (fd < 0)
+		{
+			throw std::runtime_error("Unable to create script for debugging");
+		}
+
+		const std::string debugscript =
+			// Delete the script file (after GDB closes it)
+			"shell unlink " + std::string(scrname)
+			+ "\n"
+			+ "set debuginfod enabled on\n"
+			  // Load the original file used by the script
+			  "file " + filename + "\n"
+			  // Connect remotely to the given port @port
+			  "target remote localhost:"
+			+ std::to_string(port)
+			+ "\n"
+			+ "up\nbt\n";
+
+		ssize_t len = write(fd, debugscript.c_str(), debugscript.size());
+		if (len < (ssize_t)debugscript.size())
+		{
+			throw std::runtime_error(
+				"Unable to write script file for debugging");
+		}
+		close(fd);
+
+		const char* argv[]
+			= {gdb_path.c_str(), "-x", scrname, nullptr};
+		// XXX: This is not kosher, but GDB is open-source, safe and let's not
+		// pretend that anyone downloads gdb-multiarch from a website anyway.
+		// There is a finite list of things we should pass to GDB to make it
+		// behave well, but I haven't been able to find the right combination.
+		if (-1 == execve(argv[0], (char* const*)argv, environ))
+		{
+			throw std::runtime_error(
+				"Unable to start gdb-multiarch for debugging");
+		}
+	}
+
+	RSP server {filename, *this, port};
+	auto client = server.accept();
+	if (client != nullptr)
+	{
+		printf("GDB connected\n");
+		// client->set_verbose(true);
+		while (client->process_one())
+			;
+	}
+}
+
+} // namespace tinykvm

lib/tinykvm/machine_utils.cpp

@@ -298,7 +298,23 @@ bool Machine::mmap_backed_area(
 		}
 		// Now we need to install this memory region as guest physical memory
 		this->install_memory(region_idx, VirtualMem(mmap_phys_base, (char*)real_addr, size_memory), false);
-		this->memory.mmap_ranges.emplace_back(mmap_phys_base, (char*)real_addr, virt_base, size_memory);
+		// Discover the filename of the fd
+		char fd_path[64];
+		snprintf(fd_path, sizeof(fd_path), "/proc/self/fd/%d", fd);
+		std::string filename(PATH_MAX, '\0');
+		const ssize_t r = readlink(fd_path, filename.data(), filename.size() - 1);
+		if (r > 0) {
+			filename[r] = '\0';
+			filename.resize(r);
+		} else {
+			int len = snprintf(filename.data(), filename.size(), "fd%d", fd);
+			filename.resize(len);
+		}
+		if constexpr (VERBOSE_FILE_BACKED_MMAP) {
+			printf("mmap: fd %d is file '%s'\n", fd, filename.c_str());
+		}
+		// Record the mmap range
+		this->memory.mmap_ranges.emplace_back(mmap_phys_base, (char*)real_addr, virt_base, size_memory, std::move(filename));
 		// XXX: TODO: madvise(MADV_DONTNEED) on the old pages using gather_buffers_from_range
 		// With the new physical memory, we now need to create pagetable entries
 		// we'll do it the slow way by allocating the same range and for each page redirect it to the new phys

lib/tinykvm/rsp_client.cpp

@@ -1,15 +1,17 @@
 #include "rsp_client.hpp"
 
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <sys/select.h>
+#include <cstdarg>
+#include <cstring>
+#include <fcntl.h>
 #include <linux/kvm.h>
 #include <netinet/in.h>
 #include <netinet/tcp.h>
-#include <unistd.h>
-#include <cstdarg>
-#include <cstring>
 #include <stdexcept>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/select.h>
+#include <sys/stat.h>
+#include <unistd.h>
 #include "amd64/memory_layout.hpp"
 
 /**
@@ -18,8 +20,8 @@
 
 namespace tinykvm {
 
-RSP::RSP(vCPU& cpu, uint16_t port)
-	: m_cpu{cpu}
+RSP::RSP(const std::string& filename, vCPU& cpu, uint16_t port)
+	: m_cpu{cpu}, m_filename{filename}
 {
 	this->server_fd = socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK, 0);
 
@@ -45,8 +47,8 @@ RSP::RSP(vCPU& cpu, uint16_t port)
 	/* We need to make sure the VM can be stepped through */
 	m_cpu.machine().stop(false);
 }
-RSP::RSP(Machine& machine, uint16_t port)
-	: RSP(machine.cpu(), port)
+RSP::RSP(const std::string& filename, Machine& machine, uint16_t port)
+	: RSP(filename, machine.cpu(), port)
 {}
 std::unique_ptr<RSPClient> RSP::accept(int timeout_secs)
 {
@@ -85,14 +87,14 @@ std::unique_ptr<RSPClient> RSP::accept(int timeout_secs)
 		close(sockfd);
 		return nullptr;
 	}
-	return std::make_unique<RSPClient>(m_cpu, sockfd);
+	return std::make_unique<RSPClient>(m_filename, m_cpu, sockfd);
 }
 RSP::~RSP() {
 	close(server_fd);
 }
 
-RSPClient::RSPClient(vCPU& cpu, int fd)
-	: m_cpu{&cpu}, sockfd(fd)  {}
+RSPClient::RSPClient(const std::string& filename, vCPU& cpu, int fd)
+	: m_cpu{&cpu}, sockfd(fd), m_filename{filename} {}
 RSPClient::~RSPClient() {
 	if (!is_closed())
 		close(this->sockfd);
@@ -267,11 +269,11 @@ void RSPClient::handle_query()
 {
 	if (strncmp("qSupported", buffer.data(), strlen("qSupported")) == 0)
 	{
-		sendf("PacketSize=%x;swbreak-;hwbreak+", PACKET_SIZE);
+		sendf("PacketSize=%x;swbreak-;hwbreak+;qXfer:libraries:read+;", PACKET_SIZE);
 	}
 	else if (strncmp("qAttached", buffer.data(), strlen("qC")) == 0)
 	{
-		send("1");
+		send("0");
 	}
 	else if (strncmp("qC", buffer.data(), strlen("qC")) == 0)
 	{
@@ -281,7 +283,14 @@ void RSPClient::handle_query()
 	else if (strncmp("qOffsets", buffer.data(), strlen("qOffsets")) == 0)
 	{
 		// Section relocation offsets
-		send("Text=0;Data=0;Bss=0");
+		uint64_t offset = 0x0;
+		for (const auto& mapping : machine().main_memory().mmap_ranges) {
+			if (mapping.filename == this->m_filename) {
+				offset = mapping.virtbase;
+				break;
+			}
+		}
+		sendf("TextSeg=%lx", offset);
 	}
 	else if (strncmp("qfThreadInfo", buffer.data(), strlen("qfThreadInfo")) == 0)
 	{
@@ -407,7 +416,115 @@ void RSPClient::handle_executing()
 	{
 		send("");
 	}
+	else if (strncmp("vFile:setfs", buffer.data(), strlen("vFile:setfs")) == 0)
+	{
+		send("");
+	}
 	else {
+		// Check for file operations
+		if (strncmp("vFile:open", buffer.data(), strlen("vFile:open")) == 0)
+		{
+			// vFile:open:filename,flags,mode
+			char filename[512];
+			int flags = 0, mode = 0;
+			int ret = sscanf(buffer.c_str(), "vFile:open:%511[^,],%d,%o",
+				filename, &flags, &mode);
+			if (ret == 3) {
+				printf("Opening file: %s (flags=%d, mode=%o)\n",
+					filename, flags, mode);
+				// NOTE: We are not doing any sandboxing here!
+				int fd = open(filename, flags, mode);
+				if (fd < 0) {
+					send("");
+					return;
+				} else {
+					sendf("F%d", fd);
+				}
+			} else {
+				send("F01");
+			}
+			return;
+		}
+		else if (strncmp("vFile:pread", buffer.data(), strlen("vFile:pread")) == 0)
+		{
+			// vFile:pread:fd,buf,bufsize,offset
+			int fd = 0;
+			uint32_t bufsize = 0;
+			uint64_t offset = 0;
+			int ret = sscanf(buffer.c_str(), "vFile:pread:%d,0,%x,%lx",
+				&fd, &bufsize, &offset);
+			if (ret == 3 && bufsize < 4096) {
+				char data[4096];
+				ssize_t rlen = pread(fd, data, bufsize, offset);
+				if (rlen < 0) {
+					sendf("F%02x", -errno);
+					return;
+				}
+				char out[8192 + 1];
+				char* d = out;
+				for (ssize_t i = 0; i < rlen; i++) {
+					uint8_t val = data[i];
+					*d++ = lut[(val >> 4) & 0xF];
+					*d++ = lut[(val >> 0) & 0xF];
+				}
+				*d++ = 0;
+				sendf("F00;%s", out);
+			} else {
+				send("F01");
+			}
+			return;
+		}
+		else if (strncmp("vFile:close", buffer.data(), strlen("vFile:close")) == 0)
+		{
+			// vFile:close:fd
+			int fd = 0;
+			int ret = sscanf(buffer.c_str(), "vFile:close:%d", &fd);
+			if (ret == 1) {
+				int r = close(fd);
+				if (r < 0)
+					r = -errno;
+				sendf("F%02x", r);
+			} else {
+				send("F01");
+			}
+			return;
+		}
+		else if (strncmp("vFile:fstat", buffer.data(), strlen("vFile:fstat")) == 0)
+		{
+			// vFile:fstat:fd
+			int fd = 0;
+			int ret = sscanf(buffer.c_str(), "vFile:fstat:%d", &fd);
+			if (ret == 1) {
+				struct stat st;
+				int r = fstat(fd, &st);
+				if (r < 0) {
+					sendf("F%02x", -errno);
+					return;
+				}
+				sendf("F00;0%llo,0%llo,0%llo,0%llo,0%llo,0%llo,0%llo,0%llo,0%llo,0%llo,0%llo,0%llo,0%llo,0%llo,0%llo,0%llo",
+					(__u64)st.st_dev,
+					(__u64)st.st_ino,
+					(__u64)st.st_mode,
+					(__u64)st.st_nlink,
+					(__u64)st.st_uid,
+					(__u64)st.st_gid,
+					(__u64)st.st_rdev,
+					(__u64)st.st_size,
+					(__u64)st.st_blksize,
+					(__u64)st.st_blocks,
+					(__u64)st.st_atim.tv_sec,
+					(__u64)st.st_atim.tv_nsec,
+					(__u64)st.st_mtim.tv_sec,
+					(__u64)st.st_mtim.tv_nsec,
+					(__u64)st.st_ctim.tv_sec,
+					(__u64)st.st_ctim.tv_nsec
+				);
+			} else {
+				send("F01");
+			}
+			return;
+		}
+		// Unknown v packet
 		if (UNLIKELY(m_verbose)) {
 			fprintf(stderr, "Unknown executor: %s\n",
 				buffer.data());

lib/tinykvm/rsp_client.hpp

@@ -10,13 +10,14 @@ struct RSP
 	std::unique_ptr<RSPClient> accept(int timeout_secs = 10);
 	int  fd() const noexcept { return server_fd; }
 
-	RSP(vCPU&, uint16_t);
-	RSP(Machine&, uint16_t);
+	RSP(const std::string& filename, vCPU&, uint16_t port);
+	RSP(const std::string& filename, Machine&, uint16_t port);
 	~RSP();
 
 private:
 	vCPU& m_cpu;
 	int server_fd;
+	std::string m_filename;
 };
 
 struct RSPClient
@@ -40,7 +41,7 @@ struct RSPClient
 	void set_verbose(bool v) { m_verbose = v; }
 	void on_stopped(StopFunc f) { m_on_stopped = f; }
 
-	RSPClient(vCPU& cpu, int fd);
+	RSPClient(const std::string& filename, vCPU& cpu, int fd);
 	~RSPClient();
 
 private:
@@ -74,6 +75,7 @@ struct RSPClient
 	std::array<uint64_t, 4> m_bp = {0};
 	size_t bp_iterator = 0;
 	StopFunc m_on_stopped = nullptr;
+	const std::string& m_filename;
 };
 
 }

lib/tinykvm/virtual_mem.hpp

@@ -8,12 +8,13 @@ struct VirtualMem {
 	char *   ptr;
 	uint64_t virtbase = 0;
 	uint64_t size;
+	std::string filename; // Optional, for file-backed mappings
 
 	VirtualMem(uint64_t phys, char* p, uint64_t s)
 		: physbase(phys), ptr(p), size(s) {}
 
-	VirtualMem(uint64_t phys, char* p, uint64_t v, uint64_t s)
-		: physbase(phys), ptr(p), virtbase(v), size(s) {}
+	VirtualMem(uint64_t phys, char* p, uint64_t v, uint64_t s, std::string f = "")
+		: physbase(phys), ptr(p), virtbase(v), size(s), filename(std::move(f)) {}
 
 	static VirtualMem New(uint64_t physical, char* ptr, uint64_t size) {
 		return VirtualMem { physical, ptr, size };

src/bench.cpp

@@ -32,7 +32,8 @@ int main(int argc, char** argv)
 		fprintf(stderr, "Missing argument: 64-bit ELF binary\n");
 		exit(1);
 	}
-	binary = load_file(argv[1]);
+	std::string filename = argv[1];
+	binary = load_file(filename);
 	std::vector<tinykvm::Machine*> vms;
 	vms.reserve(NUM_GUESTS);
 
@@ -75,7 +76,7 @@ int main(int argc, char** argv)
 				master_vm.set_registers(regs);
 			}
 
-			tinykvm::RSP server {*vm, 2159};
+			tinykvm::RSP server {filename, *vm, 2159};
 			printf("Waiting for connection localhost:2159...\n");
 			auto client = server.accept();
 			if (client != nullptr) {