Merge pull request #57 from varnish/coldstart

Implement fast cold start feature

Author: fwsGonzo

lib/CMakeLists.txt

@@ -18,6 +18,7 @@ set (SOURCES
 	tinykvm/machine_debug.cpp
 	tinykvm/machine_elf.cpp
 	tinykvm/machine_env.cpp
+	tinykvm/machine_state.cpp
 	tinykvm/machine_utils.cpp
 	tinykvm/memory.cpp
 	tinykvm/memory_bank.cpp

lib/tinykvm/common.hpp

@@ -96,6 +96,10 @@ namespace tinykvm
 		bool executable_heap = false;
 		/* Enable file-backed memory mappings for large files */
 		bool mmap_backed_files = false;
+		/* Enable fast cold start by file-mapping all physical memory
+		   to the given file. The file is created if it does not exist,
+		   and must be of the correct size if it does exist. */
+		std::string fast_cold_start_file;
 		/* When using hugepages, cover the given size with
 		   hugepages, unless 0, in which case the entire
 		   main memory will be covered. */

lib/tinykvm/linux/fds.cpp

@@ -162,6 +162,9 @@ namespace tinykvm
 					}
 					break;
 				}
+				case SocketType::INVALID:
+					// Ignore invalid socket types (they cannot be reconstructed)
+					break;
 				default:
 					fprintf(stderr, "TinyKVM: Unknown socket type %d\n", sp.type);
 					throw std::runtime_error("TinyKVM: Unknown socket type");

lib/tinykvm/linux/fds.hpp

@@ -51,6 +51,9 @@ namespace tinykvm
 		void set_vfd_start(int vfd_start) noexcept {
 			m_next_fd = vfd_start;
 		}
+		int vfd_start() const noexcept {
+			return m_next_fd;
+		}
 
 		/// @brief Add a file descriptor to the list of managed FDs.
 		/// @param fd The real file descriptor.
@@ -282,6 +285,7 @@ namespace tinykvm
 			std::unordered_set<int> shared_epoll_fds;
 		};
 		EpollEntry& get_epoll_entry_for_vfd(int vfd);
+		const auto& get_epoll_entries() const { return m_epoll_fds; }
 		auto& get_epoll_entries() { return m_epoll_fds; }
 		enum SocketType : int {
 			INVALID,
@@ -298,8 +302,11 @@ namespace tinykvm
 			SocketType type = INVALID;
 		};
 		void add_socket_pair(const SocketPair&);
+		const auto& get_socket_pairs() const { return m_sockets; }
+		auto& get_socket_pairs() { return m_sockets; }
 
 		std::string sockaddr_to_string(const struct sockaddr_storage& addr) const;
+
 	private:
 		Machine& m_machine;
 		std::map<int, Entry> m_fds;

lib/tinykvm/linux/threads.cpp

@@ -123,6 +123,12 @@ Thread* MultiThreading::get_thread(int tid) /* or nullptr */
 	return &it->second;
 }
 
+Thread& MultiThreading::create(int tid)
+{
+	auto it = m_threads.try_emplace(tid, *this, tid, 0, 0);
+	return it.first->second;
+}
+
 Thread& MultiThreading::create(
 	int flags, uint64_t ctid, uint64_t ptid, uint64_t stack, uint64_t tls)
 {

lib/tinykvm/linux/threads.hpp

@@ -29,6 +29,7 @@ struct MultiThreading {
 	Thread* get_thread(int tid); /* or nullptr */
 	int gettid() { return get_thread().tid; }
 
+	Thread& create(int tid);
 	Thread& create(int flags, uint64_t ctid, uint64_t ptid,
 		uint64_t stack, uint64_t tls);
 	bool suspend_and_yield(int64_t result = 0);

lib/tinykvm/machine.cpp

@@ -38,16 +38,29 @@ Machine::Machine(std::string_view binary, const MachineOptions& options)
 	  m_mt   {nullptr} /* Explicitly */
 {
 	assert(kvm_fd != -1 && "Call Machine::init() first");
+	if (options.mmap_backed_files && !options.fast_cold_start_file.empty()) {
+		throw MachineException("Cannot have fast cold start with mmap-backed files at the same time");
+	}
 
 	this->fd = create_kvm_vm();
 
 	install_memory(0, memory.vmem(), false);
 
+	this->vcpu.init(0, *this, options);
+
+	if (memory.has_loadable_cold_start_state()) {
+		if (this->load_cold_start_state()) {
+			printf("Loaded fast cold start state\n");
+			return;
+		}
+		// If the file does not exist, or anything else failed, we continue
+		// to do a normal cold start.
+	}
+
 	if (!binary.empty()) {
 		this->elf_loader(binary, options);
 	}
 
-	this->vcpu.init(0, *this, options);
 	this->setup_long_mode(options);
 
 	/* We need to adjust BRK if the kernel end address is

lib/tinykvm/machine.hpp

@@ -295,6 +295,11 @@ struct Machine
 	/* Migrates the VM to the current thread. Allows creating in
 	   one thread, and using it in another. */
 	void migrate_to_this_thread();
+	/* Store non-memory VM state to the already existing cold
+	   start state area in memory. Any failure will throw an
+	   exception. The memory must have been pre-allocated. */
+	void save_cold_start_state_now() const;
+
 	static void init();
 	static void setup_linux_system_calls(bool unsafe_syscalls = false);
 	Machine(const std::vector<uint8_t>& binary, const MachineOptions&);
@@ -321,6 +326,7 @@ struct Machine
 	void remote_update_gigapage_mappings(Machine& other, bool forced = false);
 	/* Prepare for resume with a pagetable reload */
 	void prepare_vmresume(address_t fsbase = 0, bool reload_pagetables = true);
+	bool load_cold_start_state();
 
 	vCPU  vcpu;
 	int   fd = 0;